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.XMLSecurityManager;
26 import com.sun.org.apache.xalan.internal.xsltc.DOM;
27 import com.sun.org.apache.xalan.internal.xsltc.DOMCache;
28 import com.sun.org.apache.xalan.internal.xsltc.StripFilter;
29 import com.sun.org.apache.xalan.internal.xsltc.Translet;
30 import com.sun.org.apache.xalan.internal.xsltc.TransletException;
31 import com.sun.org.apache.xalan.internal.xsltc.compiler.util.ErrorMsg;
32 import com.sun.org.apache.xalan.internal.xsltc.dom.DOMWSFilter;
33 import com.sun.org.apache.xalan.internal.xsltc.dom.SAXImpl;
34 import com.sun.org.apache.xalan.internal.xsltc.dom.XSLTCDTMManager;
35 import com.sun.org.apache.xalan.internal.xsltc.runtime.AbstractTranslet;
36 import com.sun.org.apache.xalan.internal.xsltc.runtime.output.TransletOutputHandlerFactory;
37 import com.sun.org.apache.xml.internal.dtm.DTMWSFilter;
38 import com.sun.org.apache.xml.internal.serializer.OutputPropertiesFactory;
39 import com.sun.org.apache.xml.internal.serializer.SerializationHandler;
40 import com.sun.org.apache.xml.internal.utils.SystemIDResolver;
41 import com.sun.org.apache.xml.internal.utils.XMLReaderManager;
42 import java.io.File;
43 import java.io.FileOutputStream;
44 import java.io.IOException;
45 import java.io.InputStream;
46 import java.io.OutputStream;
47 import java.io.Reader;
48 import java.io.Writer;
49 import java.net.URI;
50 import java.net.URL;
51 import java.net.URLConnection;
52 import java.net.UnknownServiceException;
53 import java.util.ArrayList;
54 import java.util.Enumeration;
55 import java.util.HashMap;
56 import java.util.Map;
57 import java.util.Properties;
58 import java.util.StringTokenizer;
59 import javax.xml.XMLConstants;
60 import javax.xml.catalog.CatalogException;
61 import javax.xml.catalog.CatalogFeatures;
62 import javax.xml.catalog.CatalogManager;
63 import javax.xml.catalog.CatalogResolver;
64 import javax.xml.parsers.DocumentBuilder;
65 import javax.xml.parsers.DocumentBuilderFactory;
66 import javax.xml.parsers.ParserConfigurationException;
67 import javax.xml.stream.XMLEventReader;
68 import javax.xml.stream.XMLStreamReader;
69 import javax.xml.transform.ErrorListener;
70 import javax.xml.transform.OutputKeys;
71 import javax.xml.transform.Result;
72 import javax.xml.transform.Source;
73 import javax.xml.transform.Transformer;
74 import javax.xml.transform.TransformerException;
75 import javax.xml.transform.URIResolver;
76 import javax.xml.transform.dom.DOMResult;
77 import javax.xml.transform.dom.DOMSource;
78 import javax.xml.transform.sax.SAXResult;
79 import javax.xml.transform.sax.SAXSource;
80 import javax.xml.transform.stax.StAXResult;
81 import javax.xml.transform.stax.StAXSource;
82 import javax.xml.transform.stream.StreamResult;
83 import javax.xml.transform.stream.StreamSource;
84 import jdk.xml.internal.JdkXmlFeatures;
85 import jdk.xml.internal.JdkXmlUtils;
86 import org.xml.sax.ContentHandler;
87 import org.xml.sax.InputSource;
88 import org.xml.sax.SAXException;
89 import org.xml.sax.XMLReader;
90 import org.xml.sax.ext.LexicalHandler;
91
92 /**
93 * @author Morten Jorgensen
94 * @author G. Todd Miller
95 * @author Santiago Pericas-Geertsen
96 */
97 public final class TransformerImpl extends Transformer
98 implements DOMCache, ErrorListener
99 {
100
101 private final static String LEXICAL_HANDLER_PROPERTY =
102 "http://xml.org/sax/properties/lexical-handler";
103 private static final String NAMESPACE_FEATURE =
104 "http://xml.org/sax/features/namespaces";
105
106 /**
107 * Namespace prefixes feature for {@link XMLReader}.
108 */
109 private static final String NAMESPACE_PREFIXES_FEATURE =
110 "http://xml.org/sax/features/namespace-prefixes";
111
112 /**
113 * A reference to the translet or null if the identity transform.
114 */
115 private AbstractTranslet _translet = null;
116
117 /**
118 * The output method of this transformation.
119 */
120 private String _method = null;
121
122 /**
123 * The output encoding of this transformation.
124 */
125 private String _encoding = null;
126
127 /**
128 * The systemId set in input source.
129 */
130 private String _sourceSystemId = null;
131
132 /**
133 * An error listener for runtime errors.
134 */
135 private ErrorListener _errorListener = this;
136
137 /**
138 * A reference to a URI resolver for calls to document().
139 */
140 private URIResolver _uriResolver = null;
141
142 /**
143 * Output properties of this transformer instance.
144 */
145 private Properties _properties, _propertiesClone;
146
147 /**
148 * A reference to an output handler factory.
149 */
150 private TransletOutputHandlerFactory _tohFactory = null;
151
152 /**
153 * A reference to a internal DOM representation of the input.
154 */
155 private DOM _dom = null;
156
157 /**
158 * Number of indent spaces to add when indentation is on.
159 */
160 private int _indentNumber = -1;
161
162 /**
163 * A reference to the transformer factory that this templates
164 * object belongs to.
165 */
166 private TransformerFactoryImpl _tfactory = null;
167
168 /**
169 * A reference to the output stream, if we create one in our code.
170 */
171 private OutputStream _ostream = null;
172
173 /**
174 * A reference to the XSLTCDTMManager which is used to build the DOM/DTM
175 * for this transformer.
176 */
177 private XSLTCDTMManager _dtmManager = null;
178
179 /**
180 * A reference to an object that creates and caches XMLReader objects.
181 */
182 private XMLReaderManager _readerManager;
183
184 /**
185 * A flag indicating whether we use incremental building of the DTM.
186 */
187 //private boolean _isIncremental = false;
188
189 /**
190 * A flag indicating whether this transformer implements the identity
191 * transform.
192 */
193 private boolean _isIdentity = false;
194
195 /**
196 * State of the secure processing feature.
197 */
198 private boolean _isSecureProcessing = false;
199
200 /**
201 * Indicates whether implementation parts should use
202 * service loader (or similar).
203 * Note the default value (false) is the safe option..
204 */
205 private boolean _useServicesMechanism;
206 /**
207 * protocols allowed for external references set by the stylesheet processing instruction, Import and Include element.
208 */
209 private String _accessExternalStylesheet = XalanConstants.EXTERNAL_ACCESS_DEFAULT;
210 /**
211 * protocols allowed for external DTD references in source file and/or stylesheet.
212 */
213 private String _accessExternalDTD = XalanConstants.EXTERNAL_ACCESS_DEFAULT;
214
215 private XMLSecurityManager _securityManager;
216 /**
217 * A map to store parameters for the identity transform. These
218 * are not needed during the transformation, but we must keep track of
219 * them to be fully complaint with the JAXP API.
220 */
221 private Map<String, Object> _parameters = null;
222
223 // Catalog features
224 CatalogFeatures _catalogFeatures;
225 CatalogResolver _catalogUriResolver;
226
227 // Catalog is enabled by default
228 boolean _useCatalog = true;
229
230 int _cdataChunkSize = JdkXmlUtils.CDATA_CHUNK_SIZE_DEFAULT;
231
232 /**
233 * This class wraps an ErrorListener into a MessageHandler in order to
234 * capture messages reported via xsl:message.
235 */
236 static class MessageHandler
237 extends com.sun.org.apache.xalan.internal.xsltc.runtime.MessageHandler
238 {
239 private ErrorListener _errorListener;
240
241 public MessageHandler(ErrorListener errorListener) {
242 _errorListener = errorListener;
243 }
244
245 @Override
246 public void displayMessage(String msg) {
247 if(_errorListener == null) {
248 System.err.println(msg);
249 }
250 else {
251 try {
252 _errorListener.warning(new TransformerException(msg));
253 }
254 catch (TransformerException e) {
255 // ignored
256 }
257 }
258 }
259 }
260
261 protected TransformerImpl(Properties outputProperties, int indentNumber,
262 TransformerFactoryImpl tfactory)
263 {
264 this(null, outputProperties, indentNumber, tfactory);
265 _isIdentity = true;
266 // _properties.put(OutputKeys.METHOD, "xml");
267 }
268
269 protected TransformerImpl(Translet translet, Properties outputProperties,
270 int indentNumber, TransformerFactoryImpl tfactory)
271 {
272 _translet = (AbstractTranslet) translet;
273 _properties = createOutputProperties(outputProperties);
274 _propertiesClone = (Properties) _properties.clone();
275 _indentNumber = indentNumber;
276 _tfactory = tfactory;
277 _useServicesMechanism = _tfactory.useServicesMechnism();
278 _accessExternalStylesheet = (String)_tfactory.getAttribute(XMLConstants.ACCESS_EXTERNAL_STYLESHEET);
279 _accessExternalDTD = (String)_tfactory.getAttribute(XMLConstants.ACCESS_EXTERNAL_DTD);
280 _securityManager = (XMLSecurityManager)_tfactory.getAttribute(XalanConstants.SECURITY_MANAGER);
281 _readerManager = XMLReaderManager.getInstance(_useServicesMechanism);
282 _readerManager.setProperty(XMLConstants.ACCESS_EXTERNAL_DTD, _accessExternalDTD);
283 _readerManager.setFeature(XMLConstants.FEATURE_SECURE_PROCESSING, _isSecureProcessing);
284 _readerManager.setProperty(XalanConstants.SECURITY_MANAGER, _securityManager);
285 _cdataChunkSize = JdkXmlUtils.getValue(_tfactory.getAttribute(JdkXmlUtils.CDATA_CHUNK_SIZE),
286 JdkXmlUtils.CDATA_CHUNK_SIZE_DEFAULT);
287 _readerManager.setProperty(JdkXmlUtils.CDATA_CHUNK_SIZE, _cdataChunkSize);
288
289 _useCatalog = _tfactory.getFeature(XMLConstants.USE_CATALOG);
290 if (_useCatalog) {
291 _catalogFeatures = (CatalogFeatures)_tfactory.getAttribute(JdkXmlFeatures.CATALOG_FEATURES);
292 String catalogFiles = _catalogFeatures.get(CatalogFeatures.Feature.DEFER);
293 if (catalogFiles != null) {
294 _readerManager.setFeature(XMLConstants.USE_CATALOG, _useCatalog);
295 _readerManager.setProperty(JdkXmlFeatures.CATALOG_FEATURES, _catalogFeatures);
296 }
297 }
298 //_isIncremental = tfactory._incremental;
299 }
300
301 /**
302 * Return the state of the secure processing feature.
303 */
304 public boolean isSecureProcessing() {
305 return _isSecureProcessing;
306 }
307
308 /**
309 * Set the state of the secure processing feature.
310 */
311 public void setSecureProcessing(boolean flag) {
312 _isSecureProcessing = flag;
313 _readerManager.setFeature(XMLConstants.FEATURE_SECURE_PROCESSING, _isSecureProcessing);
314 }
315 /**
316 * Return the state of the services mechanism feature.
317 */
318 public boolean useServicesMechnism() {
319 return _useServicesMechanism;
320 }
321
322 /**
323 * Set the state of the services mechanism feature.
324 */
325 public void setServicesMechnism(boolean flag) {
326 _useServicesMechanism = flag;
327 }
328
329 /**
330 * Returns the translet wrapped inside this Transformer or
331 * null if this is the identity transform.
332 */
333 protected AbstractTranslet getTranslet() {
334 return _translet;
335 }
336
337 public boolean isIdentity() {
338 return _isIdentity;
339 }
340
341 /**
342 * Implements JAXP's Transformer.transform()
343 *
344 * @param source Contains the input XML document
345 * @param result Will contain the output from the transformation
346 * @throws TransformerException
347 */
348 @Override
349 public void transform(Source source, Result result)
350 throws TransformerException
351 {
352 if (!_isIdentity) {
353 if (_translet == null) {
354 ErrorMsg err = new ErrorMsg(ErrorMsg.JAXP_NO_TRANSLET_ERR);
355 throw new TransformerException(err.toString());
356 }
357 // Pass output properties to the translet
358 transferOutputProperties(_translet);
359 }
360
361 final SerializationHandler toHandler = getOutputHandler(result);
362 if (toHandler == null) {
363 ErrorMsg err = new ErrorMsg(ErrorMsg.JAXP_NO_HANDLER_ERR);
364 throw new TransformerException(err.toString());
365 }
366
367 if (!_isIdentity && (_uriResolver != null || (_tfactory.getFeature(XMLConstants.USE_CATALOG)
368 && _tfactory.getAttribute(JdkXmlUtils.CATALOG_FILES) != null))) {
369 _translet.setDOMCache(this);
370 }
371
372 // Pass output properties to handler if identity
373 if (_isIdentity) {
374 transferOutputProperties(toHandler);
375 }
376
377 transform(source, toHandler, _encoding);
378 try{
379 if (result instanceof DOMResult) {
380 ((DOMResult)result).setNode(_tohFactory.getNode());
381 } else if (result instanceof StAXResult) {
382 if (((StAXResult) result).getXMLEventWriter() != null)
383 {
384 (_tohFactory.getXMLEventWriter()).flush();
385 }
386 else if (((StAXResult) result).getXMLStreamWriter() != null) {
387 (_tohFactory.getXMLStreamWriter()).flush();
388 //result = new StAXResult(_tohFactory.getXMLStreamWriter());
389 }
390 }
391 } catch (Exception e) {
392 System.out.println("Result writing error");
393 }
394 }
395
396 /**
397 * Create an output handler for the transformation output based on
398 * the type and contents of the TrAX Result object passed to the
399 * transform() method.
400 */
401 public SerializationHandler getOutputHandler(Result result)
402 throws TransformerException
403 {
404 // Get output method using get() to ignore defaults
405 _method = (String) _properties.get(OutputKeys.METHOD);
406
407 // Get encoding using getProperty() to use defaults
408 _encoding = (String) _properties.getProperty(OutputKeys.ENCODING);
409
410 _tohFactory = TransletOutputHandlerFactory.newInstance(_useServicesMechanism);
411 _tohFactory.setEncoding(_encoding);
412 if (_method != null) {
413 _tohFactory.setOutputMethod(_method);
414 }
415
416 // Set indentation number in the factory
417 if (_indentNumber >= 0) {
418 _tohFactory.setIndentNumber(_indentNumber);
419 }
420
421 // Return the content handler for this Result object
422 try {
423 // Result object could be SAXResult, DOMResult, or StreamResult
424 if (result instanceof SAXResult) {
425 final SAXResult target = (SAXResult)result;
426 final ContentHandler handler = target.getHandler();
427
428 _tohFactory.setHandler(handler);
429
430 /**
431 * Fix for bug 24414
432 * If the lexicalHandler is set then we need to get that
433 * for obtaining the lexical information
434 */
435 LexicalHandler lexicalHandler = target.getLexicalHandler();
436
437 if (lexicalHandler != null ) {
438 _tohFactory.setLexicalHandler(lexicalHandler);
439 }
440
441 _tohFactory.setOutputType(TransletOutputHandlerFactory.SAX);
442 return _tohFactory.getSerializationHandler();
443 }
444 else if (result instanceof StAXResult) {
445 if (((StAXResult) result).getXMLEventWriter() != null)
446 _tohFactory.setXMLEventWriter(((StAXResult) result).getXMLEventWriter());
447 else if (((StAXResult) result).getXMLStreamWriter() != null)
448 _tohFactory.setXMLStreamWriter(((StAXResult) result).getXMLStreamWriter());
449 _tohFactory.setOutputType(TransletOutputHandlerFactory.STAX);
450 return _tohFactory.getSerializationHandler();
451 }
452 else if (result instanceof DOMResult) {
453 _tohFactory.setNode(((DOMResult) result).getNode());
454 _tohFactory.setNextSibling(((DOMResult) result).getNextSibling());
455 _tohFactory.setOutputType(TransletOutputHandlerFactory.DOM);
456 return _tohFactory.getSerializationHandler();
457 }
458 else if (result instanceof StreamResult) {
459 // Get StreamResult
460 final StreamResult target = (StreamResult) result;
461
462 // StreamResult may have been created with a java.io.File,
463 // java.io.Writer, java.io.OutputStream or just a String
464 // systemId.
465
466 _tohFactory.setOutputType(TransletOutputHandlerFactory.STREAM);
467
468 // try to get a Writer from Result object
469 final Writer writer = target.getWriter();
470 if (writer != null) {
471 _tohFactory.setWriter(writer);
472 return _tohFactory.getSerializationHandler();
473 }
474
475 // or try to get an OutputStream from Result object
476 final OutputStream ostream = target.getOutputStream();
477 if (ostream != null) {
478 _tohFactory.setOutputStream(ostream);
479 return _tohFactory.getSerializationHandler();
480 }
481
482 // or try to get just a systemId string from Result object
483 String systemId = result.getSystemId();
484 if (systemId == null) {
485 ErrorMsg err = new ErrorMsg(ErrorMsg.JAXP_NO_RESULT_ERR);
486 throw new TransformerException(err.toString());
487 }
488
489 // System Id may be in one of several forms, (1) a uri
490 // that starts with 'file:', (2) uri that starts with 'http:'
491 // or (3) just a filename on the local system.
492 URL url;
493 if (systemId.startsWith("file:")) {
494 // if StreamResult(File) or setSystemID(File) was used,
495 // the systemId will be URI encoded as a result of File.toURI(),
496 // it must be decoded for use by URL
497 try{
498 URI uri = new URI(systemId) ;
499 systemId = "file:";
500
501 String host = uri.getHost(); // decoded String
502 String path = uri.getPath(); //decoded String
503 if (path == null) {
504 path = "";
505 }
506
507 // if host (URI authority) then file:// + host + path
508 // else just path (may be absolute or relative)
509 if (host != null) {
510 systemId += "//" + host + path;
511 } else {
512 systemId += "//" + path;
513 }
514 }
515 catch (Exception exception) {
516 // URI exception which means nothing can be done so OK to ignore
517 }
518
519 url = new URL(systemId);
520 _ostream = new FileOutputStream(url.getFile());
521 _tohFactory.setOutputStream(_ostream);
522 return _tohFactory.getSerializationHandler();
523 }
524 else if (systemId.startsWith("http:")) {
525 url = new URL(systemId);
526 final URLConnection connection = url.openConnection();
527 _tohFactory.setOutputStream(_ostream = connection.getOutputStream());
528 return _tohFactory.getSerializationHandler();
529 }
530 else {
531 // system id is just a filename
532 _tohFactory.setOutputStream(
533 _ostream = new FileOutputStream(new File(systemId)));
534 return _tohFactory.getSerializationHandler();
535 }
536 }
537 }
538 // If we cannot write to the location specified by the SystemId
539 catch (UnknownServiceException e) {
540 throw new TransformerException(e);
541 }
542 catch (ParserConfigurationException e) {
543 throw new TransformerException(e);
544 }
545 // If we cannot create the file specified by the SystemId
546 catch (IOException e) {
547 throw new TransformerException(e);
548 }
549 return null;
550 }
551
552 /**
553 * Set the internal DOM that will be used for the next transformation
554 */
555 protected void setDOM(DOM dom) {
556 _dom = dom;
557 }
558
559 /**
560 * Builds an internal DOM from a TrAX Source object
561 */
562 private DOM getDOM(Source source) throws TransformerException {
563 try {
564 DOM dom;
565
566 if (source != null) {
567 DTMWSFilter wsfilter;
568 if (_translet != null && _translet instanceof StripFilter) {
569 wsfilter = new DOMWSFilter(_translet);
570 } else {
571 wsfilter = null;
572 }
573
574 boolean hasIdCall = (_translet != null) ? _translet.hasIdCall()
575 : false;
576
577 if (_dtmManager == null) {
578 _dtmManager =
579 _tfactory.createNewDTMManagerInstance();
580 _dtmManager.setServicesMechnism(_useServicesMechanism);
581 }
582 dom = (DOM)_dtmManager.getDTM(source, false, wsfilter, true,
583 false, false, 0, hasIdCall);
584 } else if (_dom != null) {
585 dom = _dom;
586 _dom = null; // use only once, so reset to 'null'
587 } else {
588 return null;
589 }
590
591 if (!_isIdentity) {
592 // Give the translet the opportunity to make a prepass of
593 // the document, in case it can extract useful information early
594 _translet.prepassDocument(dom);
595 }
596
597 return dom;
598
599 }
600 catch (Exception e) {
601 if (_errorListener != null) {
602 postErrorToListener(e.getMessage());
603 }
604 throw new TransformerException(e);
605 }
606 }
607
608 /**
609 * Returns the {@link com.sun.org.apache.xalan.internal.xsltc.trax.TransformerFactoryImpl}
610 * object that create this <code>Transformer</code>.
611 */
612 protected TransformerFactoryImpl getTransformerFactory() {
613 return _tfactory;
614 }
615
616 /**
617 * Returns the {@link com.sun.org.apache.xalan.internal.xsltc.runtime.output.TransletOutputHandlerFactory}
618 * object that create the <code>TransletOutputHandler</code>.
619 */
620 protected TransletOutputHandlerFactory getTransletOutputHandlerFactory() {
621 return _tohFactory;
622 }
623
624 private void transformIdentity(Source source, SerializationHandler handler)
625 throws Exception
626 {
627 // Get systemId from source
628 if (source != null) {
629 _sourceSystemId = source.getSystemId();
630 }
631
632 if (source instanceof StreamSource) {
633 final StreamSource stream = (StreamSource) source;
634 final InputStream streamInput = stream.getInputStream();
635 final Reader streamReader = stream.getReader();
636 final XMLReader reader = _readerManager.getXMLReader();
637
638 try {
639 // Hook up reader and output handler
640 try {
641 reader.setProperty(LEXICAL_HANDLER_PROPERTY, handler);
642 reader.setFeature(NAMESPACE_PREFIXES_FEATURE, true);
643 } catch (SAXException e) {
644 // Falls through
645 }
646 reader.setContentHandler(handler);
647
648 // Create input source from source
649 InputSource input;
650 if (streamInput != null) {
651 input = new InputSource(streamInput);
652 input.setSystemId(_sourceSystemId);
653 }
654 else if (streamReader != null) {
655 input = new InputSource(streamReader);
656 input.setSystemId(_sourceSystemId);
657 }
658 else if (_sourceSystemId != null) {
659 input = new InputSource(_sourceSystemId);
660 }
661 else {
662 ErrorMsg err = new ErrorMsg(ErrorMsg.JAXP_NO_SOURCE_ERR);
663 throw new TransformerException(err.toString());
664 }
665
666 // Start pushing SAX events
667 reader.parse(input);
668 } finally {
669 _readerManager.releaseXMLReader(reader);
670 }
671 } else if (source instanceof SAXSource) {
672 final SAXSource sax = (SAXSource) source;
673 XMLReader reader = sax.getXMLReader();
674 final InputSource input = sax.getInputSource();
675 boolean userReader = true;
676
677 try {
678 // Create a reader if not set by user
679 if (reader == null) {
680 reader = _readerManager.getXMLReader();
681 userReader = false;
682 }
683
684 // Hook up reader and output handler
685 try {
686 reader.setProperty(LEXICAL_HANDLER_PROPERTY, handler);
687 reader.setFeature(NAMESPACE_PREFIXES_FEATURE, true);
688 } catch (SAXException e) {
689 // Falls through
690 }
691 reader.setContentHandler(handler);
692
693 // Start pushing SAX events
694 reader.parse(input);
695 } finally {
696 if (!userReader) {
697 _readerManager.releaseXMLReader(reader);
698 }
699 }
700 } else if (source instanceof StAXSource) {
701 final StAXSource staxSource = (StAXSource)source;
702 StAXEvent2SAX staxevent2sax;
703 StAXStream2SAX staxStream2SAX;
704 if (staxSource.getXMLEventReader() != null) {
705 final XMLEventReader xmlEventReader = staxSource.getXMLEventReader();
706 staxevent2sax = new StAXEvent2SAX(xmlEventReader);
707 staxevent2sax.setContentHandler(handler);
708 staxevent2sax.parse();
709 handler.flushPending();
710 } else if (staxSource.getXMLStreamReader() != null) {
711 final XMLStreamReader xmlStreamReader = staxSource.getXMLStreamReader();
712 staxStream2SAX = new StAXStream2SAX(xmlStreamReader);
713 staxStream2SAX.setContentHandler(handler);
714 staxStream2SAX.parse();
715 handler.flushPending();
716 }
717 } else if (source instanceof DOMSource) {
718 final DOMSource domsrc = (DOMSource) source;
719 new DOM2TO(domsrc.getNode(), handler).parse();
720 } else if (source instanceof XSLTCSource) {
721 final DOM dom = ((XSLTCSource) source).getDOM(null, _translet);
722 ((SAXImpl)dom).copy(handler);
723 } else {
724 ErrorMsg err = new ErrorMsg(ErrorMsg.JAXP_NO_SOURCE_ERR);
725 throw new TransformerException(err.toString());
726 }
727 }
728
729 /**
730 * Internal transformation method - uses the internal APIs of XSLTC
731 */
732 private void transform(Source source, SerializationHandler handler,
733 String encoding) throws TransformerException
734 {
735 try {
736 /*
737 * According to JAXP1.2, new SAXSource()/StreamSource()
738 * should create an empty input tree, with a default root node.
739 * new DOMSource()creates an empty document using DocumentBuilder.
740 * newDocument(); Use DocumentBuilder.newDocument() for all 3
741 * situations, since there is no clear spec. how to create
742 * an empty tree when both SAXSource() and StreamSource() are used.
743 */
744 if ((source instanceof StreamSource && source.getSystemId()==null
745 && ((StreamSource)source).getInputStream()==null &&
746 ((StreamSource)source).getReader()==null)||
747 (source instanceof SAXSource &&
748 ((SAXSource)source).getInputSource()==null &&
749 ((SAXSource)source).getXMLReader()==null )||
750 (source instanceof DOMSource &&
751 ((DOMSource)source).getNode()==null)){
752
753 boolean supportCatalog = true;
754
755 DocumentBuilderFactory builderF = FactoryImpl.getDOMFactory(_useServicesMechanism);
756 try {
757 builderF.setFeature(XMLConstants.USE_CATALOG, _useCatalog);
758 } catch (ParserConfigurationException e) {
759 supportCatalog = false;
760 }
761
762 if (supportCatalog && _useCatalog) {
763 CatalogFeatures cf = (CatalogFeatures)_tfactory.getAttribute(JdkXmlFeatures.CATALOG_FEATURES);
764 if (cf != null) {
765 for (CatalogFeatures.Feature f : CatalogFeatures.Feature.values()) {
766 builderF.setAttribute(f.getPropertyName(), cf.get(f));
767 }
768 }
769 }
770
771 DocumentBuilder builder = builderF.newDocumentBuilder();
772 String systemID = source.getSystemId();
773 source = new DOMSource(builder.newDocument());
774
775 // Copy system ID from original, empty Source to new
776 if (systemID != null) {
777 source.setSystemId(systemID);
778 }
779 }
780 if (_isIdentity) {
781 transformIdentity(source, handler);
782 } else {
783 _translet.transform(getDOM(source), handler);
784 }
785 } catch (TransletException e) {
786 if (_errorListener != null) postErrorToListener(e.getMessage());
787 throw new TransformerException(e);
788 } catch (RuntimeException e) {
789 if (_errorListener != null) postErrorToListener(e.getMessage());
790 throw new TransformerException(e);
791 } catch (Exception e) {
792 if (_errorListener != null) postErrorToListener(e.getMessage());
793 throw new TransformerException(e);
794 } finally {
795 _dtmManager = null;
796 }
797
798 // If we create an output stream for the Result, we need to close it after the transformation.
799 if (_ostream != null) {
800 try {
801 _ostream.close();
802 }
803 catch (IOException e) {}
804 _ostream = null;
805 }
806 }
807
808 /**
809 * Implements JAXP's Transformer.getErrorListener()
810 * Get the error event handler in effect for the transformation.
811 *
812 * @return The error event handler currently in effect
813 */
814 @Override
815 public ErrorListener getErrorListener() {
816 return _errorListener;
817 }
818
819 /**
820 * Implements JAXP's Transformer.setErrorListener()
821 * Set the error event listener in effect for the transformation.
822 * Register a message handler in the translet in order to forward
823 * xsl:messages to error listener.
824 *
825 * @param listener The error event listener to use
826 * @throws IllegalArgumentException
827 */
828 @Override
829 public void setErrorListener(ErrorListener listener)
830 throws IllegalArgumentException {
831 if (listener == null) {
832 ErrorMsg err = new ErrorMsg(ErrorMsg.ERROR_LISTENER_NULL_ERR,
833 "Transformer");
834 throw new IllegalArgumentException(err.toString());
835 }
836 _errorListener = listener;
837
838 // Register a message handler to report xsl:messages
839 if (_translet != null)
840 _translet.setMessageHandler(new MessageHandler(_errorListener));
841 }
842
843 /**
844 * Inform TrAX error listener of an error
845 */
846 private void postErrorToListener(String message) {
847 try {
848 _errorListener.error(new TransformerException(message));
849 }
850 catch (TransformerException e) {
851 // ignored - transformation cannot be continued
852 }
853 }
854
855 /**
856 * Inform TrAX error listener of a warning
857 */
858 private void postWarningToListener(String message) {
859 try {
860 _errorListener.warning(new TransformerException(message));
861 }
862 catch (TransformerException e) {
863 // ignored - transformation cannot be continued
864 }
865 }
866
867 /**
868 * Implements JAXP's Transformer.getOutputProperties().
869 * Returns a copy of the output properties for the transformation. This is
870 * a set of layered properties. The first layer contains properties set by
871 * calls to setOutputProperty() and setOutputProperties() on this class,
872 * and the output settings defined in the stylesheet's <xsl:output>
873 * element makes up the second level, while the default XSLT output
874 * settings are returned on the third level.
875 *
876 * @return Properties in effect for this Transformer
877 */
878 @Override
879 public Properties getOutputProperties() {
880 return (Properties) _properties.clone();
881 }
882
883 /**
884 * Implements JAXP's Transformer.getOutputProperty().
885 * Get an output property that is in effect for the transformation. The
886 * property specified may be a property that was set with setOutputProperty,
887 * or it may be a property specified in the stylesheet.
888 *
889 * @param name A non-null string that contains the name of the property
890 * @throws IllegalArgumentException if the property name is not known
891 */
892 @Override
893 public String getOutputProperty(String name)
894 throws IllegalArgumentException
895 {
896 if (!validOutputProperty(name)) {
897 ErrorMsg err = new ErrorMsg(ErrorMsg.JAXP_UNKNOWN_PROP_ERR, name);
898 throw new IllegalArgumentException(err.toString());
899 }
900 return _properties.getProperty(name);
901 }
902
903 /**
904 * Implements JAXP's Transformer.setOutputProperties().
905 * Set the output properties for the transformation. These properties
906 * will override properties set in the Templates with xsl:output.
907 * Unrecognised properties will be quitely ignored.
908 *
909 * @param properties The properties to use for the Transformer
910 * @throws IllegalArgumentException Never, errors are ignored
911 */
912 @Override
913 public void setOutputProperties(Properties properties)
914 throws IllegalArgumentException
915 {
916 if (properties != null) {
917 final Enumeration names = properties.propertyNames();
918
919 while (names.hasMoreElements()) {
920 final String name = (String) names.nextElement();
921
922 // Ignore lower layer properties
923 if (isDefaultProperty(name, properties)) continue;
924
925 if (validOutputProperty(name)) {
926 _properties.setProperty(name, properties.getProperty(name));
927 }
928 else {
929 ErrorMsg err = new ErrorMsg(ErrorMsg.JAXP_UNKNOWN_PROP_ERR, name);
930 throw new IllegalArgumentException(err.toString());
931 }
932 }
933 }
934 else {
935 _properties = _propertiesClone;
936 }
937 }
938
939 /**
940 * Implements JAXP's Transformer.setOutputProperty().
941 * Get an output property that is in effect for the transformation. The
942 * property specified may be a property that was set with
943 * setOutputProperty(), or it may be a property specified in the stylesheet.
944 *
945 * @param name The name of the property to set
946 * @param value The value to assign to the property
947 * @throws IllegalArgumentException Never, errors are ignored
948 */
949 @Override
950 public void setOutputProperty(String name, String value)
951 throws IllegalArgumentException
952 {
953 if (!validOutputProperty(name)) {
954 ErrorMsg err = new ErrorMsg(ErrorMsg.JAXP_UNKNOWN_PROP_ERR, name);
955 throw new IllegalArgumentException(err.toString());
956 }
957 _properties.setProperty(name, value);
958 }
959
960 /**
961 * Internal method to pass any properties to the translet prior to
962 * initiating the transformation
963 */
964 private void transferOutputProperties(AbstractTranslet translet)
965 {
966 // Return right now if no properties are set
967 if (_properties == null) return;
968
969 // Get a list of all the defined properties
970 Enumeration names = _properties.propertyNames();
971 while (names.hasMoreElements()) {
972 // Note the use of get() instead of getProperty()
973 String name = (String) names.nextElement();
974 String value = (String) _properties.get(name);
975
976 // Ignore default properties
977 if (value == null) continue;
978
979 // Pass property value to translet - override previous setting
980 if (name.equals(OutputKeys.ENCODING)) {
981 translet._encoding = value;
982 }
983 else if (name.equals(OutputKeys.METHOD)) {
984 translet._method = value;
985 }
986 else if (name.equals(OutputKeys.DOCTYPE_PUBLIC)) {
987 translet._doctypePublic = value;
988 }
989 else if (name.equals(OutputKeys.DOCTYPE_SYSTEM)) {
990 translet._doctypeSystem = value;
991 }
992 else if (name.equals(OutputKeys.MEDIA_TYPE)) {
993 translet._mediaType = value;
994 }
995 else if (name.equals(OutputKeys.STANDALONE)) {
996 translet._standalone = value;
997 }
998 else if (name.equals(OutputKeys.VERSION)) {
999 translet._version = value;
1000 }
1001 else if (name.equals(OutputKeys.OMIT_XML_DECLARATION)) {
1002 translet._omitHeader =
1003 (value != null && value.toLowerCase().equals("yes"));
1004 }
1005 else if (name.equals(OutputKeys.INDENT)) {
1006 translet._indent =
1007 (value != null && value.toLowerCase().equals("yes"));
1008 }
1009 else if (name.equals(OutputPropertiesFactory.S_BUILTIN_OLD_EXTENSIONS_UNIVERSAL +"indent-amount")) {
1010 if (value != null) {
1011 translet._indentamount = Integer.parseInt(value);
1012 }
1013 }
1014 else if (name.equals(OutputPropertiesFactory.S_BUILTIN_EXTENSIONS_UNIVERSAL +"indent-amount")) {
1015 if (value != null) {
1016 translet._indentamount = Integer.parseInt(value);
1017 }
1018 }
1019 else if (name.equals(OutputKeys.CDATA_SECTION_ELEMENTS)) {
1020 if (value != null) {
1021 translet._cdata = null; // clear previous setting
1022 StringTokenizer e = new StringTokenizer(value);
1023 while (e.hasMoreTokens()) {
1024 translet.addCdataElement(e.nextToken());
1025 }
1026 }
1027 }
1028 else if (name.equals(OutputPropertiesFactory.ORACLE_IS_STANDALONE)) {
1029 if (value != null && value.equals("yes")) {
1030 translet._isStandalone = true;
1031 }
1032 }
1033 }
1034 }
1035
1036 /**
1037 * This method is used to pass any properties to the output handler
1038 * when running the identity transform.
1039 */
1040 public void transferOutputProperties(SerializationHandler handler)
1041 {
1042 // Return right now if no properties are set
1043 if (_properties == null) return;
1044
1045 String doctypePublic = null;
1046 String doctypeSystem = null;
1047
1048 // Get a list of all the defined properties
1049 Enumeration names = _properties.propertyNames();
1050 while (names.hasMoreElements()) {
1051 // Note the use of get() instead of getProperty()
1052 String name = (String) names.nextElement();
1053 String value = (String) _properties.get(name);
1054
1055 // Ignore default properties
1056 if (value == null) continue;
1057
1058 // Pass property value to translet - override previous setting
1059 if (name.equals(OutputKeys.DOCTYPE_PUBLIC)) {
1060 doctypePublic = value;
1061 }
1062 else if (name.equals(OutputKeys.DOCTYPE_SYSTEM)) {
1063 doctypeSystem = value;
1064 }
1065 else if (name.equals(OutputKeys.MEDIA_TYPE)) {
1066 handler.setMediaType(value);
1067 }
1068 else if (name.equals(OutputKeys.STANDALONE)) {
1069 handler.setStandalone(value);
1070 }
1071 else if (name.equals(OutputKeys.VERSION)) {
1072 handler.setVersion(value);
1073 }
1074 else if (name.equals(OutputKeys.OMIT_XML_DECLARATION)) {
1075 handler.setOmitXMLDeclaration(
1076 value != null && value.toLowerCase().equals("yes"));
1077 }
1078 else if (name.equals(OutputKeys.INDENT)) {
1079 handler.setIndent(
1080 value != null && value.toLowerCase().equals("yes"));
1081 }
1082 else if (name.equals(OutputPropertiesFactory.S_BUILTIN_OLD_EXTENSIONS_UNIVERSAL +"indent-amount")) {
1083 if (value != null) {
1084 handler.setIndentAmount(Integer.parseInt(value));
1085 }
1086 }
1087 else if (name.equals(OutputPropertiesFactory.S_BUILTIN_EXTENSIONS_UNIVERSAL +"indent-amount")) {
1088 if (value != null) {
1089 handler.setIndentAmount(Integer.parseInt(value));
1090 }
1091 }
1092 else if (name.equals(OutputPropertiesFactory.ORACLE_IS_STANDALONE)) {
1093 if (value != null && value.equals("yes")) {
1094 handler.setIsStandalone(true);
1095 }
1096 }
1097 else if (name.equals(OutputKeys.CDATA_SECTION_ELEMENTS)) {
1098 if (value != null) {
1099 StringTokenizer e = new StringTokenizer(value);
1100 ArrayList<String> uriAndLocalNames = null;
1101 while (e.hasMoreTokens()) {
1102 final String token = e.nextToken();
1103
1104 // look for the last colon, as the String may be
1105 // something like "http://abc.com:local"
1106 int lastcolon = token.lastIndexOf(':');
1107 String uri;
1108 String localName;
1109 if (lastcolon > 0) {
1110 uri = token.substring(0, lastcolon);
1111 localName = token.substring(lastcolon+1);
1112 } else {
1113 // no colon at all, lets hope this is the
1114 // local name itself then
1115 uri = null;
1116 localName = token;
1117 }
1118
1119 if (uriAndLocalNames == null) {
1120 uriAndLocalNames = new ArrayList<>();
1121 }
1122 // add the uri/localName as a pair, in that order
1123 uriAndLocalNames.add(uri);
1124 uriAndLocalNames.add(localName);
1125 }
1126 handler.setCdataSectionElements(uriAndLocalNames);
1127 }
1128 }
1129 }
1130
1131 // Call setDoctype() if needed
1132 if (doctypePublic != null || doctypeSystem != null) {
1133 handler.setDoctype(doctypeSystem, doctypePublic);
1134 }
1135 }
1136
1137 /**
1138 * Internal method to create the initial set of properties. There
1139 * are two layers of properties: the default layer and the base layer.
1140 * The latter contains properties defined in the stylesheet or by
1141 * the user using this API.
1142 */
1143 private Properties createOutputProperties(Properties outputProperties) {
1144 final Properties defaults = new Properties();
1145 setDefaults(defaults, "xml");
1146
1147 // Copy propeties set in stylesheet to base
1148 final Properties base = new Properties(defaults);
1149 if (outputProperties != null) {
1150 final Enumeration names = outputProperties.propertyNames();
1151 while (names.hasMoreElements()) {
1152 final String name = (String) names.nextElement();
1153 base.setProperty(name, outputProperties.getProperty(name));
1154 }
1155 }
1156 else {
1157 base.setProperty(OutputKeys.ENCODING, _translet._encoding);
1158 if (_translet._method != null)
1159 base.setProperty(OutputKeys.METHOD, _translet._method);
1160 }
1161
1162 // Update defaults based on output method
1163 final String method = base.getProperty(OutputKeys.METHOD);
1164 if (method != null) {
1165 if (method.equals("html")) {
1166 setDefaults(defaults,"html");
1167 }
1168 else if (method.equals("text")) {
1169 setDefaults(defaults,"text");
1170 }
1171 }
1172
1173 return base;
1174 }
1175
1176 /**
1177 * Internal method to get the default properties from the
1178 * serializer factory and set them on the property object.
1179 * @param props a java.util.Property object on which the properties are set.
1180 * @param method The output method type, one of "xml", "text", "html" ...
1181 */
1182 private void setDefaults(Properties props, String method)
1183 {
1184 final Properties method_props =
1185 OutputPropertiesFactory.getDefaultMethodProperties(method);
1186 {
1187 final Enumeration names = method_props.propertyNames();
1188 while (names.hasMoreElements())
1189 {
1190 final String name = (String)names.nextElement();
1191 props.setProperty(name, method_props.getProperty(name));
1192 }
1193 }
1194 }
1195 /**
1196 * Verifies if a given output property name is a property defined in
1197 * the JAXP 1.1 / TrAX spec
1198 */
1199 private boolean validOutputProperty(String name) {
1200 return (name.equals(OutputKeys.ENCODING) ||
1201 name.equals(OutputKeys.METHOD) ||
1202 name.equals(OutputKeys.INDENT) ||
1203 name.equals(OutputKeys.DOCTYPE_PUBLIC) ||
1204 name.equals(OutputKeys.DOCTYPE_SYSTEM) ||
1205 name.equals(OutputKeys.CDATA_SECTION_ELEMENTS) ||
1206 name.equals(OutputKeys.MEDIA_TYPE) ||
1207 name.equals(OutputKeys.OMIT_XML_DECLARATION) ||
1208 name.equals(OutputKeys.STANDALONE) ||
1209 name.equals(OutputKeys.VERSION) ||
1210 name.equals(OutputPropertiesFactory.ORACLE_IS_STANDALONE) ||
1211 name.charAt(0) == '{');
1212 }
1213
1214 /**
1215 * Checks if a given output property is default (2nd layer only)
1216 */
1217 private boolean isDefaultProperty(String name, Properties properties) {
1218 return (properties.get(name) == null);
1219 }
1220
1221 /**
1222 * Implements JAXP's Transformer.setParameter()
1223 * Add a parameter for the transformation. The parameter is simply passed
1224 * on to the translet - no validation is performed - so any unused
1225 * parameters are quitely ignored by the translet.
1226 *
1227 * @param name The name of the parameter
1228 * @param value The value to assign to the parameter
1229 */
1230 @Override
1231 public void setParameter(String name, Object value) {
1232
1233 if (value == null) {
1234 ErrorMsg err = new ErrorMsg(ErrorMsg.JAXP_INVALID_SET_PARAM_VALUE, name);
1235 throw new IllegalArgumentException(err.toString());
1236 }
1237
1238 if (_isIdentity) {
1239 if (_parameters == null) {
1240 _parameters = new HashMap<>();
1241 }
1242 _parameters.put(name, value);
1243 }
1244 else {
1245 _translet.addParameter(name, value);
1246 }
1247 }
1248
1249 /**
1250 * Implements JAXP's Transformer.clearParameters()
1251 * Clear all parameters set with setParameter. Clears the translet's
1252 * parameter stack.
1253 */
1254 @Override
1255 public void clearParameters() {
1256 if (_isIdentity && _parameters != null) {
1257 _parameters.clear();
1258 }
1259 else {
1260 _translet.clearParameters();
1261 }
1262 }
1263
1264 /**
1265 * Implements JAXP's Transformer.getParameter()
1266 * Returns the value of a given parameter. Note that the translet will not
1267 * keep values for parameters that were not defined in the stylesheet.
1268 *
1269 * @param name The name of the parameter
1270 * @return An object that contains the value assigned to the parameter
1271 */
1272 @Override
1273 public final Object getParameter(String name) {
1274 if (_isIdentity) {
1275 return (_parameters != null) ? _parameters.get(name) : null;
1276 }
1277 else {
1278 return _translet.getParameter(name);
1279 }
1280 }
1281
1282 /**
1283 * Implements JAXP's Transformer.getURIResolver()
1284 * Set the object currently used to resolve URIs used in document().
1285 *
1286 * @return The URLResolver object currently in use
1287 */
1288 @Override
1289 public URIResolver getURIResolver() {
1290 return _uriResolver;
1291 }
1292
1293 /**
1294 * Implements JAXP's Transformer.setURIResolver()
1295 * Set an object that will be used to resolve URIs used in document().
1296 *
1297 * @param resolver The URIResolver to use in document()
1298 */
1299 @Override
1300 public void setURIResolver(URIResolver resolver) {
1301 _uriResolver = resolver;
1302 }
1303
1304 /**
1305 * This class should only be used as a DOMCache for the translet if the
1306 * URIResolver has been set.
1307 *
1308 * The method implements XSLTC's DOMCache interface, which is used to
1309 * plug in an external document loader into a translet. This method acts
1310 * as an adapter between TrAX's URIResolver interface and XSLTC's
1311 * DOMCache interface. This approach is simple, but removes the
1312 * possibility of using external document caches with XSLTC.
1313 *
1314 * @param baseURI The base URI used by the document call.
1315 * @param href The href argument passed to the document function.
1316 * @param translet A reference to the translet requesting the document
1317 */
1318 @Override
1319 public DOM retrieveDocument(String baseURI, String href, Translet translet) {
1320 try {
1321 // Argument to document function was: document('');
1322 if (href.length() == 0) {
1323 href = baseURI;
1324 }
1325
1326 /*
1327 * Fix for bug 24188
1328 * Incase the _uriResolver.resolve(href,base) is null
1329 * try to still retrieve the document before returning null
1330 * and throwing the FileNotFoundException in
1331 * com.sun.org.apache.xalan.internal.xsltc.dom.LoadDocument
1332 *
1333 */
1334 Source resolvedSource = null;
1335 if (_uriResolver != null) {
1336 resolvedSource = _uriResolver.resolve(href, baseURI);
1337 }
1338
1339 if (resolvedSource == null && _useCatalog &&
1340 _catalogFeatures.get(CatalogFeatures.Feature.FILES) != null) {
1341 if (_catalogUriResolver == null) {
1342 _catalogUriResolver = CatalogManager.catalogResolver(_catalogFeatures);
1343 }
1344 resolvedSource = _catalogUriResolver.resolve(href, baseURI);
1345 }
1346
1347 if (resolvedSource == null) {
1348 StreamSource streamSource = new StreamSource(
1349 SystemIDResolver.getAbsoluteURI(href, baseURI));
1350 return getDOM(streamSource) ;
1351 }
1352
1353 return getDOM(resolvedSource);
1354 }
1355 catch (TransformerException | CatalogException e) {
1356 if (_errorListener != null)
1357 postErrorToListener("File not found: " + e.getMessage());
1358 return(null);
1359 }
1360 }
1361
1362 /**
1363 * Receive notification of a recoverable error.
1364 * The transformer must continue to provide normal parsing events after
1365 * invoking this method. It should still be possible for the application
1366 * to process the document through to the end.
1367 *
1368 * @param e The warning information encapsulated in a transformer
1369 * exception.
1370 * @throws TransformerException if the application chooses to discontinue
1371 * the transformation (always does in our case).
1372 */
1373 @Override
1374 public void error(TransformerException e)
1375 throws TransformerException
1376 {
1377 Throwable wrapped = e.getException();
1378 if (wrapped != null) {
1379 System.err.println(new ErrorMsg(ErrorMsg.ERROR_PLUS_WRAPPED_MSG,
1380 e.getMessageAndLocation(),
1381 wrapped.getMessage()));
1382 } else {
1383 System.err.println(new ErrorMsg(ErrorMsg.ERROR_MSG,
1384 e.getMessageAndLocation()));
1385 }
1386 throw e;
1387 }
1388
1389 /**
1390 * Receive notification of a non-recoverable error.
1391 * The application must assume that the transformation cannot continue
1392 * after the Transformer has invoked this method, and should continue
1393 * (if at all) only to collect addition error messages. In fact,
1394 * Transformers are free to stop reporting events once this method has
1395 * been invoked.
1396 *
1397 * @param e The warning information encapsulated in a transformer
1398 * exception.
1399 * @throws TransformerException if the application chooses to discontinue
1400 * the transformation (always does in our case).
1401 */
1402 @Override
1403 public void fatalError(TransformerException e)
1404 throws TransformerException
1405 {
1406 Throwable wrapped = e.getException();
1407 if (wrapped != null) {
1408 System.err.println(new ErrorMsg(ErrorMsg.FATAL_ERR_PLUS_WRAPPED_MSG,
1409 e.getMessageAndLocation(),
1410 wrapped.getMessage()));
1411 } else {
1412 System.err.println(new ErrorMsg(ErrorMsg.FATAL_ERR_MSG,
1413 e.getMessageAndLocation()));
1414 }
1415 throw e;
1416 }
1417
1418 /**
1419 * Receive notification of a warning.
1420 * Transformers can use this method to report conditions that are not
1421 * errors or fatal errors. The default behaviour is to take no action.
1422 * After invoking this method, the Transformer must continue with the
1423 * transformation. It should still be possible for the application to
1424 * process the document through to the end.
1425 *
1426 * @param e The warning information encapsulated in a transformer
1427 * exception.
1428 * @throws TransformerException if the application chooses to discontinue
1429 * the transformation (never does in our case).
1430 */
1431 @Override
1432 public void warning(TransformerException e)
1433 throws TransformerException
1434 {
1435 Throwable wrapped = e.getException();
1436 if (wrapped != null) {
1437 System.err.println(new ErrorMsg(ErrorMsg.WARNING_PLUS_WRAPPED_MSG,
1438 e.getMessageAndLocation(),
1439 wrapped.getMessage()));
1440 } else {
1441 System.err.println(new ErrorMsg(ErrorMsg.WARNING_MSG,
1442 e.getMessageAndLocation()));
1443 }
1444 }
1445
1446 /**
1447 * This method resets the Transformer to its original configuration
1448 * Transformer code is reset to the same state it was when it was
1449 * created
1450 * @since 1.5
1451 */
1452 @Override
1453 public void reset() {
1454
1455 _method = null;
1456 _encoding = null;
1457 _sourceSystemId = null;
1458 _errorListener = this;
1459 _uriResolver = null;
1460 _dom = null;
1461 _parameters = null;
1462 _indentNumber = -1;
1463 setOutputProperties (null);
1464 _tohFactory = null;
1465 _ostream = null;
1466
1467 }
1468 }