• Home
  • Line#
  • Scopes#
  • Navigate#
  • Raw
  • Download
1 /*
2  * Licensed to the Apache Software Foundation (ASF) under one
3  * or more contributor license agreements. See the NOTICE file
4  * distributed with this work for additional information
5  * regarding copyright ownership. The ASF licenses this file
6  * to you under the Apache License, Version 2.0 (the  "License");
7  * you may not use this file except in compliance with the License.
8  * You may obtain a copy of the License at
9  *
10  *     http://www.apache.org/licenses/LICENSE-2.0
11  *
12  * Unless required by applicable law or agreed to in writing, software
13  * distributed under the License is distributed on an "AS IS" BASIS,
14  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
15  * See the License for the specific language governing permissions and
16  * limitations under the License.
17  */
18 /*
19  * $Id: TransformerFactoryImpl.java 468640 2006-10-28 06:53:53Z minchau $
20  */
21 package org.apache.xalan.processor;
22 
23 import java.io.BufferedInputStream;
24 import java.io.IOException;
25 import java.io.InputStream;
26 import java.util.Enumeration;
27 import java.util.Properties;
28 
29 import javax.xml.XMLConstants;
30 import javax.xml.transform.ErrorListener;
31 import javax.xml.transform.Source;
32 import javax.xml.transform.Templates;
33 import javax.xml.transform.Transformer;
34 import javax.xml.transform.TransformerConfigurationException;
35 import javax.xml.transform.TransformerException;
36 import javax.xml.transform.URIResolver;
37 import javax.xml.transform.dom.DOMResult;
38 import javax.xml.transform.dom.DOMSource;
39 import javax.xml.transform.sax.SAXResult;
40 import javax.xml.transform.sax.SAXSource;
41 import javax.xml.transform.sax.SAXTransformerFactory;
42 import javax.xml.transform.sax.TemplatesHandler;
43 import javax.xml.transform.sax.TransformerHandler;
44 import javax.xml.transform.stream.StreamResult;
45 import javax.xml.transform.stream.StreamSource;
46 
47 import org.apache.xalan.res.XSLMessages;
48 import org.apache.xalan.res.XSLTErrorResources;
49 import org.apache.xalan.transformer.TrAXFilter;
50 import org.apache.xalan.transformer.TransformerIdentityImpl;
51 import org.apache.xalan.transformer.TransformerImpl;
52 import org.apache.xalan.transformer.XalanProperties;
53 
54 import org.apache.xml.dtm.ref.sax2dtm.SAX2DTM;
55 import org.apache.xml.utils.DefaultErrorHandler;
56 import org.apache.xml.utils.SystemIDResolver;
57 import org.apache.xml.utils.TreeWalker;
58 import org.apache.xml.utils.StylesheetPIHandler;
59 import org.apache.xml.utils.StopParseException;
60 
61 import org.w3c.dom.Node;
62 
63 import org.xml.sax.InputSource;
64 import org.xml.sax.XMLFilter;
65 import org.xml.sax.XMLReader;
66 import org.xml.sax.helpers.XMLReaderFactory;
67 
68 /**
69  * The TransformerFactoryImpl, which implements the TRaX TransformerFactory
70  * interface, processes XSLT stylesheets into a Templates object
71  * (a StylesheetRoot).
72  */
73 public class TransformerFactoryImpl extends SAXTransformerFactory
74 {
75   /**
76    * The path/filename of the property file: XSLTInfo.properties
77    * Maintenance note: see also
78    * <code>org.apache.xpath.functions.FuncSystemProperty.XSLT_PROPERTIES</code>
79    */
80   public static final String XSLT_PROPERTIES =
81     "org/apache/xalan/res/XSLTInfo.properties";
82 
83   /**
84    * <p>State of secure processing feature.</p>
85    */
86   private boolean m_isSecureProcessing = false;
87 
88   /**
89    * Constructor TransformerFactoryImpl
90    *
91    */
TransformerFactoryImpl()92   public TransformerFactoryImpl()
93   {
94   }
95 
96   /** Static string to be used for incremental feature */
97   public static final String FEATURE_INCREMENTAL =
98                              "http://xml.apache.org/xalan/features/incremental";
99 
100   /** Static string to be used for optimize feature */
101   public static final String FEATURE_OPTIMIZE =
102                              "http://xml.apache.org/xalan/features/optimize";
103 
104   /** Static string to be used for source_location feature */
105   public static final String FEATURE_SOURCE_LOCATION =
106                              XalanProperties.SOURCE_LOCATION;
107 
processFromNode(Node node)108   public javax.xml.transform.Templates processFromNode(Node node)
109           throws TransformerConfigurationException
110   {
111 
112     try
113     {
114       TemplatesHandler builder = newTemplatesHandler();
115       TreeWalker walker = new TreeWalker(builder,
116                                          new org.apache.xml.utils.DOM2Helper(),
117                                          builder.getSystemId());
118 
119       walker.traverse(node);
120 
121       return builder.getTemplates();
122     }
123     catch (org.xml.sax.SAXException se)
124     {
125       if (m_errorListener != null)
126       {
127         try
128         {
129           m_errorListener.fatalError(new TransformerException(se));
130         }
131         catch (TransformerConfigurationException ex)
132         {
133           throw ex;
134         }
135         catch (TransformerException ex)
136         {
137           throw new TransformerConfigurationException(ex);
138         }
139 
140         return null;
141       }
142       else
143       {
144 
145         // Should remove this later... but right now diagnostics from
146         // TransformerConfigurationException are not good.
147         // se.printStackTrace();
148         throw new TransformerConfigurationException(XSLMessages.createMessage(XSLTErrorResources.ER_PROCESSFROMNODE_FAILED, null), se);
149         //"processFromNode failed", se);
150       }
151     }
152     catch (TransformerConfigurationException tce)
153     {
154       // Assume it's already been reported to the error listener.
155       throw tce;
156     }
157    /* catch (TransformerException tce)
158     {
159       // Assume it's already been reported to the error listener.
160       throw new TransformerConfigurationException(tce.getMessage(), tce);
161     }*/
162     catch (Exception e)
163     {
164       if (m_errorListener != null)
165       {
166         try
167         {
168           m_errorListener.fatalError(new TransformerException(e));
169         }
170         catch (TransformerConfigurationException ex)
171         {
172           throw ex;
173         }
174         catch (TransformerException ex)
175         {
176           throw new TransformerConfigurationException(ex);
177         }
178 
179         return null;
180       }
181       else
182       {
183         // Should remove this later... but right now diagnostics from
184         // TransformerConfigurationException are not good.
185         // se.printStackTrace();
186         throw new TransformerConfigurationException(XSLMessages.createMessage(XSLTErrorResources.ER_PROCESSFROMNODE_FAILED, null), e); //"processFromNode failed",
187                                                     //e);
188       }
189     }
190   }
191 
192   /**
193    * The systemID that was specified in
194    * processFromNode(Node node, String systemID).
195    */
196   private String m_DOMsystemID = null;
197 
198   /**
199    * The systemID that was specified in
200    * processFromNode(Node node, String systemID).
201    *
202    * @return The systemID, or null.
203    */
getDOMsystemID()204   String getDOMsystemID()
205   {
206     return m_DOMsystemID;
207   }
208 
209   /**
210    * Process the stylesheet from a DOM tree, if the
211    * processor supports the "http://xml.org/trax/features/dom/input"
212    * feature.
213    *
214    * @param node A DOM tree which must contain
215    * valid transform instructions that this processor understands.
216    * @param systemID The systemID from where xsl:includes and xsl:imports
217    * should be resolved from.
218    *
219    * @return A Templates object capable of being used for transformation purposes.
220    *
221    * @throws TransformerConfigurationException
222    */
processFromNode(Node node, String systemID)223   javax.xml.transform.Templates processFromNode(Node node, String systemID)
224           throws TransformerConfigurationException
225   {
226 
227     m_DOMsystemID = systemID;
228 
229     return processFromNode(node);
230   }
231 
232   /**
233    * Get InputSource specification(s) that are associated with the
234    * given document specified in the source param,
235    * via the xml-stylesheet processing instruction
236    * (see http://www.w3.org/TR/xml-stylesheet/), and that matches
237    * the given criteria.  Note that it is possible to return several stylesheets
238    * that match the criteria, in which case they are applied as if they were
239    * a list of imports or cascades.
240    *
241    * <p>Note that DOM2 has it's own mechanism for discovering stylesheets.
242    * Therefore, there isn't a DOM version of this method.</p>
243    *
244    *
245    * @param source The XML source that is to be searched.
246    * @param media The media attribute to be matched.  May be null, in which
247    *              case the prefered templates will be used (i.e. alternate = no).
248    * @param title The value of the title attribute to match.  May be null.
249    * @param charset The value of the charset attribute to match.  May be null.
250    *
251    * @return A Source object capable of being used to create a Templates object.
252    *
253    * @throws TransformerConfigurationException
254    */
getAssociatedStylesheet( Source source, String media, String title, String charset)255   public Source getAssociatedStylesheet(
256           Source source, String media, String title, String charset)
257             throws TransformerConfigurationException
258   {
259 
260     String baseID;
261     InputSource isource = null;
262     Node node = null;
263     XMLReader reader = null;
264 
265     if (source instanceof DOMSource)
266     {
267       DOMSource dsource = (DOMSource) source;
268 
269       node = dsource.getNode();
270       baseID = dsource.getSystemId();
271     }
272     else
273     {
274       isource = SAXSource.sourceToInputSource(source);
275       baseID = isource.getSystemId();
276     }
277 
278     // What I try to do here is parse until the first startElement
279     // is found, then throw a special exception in order to terminate
280     // the parse.
281     StylesheetPIHandler handler = new StylesheetPIHandler(baseID, media,
282                                     title, charset);
283 
284     // Use URIResolver. Patch from Dmitri Ilyin
285     if (m_uriResolver != null)
286     {
287       handler.setURIResolver(m_uriResolver);
288     }
289 
290     try
291     {
292       if (null != node)
293       {
294         TreeWalker walker = new TreeWalker(handler, new org.apache.xml.utils.DOM2Helper(), baseID);
295 
296         walker.traverse(node);
297       }
298       else
299       {
300 
301         // Use JAXP1.1 ( if possible )
302         try
303         {
304           javax.xml.parsers.SAXParserFactory factory =
305             javax.xml.parsers.SAXParserFactory.newInstance();
306 
307           factory.setNamespaceAware(true);
308 
309           if (m_isSecureProcessing)
310           {
311             try
312             {
313               factory.setFeature(XMLConstants.FEATURE_SECURE_PROCESSING, true);
314             }
315             catch (org.xml.sax.SAXException e) {}
316           }
317 
318           javax.xml.parsers.SAXParser jaxpParser = factory.newSAXParser();
319 
320           reader = jaxpParser.getXMLReader();
321         }
322         catch (javax.xml.parsers.ParserConfigurationException ex)
323         {
324           throw new org.xml.sax.SAXException(ex);
325         }
326         catch (javax.xml.parsers.FactoryConfigurationError ex1)
327         {
328           throw new org.xml.sax.SAXException(ex1.toString());
329         }
330         catch (NoSuchMethodError ex2){}
331         catch (AbstractMethodError ame){}
332 
333         if (null == reader)
334         {
335           reader = XMLReaderFactory.createXMLReader();
336         }
337 
338         if(m_isSecureProcessing)
339         {
340             reader.setFeature("http://xml.org/sax/features/external-general-entities",false);
341         }
342         // Need to set options!
343         reader.setContentHandler(handler);
344         reader.parse(isource);
345       }
346     }
347     catch (StopParseException spe)
348     {
349 
350       // OK, good.
351     }
352     catch (org.xml.sax.SAXException se)
353     {
354       throw new TransformerConfigurationException(
355         "getAssociatedStylesheets failed", se);
356     }
357     catch (IOException ioe)
358     {
359       throw new TransformerConfigurationException(
360         "getAssociatedStylesheets failed", ioe);
361     }
362 
363     return handler.getAssociatedStylesheet();
364   }
365 
366   /**
367    * Create a new Transformer object that performs a copy
368    * of the source to the result.
369    *
370    * @return A Transformer object that may be used to perform a transformation
371    * in a single thread, never null.
372    *
373    * @throws TransformerConfigurationException May throw this during
374    *            the parse when it is constructing the
375    *            Templates object and fails.
376    */
newTemplatesHandler()377   public TemplatesHandler newTemplatesHandler()
378           throws TransformerConfigurationException
379   {
380     return new StylesheetHandler(this);
381   }
382 
383   /**
384    * <p>Set a feature for this <code>TransformerFactory</code> and <code>Transformer</code>s
385    * or <code>Template</code>s created by this factory.</p>
386    *
387    * <p>
388    * Feature names are fully qualified {@link java.net.URI}s.
389    * Implementations may define their own features.
390    * An {@link TransformerConfigurationException} is thrown if this <code>TransformerFactory</code> or the
391    * <code>Transformer</code>s or <code>Template</code>s it creates cannot support the feature.
392    * It is possible for an <code>TransformerFactory</code> to expose a feature value but be unable to change its state.
393    * </p>
394    *
395    * <p>See {@link javax.xml.transform.TransformerFactory} for full documentation of specific features.</p>
396    *
397    * @param name Feature name.
398    * @param value Is feature state <code>true</code> or <code>false</code>.
399    *
400    * @throws TransformerConfigurationException if this <code>TransformerFactory</code>
401    *   or the <code>Transformer</code>s or <code>Template</code>s it creates cannot support this feature.
402    * @throws NullPointerException If the <code>name</code> parameter is null.
403    */
setFeature(String name, boolean value)404   public void setFeature(String name, boolean value)
405 	  throws TransformerConfigurationException {
406 
407   	// feature name cannot be null
408   	if (name == null) {
409   	    throw new NullPointerException(
410                   XSLMessages.createMessage(
411                       XSLTErrorResources.ER_SET_FEATURE_NULL_NAME, null));
412   	}
413 
414   	// secure processing?
415   	if (name.equals(XMLConstants.FEATURE_SECURE_PROCESSING)) {
416   	    m_isSecureProcessing = value;
417   	}
418   	// This implementation does not support the setting of a feature other than
419   	// the secure processing feature.
420   	else
421     {
422       throw new TransformerConfigurationException(
423           XSLMessages.createMessage(
424             XSLTErrorResources.ER_UNSUPPORTED_FEATURE,
425             new Object[] {name}));
426     }
427   }
428 
429   /**
430    * Look up the value of a feature.
431    * <p>The feature name is any fully-qualified URI.  It is
432    * possible for an TransformerFactory to recognize a feature name but
433    * to be unable to return its value; this is especially true
434    * in the case of an adapter for a SAX1 Parser, which has
435    * no way of knowing whether the underlying parser is
436    * validating, for example.</p>
437    *
438    * @param name The feature name, which is a fully-qualified URI.
439    * @return The current state of the feature (true or false).
440    */
getFeature(String name)441   public boolean getFeature(String name) {
442 
443     // feature name cannot be null
444     if (name == null)
445     {
446     	throw new NullPointerException(
447             XSLMessages.createMessage(
448             XSLTErrorResources.ER_GET_FEATURE_NULL_NAME, null));
449     }
450 
451     // Try first with identity comparison, which
452     // will be faster.
453     if ((DOMResult.FEATURE == name) || (DOMSource.FEATURE == name)
454             || (SAXResult.FEATURE == name) || (SAXSource.FEATURE == name)
455             || (StreamResult.FEATURE == name)
456             || (StreamSource.FEATURE == name)
457             || (SAXTransformerFactory.FEATURE == name)
458             || (SAXTransformerFactory.FEATURE_XMLFILTER == name))
459       return true;
460     else if ((DOMResult.FEATURE.equals(name))
461              || (DOMSource.FEATURE.equals(name))
462              || (SAXResult.FEATURE.equals(name))
463              || (SAXSource.FEATURE.equals(name))
464              || (StreamResult.FEATURE.equals(name))
465              || (StreamSource.FEATURE.equals(name))
466              || (SAXTransformerFactory.FEATURE.equals(name))
467              || (SAXTransformerFactory.FEATURE_XMLFILTER.equals(name)))
468       return true;
469     // secure processing?
470     else if (name.equals(XMLConstants.FEATURE_SECURE_PROCESSING))
471       return m_isSecureProcessing;
472     else
473       // unknown feature
474       return false;
475   }
476 
477   /**
478    * Flag set by FEATURE_OPTIMIZE.
479    * This feature specifies whether to Optimize stylesheet processing. By
480    * default it is set to true.
481    */
482   private boolean m_optimize = true;
483 
484   /** Flag set by FEATURE_SOURCE_LOCATION.
485    * This feature specifies whether the transformation phase should
486    * keep track of line and column numbers for the input source
487    * document. Note that this works only when that
488    * information is available from the source -- in other words, if you
489    * pass in a DOM, there's little we can do for you.
490    *
491    * The default is false. Setting it true may significantly
492    * increase storage cost per node.
493    */
494   private boolean m_source_location = false;
495 
496   /**
497    * Flag set by FEATURE_INCREMENTAL.
498    * This feature specifies whether to produce output incrementally, rather than
499    * waiting to finish parsing the input before generating any output. By
500    * default this attribute is set to false.
501    */
502   private boolean m_incremental = false;
503 
504   /**
505    * Allows the user to set specific attributes on the underlying
506    * implementation.
507    *
508    * @param name The name of the attribute.
509    * @param value The value of the attribute; Boolean or String="true"|"false"
510    *
511    * @throws IllegalArgumentException thrown if the underlying
512    * implementation doesn't recognize the attribute.
513    */
setAttribute(String name, Object value)514   public void setAttribute(String name, Object value)
515           throws IllegalArgumentException
516   {
517     if (name.equals(FEATURE_INCREMENTAL))
518     {
519       if(value instanceof Boolean)
520       {
521         // Accept a Boolean object..
522         m_incremental = ((Boolean)value).booleanValue();
523       }
524       else if(value instanceof String)
525       {
526         // .. or a String object
527         m_incremental = (new Boolean((String)value)).booleanValue();
528       }
529       else
530       {
531         // Give a more meaningful error message
532         throw new IllegalArgumentException(XSLMessages.createMessage(XSLTErrorResources.ER_BAD_VALUE, new Object[]{name, value})); //name + " bad value " + value);
533       }
534 	}
535     else if (name.equals(FEATURE_OPTIMIZE))
536     {
537       if(value instanceof Boolean)
538       {
539         // Accept a Boolean object..
540         m_optimize = ((Boolean)value).booleanValue();
541       }
542       else if(value instanceof String)
543       {
544         // .. or a String object
545         m_optimize = (new Boolean((String)value)).booleanValue();
546       }
547       else
548       {
549         // Give a more meaningful error message
550         throw new IllegalArgumentException(XSLMessages.createMessage(XSLTErrorResources.ER_BAD_VALUE, new Object[]{name, value})); //name + " bad value " + value);
551       }
552     }
553 
554     // Custom Xalan feature: annotate DTM with SAX source locator fields.
555     // This gets used during SAX2DTM instantiation.
556     //
557     // %REVIEW% Should the name of this field really be in XalanProperties?
558     // %REVIEW% I hate that it's a global static, but didn't want to change APIs yet.
559     else if(name.equals(FEATURE_SOURCE_LOCATION))
560     {
561       if(value instanceof Boolean)
562       {
563         // Accept a Boolean object..
564         m_source_location = ((Boolean)value).booleanValue();
565       }
566       else if(value instanceof String)
567       {
568         // .. or a String object
569         m_source_location = (new Boolean((String)value)).booleanValue();
570       }
571       else
572       {
573         // Give a more meaningful error message
574         throw new IllegalArgumentException(XSLMessages.createMessage(XSLTErrorResources.ER_BAD_VALUE, new Object[]{name, value})); //name + " bad value " + value);
575       }
576     }
577 
578     else
579     {
580       throw new IllegalArgumentException(XSLMessages.createMessage(XSLTErrorResources.ER_NOT_SUPPORTED, new Object[]{name})); //name + "not supported");
581     }
582   }
583 
584   /**
585    * Allows the user to retrieve specific attributes on the underlying
586    * implementation.
587    *
588    * @param name The name of the attribute.
589    * @return value The value of the attribute.
590    *
591    * @throws IllegalArgumentException thrown if the underlying
592    * implementation doesn't recognize the attribute.
593    */
getAttribute(String name)594   public Object getAttribute(String name) throws IllegalArgumentException
595   {
596     if (name.equals(FEATURE_INCREMENTAL))
597     {
598       return new Boolean(m_incremental);
599     }
600     else if (name.equals(FEATURE_OPTIMIZE))
601     {
602       return new Boolean(m_optimize);
603     }
604     else if (name.equals(FEATURE_SOURCE_LOCATION))
605     {
606       return new Boolean(m_source_location);
607     }
608     else
609       throw new IllegalArgumentException(XSLMessages.createMessage(XSLTErrorResources.ER_ATTRIB_VALUE_NOT_RECOGNIZED, new Object[]{name})); //name + " attribute not recognized");
610   }
611 
612   /**
613    * Create an XMLFilter that uses the given source as the
614    * transformation instructions.
615    *
616    * @param src The source of the transformation instructions.
617    *
618    * @return An XMLFilter object, or null if this feature is not supported.
619    *
620    * @throws TransformerConfigurationException
621    */
newXMLFilter(Source src)622   public XMLFilter newXMLFilter(Source src)
623           throws TransformerConfigurationException
624   {
625 
626     Templates templates = newTemplates(src);
627     if( templates==null ) return null;
628 
629     return newXMLFilter(templates);
630   }
631 
632   /**
633    * Create an XMLFilter that uses the given source as the
634    * transformation instructions.
635    *
636    * @param templates non-null reference to Templates object.
637    *
638    * @return An XMLFilter object, or null if this feature is not supported.
639    *
640    * @throws TransformerConfigurationException
641    */
newXMLFilter(Templates templates)642   public XMLFilter newXMLFilter(Templates templates)
643           throws TransformerConfigurationException
644   {
645     try
646     {
647       return new TrAXFilter(templates);
648     }
649     catch( TransformerConfigurationException ex )
650     {
651       if( m_errorListener != null)
652       {
653         try
654         {
655           m_errorListener.fatalError( ex );
656           return null;
657         }
658         catch( TransformerConfigurationException ex1 )
659         {
660           throw ex1;
661         }
662         catch( TransformerException ex1 )
663         {
664           throw new TransformerConfigurationException(ex1);
665         }
666       }
667       throw ex;
668     }
669   }
670 
671   /**
672    * Get a TransformerHandler object that can process SAX
673    * ContentHandler events into a Result, based on the transformation
674    * instructions specified by the argument.
675    *
676    * @param src The source of the transformation instructions.
677    *
678    * @return TransformerHandler ready to transform SAX events.
679    *
680    * @throws TransformerConfigurationException
681    */
newTransformerHandler(Source src)682   public TransformerHandler newTransformerHandler(Source src)
683           throws TransformerConfigurationException
684   {
685 
686     Templates templates = newTemplates(src);
687     if( templates==null ) return null;
688 
689     return newTransformerHandler(templates);
690   }
691 
692   /**
693    * Get a TransformerHandler object that can process SAX
694    * ContentHandler events into a Result, based on the Templates argument.
695    *
696    * @param templates The source of the transformation instructions.
697    *
698    * @return TransformerHandler ready to transform SAX events.
699    * @throws TransformerConfigurationException
700    */
newTransformerHandler(Templates templates)701   public TransformerHandler newTransformerHandler(Templates templates)
702           throws TransformerConfigurationException
703   {
704     try {
705       TransformerImpl transformer =
706         (TransformerImpl) templates.newTransformer();
707       transformer.setURIResolver(m_uriResolver);
708       TransformerHandler th =
709         (TransformerHandler) transformer.getInputContentHandler(true);
710 
711       return th;
712     }
713     catch( TransformerConfigurationException ex )
714     {
715       if( m_errorListener != null )
716       {
717         try
718         {
719           m_errorListener.fatalError( ex );
720           return null;
721         }
722         catch (TransformerConfigurationException ex1 )
723         {
724           throw ex1;
725         }
726         catch (TransformerException ex1 )
727         {
728           throw new TransformerConfigurationException(ex1);
729         }
730       }
731 
732       throw ex;
733     }
734 
735   }
736 
737 //  /** The identity transform string, for support of newTransformerHandler()
738 //   *  and newTransformer().  */
739 //  private static final String identityTransform =
740 //    "<xsl:stylesheet " + "xmlns:xsl='http://www.w3.org/1999/XSL/Transform' "
741 //    + "version='1.0'>" + "<xsl:template match='/|node()'>"
742 //    + "<xsl:copy-of select='.'/>" + "</xsl:template>" + "</xsl:stylesheet>";
743 //
744 //  /** The identity transform Templates, built from identityTransform,
745 //   *  for support of newTransformerHandler() and newTransformer().  */
746 //  private static Templates m_identityTemplate = null;
747 
748   /**
749    * Get a TransformerHandler object that can process SAX
750    * ContentHandler events into a Result.
751    *
752    * @return TransformerHandler ready to transform SAX events.
753    *
754    * @throws TransformerConfigurationException
755    */
newTransformerHandler()756   public TransformerHandler newTransformerHandler()
757           throws TransformerConfigurationException
758   {
759     return new TransformerIdentityImpl(m_isSecureProcessing);
760   }
761 
762   /**
763    * Process the source into a Transformer object.  Care must
764    * be given to know that this object can not be used concurrently
765    * in multiple threads.
766    *
767    * @param source An object that holds a URL, input stream, etc.
768    *
769    * @return A Transformer object capable of
770    * being used for transformation purposes in a single thread.
771    *
772    * @throws TransformerConfigurationException May throw this during the parse when it
773    *            is constructing the Templates object and fails.
774    */
newTransformer(Source source)775   public Transformer newTransformer(Source source)
776           throws TransformerConfigurationException
777   {
778     try
779     {
780       Templates tmpl=newTemplates( source );
781       /* this can happen if an ErrorListener is present and it doesn't
782          throw any exception in fatalError.
783          The spec says: "a Transformer must use this interface
784          instead of throwing an exception" - the newTemplates() does
785          that, and returns null.
786       */
787       if( tmpl==null ) return null;
788       Transformer transformer = tmpl.newTransformer();
789       transformer.setURIResolver(m_uriResolver);
790       return transformer;
791     }
792     catch( TransformerConfigurationException ex )
793     {
794       if( m_errorListener != null )
795       {
796         try
797         {
798           m_errorListener.fatalError( ex );
799           return null; // TODO: but the API promises to never return null...
800         }
801         catch( TransformerConfigurationException ex1 )
802         {
803           throw ex1;
804         }
805         catch( TransformerException ex1 )
806         {
807           throw new TransformerConfigurationException( ex1 );
808         }
809       }
810       throw ex;
811     }
812   }
813 
814   /**
815    * Create a new Transformer object that performs a copy
816    * of the source to the result.
817    *
818    * @return A Transformer object capable of
819    * being used for transformation purposes in a single thread.
820    *
821    * @throws TransformerConfigurationException May throw this during
822    *            the parse when it is constructing the
823    *            Templates object and it fails.
824    */
newTransformer()825   public Transformer newTransformer() throws TransformerConfigurationException
826   {
827       return new TransformerIdentityImpl(m_isSecureProcessing);
828   }
829 
830   /**
831    * Process the source into a Templates object, which is likely
832    * a compiled representation of the source. This Templates object
833    * may then be used concurrently across multiple threads.  Creating
834    * a Templates object allows the TransformerFactory to do detailed
835    * performance optimization of transformation instructions, without
836    * penalizing runtime transformation.
837    *
838    * @param source An object that holds a URL, input stream, etc.
839    * @return A Templates object capable of being used for transformation purposes.
840    *
841    * @throws TransformerConfigurationException May throw this during the parse when it
842    *            is constructing the Templates object and fails.
843    */
newTemplates(Source source)844   public Templates newTemplates(Source source)
845           throws TransformerConfigurationException
846   {
847 
848     String baseID = source.getSystemId();
849 
850     if (null != baseID) {
851        baseID = SystemIDResolver.getAbsoluteURI(baseID);
852     }
853 
854 
855     if (source instanceof DOMSource)
856     {
857       DOMSource dsource = (DOMSource) source;
858       Node node = dsource.getNode();
859 
860       if (null != node)
861         return processFromNode(node, baseID);
862       else
863       {
864         String messageStr = XSLMessages.createMessage(
865           XSLTErrorResources.ER_ILLEGAL_DOMSOURCE_INPUT, null);
866 
867         throw new IllegalArgumentException(messageStr);
868       }
869     }
870 
871     TemplatesHandler builder = newTemplatesHandler();
872     builder.setSystemId(baseID);
873 
874     try
875     {
876       InputSource isource = SAXSource.sourceToInputSource(source);
877       isource.setSystemId(baseID);
878       XMLReader reader = null;
879 
880       if (source instanceof SAXSource)
881         reader = ((SAXSource) source).getXMLReader();
882 
883       if (null == reader)
884       {
885 
886         // Use JAXP1.1 ( if possible )
887         try
888         {
889           javax.xml.parsers.SAXParserFactory factory =
890             javax.xml.parsers.SAXParserFactory.newInstance();
891 
892           factory.setNamespaceAware(true);
893 
894           if (m_isSecureProcessing)
895           {
896             try
897             {
898               factory.setFeature(XMLConstants.FEATURE_SECURE_PROCESSING, true);
899             }
900             catch (org.xml.sax.SAXException se) {}
901           }
902 
903           javax.xml.parsers.SAXParser jaxpParser = factory.newSAXParser();
904 
905           reader = jaxpParser.getXMLReader();
906         }
907         catch (javax.xml.parsers.ParserConfigurationException ex)
908         {
909           throw new org.xml.sax.SAXException(ex);
910         }
911         catch (javax.xml.parsers.FactoryConfigurationError ex1)
912         {
913           throw new org.xml.sax.SAXException(ex1.toString());
914         }
915         catch (NoSuchMethodError ex2){}
916         catch (AbstractMethodError ame){}
917       }
918 
919       if (null == reader)
920         reader = XMLReaderFactory.createXMLReader();
921 
922       // If you set the namespaces to true, we'll end up getting double
923       // xmlns attributes.  Needs to be fixed.  -sb
924       // reader.setFeature("http://xml.org/sax/features/namespace-prefixes", true);
925       reader.setContentHandler(builder);
926       reader.parse(isource);
927     }
928     catch (org.xml.sax.SAXException se)
929     {
930       if (m_errorListener != null)
931       {
932         try
933         {
934           m_errorListener.fatalError(new TransformerException(se));
935         }
936         catch (TransformerConfigurationException ex1)
937         {
938           throw ex1;
939         }
940         catch (TransformerException ex1)
941         {
942           throw new TransformerConfigurationException(ex1);
943         }
944       }
945       else
946       {
947         throw new TransformerConfigurationException(se.getMessage(), se);
948       }
949     }
950     catch (Exception e)
951     {
952       if (m_errorListener != null)
953       {
954         try
955         {
956           m_errorListener.fatalError(new TransformerException(e));
957           return null;
958         }
959         catch (TransformerConfigurationException ex1)
960         {
961           throw ex1;
962         }
963         catch (TransformerException ex1)
964         {
965           throw new TransformerConfigurationException(ex1);
966         }
967       }
968       else
969       {
970         throw new TransformerConfigurationException(e.getMessage(), e);
971       }
972     }
973 
974     return builder.getTemplates();
975   }
976 
977   /**
978    * The object that implements the URIResolver interface,
979    * or null.
980    */
981   URIResolver m_uriResolver;
982 
983   /**
984    * Set an object that will be used to resolve URIs used in
985    * xsl:import, etc.  This will be used as the default for the
986    * transformation.
987    * @param resolver An object that implements the URIResolver interface,
988    * or null.
989    */
setURIResolver(URIResolver resolver)990   public void setURIResolver(URIResolver resolver)
991   {
992     m_uriResolver = resolver;
993   }
994 
995   /**
996    * Get the object that will be used to resolve URIs used in
997    * xsl:import, etc.  This will be used as the default for the
998    * transformation.
999    *
1000    * @return The URIResolver that was set with setURIResolver.
1001    */
getURIResolver()1002   public URIResolver getURIResolver()
1003   {
1004     return m_uriResolver;
1005   }
1006 
1007   /** The error listener.   */
1008   private ErrorListener m_errorListener = new org.apache.xml.utils.DefaultErrorHandler(false);
1009 
1010   /**
1011    * Get the error listener in effect for the TransformerFactory.
1012    *
1013    * @return A non-null reference to an error listener.
1014    */
getErrorListener()1015   public ErrorListener getErrorListener()
1016   {
1017     return m_errorListener;
1018   }
1019 
1020   /**
1021    * Set an error listener for the TransformerFactory.
1022    *
1023    * @param listener Must be a non-null reference to an ErrorListener.
1024    *
1025    * @throws IllegalArgumentException if the listener argument is null.
1026    */
setErrorListener(ErrorListener listener)1027   public void setErrorListener(ErrorListener listener)
1028           throws IllegalArgumentException
1029   {
1030 
1031     if (null == listener)
1032       throw new IllegalArgumentException(XSLMessages.createMessage(XSLTErrorResources.ER_ERRORLISTENER, null));
1033       // "ErrorListener");
1034 
1035     m_errorListener = listener;
1036   }
1037 
1038   /**
1039    * Return the state of the secure processing feature.
1040    *
1041    * @return state of the secure processing feature.
1042    */
isSecureProcessing()1043   public boolean isSecureProcessing()
1044   {
1045     return m_isSecureProcessing;
1046   }
1047 }
1048