import net.sf.saxon.lib.FeatureKeys; //导入依赖的package包/类
/**
 * Constructs a new GauloisPipe.
 * This constructor is the main one, the other one is only for backward compatibility.
 * @param configurationFactory The configuration factory to use
 * @throws fr.efl.chaine.xslt.InvalidSyntaxException
 */
@SuppressWarnings("OverridableMethodCallInConstructor")
public GauloisPipe(final SaxonConfigurationFactory configurationFactory) throws InvalidSyntaxException {
    super();
    if(!protocolInstalled) {
        ProtocolInstaller.registerAdditionalProtocols();
        protocolInstalled = true;
    }
    this.configurationFactory = configurationFactory;
    Configuration saxonConfig=configurationFactory.getConfiguration();
    saxonConfig.setURIResolver(getUriResolver());
    // issue #30
    if(getEntityResolver() != null) {
        saxonConfig.setConfigurationProperty(FeatureKeys.ENTITY_RESOLVER_CLASS, getEntityResolver().getClass().getName());
    }
    xslCache = new HashMap<>();
    try {
        datatypeFactory = DatatypeFactory.getInstance(saxonConfig);
        xmlDatatypeFactory = javax.xml.datatype.DatatypeFactory.newInstance();
    } catch(ValidationException | DatatypeConfigurationException ex) {
        throw new InvalidSyntaxException(ex);
    }
}
 

import net.sf.saxon.lib.FeatureKeys; //导入依赖的package包/类
private Configuration createConfiguration() throws IOException {
  File licenseFile = new File(Context.getInstance().getHomeDir(), "config/saxon-license.lic");
  String className = "net.sf.saxon.Configuration";
  String edition = "HE";
  if (licenseFile.isFile()) {
    Properties props = XSLWebUtils.readProperties(licenseFile);
    edition = props.getProperty("Edition", edition);
    if (edition.equals("PE")) {
      className = "com.saxonica.config.ProfessionalConfiguration";
    } else if (edition.equals("EE")) {
      className = "com.saxonica.config.EnterpriseConfiguration";
    }
    logger.info("Creating Saxon " + edition + " configuration ...");
    this.config = Configuration.makeLicensedConfiguration(this.getClass().getClassLoader(), className);
    config.setConfigurationProperty(FeatureKeys.LICENSE_FILE_LOCATION, licenseFile.getAbsolutePath());
  } else {
    logger.info("Creating Saxon " + edition + " configuration ...");
    this.config = new Configuration();
  }
  return config;
}
 

import net.sf.saxon.lib.FeatureKeys; //导入依赖的package包/类
public static TransformerFactory createTransformerFactory() {
  final TransformerFactoryImpl factory = new TransformerFactoryImpl();
  factory.setAttribute(FeatureKeys.TRACE_LISTENER, new Saxon9TraceListener());
  try {
    factory.setAttribute(FeatureKeys.OPTIMIZATION_LEVEL, "0");
  } catch (IllegalArgumentException e) {
    e.printStackTrace();
  }
  return factory;
}
 

import net.sf.saxon.lib.FeatureKeys; //导入依赖的package包/类
public void initTransformerFactory(TransformerFactory factory) {
  try {
    factory.setAttribute(FeatureKeys.XSLT_VERSION, "2.0");
  } catch (IllegalArgumentException e) {
    // The old Saxon 9 (pre HE/PE/EE) throws this exception.
  }
  factory.setAttribute(FeatureKeys.LINE_NUMBERING, Boolean.TRUE);
  factory.setAttribute(FeatureKeys.VERSION_WARNING, Boolean.FALSE);
}
 

import net.sf.saxon.lib.FeatureKeys; //导入依赖的package包/类
@Override
protected void doAdditionalConfiguration(Processor processor) {
    Configuration configuration = processor.getUnderlyingConfiguration();
    configuration.setBooleanProperty(FeatureKeys.EAGER_EVALUATION, true);
    StaticQueryContext context = configuration.getDefaultStaticQueryContext();
    configuration.setTraceListener(new SaxonTraceListener(this));
    context.setCodeInjector(new SaxonExtendedTraceCodeInjector());
    Optimizer optimizer = configuration.obtainOptimizer();
    optimizer.setOptimizationLevel(Optimizer.NO_OPTIMIZATION);
}
 

import net.sf.saxon.lib.FeatureKeys; //导入依赖的package包/类
public void setXsltVersion(String xsltVersion) {
    this.setConfigurationProperty(FeatureKeys.XSLT_VERSION, xsltVersion);
}
 

import net.sf.saxon.lib.FeatureKeys; //导入依赖的package包/类
/**
 * Create a new {@link TransformerFactory} trying to invoke the Saxon
 * implementation first using the class
 * {@value #SAXON_TRANSFORMER_FACTORY_CLASS}.
 *
 * @param aClassLoader
 *        The optional class loader to be used. May be <code>null</code>.
 * @param aErrorListener
 *        An optional XSLT error listener to be used. May be
 *        <code>null</code>.
 * @param aURIResolver
 *        An optional XSLT URI resolver to be used. May be <code>null</code>.
 * @return A new {@link TransformerFactory} and not <code>null</code>.
 * @throws InitializationException
 *         In case initialization fails.
 */
@Nonnull
public static TransformerFactory createTransformerFactorySaxonFirst (@Nullable final ClassLoader aClassLoader,
                                                                     @Nullable final ErrorListener aErrorListener,
                                                                     @Nullable final URIResolver aURIResolver)
{
  TransformerFactory aFactory;
  try
  {
    // Try Saxon first
    final ClassLoader aEffectiveClassLoader = aClassLoader != null ? aClassLoader
                                                                   : ClassLoaderHelper.getContextClassLoader ();
    aFactory = TransformerFactory.newInstance (SAXON_TRANSFORMER_FACTORY_CLASS, aEffectiveClassLoader);

    // Debug/testing only
    if (false)
      aFactory.setFeature (FeatureKeys.TRACE_OPTIMIZER_DECISIONS, true);
    if (false)
      aFactory.setFeature (FeatureKeys.COMPILE_WITH_TRACING, true);
    if (false)
      aFactory.setAttribute (FeatureKeys.XSLT_VERSION, "2.0");
  }
  catch (final TransformerFactoryConfigurationError | TransformerConfigurationException ex)
  {
    try
    {
      // Try default afterwards
      aFactory = TransformerFactory.newInstance ();
    }
    catch (final TransformerFactoryConfigurationError ex2)
    {
      throw new InitializationException ("Failed to create XML TransformerFactory", ex2);
    }
  }

  if (aErrorListener != null)
    aFactory.setErrorListener (aErrorListener);
  if (aURIResolver != null)
    aFactory.setURIResolver (aURIResolver);
  return aFactory;
}
 

import net.sf.saxon.lib.FeatureKeys; //导入依赖的package包/类
/**
 * Creates and configures an instance of the default TransformerFactory
 * implementation.
 */
public static TransformerFactory newTransformerFactory() {

	TransformerFactory factory = new net.sf.saxon.TransformerFactoryImpl();

	factory.setAttribute(FeatureKeys.XINCLUDE, PrimedTransformer.SET_XINCLUDE_AWARE);
	factory.setAttribute(FeatureKeys.VALIDATION_WARNINGS, !PrimedTransformer.SET_VALIDATING);

	return factory;

}