| /* |
| * Licensed to the Apache Software Foundation (ASF) under one |
| * or more contributor license agreements. See the NOTICE file |
| * distributed with this work for additional information |
| * regarding copyright ownership. The ASF licenses this file |
| * to you under the Apache License, Version 2.0 (the "License"); |
| * you may not use this file except in compliance with the License. |
| * You may obtain a copy of the License at |
| * |
| * http://www.apache.org/licenses/LICENSE-2.0 |
| * |
| * Unless required by applicable law or agreed to in writing, software |
| * distributed under the License is distributed on an "AS IS" BASIS, |
| * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. |
| * See the License for the specific language governing permissions and |
| * limitations under the License. |
| */ |
| /* |
| * $Id$ |
| */ |
| package org.apache.xalan.processor; |
| |
| import java.io.BufferedInputStream; |
| import java.io.IOException; |
| import java.io.InputStream; |
| import java.util.Enumeration; |
| import java.util.Properties; |
| |
| import javax.xml.XMLConstants; |
| import javax.xml.transform.ErrorListener; |
| import javax.xml.transform.Source; |
| import javax.xml.transform.Templates; |
| import javax.xml.transform.Transformer; |
| import javax.xml.transform.TransformerConfigurationException; |
| import javax.xml.transform.TransformerException; |
| import javax.xml.transform.URIResolver; |
| import javax.xml.transform.dom.DOMResult; |
| import javax.xml.transform.dom.DOMSource; |
| import javax.xml.transform.sax.SAXResult; |
| import javax.xml.transform.sax.SAXSource; |
| import javax.xml.transform.sax.SAXTransformerFactory; |
| import javax.xml.transform.sax.TemplatesHandler; |
| import javax.xml.transform.sax.TransformerHandler; |
| import javax.xml.transform.stream.StreamResult; |
| import javax.xml.transform.stream.StreamSource; |
| |
| import org.apache.xalan.res.XSLMessages; |
| import org.apache.xalan.res.XSLTErrorResources; |
| import org.apache.xalan.transformer.TrAXFilter; |
| import org.apache.xalan.transformer.TransformerIdentityImpl; |
| import org.apache.xalan.transformer.TransformerImpl; |
| import org.apache.xalan.transformer.XalanProperties; |
| |
| import org.apache.xml.dtm.ref.sax2dtm.SAX2DTM; |
| import org.apache.xml.utils.DefaultErrorHandler; |
| import org.apache.xml.utils.SystemIDResolver; |
| import org.apache.xml.utils.TreeWalker; |
| import org.apache.xml.utils.StylesheetPIHandler; |
| import org.apache.xml.utils.StopParseException; |
| |
| import org.w3c.dom.Node; |
| |
| import org.xml.sax.InputSource; |
| import org.xml.sax.XMLFilter; |
| import org.xml.sax.XMLReader; |
| import org.xml.sax.helpers.XMLReaderFactory; |
| |
| /** |
| * The TransformerFactoryImpl, which implements the TRaX TransformerFactory |
| * interface, processes XSLT stylesheets into a Templates object |
| * (a StylesheetRoot). |
| */ |
| public class TransformerFactoryImpl extends SAXTransformerFactory |
| { |
| /** |
| * The path/filename of the property file: XSLTInfo.properties |
| * Maintenance note: see also |
| * <code>org.apache.xpath.functions.FuncSystemProperty.XSLT_PROPERTIES</code> |
| */ |
| public static final String XSLT_PROPERTIES = |
| "org/apache/xalan/res/XSLTInfo.properties"; |
| |
| /** |
| * <p>State of secure processing feature.</p> |
| */ |
| private boolean m_isSecureProcessing = false; |
| |
| /** |
| * Constructor TransformerFactoryImpl |
| * |
| */ |
| public TransformerFactoryImpl() |
| { |
| } |
| |
| /** Static string to be used for incremental feature */ |
| public static final String FEATURE_INCREMENTAL = |
| "http://xml.apache.org/xalan/features/incremental"; |
| |
| /** Static string to be used for optimize feature */ |
| public static final String FEATURE_OPTIMIZE = |
| "http://xml.apache.org/xalan/features/optimize"; |
| |
| /** Static string to be used for source_location feature */ |
| public static final String FEATURE_SOURCE_LOCATION = |
| XalanProperties.SOURCE_LOCATION; |
| |
| public javax.xml.transform.Templates processFromNode(Node node) |
| throws TransformerConfigurationException |
| { |
| |
| try |
| { |
| TemplatesHandler builder = newTemplatesHandler(); |
| TreeWalker walker = new TreeWalker(builder, |
| new org.apache.xml.utils.DOM2Helper(), |
| builder.getSystemId()); |
| |
| walker.traverse(node); |
| |
| return builder.getTemplates(); |
| } |
| catch (org.xml.sax.SAXException se) |
| { |
| if (m_errorListener != null) |
| { |
| try |
| { |
| m_errorListener.fatalError(new TransformerException(se)); |
| } |
| catch (TransformerConfigurationException ex) |
| { |
| throw ex; |
| } |
| catch (TransformerException ex) |
| { |
| throw new TransformerConfigurationException(ex); |
| } |
| |
| return null; |
| } |
| else |
| { |
| |
| // Should remove this later... but right now diagnostics from |
| // TransformerConfigurationException are not good. |
| // se.printStackTrace(); |
| throw new TransformerConfigurationException(XSLMessages.createMessage(XSLTErrorResources.ER_PROCESSFROMNODE_FAILED, null), se); |
| //"processFromNode failed", se); |
| } |
| } |
| catch (TransformerConfigurationException tce) |
| { |
| // Assume it's already been reported to the error listener. |
| throw tce; |
| } |
| /* catch (TransformerException tce) |
| { |
| // Assume it's already been reported to the error listener. |
| throw new TransformerConfigurationException(tce.getMessage(), tce); |
| }*/ |
| catch (Exception e) |
| { |
| if (m_errorListener != null) |
| { |
| try |
| { |
| m_errorListener.fatalError(new TransformerException(e)); |
| } |
| catch (TransformerConfigurationException ex) |
| { |
| throw ex; |
| } |
| catch (TransformerException ex) |
| { |
| throw new TransformerConfigurationException(ex); |
| } |
| |
| return null; |
| } |
| else |
| { |
| // Should remove this later... but right now diagnostics from |
| // TransformerConfigurationException are not good. |
| // se.printStackTrace(); |
| throw new TransformerConfigurationException(XSLMessages.createMessage(XSLTErrorResources.ER_PROCESSFROMNODE_FAILED, null), e); //"processFromNode failed", |
| //e); |
| } |
| } |
| } |
| |
| /** |
| * The systemID that was specified in |
| * processFromNode(Node node, String systemID). |
| */ |
| private String m_DOMsystemID = null; |
| |
| /** |
| * The systemID that was specified in |
| * processFromNode(Node node, String systemID). |
| * |
| * @return The systemID, or null. |
| */ |
| String getDOMsystemID() |
| { |
| return m_DOMsystemID; |
| } |
| |
| /** |
| * Process the stylesheet from a DOM tree, if the |
| * processor supports the "http://xml.org/trax/features/dom/input" |
| * feature. |
| * |
| * @param node A DOM tree which must contain |
| * valid transform instructions that this processor understands. |
| * @param systemID The systemID from where xsl:includes and xsl:imports |
| * should be resolved from. |
| * |
| * @return A Templates object capable of being used for transformation purposes. |
| * |
| * @throws TransformerConfigurationException |
| */ |
| javax.xml.transform.Templates processFromNode(Node node, String systemID) |
| throws TransformerConfigurationException |
| { |
| |
| m_DOMsystemID = systemID; |
| |
| return processFromNode(node); |
| } |
| |
| /** |
| * Get InputSource specification(s) that are associated with the |
| * given document specified in the source param, |
| * via the xml-stylesheet processing instruction |
| * (see http://www.w3.org/TR/xml-stylesheet/), and that matches |
| * the given criteria. Note that it is possible to return several stylesheets |
| * that match the criteria, in which case they are applied as if they were |
| * a list of imports or cascades. |
| * |
| * <p>Note that DOM2 has it's own mechanism for discovering stylesheets. |
| * Therefore, there isn't a DOM version of this method.</p> |
| * |
| * |
| * @param source The XML source that is to be searched. |
| * @param media The media attribute to be matched. May be null, in which |
| * case the prefered templates will be used (i.e. alternate = no). |
| * @param title The value of the title attribute to match. May be null. |
| * @param charset The value of the charset attribute to match. May be null. |
| * |
| * @return A Source object capable of being used to create a Templates object. |
| * |
| * @throws TransformerConfigurationException |
| */ |
| public Source getAssociatedStylesheet( |
| Source source, String media, String title, String charset) |
| throws TransformerConfigurationException |
| { |
| |
| String baseID; |
| InputSource isource = null; |
| Node node = null; |
| XMLReader reader = null; |
| |
| if (source instanceof DOMSource) |
| { |
| DOMSource dsource = (DOMSource) source; |
| |
| node = dsource.getNode(); |
| baseID = dsource.getSystemId(); |
| } |
| else |
| { |
| isource = SAXSource.sourceToInputSource(source); |
| baseID = isource.getSystemId(); |
| } |
| |
| // What I try to do here is parse until the first startElement |
| // is found, then throw a special exception in order to terminate |
| // the parse. |
| StylesheetPIHandler handler = new StylesheetPIHandler(baseID, media, |
| title, charset); |
| |
| // Use URIResolver. Patch from Dmitri Ilyin |
| if (m_uriResolver != null) |
| { |
| handler.setURIResolver(m_uriResolver); |
| } |
| |
| try |
| { |
| if (null != node) |
| { |
| TreeWalker walker = new TreeWalker(handler, new org.apache.xml.utils.DOM2Helper(), baseID); |
| |
| walker.traverse(node); |
| } |
| else |
| { |
| |
| // Use JAXP1.1 ( if possible ) |
| try |
| { |
| javax.xml.parsers.SAXParserFactory factory = |
| javax.xml.parsers.SAXParserFactory.newInstance(); |
| |
| factory.setNamespaceAware(true); |
| |
| if (m_isSecureProcessing) |
| { |
| try |
| { |
| factory.setFeature(XMLConstants.FEATURE_SECURE_PROCESSING, true); |
| } |
| catch (org.xml.sax.SAXException e) {} |
| } |
| |
| javax.xml.parsers.SAXParser jaxpParser = factory.newSAXParser(); |
| |
| reader = jaxpParser.getXMLReader(); |
| } |
| catch (javax.xml.parsers.ParserConfigurationException ex) |
| { |
| throw new org.xml.sax.SAXException(ex); |
| } |
| catch (javax.xml.parsers.FactoryConfigurationError ex1) |
| { |
| throw new org.xml.sax.SAXException(ex1.toString()); |
| } |
| catch (NoSuchMethodError ex2){} |
| catch (AbstractMethodError ame){} |
| |
| if (null == reader) |
| { |
| reader = XMLReaderFactory.createXMLReader(); |
| } |
| |
| // Need to set options! |
| reader.setContentHandler(handler); |
| reader.parse(isource); |
| } |
| } |
| catch (StopParseException spe) |
| { |
| |
| // OK, good. |
| } |
| catch (org.xml.sax.SAXException se) |
| { |
| throw new TransformerConfigurationException( |
| "getAssociatedStylesheets failed", se); |
| } |
| catch (IOException ioe) |
| { |
| throw new TransformerConfigurationException( |
| "getAssociatedStylesheets failed", ioe); |
| } |
| |
| return handler.getAssociatedStylesheet(); |
| } |
| |
| /** |
| * Create a new Transformer object that performs a copy |
| * of the source to the result. |
| * |
| * @return A Transformer object that may be used to perform a transformation |
| * in a single thread, never null. |
| * |
| * @throws TransformerConfigurationException May throw this during |
| * the parse when it is constructing the |
| * Templates object and fails. |
| */ |
| public TemplatesHandler newTemplatesHandler() |
| throws TransformerConfigurationException |
| { |
| return new StylesheetHandler(this); |
| } |
| |
| /** |
| * <p>Set a feature for this <code>TransformerFactory</code> and <code>Transformer</code>s |
| * or <code>Template</code>s created by this factory.</p> |
| * |
| * <p> |
| * Feature names are fully qualified {@link java.net.URI}s. |
| * Implementations may define their own features. |
| * An {@link TransformerConfigurationException} is thrown if this <code>TransformerFactory</code> or the |
| * <code>Transformer</code>s or <code>Template</code>s it creates cannot support the feature. |
| * It is possible for an <code>TransformerFactory</code> to expose a feature value but be unable to change its state. |
| * </p> |
| * |
| * <p>See {@link javax.xml.transform.TransformerFactory} for full documentation of specific features.</p> |
| * |
| * @param name Feature name. |
| * @param value Is feature state <code>true</code> or <code>false</code>. |
| * |
| * @throws TransformerConfigurationException if this <code>TransformerFactory</code> |
| * or the <code>Transformer</code>s or <code>Template</code>s it creates cannot support this feature. |
| * @throws NullPointerException If the <code>name</code> parameter is null. |
| */ |
| public void setFeature(String name, boolean value) |
| throws TransformerConfigurationException { |
| |
| // feature name cannot be null |
| if (name == null) { |
| throw new NullPointerException( |
| XSLMessages.createMessage( |
| XSLTErrorResources.ER_SET_FEATURE_NULL_NAME, null)); |
| } |
| |
| // secure processing? |
| if (name.equals(XMLConstants.FEATURE_SECURE_PROCESSING)) { |
| m_isSecureProcessing = value; |
| } |
| // This implementation does not support the setting of a feature other than |
| // the secure processing feature. |
| else |
| { |
| throw new TransformerConfigurationException( |
| XSLMessages.createMessage( |
| XSLTErrorResources.ER_UNSUPPORTED_FEATURE, |
| new Object[] {name})); |
| } |
| } |
| |
| /** |
| * Look up the value of a feature. |
| * <p>The feature name is any fully-qualified URI. It is |
| * possible for an TransformerFactory to recognize a feature name but |
| * to be unable to return its value; this is especially true |
| * in the case of an adapter for a SAX1 Parser, which has |
| * no way of knowing whether the underlying parser is |
| * validating, for example.</p> |
| * |
| * @param name The feature name, which is a fully-qualified URI. |
| * @return The current state of the feature (true or false). |
| */ |
| public boolean getFeature(String name) { |
| |
| // feature name cannot be null |
| if (name == null) |
| { |
| throw new NullPointerException( |
| XSLMessages.createMessage( |
| XSLTErrorResources.ER_GET_FEATURE_NULL_NAME, null)); |
| } |
| |
| // Try first with identity comparison, which |
| // will be faster. |
| if ((DOMResult.FEATURE == name) || (DOMSource.FEATURE == name) |
| || (SAXResult.FEATURE == name) || (SAXSource.FEATURE == name) |
| || (StreamResult.FEATURE == name) |
| || (StreamSource.FEATURE == name) |
| || (SAXTransformerFactory.FEATURE == name) |
| || (SAXTransformerFactory.FEATURE_XMLFILTER == name)) |
| return true; |
| else if ((DOMResult.FEATURE.equals(name)) |
| || (DOMSource.FEATURE.equals(name)) |
| || (SAXResult.FEATURE.equals(name)) |
| || (SAXSource.FEATURE.equals(name)) |
| || (StreamResult.FEATURE.equals(name)) |
| || (StreamSource.FEATURE.equals(name)) |
| || (SAXTransformerFactory.FEATURE.equals(name)) |
| || (SAXTransformerFactory.FEATURE_XMLFILTER.equals(name))) |
| return true; |
| // secure processing? |
| else if (name.equals(XMLConstants.FEATURE_SECURE_PROCESSING)) |
| return m_isSecureProcessing; |
| else |
| // unknown feature |
| return false; |
| } |
| |
| /** |
| * Flag set by FEATURE_OPTIMIZE. |
| * This feature specifies whether to Optimize stylesheet processing. By |
| * default it is set to true. |
| */ |
| private boolean m_optimize = true; |
| |
| /** Flag set by FEATURE_SOURCE_LOCATION. |
| * This feature specifies whether the transformation phase should |
| * keep track of line and column numbers for the input source |
| * document. Note that this works only when that |
| * information is available from the source -- in other words, if you |
| * pass in a DOM, there's little we can do for you. |
| * |
| * The default is false. Setting it true may significantly |
| * increase storage cost per node. |
| */ |
| private boolean m_source_location = false; |
| |
| /** |
| * Flag set by FEATURE_INCREMENTAL. |
| * This feature specifies whether to produce output incrementally, rather than |
| * waiting to finish parsing the input before generating any output. By |
| * default this attribute is set to false. |
| */ |
| private boolean m_incremental = false; |
| |
| /** |
| * Allows the user to set specific attributes on the underlying |
| * implementation. |
| * |
| * @param name The name of the attribute. |
| * @param value The value of the attribute; Boolean or String="true"|"false" |
| * |
| * @throws IllegalArgumentException thrown if the underlying |
| * implementation doesn't recognize the attribute. |
| */ |
| public void setAttribute(String name, Object value) |
| throws IllegalArgumentException |
| { |
| if (name.equals(FEATURE_INCREMENTAL)) |
| { |
| if(value instanceof Boolean) |
| { |
| // Accept a Boolean object.. |
| m_incremental = ((Boolean)value).booleanValue(); |
| } |
| else if(value instanceof String) |
| { |
| // .. or a String object |
| m_incremental = (new Boolean((String)value)).booleanValue(); |
| } |
| else |
| { |
| // Give a more meaningful error message |
| throw new IllegalArgumentException(XSLMessages.createMessage(XSLTErrorResources.ER_BAD_VALUE, new Object[]{name, value})); //name + " bad value " + value); |
| } |
| } |
| else if (name.equals(FEATURE_OPTIMIZE)) |
| { |
| if(value instanceof Boolean) |
| { |
| // Accept a Boolean object.. |
| m_optimize = ((Boolean)value).booleanValue(); |
| } |
| else if(value instanceof String) |
| { |
| // .. or a String object |
| m_optimize = (new Boolean((String)value)).booleanValue(); |
| } |
| else |
| { |
| // Give a more meaningful error message |
| throw new IllegalArgumentException(XSLMessages.createMessage(XSLTErrorResources.ER_BAD_VALUE, new Object[]{name, value})); //name + " bad value " + value); |
| } |
| } |
| |
| // Custom Xalan feature: annotate DTM with SAX source locator fields. |
| // This gets used during SAX2DTM instantiation. |
| // |
| // %REVIEW% Should the name of this field really be in XalanProperties? |
| // %REVIEW% I hate that it's a global static, but didn't want to change APIs yet. |
| else if(name.equals(FEATURE_SOURCE_LOCATION)) |
| { |
| if(value instanceof Boolean) |
| { |
| // Accept a Boolean object.. |
| m_source_location = ((Boolean)value).booleanValue(); |
| } |
| else if(value instanceof String) |
| { |
| // .. or a String object |
| m_source_location = (new Boolean((String)value)).booleanValue(); |
| } |
| else |
| { |
| // Give a more meaningful error message |
| throw new IllegalArgumentException(XSLMessages.createMessage(XSLTErrorResources.ER_BAD_VALUE, new Object[]{name, value})); //name + " bad value " + value); |
| } |
| } |
| |
| else |
| { |
| throw new IllegalArgumentException(XSLMessages.createMessage(XSLTErrorResources.ER_NOT_SUPPORTED, new Object[]{name})); //name + "not supported"); |
| } |
| } |
| |
| /** |
| * Allows the user to retrieve specific attributes on the underlying |
| * implementation. |
| * |
| * @param name The name of the attribute. |
| * @return value The value of the attribute. |
| * |
| * @throws IllegalArgumentException thrown if the underlying |
| * implementation doesn't recognize the attribute. |
| */ |
| public Object getAttribute(String name) throws IllegalArgumentException |
| { |
| if (name.equals(FEATURE_INCREMENTAL)) |
| { |
| return new Boolean(m_incremental); |
| } |
| else if (name.equals(FEATURE_OPTIMIZE)) |
| { |
| return new Boolean(m_optimize); |
| } |
| else if (name.equals(FEATURE_SOURCE_LOCATION)) |
| { |
| return new Boolean(m_source_location); |
| } |
| else |
| throw new IllegalArgumentException(XSLMessages.createMessage(XSLTErrorResources.ER_ATTRIB_VALUE_NOT_RECOGNIZED, new Object[]{name})); //name + " attribute not recognized"); |
| } |
| |
| /** |
| * Create an XMLFilter that uses the given source as the |
| * transformation instructions. |
| * |
| * @param src The source of the transformation instructions. |
| * |
| * @return An XMLFilter object, or null if this feature is not supported. |
| * |
| * @throws TransformerConfigurationException |
| */ |
| public XMLFilter newXMLFilter(Source src) |
| throws TransformerConfigurationException |
| { |
| |
| Templates templates = newTemplates(src); |
| if( templates==null ) return null; |
| |
| return newXMLFilter(templates); |
| } |
| |
| /** |
| * Create an XMLFilter that uses the given source as the |
| * transformation instructions. |
| * |
| * @param templates non-null reference to Templates object. |
| * |
| * @return An XMLFilter object, or null if this feature is not supported. |
| * |
| * @throws TransformerConfigurationException |
| */ |
| public XMLFilter newXMLFilter(Templates templates) |
| throws TransformerConfigurationException |
| { |
| try |
| { |
| return new TrAXFilter(templates); |
| } |
| catch( TransformerConfigurationException ex ) |
| { |
| if( m_errorListener != null) |
| { |
| try |
| { |
| m_errorListener.fatalError( ex ); |
| return null; |
| } |
| catch( TransformerConfigurationException ex1 ) |
| { |
| throw ex1; |
| } |
| catch( TransformerException ex1 ) |
| { |
| throw new TransformerConfigurationException(ex1); |
| } |
| } |
| throw ex; |
| } |
| } |
| |
| /** |
| * Get a TransformerHandler object that can process SAX |
| * ContentHandler events into a Result, based on the transformation |
| * instructions specified by the argument. |
| * |
| * @param src The source of the transformation instructions. |
| * |
| * @return TransformerHandler ready to transform SAX events. |
| * |
| * @throws TransformerConfigurationException |
| */ |
| public TransformerHandler newTransformerHandler(Source src) |
| throws TransformerConfigurationException |
| { |
| |
| Templates templates = newTemplates(src); |
| if( templates==null ) return null; |
| |
| return newTransformerHandler(templates); |
| } |
| |
| /** |
| * Get a TransformerHandler object that can process SAX |
| * ContentHandler events into a Result, based on the Templates argument. |
| * |
| * @param templates The source of the transformation instructions. |
| * |
| * @return TransformerHandler ready to transform SAX events. |
| * @throws TransformerConfigurationException |
| */ |
| public TransformerHandler newTransformerHandler(Templates templates) |
| throws TransformerConfigurationException |
| { |
| try { |
| TransformerImpl transformer = |
| (TransformerImpl) templates.newTransformer(); |
| transformer.setURIResolver(m_uriResolver); |
| TransformerHandler th = |
| (TransformerHandler) transformer.getInputContentHandler(true); |
| |
| return th; |
| } |
| catch( TransformerConfigurationException ex ) |
| { |
| if( m_errorListener != null ) |
| { |
| try |
| { |
| m_errorListener.fatalError( ex ); |
| return null; |
| } |
| catch (TransformerConfigurationException ex1 ) |
| { |
| throw ex1; |
| } |
| catch (TransformerException ex1 ) |
| { |
| throw new TransformerConfigurationException(ex1); |
| } |
| } |
| |
| throw ex; |
| } |
| |
| } |
| |
| // /** The identity transform string, for support of newTransformerHandler() |
| // * and newTransformer(). */ |
| // private static final String identityTransform = |
| // "<xsl:stylesheet " + "xmlns:xsl='http://www.w3.org/1999/XSL/Transform' " |
| // + "version='1.0'>" + "<xsl:template match='/|node()'>" |
| // + "<xsl:copy-of select='.'/>" + "</xsl:template>" + "</xsl:stylesheet>"; |
| // |
| // /** The identity transform Templates, built from identityTransform, |
| // * for support of newTransformerHandler() and newTransformer(). */ |
| // private static Templates m_identityTemplate = null; |
| |
| /** |
| * Get a TransformerHandler object that can process SAX |
| * ContentHandler events into a Result. |
| * |
| * @return TransformerHandler ready to transform SAX events. |
| * |
| * @throws TransformerConfigurationException |
| */ |
| public TransformerHandler newTransformerHandler() |
| throws TransformerConfigurationException |
| { |
| return new TransformerIdentityImpl(m_isSecureProcessing); |
| } |
| |
| /** |
| * Process the source into a Transformer object. Care must |
| * be given to know that this object can not be used concurrently |
| * in multiple threads. |
| * |
| * @param source An object that holds a URL, input stream, etc. |
| * |
| * @return A Transformer object capable of |
| * being used for transformation purposes in a single thread. |
| * |
| * @throws TransformerConfigurationException May throw this during the parse when it |
| * is constructing the Templates object and fails. |
| */ |
| public Transformer newTransformer(Source source) |
| throws TransformerConfigurationException |
| { |
| try |
| { |
| Templates tmpl=newTemplates( source ); |
| /* this can happen if an ErrorListener is present and it doesn't |
| throw any exception in fatalError. |
| The spec says: "a Transformer must use this interface |
| instead of throwing an exception" - the newTemplates() does |
| that, and returns null. |
| */ |
| if( tmpl==null ) return null; |
| Transformer transformer = tmpl.newTransformer(); |
| transformer.setURIResolver(m_uriResolver); |
| return transformer; |
| } |
| catch( TransformerConfigurationException ex ) |
| { |
| if( m_errorListener != null ) |
| { |
| try |
| { |
| m_errorListener.fatalError( ex ); |
| return null; |
| } |
| catch( TransformerConfigurationException ex1 ) |
| { |
| throw ex1; |
| } |
| catch( TransformerException ex1 ) |
| { |
| throw new TransformerConfigurationException( ex1 ); |
| } |
| } |
| throw ex; |
| } |
| } |
| |
| /** |
| * Create a new Transformer object that performs a copy |
| * of the source to the result. |
| * |
| * @return A Transformer object capable of |
| * being used for transformation purposes in a single thread. |
| * |
| * @throws TransformerConfigurationException May throw this during |
| * the parse when it is constructing the |
| * Templates object and it fails. |
| */ |
| public Transformer newTransformer() throws TransformerConfigurationException |
| { |
| return new TransformerIdentityImpl(m_isSecureProcessing); |
| } |
| |
| /** |
| * Process the source into a Templates object, which is likely |
| * a compiled representation of the source. This Templates object |
| * may then be used concurrently across multiple threads. Creating |
| * a Templates object allows the TransformerFactory to do detailed |
| * performance optimization of transformation instructions, without |
| * penalizing runtime transformation. |
| * |
| * @param source An object that holds a URL, input stream, etc. |
| * @return A Templates object capable of being used for transformation purposes. |
| * |
| * @throws TransformerConfigurationException May throw this during the parse when it |
| * is constructing the Templates object and fails. |
| */ |
| public Templates newTemplates(Source source) |
| throws TransformerConfigurationException |
| { |
| |
| String baseID = source.getSystemId(); |
| |
| if (null != baseID) { |
| baseID = SystemIDResolver.getAbsoluteURI(baseID); |
| } |
| |
| |
| if (source instanceof DOMSource) |
| { |
| DOMSource dsource = (DOMSource) source; |
| Node node = dsource.getNode(); |
| |
| if (null != node) |
| return processFromNode(node, baseID); |
| else |
| { |
| String messageStr = XSLMessages.createMessage( |
| XSLTErrorResources.ER_ILLEGAL_DOMSOURCE_INPUT, null); |
| |
| throw new IllegalArgumentException(messageStr); |
| } |
| } |
| |
| TemplatesHandler builder = newTemplatesHandler(); |
| builder.setSystemId(baseID); |
| |
| try |
| { |
| InputSource isource = SAXSource.sourceToInputSource(source); |
| isource.setSystemId(baseID); |
| XMLReader reader = null; |
| |
| if (source instanceof SAXSource) |
| reader = ((SAXSource) source).getXMLReader(); |
| |
| if (null == reader) |
| { |
| |
| // Use JAXP1.1 ( if possible ) |
| try |
| { |
| javax.xml.parsers.SAXParserFactory factory = |
| javax.xml.parsers.SAXParserFactory.newInstance(); |
| |
| factory.setNamespaceAware(true); |
| |
| if (m_isSecureProcessing) |
| { |
| try |
| { |
| factory.setFeature(XMLConstants.FEATURE_SECURE_PROCESSING, true); |
| } |
| catch (org.xml.sax.SAXException se) {} |
| } |
| |
| javax.xml.parsers.SAXParser jaxpParser = factory.newSAXParser(); |
| |
| reader = jaxpParser.getXMLReader(); |
| } |
| catch (javax.xml.parsers.ParserConfigurationException ex) |
| { |
| throw new org.xml.sax.SAXException(ex); |
| } |
| catch (javax.xml.parsers.FactoryConfigurationError ex1) |
| { |
| throw new org.xml.sax.SAXException(ex1.toString()); |
| } |
| catch (NoSuchMethodError ex2){} |
| catch (AbstractMethodError ame){} |
| } |
| |
| if (null == reader) |
| reader = XMLReaderFactory.createXMLReader(); |
| |
| // If you set the namespaces to true, we'll end up getting double |
| // xmlns attributes. Needs to be fixed. -sb |
| // reader.setFeature("http://xml.org/sax/features/namespace-prefixes", true); |
| reader.setContentHandler(builder); |
| reader.parse(isource); |
| } |
| catch (org.xml.sax.SAXException se) |
| { |
| if (m_errorListener != null) |
| { |
| try |
| { |
| m_errorListener.fatalError(new TransformerException(se)); |
| } |
| catch (TransformerConfigurationException ex1) |
| { |
| throw ex1; |
| } |
| catch (TransformerException ex1) |
| { |
| throw new TransformerConfigurationException(ex1); |
| } |
| } |
| else |
| { |
| throw new TransformerConfigurationException(se.getMessage(), se); |
| } |
| } |
| catch (Exception e) |
| { |
| if (m_errorListener != null) |
| { |
| try |
| { |
| m_errorListener.fatalError(new TransformerException(e)); |
| return null; |
| } |
| catch (TransformerConfigurationException ex1) |
| { |
| throw ex1; |
| } |
| catch (TransformerException ex1) |
| { |
| throw new TransformerConfigurationException(ex1); |
| } |
| } |
| else |
| { |
| throw new TransformerConfigurationException(e.getMessage(), e); |
| } |
| } |
| |
| return builder.getTemplates(); |
| } |
| |
| /** |
| * The object that implements the URIResolver interface, |
| * or null. |
| */ |
| URIResolver m_uriResolver; |
| |
| /** |
| * Set an object that will be used to resolve URIs used in |
| * xsl:import, etc. This will be used as the default for the |
| * transformation. |
| * @param resolver An object that implements the URIResolver interface, |
| * or null. |
| */ |
| public void setURIResolver(URIResolver resolver) |
| { |
| m_uriResolver = resolver; |
| } |
| |
| /** |
| * Get the object that will be used to resolve URIs used in |
| * xsl:import, etc. This will be used as the default for the |
| * transformation. |
| * |
| * @return The URIResolver that was set with setURIResolver. |
| */ |
| public URIResolver getURIResolver() |
| { |
| return m_uriResolver; |
| } |
| |
| /** The error listener. */ |
| private ErrorListener m_errorListener = new org.apache.xml.utils.DefaultErrorHandler(false); |
| |
| /** |
| * Get the error listener in effect for the TransformerFactory. |
| * |
| * @return A non-null reference to an error listener. |
| */ |
| public ErrorListener getErrorListener() |
| { |
| return m_errorListener; |
| } |
| |
| /** |
| * Set an error listener for the TransformerFactory. |
| * |
| * @param listener Must be a non-null reference to an ErrorListener. |
| * |
| * @throws IllegalArgumentException if the listener argument is null. |
| */ |
| public void setErrorListener(ErrorListener listener) |
| throws IllegalArgumentException |
| { |
| |
| if (null == listener) |
| throw new IllegalArgumentException(XSLMessages.createMessage(XSLTErrorResources.ER_ERRORLISTENER, null)); |
| // "ErrorListener"); |
| |
| m_errorListener = listener; |
| } |
| |
| /** |
| * Return the state of the secure processing feature. |
| * |
| * @return state of the secure processing feature. |
| */ |
| public boolean isSecureProcessing() |
| { |
| return m_isSecureProcessing; |
| } |
| } |
