rev 1063 : 8172974: [JAXP] XALAN: Wrong result when transforming namespace unaware StAX Input

   1 /*
   2  * Copyright (c) 2007, 2016, Oracle and/or its affiliates. All rights reserved.
   3  */
   4 /*
   5  * Licensed to the Apache Software Foundation (ASF) under one or more
   6  * contributor license agreements.  See the NOTICE file distributed with
   7  * this work for additional information regarding copyright ownership.
   8  * The ASF licenses this file to You under the Apache License, Version 2.0
   9  * (the "License"); you may not use this file except in compliance with
  10  * the License.  You may obtain a copy of the License at
  11  *
  12  *     http://www.apache.org/licenses/LICENSE-2.0
  13  *
  14  * Unless required by applicable law or agreed to in writing, software
  15  * distributed under the License is distributed on an "AS IS" BASIS,
  16  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  17  * See the License for the specific language governing permissions and
  18  * limitations under the License.
  19  */
  20 
  21 package com.sun.org.apache.xalan.internal.xsltc.trax;
  22 
  23 import com.sun.org.apache.xalan.internal.XalanConstants;
  24 import com.sun.org.apache.xalan.internal.utils.FactoryImpl;
  25 import com.sun.org.apache.xalan.internal.utils.FeaturePropertyBase;
  26 import com.sun.org.apache.xalan.internal.utils.ObjectFactory;
  27 import com.sun.org.apache.xalan.internal.utils.SecuritySupport;
  28 import com.sun.org.apache.xalan.internal.utils.XMLSecurityManager;
  29 import com.sun.org.apache.xalan.internal.utils.XMLSecurityPropertyManager;
  30 import com.sun.org.apache.xalan.internal.utils.XMLSecurityPropertyManager.Property;
  31 import com.sun.org.apache.xalan.internal.xsltc.compiler.Constants;
  32 import com.sun.org.apache.xalan.internal.xsltc.compiler.SourceLoader;
  33 import com.sun.org.apache.xalan.internal.xsltc.compiler.XSLTC;
  34 import com.sun.org.apache.xalan.internal.xsltc.compiler.util.ErrorMsg;
  35 import com.sun.org.apache.xalan.internal.xsltc.dom.XSLTCDTMManager;
  36 import com.sun.org.apache.xml.internal.utils.StopParseException;
  37 import com.sun.org.apache.xml.internal.utils.StylesheetPIHandler;
  38 import java.io.File;
  39 import java.io.FileInputStream;
  40 import java.io.FileNotFoundException;
  41 import java.io.FilenameFilter;
  42 import java.io.IOException;
  43 import java.io.InputStream;
  44 import java.net.MalformedURLException;
  45 import java.net.URL;
  46 import java.util.ArrayList;
  47 import java.util.Enumeration;
  48 import java.util.Map;
  49 import java.util.Properties;
  50 import java.util.Vector;
  51 import java.util.zip.ZipEntry;
  52 import java.util.zip.ZipFile;
  53 import javax.xml.XMLConstants;
  54 import javax.xml.catalog.CatalogException;
  55 import javax.xml.catalog.CatalogFeatures;
  56 import javax.xml.catalog.CatalogFeatures.Feature;
  57 import javax.xml.catalog.CatalogManager;
  58 import javax.xml.catalog.CatalogResolver;
  59 import javax.xml.parsers.SAXParser;
  60 import javax.xml.parsers.SAXParserFactory;
  61 import javax.xml.transform.ErrorListener;
  62 import javax.xml.transform.Source;
  63 import javax.xml.transform.Templates;
  64 import javax.xml.transform.Transformer;
  65 import javax.xml.transform.TransformerConfigurationException;
  66 import javax.xml.transform.TransformerException;
  67 import javax.xml.transform.TransformerFactory;
  68 import javax.xml.transform.URIResolver;
  69 import javax.xml.transform.dom.DOMResult;
  70 import javax.xml.transform.dom.DOMSource;
  71 import javax.xml.transform.sax.SAXResult;
  72 import javax.xml.transform.sax.SAXSource;
  73 import javax.xml.transform.sax.SAXTransformerFactory;
  74 import javax.xml.transform.sax.TemplatesHandler;
  75 import javax.xml.transform.sax.TransformerHandler;
  76 import javax.xml.transform.stax.*;
  77 import javax.xml.transform.stream.StreamResult;
  78 import javax.xml.transform.stream.StreamSource;
  79 import jdk.xml.internal.JdkXmlFeatures;
  80 import jdk.xml.internal.JdkXmlUtils;
  81 import org.xml.sax.InputSource;
  82 import org.xml.sax.XMLFilter;
  83 import org.xml.sax.XMLReader;
  84 import org.xml.sax.helpers.XMLReaderFactory;
  85 
  86 /**
  87  * Implementation of a JAXP1.1 TransformerFactory for Translets.
  88  * @author G. Todd Miller
  89  * @author Morten Jorgensen
  90  * @author Santiago Pericas-Geertsen
  91  */
  92 @SuppressWarnings("deprecation") //org.xml.sax.helpers.XMLReaderFactory
  93 public class TransformerFactoryImpl
  94     extends SAXTransformerFactory implements SourceLoader, ErrorListener
  95 {
  96     // Public constants for attributes supported by the XSLTC TransformerFactory.
  97     public final static String TRANSLET_NAME = "translet-name";
  98     public final static String DESTINATION_DIRECTORY = "destination-directory";
  99     public final static String PACKAGE_NAME = "package-name";
 100     public final static String JAR_NAME = "jar-name";
 101     public final static String GENERATE_TRANSLET = "generate-translet";
 102     public final static String AUTO_TRANSLET = "auto-translet";
 103     public final static String USE_CLASSPATH = "use-classpath";
 104     public final static String DEBUG = "debug";
 105     public final static String ENABLE_INLINING = "enable-inlining";
 106     public final static String INDENT_NUMBER = "indent-number";
 107 
 108     /**
 109      * This error listener is used only for this factory and is not passed to
 110      * the Templates or Transformer objects that we create.
 111      */
 112     private ErrorListener _errorListener = this;
 113 
 114     /**
 115      * This URIResolver is passed to all created Templates and Transformers
 116      */
 117     private URIResolver _uriResolver = null;
 118 
 119     /**
 120      * As Gregor Samsa awoke one morning from uneasy dreams he found himself
 121      * transformed in his bed into a gigantic insect. He was lying on his hard,
 122      * as it were armour plated, back, and if he lifted his head a little he
 123      * could see his big, brown belly divided into stiff, arched segments, on
 124      * top of which the bed quilt could hardly keep in position and was about
 125      * to slide off completely. His numerous legs, which were pitifully thin
 126      * compared to the rest of his bulk, waved helplessly before his eyes.
 127      * "What has happened to me?", he thought. It was no dream....
 128      */
 129     protected final static String DEFAULT_TRANSLET_NAME = "GregorSamsa";
 130 
 131     /**
 132      * The class name of the translet
 133      */
 134     private String _transletName = DEFAULT_TRANSLET_NAME;
 135 
 136     /**
 137      * The destination directory for the translet
 138      */
 139     private String _destinationDirectory = null;
 140 
 141     /**
 142      * The package name prefix for all generated translet classes
 143      */
 144     private static final String DEFAULT_TRANSLATE_PACKAGE = "die.verwandlung";
 145     private String _packageName = DEFAULT_TRANSLATE_PACKAGE;
 146 
 147     /**
 148      * The jar file name which the translet classes are packaged into
 149      */
 150     private String _jarFileName = null;
 151 
 152     /**
 153      * This Map is used to store parameters for locating
 154      * <?xml-stylesheet ...?> processing instructions in XML docs.
 155      */
 156     private Map<Source, PIParamWrapper> _piParams = null;
 157 
 158     /**
 159      * The above Map stores objects of this class.
 160      */
 161     private static class PIParamWrapper {
 162         public String _media = null;
 163         public String _title = null;
 164         public String _charset = null;
 165 
 166         public PIParamWrapper(String media, String title, String charset) {
 167             _media = media;
 168             _title = title;
 169             _charset = charset;
 170         }
 171     }
 172 
 173     /**
 174      * Set to <code>true</code> when debugging is enabled.
 175      */
 176     private boolean _debug = false;
 177 
 178     /**
 179      * Set to <code>true</code> when templates are inlined.
 180      */
 181     private boolean _enableInlining = false;
 182 
 183     /**
 184      * Set to <code>true</code> when we want to generate
 185      * translet classes from the stylesheet.
 186      */
 187     private boolean _generateTranslet = false;
 188 
 189     /**
 190      * If this is set to <code>true</code>, we attempt to use translet classes
 191      * for transformation if possible without compiling the stylesheet. The
 192      * translet class is only used if its timestamp is newer than the timestamp
 193      * of the stylesheet.
 194      */
 195     private boolean _autoTranslet = false;
 196 
 197     /**
 198      * If this is set to <code>true</code>, we attempt to load the translet
 199      * from the CLASSPATH.
 200      */
 201     private boolean _useClasspath = false;
 202 
 203     /**
 204      * Number of indent spaces when indentation is turned on.
 205      */
 206     private int _indentNumber = -1;
 207 
 208     /**
 209      * <p>State of secure processing feature.</p>
 210      */
 211     private boolean _isNotSecureProcessing = true;

 212     /**
 213      * <p>State of secure mode.</p>
 214      */
 215     private boolean _isSecureMode = false;
 216 
 217     /**
 218      * Indicates whether implementation parts should use
 219      *   service loader (or similar).
 220      * Note the default value (false) is the safe option..
 221      */
 222     private boolean _useServicesMechanism;
 223 
 224     /**
 225      * protocols allowed for external references set by the stylesheet
 226      * processing instruction, Import and Include element.
 227      */
 228     private String _accessExternalStylesheet = XalanConstants.EXTERNAL_ACCESS_DEFAULT;
 229      /**

 230      * protocols allowed for external DTD references in source file and/or stylesheet.
 231      */
 232     private String _accessExternalDTD = XalanConstants.EXTERNAL_ACCESS_DEFAULT;
 233 
 234     private XMLSecurityPropertyManager _xmlSecurityPropertyMgr;
 235     private XMLSecurityManager _xmlSecurityManager;
 236 
 237     private final JdkXmlFeatures _xmlFeatures;
 238 
 239     private ClassLoader _extensionClassLoader = null;
 240 
 241     // Unmodifiable view of external extension function from xslt compiler
 242     // It will be populated by user-specified extension functions during the
 243     // type checking
 244     private Map<String, Class<?>> _xsltcExtensionFunctions;
 245 
 246     CatalogResolver _catalogUriResolver;
 247     CatalogFeatures _catalogFeatures;
 248     CatalogFeatures.Builder cfBuilder = CatalogFeatures.builder();
 249     // Catalog features
 250     String _catalogFiles = null;
 251     String _catalogDefer = null;
 252     String _catalogPrefer = null;
 253     String _catalogResolve = null;
 254 
 255     int _cdataChunkSize = JdkXmlUtils.CDATA_CHUNK_SIZE_DEFAULT;
 256 
 257     /**
 258      * javax.xml.transform.sax.TransformerFactory implementation.
 259      */
 260     public TransformerFactoryImpl() {
 261         this(true);
 262     }
 263 
 264     public static TransformerFactory newTransformerFactoryNoServiceLoader() {
 265         return new TransformerFactoryImpl(false);
 266     }
 267 
 268     private TransformerFactoryImpl(boolean useServicesMechanism) {
 269         this._useServicesMechanism = useServicesMechanism;
 270 
 271         if (System.getSecurityManager() != null) {
 272             _isSecureMode = true;
 273             _isNotSecureProcessing = false;
 274         }
 275 
 276         _xmlFeatures = new JdkXmlFeatures(!_isNotSecureProcessing);
 277         _xmlSecurityPropertyMgr = new XMLSecurityPropertyManager();
 278         _accessExternalDTD = _xmlSecurityPropertyMgr.getValue(
 279                 Property.ACCESS_EXTERNAL_DTD);
 280         _accessExternalStylesheet = _xmlSecurityPropertyMgr.getValue(
 281                 Property.ACCESS_EXTERNAL_STYLESHEET);
 282 
 283         //Parser's security manager
 284         _xmlSecurityManager = new XMLSecurityManager(true);
 285         //Unmodifiable hash map with loaded external extension functions
 286         _xsltcExtensionFunctions = null;
 287     }
 288 
 289     public Map<String, Class<?>> getExternalExtensionsMap() {
 290         return _xsltcExtensionFunctions;
 291     }
 292 
 293     /**
 294      * javax.xml.transform.sax.TransformerFactory implementation.
 295      * Set the error event listener for the TransformerFactory, which is used
 296      * for the processing of transformation instructions, and not for the
 297      * transformation itself.
 298      *
 299      * @param listener The error listener to use with the TransformerFactory
 300      * @throws IllegalArgumentException
 301      */
 302     @Override
 303     public void setErrorListener(ErrorListener listener)
 304         throws IllegalArgumentException
 305     {
 306         if (listener == null) {
 307             ErrorMsg err = new ErrorMsg(ErrorMsg.ERROR_LISTENER_NULL_ERR,
 308                                         "TransformerFactory");
 309             throw new IllegalArgumentException(err.toString());
 310         }
 311         _errorListener = listener;
 312     }
 313 
 314     /**
 315      * javax.xml.transform.sax.TransformerFactory implementation.
 316      * Get the error event handler for the TransformerFactory.
 317      *
 318      * @return The error listener used with the TransformerFactory
 319      */
 320     @Override
 321     public ErrorListener getErrorListener() {
 322         return _errorListener;
 323     }
 324 
 325     /**
 326      * Returns the package name.
 327      */
 328     String getPackageName() {
 329         return _packageName;
 330     }
 331 
 332     /**
 333      * javax.xml.transform.sax.TransformerFactory implementation.
 334      * Returns the value set for a TransformerFactory attribute
 335      *
 336      * @param name The attribute name
 337      * @return An object representing the attribute value
 338      * @throws IllegalArgumentException
 339      */
 340     @Override
 341     public Object getAttribute(String name)
 342         throws IllegalArgumentException
 343     {
 344         // Return value for attribute 'translet-name'
 345         if (name.equals(TRANSLET_NAME)) {
 346             return _transletName;
 347         }
 348         else if (name.equals(GENERATE_TRANSLET)) {
 349             return _generateTranslet;
 350         }
 351         else if (name.equals(AUTO_TRANSLET)) {
 352             return _autoTranslet;
 353         }
 354         else if (name.equals(ENABLE_INLINING)) {
 355             if (_enableInlining)
 356               return Boolean.TRUE;
 357             else
 358               return Boolean.FALSE;
 359         } else if (name.equals(XalanConstants.SECURITY_MANAGER)) {
 360             return _xmlSecurityManager;
 361         } else if (name.equals(XalanConstants.JDK_EXTENSION_CLASSLOADER)) {
 362            return _extensionClassLoader;
 363         } else if (JdkXmlUtils.CATALOG_FILES.equals(name)) {
 364             return _catalogFiles;
 365         } else if (JdkXmlUtils.CATALOG_DEFER.equals(name)) {
 366             return _catalogDefer;
 367         } else if (JdkXmlUtils.CATALOG_PREFER.equals(name)) {
 368             return _catalogPrefer;
 369         } else if (JdkXmlUtils.CATALOG_RESOLVE.equals(name)) {
 370             return _catalogResolve;
 371         } else if (JdkXmlFeatures.CATALOG_FEATURES.equals(name)) {
 372             return buildCatalogFeatures();
 373         } else if (JdkXmlUtils.CDATA_CHUNK_SIZE.equals(name)) {
 374             return _cdataChunkSize;
 375         }
 376 
 377         /** Check to see if the property is managed by the security manager **/
 378         String propertyValue = (_xmlSecurityManager != null) ?
 379                 _xmlSecurityManager.getLimitAsString(name) : null;
 380         if (propertyValue != null) {
 381             return propertyValue;
 382         } else {
 383             propertyValue = (_xmlSecurityPropertyMgr != null) ?
 384                 _xmlSecurityPropertyMgr.getValue(name) : null;
 385             if (propertyValue != null) {
 386                 return propertyValue;
 387             }
 388         }
 389 
 390         // Throw an exception for all other attributes
 391         ErrorMsg err = new ErrorMsg(ErrorMsg.JAXP_INVALID_ATTR_ERR, name);
 392         throw new IllegalArgumentException(err.toString());
 393     }
 394 
 395     /**
 396      * javax.xml.transform.sax.TransformerFactory implementation.
 397      * Sets the value for a TransformerFactory attribute.
 398      *
 399      * @param name The attribute name
 400      * @param value An object representing the attribute value
 401      * @throws IllegalArgumentException
 402      */
 403     @Override
 404     public void setAttribute(String name, Object value)
 405         throws IllegalArgumentException
 406     {
 407         // Set the default translet name (ie. class name), which will be used
 408         // for translets that cannot be given a name from their system-id.
 409         if (name.equals(TRANSLET_NAME) && value instanceof String) {
 410             _transletName = (String) value;
 411             return;
 412         }
 413         else if (name.equals(DESTINATION_DIRECTORY) && value instanceof String) {
 414             _destinationDirectory = (String) value;
 415             return;
 416         }
 417         else if (name.equals(PACKAGE_NAME) && value instanceof String) {
 418             _packageName = (String) value;
 419             return;
 420         }
 421         else if (name.equals(JAR_NAME) && value instanceof String) {
 422             _jarFileName = (String) value;
 423             return;
 424         }
 425         else if (name.equals(GENERATE_TRANSLET)) {
 426             if (value instanceof Boolean) {
 427                 _generateTranslet = ((Boolean) value);
 428                 return;
 429             }
 430             else if (value instanceof String) {
 431                 _generateTranslet = ((String) value).equalsIgnoreCase("true");
 432                 return;
 433             }
 434         }
 435         else if (name.equals(AUTO_TRANSLET)) {
 436             if (value instanceof Boolean) {
 437                 _autoTranslet = ((Boolean) value);
 438                 return;
 439             }
 440             else if (value instanceof String) {
 441                 _autoTranslet = ((String) value).equalsIgnoreCase("true");
 442                 return;
 443             }
 444         }
 445         else if (name.equals(USE_CLASSPATH)) {
 446             if (value instanceof Boolean) {
 447                 _useClasspath = ((Boolean) value);
 448                 return;
 449             }
 450             else if (value instanceof String) {
 451                 _useClasspath = ((String) value).equalsIgnoreCase("true");
 452                 return;
 453             }
 454         }
 455         else if (name.equals(DEBUG)) {
 456             if (value instanceof Boolean) {
 457                 _debug = ((Boolean) value);
 458                 return;
 459             }
 460             else if (value instanceof String) {
 461                 _debug = ((String) value).equalsIgnoreCase("true");
 462                 return;
 463             }
 464         }
 465         else if (name.equals(ENABLE_INLINING)) {
 466             if (value instanceof Boolean) {
 467                 _enableInlining = ((Boolean) value);
 468                 return;
 469             }
 470             else if (value instanceof String) {
 471                 _enableInlining = ((String) value).equalsIgnoreCase("true");
 472                 return;
 473             }
 474         }
 475         else if (name.equals(INDENT_NUMBER)) {
 476             if (value instanceof String) {
 477                 try {
 478                     _indentNumber = Integer.parseInt((String) value);
 479                     return;
 480                 }
 481                 catch (NumberFormatException e) {
 482                     // Falls through
 483                 }
 484             }
 485             else if (value instanceof Integer) {
 486                 _indentNumber = ((Integer) value);
 487                 return;
 488             }
 489         }
 490         else if ( name.equals(XalanConstants.JDK_EXTENSION_CLASSLOADER)) {
 491             if (value instanceof ClassLoader) {
 492                 _extensionClassLoader = (ClassLoader) value;
 493                 return;
 494             } else {
 495                 final ErrorMsg err
 496                     = new ErrorMsg(ErrorMsg.JAXP_INVALID_ATTR_VALUE_ERR, "Extension Functions ClassLoader");
 497                 throw new IllegalArgumentException(err.toString());
 498             }
 499         } else if (JdkXmlUtils.CATALOG_FILES.equals(name)) {
 500             _catalogFiles = (String) value;
 501             cfBuilder = CatalogFeatures.builder().with(Feature.FILES, _catalogFiles);
 502             return;
 503         } else if (JdkXmlUtils.CATALOG_DEFER.equals(name)) {
 504             _catalogDefer = (String) value;
 505             cfBuilder = CatalogFeatures.builder().with(Feature.DEFER, _catalogDefer);
 506             return;
 507         } else if (JdkXmlUtils.CATALOG_PREFER.equals(name)) {
 508             _catalogPrefer = (String) value;
 509             cfBuilder = CatalogFeatures.builder().with(Feature.PREFER, _catalogPrefer);
 510             return;
 511         } else if (JdkXmlUtils.CATALOG_RESOLVE.equals(name)) {
 512             _catalogResolve = (String) value;
 513             cfBuilder = CatalogFeatures.builder().with(Feature.RESOLVE, _catalogResolve);
 514             return;
 515         } else if (JdkXmlUtils.CDATA_CHUNK_SIZE.equals(name)) {
 516             _cdataChunkSize = JdkXmlUtils.getValue(value, _cdataChunkSize);
 517             return;
 518         }
 519 
 520         if (_xmlSecurityManager != null &&
 521                 _xmlSecurityManager.setLimit(name, XMLSecurityManager.State.APIPROPERTY, value)) {
 522             return;
 523         }
 524 
 525         if (_xmlSecurityPropertyMgr != null &&
 526             _xmlSecurityPropertyMgr.setValue(name, XMLSecurityPropertyManager.State.APIPROPERTY, value)) {
 527             _accessExternalDTD = _xmlSecurityPropertyMgr.getValue(
 528                     Property.ACCESS_EXTERNAL_DTD);
 529             _accessExternalStylesheet = _xmlSecurityPropertyMgr.getValue(
 530                     Property.ACCESS_EXTERNAL_STYLESHEET);
 531             return;
 532         }
 533 
 534         // Throw an exception for all other attributes
 535         final ErrorMsg err
 536             = new ErrorMsg(ErrorMsg.JAXP_INVALID_ATTR_ERR, name);
 537         throw new IllegalArgumentException(err.toString());
 538     }
 539 
 540     /**
 541      * <p>Set a feature for this <code>TransformerFactory</code> and <code>Transformer</code>s
 542      * or <code>Template</code>s created by this factory.</p>
 543      *
 544      * <p>
 545      * Feature names are fully qualified {@link java.net.URI}s.
 546      * Implementations may define their own features.
 547      * An {@link TransformerConfigurationException} is thrown if this <code>TransformerFactory</code> or the
 548      * <code>Transformer</code>s or <code>Template</code>s it creates cannot support the feature.
 549      * It is possible for an <code>TransformerFactory</code> to expose a feature value but be unable to change its state.
 550      * </p>
 551      *
 552      * <p>See {@link javax.xml.transform.TransformerFactory} for full documentation of specific features.</p>
 553      *
 554      * @param name Feature name.
 555      * @param value Is feature state <code>true</code> or <code>false</code>.
 556      *
 557      * @throws TransformerConfigurationException if this <code>TransformerFactory</code>
 558      *   or the <code>Transformer</code>s or <code>Template</code>s it creates cannot support this feature.
 559      * @throws NullPointerException If the <code>name</code> parameter is null.
 560      */
 561     @Override
 562     public void setFeature(String name, boolean value)
 563         throws TransformerConfigurationException {
 564 
 565         // feature name cannot be null
 566         if (name == null) {
 567             ErrorMsg err = new ErrorMsg(ErrorMsg.JAXP_SET_FEATURE_NULL_NAME);
 568             throw new NullPointerException(err.toString());
 569         }
 570         // secure processing?
 571         else if (name.equals(XMLConstants.FEATURE_SECURE_PROCESSING)) {
 572             if ((_isSecureMode) && (!value)) {
 573                 ErrorMsg err = new ErrorMsg(ErrorMsg.JAXP_SECUREPROCESSING_FEATURE);
 574                 throw new TransformerConfigurationException(err.toString());
 575             }
 576             _isNotSecureProcessing = !value;
 577             _xmlSecurityManager.setSecureProcessing(value);
 578 
 579             // set external access restriction when FSP is explicitly set
 580             if (value) {
 581                 _xmlSecurityPropertyMgr.setValue(Property.ACCESS_EXTERNAL_DTD,
 582                         FeaturePropertyBase.State.FSP, XalanConstants.EXTERNAL_ACCESS_DEFAULT_FSP);
 583                 _xmlSecurityPropertyMgr.setValue(Property.ACCESS_EXTERNAL_STYLESHEET,
 584                         FeaturePropertyBase.State.FSP, XalanConstants.EXTERNAL_ACCESS_DEFAULT_FSP);
 585                 _accessExternalDTD = _xmlSecurityPropertyMgr.getValue(
 586                         Property.ACCESS_EXTERNAL_DTD);
 587                 _accessExternalStylesheet = _xmlSecurityPropertyMgr.getValue(
 588                         Property.ACCESS_EXTERNAL_STYLESHEET);
 589             }
 590 
 591             if (value && _xmlFeatures != null) {
 592                 _xmlFeatures.setFeature(JdkXmlFeatures.XmlFeature.ENABLE_EXTENSION_FUNCTION,
 593                         JdkXmlFeatures.State.FSP, false);
 594             }
 595         }
 596         else if (name.equals(XalanConstants.ORACLE_FEATURE_SERVICE_MECHANISM)) {
 597             //in secure mode, let _useServicesMechanism be determined by the constructor
 598             if (!_isSecureMode)
 599                 _useServicesMechanism = value;
 600         }
 601         else {
 602             if (_xmlFeatures != null &&
 603                     _xmlFeatures.setFeature(name, JdkXmlFeatures.State.APIPROPERTY, value)) {
 604                 return;
 605             }
 606 
 607             // unknown feature
 608             ErrorMsg err = new ErrorMsg(ErrorMsg.JAXP_UNSUPPORTED_FEATURE, name);
 609             throw new TransformerConfigurationException(err.toString());
 610         }
 611     }
 612 
 613     /**
 614      * javax.xml.transform.sax.TransformerFactory implementation.
 615      * Look up the value of a feature (to see if it is supported).
 616      * This method must be updated as the various methods and features of this
 617      * class are implemented.
 618      *
 619      * @param name The feature name
 620      * @return 'true' if feature is supported, 'false' if not
 621      */
 622     @Override
 623     public boolean getFeature(String name) {
 624         // All supported features should be listed here
 625         String[] features = {
 626             DOMSource.FEATURE,
 627             DOMResult.FEATURE,
 628             SAXSource.FEATURE,
 629             SAXResult.FEATURE,
 630             StAXSource.FEATURE,
 631             StAXResult.FEATURE,
 632             StreamSource.FEATURE,
 633             StreamResult.FEATURE,
 634             SAXTransformerFactory.FEATURE,
 635             SAXTransformerFactory.FEATURE_XMLFILTER,
 636             XalanConstants.ORACLE_FEATURE_SERVICE_MECHANISM
 637         };
 638 
 639         // feature name cannot be null
 640         if (name == null) {
 641             ErrorMsg err = new ErrorMsg(ErrorMsg.JAXP_GET_FEATURE_NULL_NAME);
 642             throw new NullPointerException(err.toString());
 643         }
 644 
 645         // Inefficient, but array is small
 646         for (int i =0; i < features.length; i++) {
 647             if (name.equals(features[i])) {
 648                 return true;
 649             }
 650         }
 651 

 652         if (name.equals(XMLConstants.FEATURE_SECURE_PROCESSING)) {
 653             return !_isNotSecureProcessing;
 654         }
 655 
 656         /** Check to see if the property is managed by the JdkXmlFeatues **/
 657         int index = _xmlFeatures.getIndex(name);
 658         if (index > -1) {
 659             return _xmlFeatures.getFeature(index);
 660         }
 661 
 662         // Feature not supported
 663         return false;
 664     }

 665     /**
 666      * Return the state of the services mechanism feature.
 667      */
 668     public boolean useServicesMechnism() {
 669         return _useServicesMechanism;
 670     }
 671 
 672      /**
 673      * @return the feature manager
 674      */
 675     public JdkXmlFeatures getJdkXmlFeatures() {
 676         return _xmlFeatures;
 677     }
 678 
 679     /**
 680      * javax.xml.transform.sax.TransformerFactory implementation.
 681      * Get the object that is used by default during the transformation to
 682      * resolve URIs used in document(), xsl:import, or xsl:include.
 683      *
 684      * @return The URLResolver used for this TransformerFactory and all
 685      * Templates and Transformer objects created using this factory
 686      */
 687     @Override
 688     public URIResolver getURIResolver() {
 689         return _uriResolver;
 690     }
 691 
 692     /**
 693      * javax.xml.transform.sax.TransformerFactory implementation.
 694      * Set the object that is used by default during the transformation to
 695      * resolve URIs used in document(), xsl:import, or xsl:include. Note that
 696      * this does not affect Templates and Transformers that are already
 697      * created with this factory.
 698      *
 699      * @param resolver The URLResolver used for this TransformerFactory and all
 700      * Templates and Transformer objects created using this factory
 701      */
 702     @Override
 703     public void setURIResolver(URIResolver resolver) {
 704         _uriResolver = resolver;
 705     }
 706 
 707     /**
 708      * javax.xml.transform.sax.TransformerFactory implementation.
 709      * Get the stylesheet specification(s) associated via the xml-stylesheet
 710      * processing instruction (see http://www.w3.org/TR/xml-stylesheet/) with
 711      * the document document specified in the source parameter, and that match
 712      * the given criteria.
 713      *
 714      * @param source The XML source document.
 715      * @param media The media attribute to be matched. May be null, in which
 716      * case the prefered templates will be used (i.e. alternate = no).
 717      * @param title The value of the title attribute to match. May be null.
 718      * @param charset The value of the charset attribute to match. May be null.
 719      * @return A Source object suitable for passing to the TransformerFactory.
 720      * @throws TransformerConfigurationException
 721      */
 722     @Override
 723     public Source  getAssociatedStylesheet(Source source, String media,
 724                                           String title, String charset)
 725         throws TransformerConfigurationException {
 726 
 727         String baseId;
 728         XMLReader reader;
 729         InputSource isource;
 730 
 731 
 732         /**
 733          * Fix for bugzilla bug 24187
 734          */
 735         StylesheetPIHandler _stylesheetPIHandler = new StylesheetPIHandler(null,media,title,charset);
 736 
 737         try {
 738 
 739             if (source instanceof DOMSource ) {
 740                 final DOMSource domsrc = (DOMSource) source;
 741                 baseId = domsrc.getSystemId();
 742                 final org.w3c.dom.Node node = domsrc.getNode();
 743                 final DOM2SAX dom2sax = new DOM2SAX(node);
 744 
 745                 _stylesheetPIHandler.setBaseId(baseId);
 746 
 747                 dom2sax.setContentHandler( _stylesheetPIHandler);
 748                 dom2sax.parse();
 749             } else {
 750                 isource = SAXSource.sourceToInputSource(source);
 751                 baseId = isource.getSystemId();
 752 
 753                 SAXParserFactory factory = FactoryImpl.getSAXFactory(_useServicesMechanism);
 754                 factory.setNamespaceAware(true);
 755 
 756                 if (!_isNotSecureProcessing) {
 757                     try {
 758                         factory.setFeature(XMLConstants.FEATURE_SECURE_PROCESSING, true);
 759                     }
 760                     catch (org.xml.sax.SAXException e) {}
 761                 }
 762 
 763                 SAXParser jaxpParser = factory.newSAXParser();
 764 
 765                 reader = jaxpParser.getXMLReader();
 766                 if (reader == null) {
 767                     reader = XMLReaderFactory.createXMLReader();
 768                 }
 769 
 770                 _stylesheetPIHandler.setBaseId(baseId);
 771                 reader.setContentHandler(_stylesheetPIHandler);
 772                 reader.parse(isource);
 773 
 774             }
 775 
 776             if (_uriResolver != null ) {
 777                 _stylesheetPIHandler.setURIResolver(_uriResolver);
 778             }
 779 
 780         } catch (StopParseException e ) {
 781           // startElement encountered so do not parse further
 782 
 783         } catch (javax.xml.parsers.ParserConfigurationException | org.xml.sax.SAXException | IOException e) {
 784              throw new TransformerConfigurationException(
 785              "getAssociatedStylesheets failed", e);
 786         }
 787 
 788          return _stylesheetPIHandler.getAssociatedStylesheet();
 789 
 790     }
 791 
 792     /**
 793      * javax.xml.transform.sax.TransformerFactory implementation.
 794      * Create a Transformer object that copies the input document to the result.
 795      *
 796      * @return A Transformer object that simply copies the source to the result.
 797      * @throws TransformerConfigurationException
 798      */
 799     @Override
 800     public Transformer newTransformer()
 801         throws TransformerConfigurationException
 802     {
 803         // create CatalogFeatures that is accessible by the Transformer
 804         // through the factory instance
 805         buildCatalogFeatures();
 806         TransformerImpl result = new TransformerImpl(new Properties(),
 807             _indentNumber, this);
 808         if (_uriResolver != null) {
 809             result.setURIResolver(_uriResolver);
 810         }
 811 
 812         if (!_isNotSecureProcessing) {
 813             result.setSecureProcessing(true);
 814         }
 815         return result;
 816     }
 817 
 818     /**
 819      * javax.xml.transform.sax.TransformerFactory implementation.
 820      * Process the Source into a Templates object, which is a a compiled
 821      * representation of the source. Note that this method should not be
 822      * used with XSLTC, as the time-consuming compilation is done for each
 823      * and every transformation.
 824      *
 825      * @return A Templates object that can be used to create Transformers.
 826      * @throws TransformerConfigurationException
 827      */
 828     @Override
 829     public Transformer newTransformer(Source source) throws
 830         TransformerConfigurationException
 831     {
 832         final Templates templates = newTemplates(source);
 833         final Transformer transformer = templates.newTransformer();
 834         if (_uriResolver != null) {
 835             transformer.setURIResolver(_uriResolver);
 836         }
 837         return(transformer);
 838     }
 839 
 840     /**
 841      * Pass warning messages from the compiler to the error listener
 842      */
 843     private void passWarningsToListener(ArrayList<ErrorMsg> messages)
 844         throws TransformerException
 845     {
 846         if (_errorListener == null || messages == null) {
 847             return;
 848         }
 849         // Pass messages to listener, one by one
 850         final int count = messages.size();
 851         for (int pos = 0; pos < count; pos++) {
 852             ErrorMsg msg = messages.get(pos);
 853             // Workaround for the TCK failure ErrorListener.errorTests.error001.
 854             if (msg.isWarningError())
 855                 _errorListener.error(
 856                     new TransformerConfigurationException(msg.toString()));
 857             else
 858                 _errorListener.warning(
 859                     new TransformerConfigurationException(msg.toString()));
 860         }
 861     }
 862 
 863     /**
 864      * Pass error messages from the compiler to the error listener
 865      */
 866     private void passErrorsToListener(ArrayList<ErrorMsg> messages) {
 867         try {
 868             if (_errorListener == null || messages == null) {
 869                 return;
 870             }
 871             // Pass messages to listener, one by one
 872             final int count = messages.size();
 873             for (int pos = 0; pos < count; pos++) {
 874                 String message = messages.get(pos).toString();
 875                 _errorListener.error(new TransformerException(message));
 876             }
 877         }
 878         catch (TransformerException e) {
 879             // nada
 880         }
 881     }
 882 
 883     /**
 884      * javax.xml.transform.sax.TransformerFactory implementation.
 885      * Process the Source into a Templates object, which is a a compiled
 886      * representation of the source.
 887      *
 888      * @param source The input stylesheet - DOMSource not supported!!!
 889      * @return A Templates object that can be used to create Transformers.
 890      * @throws TransformerConfigurationException
 891      */
 892     @Override
 893     public Templates newTemplates(Source source)
 894         throws TransformerConfigurationException
 895     {
 896         TemplatesImpl templates;
 897         // If the _useClasspath attribute is true, try to load the translet from
 898         // the CLASSPATH and create a template object using the loaded
 899         // translet.
 900         if (_useClasspath) {
 901             String transletName = getTransletBaseName(source);
 902 
 903             if (_packageName != null)
 904                 transletName = _packageName + "." + transletName;
 905 
 906             try {
 907                 final Class<?> clazz = ObjectFactory.findProviderClass(transletName, true);
 908                 resetTransientAttributes();
 909 
 910                 templates = new TemplatesImpl(new Class<?>[]{clazz}, transletName, null, _indentNumber, this);
 911                 if (_uriResolver != null) {
 912                     templates.setURIResolver(_uriResolver);
 913                 }
 914                 return templates;
 915             }
 916             catch (ClassNotFoundException cnfe) {
 917                 ErrorMsg err = new ErrorMsg(ErrorMsg.CLASS_NOT_FOUND_ERR, transletName);
 918                 throw new TransformerConfigurationException(err.toString());
 919             }
 920             catch (Exception e) {
 921                 ErrorMsg err = new ErrorMsg(
 922                                      new ErrorMsg(ErrorMsg.RUNTIME_ERROR_KEY)
 923                                      + e.getMessage());
 924                 throw new TransformerConfigurationException(err.toString());
 925             }
 926         }
 927 
 928         // If _autoTranslet is true, we will try to load the bytecodes
 929         // from the translet classes without compiling the stylesheet.
 930         if (_autoTranslet)  {
 931             byte[][] bytecodes;
 932             String transletClassName = getTransletBaseName(source);
 933 
 934             if (_packageName != null)
 935                transletClassName = _packageName + "." + transletClassName;
 936 
 937             if (_jarFileName != null)
 938                 bytecodes = getBytecodesFromJar(source, transletClassName);
 939             else
 940                 bytecodes = getBytecodesFromClasses(source, transletClassName);
 941 
 942             if (bytecodes != null) {
 943                 if (_debug) {
 944                     if (_jarFileName != null)
 945                         System.err.println(new ErrorMsg(
 946                             ErrorMsg.TRANSFORM_WITH_JAR_STR, transletClassName, _jarFileName));
 947                     else
 948                         System.err.println(new ErrorMsg(
 949                             ErrorMsg.TRANSFORM_WITH_TRANSLET_STR, transletClassName));
 950                 }
 951 
 952                 // Reset the per-session attributes to their default values
 953                 // after each newTemplates() call.
 954                 resetTransientAttributes();
 955                 templates = new TemplatesImpl(bytecodes, transletClassName, null, _indentNumber, this);
 956                 if (_uriResolver != null) {
 957                     templates.setURIResolver(_uriResolver);
 958                 }
 959                 return templates;
 960             }
 961         }
 962 
 963         // Create and initialize a stylesheet compiler
 964         final XSLTC xsltc = new XSLTC(_useServicesMechanism, _xmlFeatures);
 965         if (_debug) xsltc.setDebug(true);
 966         if (_enableInlining)
 967                 xsltc.setTemplateInlining(true);
 968         else
 969                 xsltc.setTemplateInlining(false);
 970 
 971         if (!_isNotSecureProcessing) xsltc.setSecureProcessing(true);
 972         xsltc.setProperty(XMLConstants.ACCESS_EXTERNAL_STYLESHEET, _accessExternalStylesheet);
 973         xsltc.setProperty(XMLConstants.ACCESS_EXTERNAL_DTD, _accessExternalDTD);
 974         xsltc.setProperty(XalanConstants.SECURITY_MANAGER, _xmlSecurityManager);
 975         xsltc.setProperty(XalanConstants.JDK_EXTENSION_CLASSLOADER, _extensionClassLoader);
 976 
 977         // set Catalog features
 978         buildCatalogFeatures();
 979         xsltc.setProperty(JdkXmlFeatures.CATALOG_FEATURES, _catalogFeatures);
 980 
 981         xsltc.init();
 982         if (!_isNotSecureProcessing)
 983             _xsltcExtensionFunctions = xsltc.getExternalExtensionFunctions();
 984         // Set a document loader (for xsl:include/import) if defined
 985         if (_uriResolver != null || ( _catalogFiles != null
 986                 && _xmlFeatures.getFeature(JdkXmlFeatures.XmlFeature.USE_CATALOG))) {
 987             xsltc.setSourceLoader(this);
 988         }
 989 
 990         // Pass parameters to the Parser to make sure it locates the correct
 991         // <?xml-stylesheet ...?> PI in an XML input document
 992         if ((_piParams != null) && (_piParams.get(source) != null)) {
 993             // Get the parameters for this Source object
 994             PIParamWrapper p = _piParams.get(source);
 995             // Pass them on to the compiler (which will pass then to the parser)
 996             if (p != null) {
 997                 xsltc.setPIParameters(p._media, p._title, p._charset);
 998             }
 999         }
1000 
1001         // Set the attributes for translet generation
1002         int outputType = XSLTC.BYTEARRAY_OUTPUT;
1003         if (_generateTranslet || _autoTranslet) {
1004             // Set the translet name
1005             xsltc.setClassName(getTransletBaseName(source));
1006 
1007             if (_destinationDirectory != null)
1008                 xsltc.setDestDirectory(_destinationDirectory);
1009             else {
1010                 String xslName = getStylesheetFileName(source);
1011                 if (xslName != null) {
1012                     File xslFile = new File(xslName);
1013                     String xslDir = xslFile.getParent();
1014 
1015                     if (xslDir != null)
1016                         xsltc.setDestDirectory(xslDir);
1017                 }
1018             }
1019 
1020             if (_packageName != null)
1021                 xsltc.setPackageName(_packageName);
1022 
1023             if (_jarFileName != null) {
1024                 xsltc.setJarFileName(_jarFileName);
1025                 outputType = XSLTC.BYTEARRAY_AND_JAR_OUTPUT;
1026             }
1027             else
1028                 outputType = XSLTC.BYTEARRAY_AND_FILE_OUTPUT;
1029         }
1030 
1031         // Compile the stylesheet
1032         final InputSource input = Util.getInputSource(xsltc, source);
1033         byte[][] bytecodes = xsltc.compile(null, input, outputType);
1034         final String transletName = xsltc.getClassName();
1035 
1036         // Output to the jar file if the jar file name is set.
1037         if ((_generateTranslet || _autoTranslet)
1038                 && bytecodes != null && _jarFileName != null) {
1039             try {
1040                 xsltc.outputToJar();
1041             }
1042             catch (java.io.IOException e) { }
1043         }
1044 
1045         // Reset the per-session attributes to their default values
1046         // after each newTemplates() call.
1047         resetTransientAttributes();
1048 
1049         // Pass compiler warnings to the error listener
1050         if (_errorListener != this) {
1051             try {
1052                 passWarningsToListener(xsltc.getWarnings());
1053             }
1054             catch (TransformerException e) {
1055                 throw new TransformerConfigurationException(e);
1056             }
1057         }
1058         else {
1059             xsltc.printWarnings();
1060         }
1061 
1062         // Check that the transformation went well before returning
1063         if (bytecodes == null) {
1064             ArrayList<ErrorMsg> errs = xsltc.getErrors();
1065             ErrorMsg err;
1066             if (errs != null) {
1067                 err = errs.get(errs.size()-1);
1068             } else {
1069                 err = new ErrorMsg(ErrorMsg.JAXP_COMPILE_ERR);
1070             }
1071             Throwable cause = err.getCause();
1072             TransformerConfigurationException exc;
1073             if (cause != null) {
1074                 exc =  new TransformerConfigurationException(cause.getMessage(), cause);
1075             } else {
1076                 exc =  new TransformerConfigurationException(err.toString());
1077             }
1078 
1079             // Pass compiler errors to the error listener
1080             if (_errorListener != null) {
1081                 passErrorsToListener(xsltc.getErrors());
1082 
1083                 // As required by TCK 1.2, send a fatalError to the
1084                 // error listener because compilation of the stylesheet
1085                 // failed and no further processing will be possible.
1086                 try {
1087                     _errorListener.fatalError(exc);
1088                 } catch (TransformerException te) {
1089                     // well, we tried.
1090                 }
1091             }
1092             else {
1093                 xsltc.printErrors();
1094             }
1095             throw exc;
1096         }
1097 
1098         templates = new TemplatesImpl(bytecodes, transletName, xsltc.getOutputProperties(),
1099                 _indentNumber, this);
1100         if (_uriResolver != null) {
1101             templates.setURIResolver(_uriResolver);
1102         }
1103         return templates;
1104     }
1105 
1106     /**
1107      * javax.xml.transform.sax.SAXTransformerFactory implementation.
1108      * Get a TemplatesHandler object that can process SAX ContentHandler
1109      * events into a Templates object.
1110      *
1111      * @return A TemplatesHandler object that can handle SAX events
1112      * @throws TransformerConfigurationException
1113      */
1114     @Override
1115     public TemplatesHandler newTemplatesHandler()
1116         throws TransformerConfigurationException
1117     {
1118         // create CatalogFeatures that is accessible by the Handler
1119         // through the factory instance
1120         buildCatalogFeatures();
1121         final TemplatesHandlerImpl handler =
1122             new TemplatesHandlerImpl(_indentNumber, this);
1123         if (_uriResolver != null) {
1124             handler.setURIResolver(_uriResolver);
1125         }
1126         return handler;
1127     }
1128 
1129     /**
1130      * javax.xml.transform.sax.SAXTransformerFactory implementation.
1131      * Get a TransformerHandler object that can process SAX ContentHandler
1132      * events into a Result. This method will return a pure copy transformer.
1133      *
1134      * @return A TransformerHandler object that can handle SAX events
1135      * @throws TransformerConfigurationException
1136      */
1137     @Override
1138     public TransformerHandler newTransformerHandler()
1139         throws TransformerConfigurationException
1140     {
1141         final Transformer transformer = newTransformer();
1142         if (_uriResolver != null) {
1143             transformer.setURIResolver(_uriResolver);
1144         }
1145         return new TransformerHandlerImpl((TransformerImpl) transformer);
1146     }
1147 
1148     /**
1149      * javax.xml.transform.sax.SAXTransformerFactory implementation.
1150      * Get a TransformerHandler object that can process SAX ContentHandler
1151      * events into a Result, based on the transformation instructions
1152      * specified by the argument.
1153      *
1154      * @param src The source of the transformation instructions.
1155      * @return A TransformerHandler object that can handle SAX events
1156      * @throws TransformerConfigurationException
1157      */
1158     @Override
1159     public TransformerHandler newTransformerHandler(Source src)
1160         throws TransformerConfigurationException
1161     {
1162         final Transformer transformer = newTransformer(src);
1163         if (_uriResolver != null) {
1164             transformer.setURIResolver(_uriResolver);
1165         }
1166         return new TransformerHandlerImpl((TransformerImpl) transformer);
1167     }
1168 
1169     /**
1170      * javax.xml.transform.sax.SAXTransformerFactory implementation.
1171      * Get a TransformerHandler object that can process SAX ContentHandler
1172      * events into a Result, based on the transformation instructions
1173      * specified by the argument.
1174      *
1175      * @param templates Represents a pre-processed stylesheet
1176      * @return A TransformerHandler object that can handle SAX events
1177      * @throws TransformerConfigurationException
1178      */
1179     @Override
1180     public TransformerHandler newTransformerHandler(Templates templates)
1181         throws TransformerConfigurationException
1182     {
1183         final Transformer transformer = templates.newTransformer();
1184         final TransformerImpl internal = (TransformerImpl)transformer;
1185         return new TransformerHandlerImpl(internal);
1186     }
1187 
1188     /**
1189      * javax.xml.transform.sax.SAXTransformerFactory implementation.
1190      * Create an XMLFilter that uses the given source as the
1191      * transformation instructions.
1192      *
1193      * @param src The source of the transformation instructions.
1194      * @return An XMLFilter object, or null if this feature is not supported.
1195      * @throws TransformerConfigurationException
1196      */
1197     @Override
1198     public XMLFilter newXMLFilter(Source src)
1199         throws TransformerConfigurationException
1200     {
1201         Templates templates = newTemplates(src);
1202         if (templates == null) return null;
1203         return newXMLFilter(templates);
1204     }
1205 
1206     /**
1207      * javax.xml.transform.sax.SAXTransformerFactory implementation.
1208      * Create an XMLFilter that uses the given source as the
1209      * transformation instructions.
1210      *
1211      * @param templates The source of the transformation instructions.
1212      * @return An XMLFilter object, or null if this feature is not supported.
1213      * @throws TransformerConfigurationException
1214      */
1215     @Override
1216     public XMLFilter newXMLFilter(Templates templates)
1217         throws TransformerConfigurationException
1218     {
1219         try {
1220             return new com.sun.org.apache.xalan.internal.xsltc.trax.TrAXFilter(templates);
1221         }
1222         catch (TransformerConfigurationException e1) {
1223             if (_errorListener != null) {
1224                 try {
1225                     _errorListener.fatalError(e1);
1226                     return null;
1227                 }
1228                 catch (TransformerException e2) {
1229                     new TransformerConfigurationException(e2);
1230                 }
1231             }
1232             throw e1;
1233         }
1234     }
1235 
1236     /**
1237      * Receive notification of a recoverable error.
1238      * The transformer must continue to provide normal parsing events after
1239      * invoking this method. It should still be possible for the application
1240      * to process the document through to the end.
1241      *
1242      * @param e The warning information encapsulated in a transformer
1243      * exception.
1244      * @throws TransformerException if the application chooses to discontinue
1245      * the transformation (always does in our case).
1246      */
1247     @Override
1248     public void error(TransformerException e)
1249         throws TransformerException
1250     {
1251         Throwable wrapped = e.getException();
1252         if (wrapped != null) {
1253             System.err.println(new ErrorMsg(ErrorMsg.ERROR_PLUS_WRAPPED_MSG,
1254                                             e.getMessageAndLocation(),
1255                                             wrapped.getMessage()));
1256         } else {
1257             System.err.println(new ErrorMsg(ErrorMsg.ERROR_MSG,
1258                                             e.getMessageAndLocation()));
1259         }
1260         throw e;
1261     }
1262 
1263     /**
1264      * Receive notification of a non-recoverable error.
1265      * The application must assume that the transformation cannot continue
1266      * after the Transformer has invoked this method, and should continue
1267      * (if at all) only to collect addition error messages. In fact,
1268      * Transformers are free to stop reporting events once this method has
1269      * been invoked.
1270      *
1271      * @param e warning information encapsulated in a transformer
1272      * exception.
1273      * @throws TransformerException if the application chooses to discontinue
1274      * the transformation (always does in our case).
1275      */
1276     @Override
1277     public void fatalError(TransformerException e)
1278         throws TransformerException
1279     {
1280         Throwable wrapped = e.getException();
1281         if (wrapped != null) {
1282             System.err.println(new ErrorMsg(ErrorMsg.FATAL_ERR_PLUS_WRAPPED_MSG,
1283                                             e.getMessageAndLocation(),
1284                                             wrapped.getMessage()));
1285         } else {
1286             System.err.println(new ErrorMsg(ErrorMsg.FATAL_ERR_MSG,
1287                                             e.getMessageAndLocation()));
1288         }
1289         throw e;
1290     }
1291 
1292     /**
1293      * Receive notification of a warning.
1294      * Transformers can use this method to report conditions that are not
1295      * errors or fatal errors. The default behaviour is to take no action.
1296      * After invoking this method, the Transformer must continue with the
1297      * transformation. It should still be possible for the application to
1298      * process the document through to the end.
1299      *
1300      * @param e The warning information encapsulated in a transformer
1301      * exception.
1302      * @throws TransformerException if the application chooses to discontinue
1303      * the transformation (never does in our case).
1304      */
1305     @Override
1306     public void warning(TransformerException e)
1307         throws TransformerException
1308     {
1309         Throwable wrapped = e.getException();
1310         if (wrapped != null) {
1311             System.err.println(new ErrorMsg(ErrorMsg.WARNING_PLUS_WRAPPED_MSG,
1312                                             e.getMessageAndLocation(),
1313                                             wrapped.getMessage()));
1314         } else {
1315             System.err.println(new ErrorMsg(ErrorMsg.WARNING_MSG,
1316                                             e.getMessageAndLocation()));
1317         }
1318     }
1319 
1320     /**
1321      * This method implements XSLTC's SourceLoader interface. It is used to
1322      * glue a TrAX URIResolver to the XSLTC compiler's Input and Import classes.
1323      *
1324      * @param href The URI of the document to load
1325      * @param context The URI of the currently loaded document
1326      * @param xsltc The compiler that resuests the document
1327      * @return An InputSource with the loaded document
1328      */
1329     @Override
1330     public InputSource loadSource(String href, String context, XSLTC xsltc) {
1331         try {
1332             Source source = null;
1333             if (_uriResolver != null) {
1334                 source = _uriResolver.resolve(href, context);
1335             }
1336             if (source == null && _catalogFiles != null &&
1337                     _xmlFeatures.getFeature(JdkXmlFeatures.XmlFeature.USE_CATALOG)) {
1338                 if (_catalogUriResolver == null) {
1339                     _catalogUriResolver = CatalogManager.catalogResolver(_catalogFeatures);
1340                 }
1341                 source = _catalogUriResolver.resolve(href, context);
1342             }
1343             if (source != null) {
1344                 return Util.getInputSource(xsltc, source);
1345             }
1346         }
1347         catch (TransformerException e) {
1348             // should catch it when the resolver explicitly throws the exception
1349             final ErrorMsg msg = new ErrorMsg(ErrorMsg.INVALID_URI_ERR, href + "\n" + e.getMessage(), this);
1350             xsltc.getParser().reportError(Constants.FATAL, msg);
1351         }
1352         catch (CatalogException e) {
1353             final ErrorMsg msg = new ErrorMsg(ErrorMsg.CATALOG_EXCEPTION, href + "\n" + e.getMessage(), this);
1354             xsltc.getParser().reportError(Constants.FATAL, msg);
1355         }
1356 
1357         return null;
1358     }
1359 
1360     /**
1361      * Build the CatalogFeatures object when a newTemplates or newTransformer is
1362      * created. This will read any System Properties for the CatalogFeatures that
1363      * may have been set.
1364      */
1365     private CatalogFeatures buildCatalogFeatures() {
1366         // build will cause the CatalogFeatures to read SPs for those not set through the API
1367         if (_catalogFeatures == null) {
1368             _catalogFeatures = cfBuilder.build();
1369         }
1370 
1371         // update fields
1372         _catalogFiles = _catalogFeatures.get(Feature.FILES);
1373         _catalogDefer = _catalogFeatures.get(Feature.DEFER);
1374         _catalogPrefer = _catalogFeatures.get(Feature.PREFER);
1375         _catalogResolve = _catalogFeatures.get(Feature.RESOLVE);
1376 
1377         return _catalogFeatures;
1378     }
1379 
1380     /**
1381      * Reset the per-session attributes to their default values
1382      */
1383     private void resetTransientAttributes() {
1384         _transletName = DEFAULT_TRANSLET_NAME;
1385         _destinationDirectory = null;
1386         _packageName = DEFAULT_TRANSLATE_PACKAGE;
1387         _jarFileName = null;
1388     }
1389 
1390     /**
1391      * Load the translet classes from local .class files and return
1392      * the bytecode array.
1393      *
1394      * @param source The xsl source
1395      * @param fullClassName The full name of the translet
1396      * @return The bytecode array
1397      */
1398     private byte[][] getBytecodesFromClasses(Source source, String fullClassName)
1399     {
1400         if (fullClassName == null)
1401             return null;
1402 
1403         String xslFileName = getStylesheetFileName(source);
1404         File xslFile = null;
1405         if (xslFileName != null)
1406             xslFile = new File(xslFileName);
1407 
1408         // Find the base name of the translet
1409         final String transletName;
1410         int lastDotIndex = fullClassName.lastIndexOf('.');
1411         if (lastDotIndex > 0)
1412             transletName = fullClassName.substring(lastDotIndex+1);
1413         else
1414             transletName = fullClassName;
1415 
1416         // Construct the path name for the translet class file
1417         String transletPath = fullClassName.replace('.', '/');
1418         if (_destinationDirectory != null) {
1419             transletPath = _destinationDirectory + "/" + transletPath + ".class";
1420         }
1421         else {
1422             if (xslFile != null && xslFile.getParent() != null)
1423                 transletPath = xslFile.getParent() + "/" + transletPath + ".class";
1424             else
1425                 transletPath = transletPath + ".class";
1426         }
1427 
1428         // Return null if the translet class file does not exist.
1429         File transletFile = new File(transletPath);
1430         if (!transletFile.exists())
1431             return null;
1432 
1433         // Compare the timestamps of the translet and the xsl file.
1434         // If the translet is older than the xsl file, return null
1435         // so that the xsl file is used for the transformation and
1436         // the translet is regenerated.
1437         if (xslFile != null && xslFile.exists()) {
1438             long xslTimestamp = xslFile.lastModified();
1439             long transletTimestamp = transletFile.lastModified();
1440             if (transletTimestamp < xslTimestamp)
1441                 return null;
1442         }
1443 
1444         // Load the translet into a bytecode array.
1445         Vector bytecodes = new Vector();
1446         int fileLength = (int)transletFile.length();
1447         if (fileLength > 0) {
1448             FileInputStream input;
1449             try {
1450                 input = new FileInputStream(transletFile);
1451             }
1452             catch (FileNotFoundException e) {
1453                 return null;
1454             }
1455 
1456             byte[] bytes = new byte[fileLength];
1457             try {
1458                 readFromInputStream(bytes, input, fileLength);
1459                 input.close();
1460             }
1461             catch (IOException e) {
1462                 return null;
1463             }
1464 
1465             bytecodes.addElement(bytes);
1466         }
1467         else
1468             return null;

1469 
1470         // Find the parent directory of the translet.
1471         String transletParentDir = transletFile.getParent();
1472         if (transletParentDir == null)
1473             transletParentDir = SecuritySupport.getSystemProperty("user.dir");
1474 
1475         File transletParentFile = new File(transletParentDir);
1476 
1477         // Find all the auxiliary files which have a name pattern of "transletClass$nnn.class".
1478         final String transletAuxPrefix = transletName + "$";
1479         File[] auxfiles = transletParentFile.listFiles(new FilenameFilter() {
1480                 @Override
1481                 public boolean accept(File dir, String name)
1482                 {
1483                     return (name.endsWith(".class") && name.startsWith(transletAuxPrefix));
1484                 }
1485               });
1486 
1487         // Load the auxiliary class files and add them to the bytecode array.
1488         for (int i = 0; i < auxfiles.length; i++)
1489         {
1490             File auxfile = auxfiles[i];
1491             int auxlength = (int)auxfile.length();
1492             if (auxlength > 0) {
1493                 FileInputStream auxinput = null;
1494                 try {
1495                     auxinput = new FileInputStream(auxfile);
1496                 }
1497                 catch (FileNotFoundException e) {
1498                     continue;
1499                 }
1500 
1501                 byte[] bytes = new byte[auxlength];
1502 
1503                 try {
1504                     readFromInputStream(bytes, auxinput, auxlength);
1505                     auxinput.close();
1506                 }
1507                 catch (IOException e) {
1508                     continue;
1509                 }
1510 
1511                 bytecodes.addElement(bytes);
1512             }
1513         }
1514 
1515         // Convert the Vector of byte[] to byte[][].
1516         final int count = bytecodes.size();
1517         if ( count > 0) {
1518             final byte[][] result = new byte[count][1];
1519             for (int i = 0; i < count; i++) {
1520                 result[i] = (byte[])bytecodes.elementAt(i);
1521             }
1522 
1523             return result;
1524         }
1525         else
1526             return null;
1527     }
1528 
1529     /**
1530      * Load the translet classes from the jar file and return the bytecode.
1531      *
1532      * @param source The xsl source
1533      * @param fullClassName The full name of the translet
1534      * @return The bytecode array
1535      */
1536     private byte[][] getBytecodesFromJar(Source source, String fullClassName)
1537     {
1538         String xslFileName = getStylesheetFileName(source);
1539         File xslFile = null;
1540         if (xslFileName != null)
1541             xslFile = new File(xslFileName);
1542 
1543         // Construct the path for the jar file
1544         String jarPath;
1545         if (_destinationDirectory != null)
1546             jarPath = _destinationDirectory + "/" + _jarFileName;
1547         else {
1548             if (xslFile != null && xslFile.getParent() != null)
1549                 jarPath = xslFile.getParent() + "/" + _jarFileName;
1550             else
1551                 jarPath = _jarFileName;
1552         }
1553 
1554         // Return null if the jar file does not exist.
1555         File file = new File(jarPath);
1556         if (!file.exists())
1557             return null;
1558 
1559         // Compare the timestamps of the jar file and the xsl file. Return null
1560         // if the xsl file is newer than the jar file.
1561         if (xslFile != null && xslFile.exists()) {
1562             long xslTimestamp = xslFile.lastModified();
1563             long transletTimestamp = file.lastModified();
1564             if (transletTimestamp < xslTimestamp)
1565                 return null;
1566         }
1567 
1568         // Create a ZipFile object for the jar file
1569         ZipFile jarFile;
1570         try {
1571             jarFile = new ZipFile(file);
1572         }
1573         catch (IOException e) {
1574             return null;
1575         }
1576 
1577         String transletPath = fullClassName.replace('.', '/');
1578         String transletAuxPrefix = transletPath + "$";
1579         String transletFullName = transletPath + ".class";
1580 
1581         Vector bytecodes = new Vector();
1582 
1583         // Iterate through all entries in the jar file to find the
1584         // translet and auxiliary classes.
1585         Enumeration entries = jarFile.entries();
1586         while (entries.hasMoreElements())
1587         {
1588             ZipEntry entry = (ZipEntry)entries.nextElement();
1589             String entryName = entry.getName();
1590             if (entry.getSize() > 0 &&
1591                   (entryName.equals(transletFullName) ||
1592                   (entryName.endsWith(".class") &&
1593                       entryName.startsWith(transletAuxPrefix))))
1594             {
1595                 try {
1596                     InputStream input = jarFile.getInputStream(entry);
1597                     int size = (int)entry.getSize();
1598                     byte[] bytes = new byte[size];
1599                     readFromInputStream(bytes, input, size);
1600                     input.close();
1601                     bytecodes.addElement(bytes);
1602                 }
1603                 catch (IOException e) {
1604                     return null;
1605                 }
1606             }
1607         }
1608 
1609         // Convert the Vector of byte[] to byte[][].
1610         final int count = bytecodes.size();
1611         if (count > 0) {
1612             final byte[][] result = new byte[count][1];
1613             for (int i = 0; i < count; i++) {
1614                 result[i] = (byte[])bytecodes.elementAt(i);




1615             }
1616 
1617             return result;
1618         }
1619         else
1620             return null;

1621     }
1622 
1623     /**
1624      * Read a given number of bytes from the InputStream into a byte array.
1625      *
1626      * @param bytes The byte array to store the input content.
1627      * @param input The input stream.
1628      * @param size The number of bytes to read.
1629      */
1630     private void readFromInputStream(byte[] bytes, InputStream input, int size)
1631         throws IOException
1632     {
1633       int n = 0;
1634       int offset = 0;
1635       int length = size;
1636       while (length > 0 && (n = input.read(bytes, offset, length)) > 0) {
1637           offset = offset + n;
1638           length = length - n;
1639       }
1640     }
1641 
1642     /**
1643      * Return the base class name of the translet.
1644      * The translet name is resolved using the following rules:
1645      * 1. if the _transletName attribute is set and its value is not "GregorSamsa",
1646      *    then _transletName is returned.
1647      * 2. otherwise get the translet name from the base name of the system ID
1648      * 3. return "GregorSamsa" if the result from step 2 is null.
1649      *
1650      * @param source The input Source
1651      * @return The name of the translet class
1652      */
1653     private String getTransletBaseName(Source source)
1654     {
1655         String transletBaseName = null;
1656         if (!_transletName.equals(DEFAULT_TRANSLET_NAME))
1657             return _transletName;
1658         else {
1659             String systemId = source.getSystemId();
1660             if (systemId != null) {
1661                 String baseName = Util.baseName(systemId);
1662                 if (baseName != null) {
1663                     baseName = Util.noExtName(baseName);
1664                     transletBaseName = Util.toJavaName(baseName);
1665                 }
1666             }
1667         }
1668 
1669         return (transletBaseName != null) ? transletBaseName : DEFAULT_TRANSLET_NAME;
1670     }
1671 
1672     /**
1673      *  Return the local file name from the systemId of the Source object
1674      *
1675      * @param source The Source
1676      * @return The file name in the local filesystem, or null if the
1677      * systemId does not represent a local file.
1678      */
1679     private String getStylesheetFileName(Source source)
1680     {
1681         String systemId = source.getSystemId();
1682         if (systemId != null) {
1683             File file = new File(systemId);
1684             if (file.exists())
1685                 return systemId;
1686             else {
1687                 URL url;
1688                 try {
1689                     url = new URL(systemId);
1690                 }
1691                 catch (MalformedURLException e) {
1692                     return null;
1693                 }
1694 
1695                 if ("file".equals(url.getProtocol()))
1696                     return url.getFile();
1697                 else
1698                     return null;
1699             }
1700         }
1701         else
1702             return null;

1703     }
1704 
1705     /**
1706      * Returns a new instance of the XSLTC DTM Manager service.
1707      */
1708     protected final XSLTCDTMManager createNewDTMManagerInstance() {
1709         return XSLTCDTMManager.createNewDTMManagerInstance();
1710     }
1711 }
--- EOF ---