src/org/apache/xalan/xsltc/trax/TransformerImpl.java

/*
 * @(#)$Id$
 *
 * The Apache Software License, Version 1.1
 *
 *
 * Copyright (c) 2001 The Apache Software Foundation.  All rights
 * reserved.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions
 * are met:
 *
 * 1. Redistributions of source code must retain the above copyright
 *    notice, this list of conditions and the following disclaimer.
 *
 * 2. Redistributions in binary form must reproduce the above copyright
 *    notice, this list of conditions and the following disclaimer in
 *    the documentation and/or other materials provided with the
 *    distribution.
 *
 * 3. The end-user documentation included with the redistribution,
 *    if any, must include the following acknowledgment:
 *       "This product includes software developed by the
 *        Apache Software Foundation (http://www.apache.org/)."
 *    Alternately, this acknowledgment may appear in the software itself,
 *    if and wherever such third-party acknowledgments normally appear.
 *
 * 4. The names "Xalan" and "Apache Software Foundation" must
 *    not be used to endorse or promote products derived from this
 *    software without prior written permission. For written
 *    permission, please contact apache@apache.org.
 *
 * 5. Products derived from this software may not be called "Apache",
 *    nor may "Apache" appear in their name, without prior written
 *    permission of the Apache Software Foundation.
 *
 * THIS SOFTWARE IS PROVIDED ``AS IS'' AND ANY EXPRESSED OR IMPLIED
 * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
 * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
 * DISCLAIMED.  IN NO EVENT SHALL THE APACHE SOFTWARE FOUNDATION OR
 * ITS CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
 * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
 * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF
 * USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
 * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
 * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT
 * OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
 * SUCH DAMAGE.
 * ====================================================================
 *
 * This software consists of voluntary contributions made by many
 * individuals on behalf of the Apache Software Foundation and was
 * originally based on software copyright (c) 2001, Sun
 * Microsystems., http://www.sun.com.  For more
 * information on the Apache Software Foundation, please see
 * <http://www.apache.org/>.
 *
 * @author Morten Jorgensen
 * @author G. Todd Miller
 *
 */

package org.apache.xalan.xsltc.trax;

import java.io.File;
import java.io.Writer;
import java.io.Reader;
import java.io.InputStream;
import java.io.OutputStream;
import java.io.FileOutputStream;
import java.io.FileNotFoundException;
import java.io.IOException;

import java.net.URL;
import java.net.URLConnection;
import java.net.MalformedURLException;
import java.net.UnknownHostException;
import java.net.UnknownServiceException;

import java.lang.IllegalArgumentException;
import java.util.Enumeration;
import java.util.StringTokenizer;

import org.xml.sax.XMLReader;
import org.xml.sax.ContentHandler;
import org.xml.sax.InputSource;
import org.xml.sax.ext.LexicalHandler;

import org.w3c.dom.Document;

import javax.xml.parsers.SAXParser;
import javax.xml.parsers.SAXParserFactory;
import javax.xml.parsers.ParserConfigurationException;
import javax.xml.transform.*;
import javax.xml.transform.sax.*;
import javax.xml.transform.dom.*;
import javax.xml.transform.stream.*;

import org.apache.xalan.xsltc.Translet;
import org.apache.xalan.xsltc.TransletException;
import org.apache.xalan.xsltc.DOMCache;
import org.apache.xalan.xsltc.dom.*;
import org.apache.xalan.xsltc.runtime.*;
import org.apache.xalan.xsltc.compiler.*;

import java.util.Properties;

public final class TransformerImpl extends Transformer implements DOMCache {

    private AbstractTranslet _translet = null;
    private String           _encoding = null;
    private ContentHandler   _handler = null;

    private ErrorListener _errorListener = null;
    private URIResolver   _uriResolver = null;
    private Properties    _properties = null;

    // Used for default output property settings
    private final static String EMPTY_STRING = "";
    private final static String NO_STRING    = "no";
    private final static String YES_STRING   = "yes";
    private final static String XML_STRING   = "xml";

    // Pre-set DOMImpl to use as input (used only with TransformerHandlerImpl)
    private DOMImpl _dom = null;
    
    // List all error messages here
    private final static String TRANSLET_ERR_MSG = 
	"The transformer has no encapsulated translet object.";
    private final static String HANDLER_ERR_MSG = 
	"No defined output handler for transformation result.";
    private static final String ERROR_LISTENER_NULL =
	"Attempting to set ErrorListener for Transformer to null";
    private static final String INPUT_SOURCE_EMPTY =
	"The Source object passed to transform() has no contents.";
    private static final String OUTPUT_RESULT_EMPTY =
	"The Result object passed to transform() is invalid.";

    /**
     * Implements JAXP's Transformer constructor
     * Our Transformer objects always need a translet to do the actual work
     */
    protected TransformerImpl(Translet translet) {
	_translet = (AbstractTranslet)translet;
    }

    /**
     * Returns the translet wrapped inside this Transformer
     */
    protected AbstractTranslet getTranslet() {
	return(_translet);
    }

    /**
     * Implements JAXP's Transformer.transform()
     *
     * @param source Contains the input XML document
     * @param result Will contain the output from the transformation
     * @throws TransformerException
     */
    public void transform(Source source, Result result)
	throws TransformerException {

	if (_translet == null) {
	    throw new TransformerException(TRANSLET_ERR_MSG);
	}

	_handler = getOutputHandler(result);
	if (_handler == null) { 
	    throw new TransformerException(HANDLER_ERR_MSG);
	}

	if (_uriResolver != null) {
	    _translet.setDOMCache(this);
	}

	// Run the transformation
	transform(source, (ContentHandler)_handler, _encoding);

	// If a DOMResult, then we must set the DOM Tree so it can
	// be retrieved later 
	if (result instanceof DOMResult) {
	    ((DOMResult)result).setNode(((SAX2DOM)_handler).getDOM());
	}
    }

    /**
     * Create an output handler (SAX2 handler) for the transformation output
     * based on the type and contents of the TrAX Result object passed to
     * the transform() method. Only StreamResult and SAXResult are currently
     * handled.
     */
    private ContentHandler getOutputHandler(Result result) 
	throws TransformerException {
	// Try to get the encoding from Translet (may not be set)
	if (_translet._encoding != null)
	    _encoding = _translet._encoding;
	else
	    _encoding = "utf-8"; // default output encoding

	try {
	    String systemId = result.getSystemId();

	    // Handle SAXResult output handler
	    if (result instanceof SAXResult) {
		final SAXResult target = (SAXResult)result;
		final ContentHandler handler = target.getHandler();
		// Simple as feck, just pass the SAX handler back...
		if (handler != null) return handler;
	    }
	    // Handle StreamResult output handler
	    else if (result instanceof StreamResult) {
		final StreamResult target = (StreamResult)result;
		final OutputStream ostream = target.getOutputStream();
		final Writer writer = target.getWriter();

		if (ostream != null)
		    return (new DefaultSAXOutputHandler(ostream, _encoding));
		else if (writer != null)
		    return (new DefaultSAXOutputHandler(writer, _encoding));
	    }
	    // Handle DOMResult output handler
	    else if (result instanceof DOMResult) {
		return (new SAX2DOM());
	    }

	    // Common, final handling of all input sources, only used if the
	    // other contents of the Result object could not be used
	    if (systemId != null) {
		if ((new File(systemId)).exists())
		    systemId = "file:/"+systemId;
		final URL url = new URL(systemId);
		final URLConnection connection = url.openConnection();
		final OutputStream ostream = connection.getOutputStream();
		return(new DefaultSAXOutputHandler(ostream, _encoding));
	    }
	    else {
		throw new TransformerException(OUTPUT_RESULT_EMPTY);
	    }
	}
	// If we cannot write to the location specified by the SystemId
	catch (UnknownServiceException e) {
	    throw new TransformerException(e);
	}
	// If we cannot create a SAX2DOM adapter
	catch (ParserConfigurationException e) {
	    throw new TransformerException(
		"SAX2DOM adapter could not be created, " + e.getMessage());
	}
	// If we cannot create the file specified by the SystemId
	catch (IOException e) {
	    throw new TransformerException(e);
	}
    }

    /**
     * Set the internal DOMImpl that will be used for the next transformation
     */
    protected void setDOM(DOMImpl dom) {
	_dom = dom;
    }

    /**
     * Builds an internal DOM from a TrAX Source object
     */
    private DOMImpl getDOM(Source source, int mask)
	throws TransformerException {
	try {
	    // Use the pre-defined DOM if present
	    if (_dom != null) {
		DOMImpl dom = _dom;
		_dom = null; // use only once, so reset to 'null'
		return(dom);
	    }

	    // Create an internal DOM (not W3C) and get SAX2 input handler
	    final DOMImpl dom = new DOMImpl();
	    final ContentHandler inputHandler = dom.getBuilder();

	    // Create a DTDMonitor that will trace all unparsed entity URIs
	    final DTDMonitor dtdMonitor = new DTDMonitor();

	    // Handle SAXSource input
	    if (source instanceof SAXSource) {
		// Get all info from the input SAXSource object
		final SAXSource   sax    = (SAXSource)source;
		final XMLReader   reader = sax.getXMLReader();
		final InputSource input  = sax.getInputSource();
		final String      systemId = sax.getSystemId();
		dtdMonitor.handleDTD(reader);
		reader.setContentHandler(inputHandler);
		reader.parse(input);
		dom.setDocumentURI(systemId);
	    }
	    // Handle DOMSource input
	    else if (source instanceof DOMSource) {
		final DOMSource   domsrc = (DOMSource)source;
		final Document    tree = (Document)domsrc.getNode();
		final DOM2SAX     dom2sax = new DOM2SAX(tree);
		final InputSource input = null; 
		final String      systemId = domsrc.getSystemId(); 
		dtdMonitor.handleDTD(dom2sax);
		dom2sax.setContentHandler(inputHandler);
		dom2sax.parse(input); // need this parameter?
		dom.setDocumentURI(systemId);
	    }
	    // Handle StreamSource input
	    else if (source instanceof StreamSource) {
		// With a StreamSource we need to create our own parser
		final SAXParserFactory factory = SAXParserFactory.newInstance();
		final SAXParser parser = factory.newSAXParser();
		final XMLReader reader = parser.getXMLReader();
		dtdMonitor.handleDTD(reader);

		// Get all info from the input StreamSource object
		final StreamSource stream = (StreamSource)source;
		final InputStream  streamInput = stream.getInputStream();
		final Reader streamReader = stream.getReader();
		final String systemId = stream.getSystemId();

		reader.setContentHandler(inputHandler);
		
		InputSource input;
		if (streamInput != null)
		    input = new InputSource(streamInput);
		else if (streamReader != null)
		    input = new InputSource(streamReader);
		else if (systemId != null)
		    input = new InputSource(systemId);
		else
		    throw new TransformerException(INPUT_SOURCE_EMPTY);
		reader.parse(input);
		dom.setDocumentURI(systemId);
	    }
	    else {
		return null;
	    }

	    // Set size of key/id indices
	    _translet.setIndexSize(dom.getSize());
	    // If there are any elements with ID attributes, build an index
	    dtdMonitor.buildIdIndex(dom, mask, _translet);
	    // Pass unparsed entity URIs to the translet
	    _translet.setDTDMonitor(dtdMonitor);
	    return dom;
	}
	catch (FileNotFoundException e) {
	    if (_errorListener != null)
		postErrorToListener("File not found: " + e.getMessage());
	    throw new TransformerException(e);
	}
	catch (MalformedURLException e) {
	    if (_errorListener != null)
		postErrorToListener("Malformed URL: " + e.getMessage());
	    throw new TransformerException(e);
	}
	catch (UnknownHostException e) {
	    if (_errorListener != null)
		postErrorToListener("Cannot resolve URI: " + e.getMessage());
	    throw new TransformerException(e);
	}
	catch (Exception e) {
	    if (_errorListener != null)
		postErrorToListener("Internal error: " + e.getMessage()); 
	    throw new TransformerException(e);
	}
    }
 
    /**
     * Internal transformation method - uses the internal APIs of XSLTC
     */
    private void transform(Source src, ContentHandler sax, String encoding)
	throws TransformerException {
	try {
	    // Build an iternal DOMImpl from the TrAX Source
	    DOMImpl dom = getDOM(src, 0);

	    // Pass output properties to the translet
	    setOutputProperties(_translet, _properties);
	    
	    // This handler will post-process the translet output
	    TextOutput handler;

	    // Check if the ContentHandler also implements LexicalHandler
	    if (sax instanceof LexicalHandler)
		handler = new TextOutput(sax, (LexicalHandler)sax, encoding);
	    else
		handler = new TextOutput(sax, encoding);
	    _translet.transform(dom, handler);
	}
	catch (TransletException e) {
	    if (_errorListener != null)
		postErrorToListener(e.getMessage());
	    throw new TransformerException(e);
	}
	catch (RuntimeException e) {
	    if (_errorListener != null)
		postErrorToListener("Runtime Error: " + e.getMessage());
	    System.err.println("Error: "+e.getMessage());
	    e.printStackTrace();
	    throw new TransformerException(e);
	}
	catch (Exception e) {
	    if (_errorListener != null)
		postErrorToListener("Internal error: " + e.getMessage()); 
	    throw new TransformerException(e);
	}
    }

    /**
     * Implements JAXP's Transformer.getErrorListener()
     * Get the error event handler in effect for the transformation.
     *
     * @return The error event handler currently in effect
     */
    public ErrorListener getErrorListener() {  
	return _errorListener; 
    }

    /**
     * Implements JAXP's Transformer.setErrorListener()
     * Set the error event listener in effect for the transformation.
     *
     * @param listener The error event listener to use
     * @throws IllegalArgumentException
     */
    public void setErrorListener(ErrorListener listener)
	throws IllegalArgumentException {
        if (listener == null)
            throw new IllegalArgumentException(ERROR_LISTENER_NULL);
        _errorListener = listener;
    }

    /**
     * Inform TrAX error listener of an error
     */
    private void postErrorToListener(String message) {
        try {
            _errorListener.error(new TransformerException(message));
	}
	catch (TransformerException e) {
            // ignored - transformation cannot be continued
        }
    }

    /**
     * Inform TrAX error listener of a warning
     */
    private void postWarningToListener(String message) {
        try {
            _errorListener.warning(new TransformerException(message));
        }
	catch (TransformerException e) {
            // ignored - transformation cannot be continued
        }
    }

    /**
     * Implements JAXP's Transformer.getOutputProperties().
     * Returns a copy of the output properties for the transformation. Note that
     * this method will only return properties that were set in this class.
     * The output settings defined in the stylesheet's <xsl:output> element
     * and default XSLT output settings will not be returned by this method.
     *
     * @return Properties explicitly set for this Transformer
     */
    public Properties getOutputProperties() {
	return(_properties);
    }

    /**
     * The translet stores all CDATA sections set in the <xsl:output> element
     * in a Hashtable. This method will re-construct the whitespace separated
     * list of elements given in the <xsl:output> element.
     */
    private String makeCDATAString(Hashtable cdata) {
	// Return a 'null' string if no CDATA section elements were specified
	if (cdata == null) return null;

	StringBuffer result = new StringBuffer();

	// Get an enumeration of all the elements in the hashtable
	Enumeration elements = cdata.keys();
	if (elements.hasMoreElements()) {
	    result.append((String)elements.nextElement());
	    while (elements.hasMoreElements()) {
		String element = (String)elements.nextElement();
		result.append(' ');
		result.append(element);
	    }
	}
	
	return(result.toString());
    }

    /**
     * Implements JAXP's Transformer.getOutputProperty().
     * Get an output property that is in effect for the transformation. The
     * property specified may be a property that was set with setOutputProperty,
     * or it may be a property specified in the stylesheet.
     *
     * @param name A non-null string that contains the name of the property
     * @throws IllegalArgumentException if the property name is not known
     */
    public String getOutputProperty(String name)
	throws IllegalArgumentException {

	String value = null;

	// Level1: Check if the property is overridden in this Transformer
	if (_properties != null) value = _properties.getProperty(name);

	// Level2: Check if the property value is set in the translet
	if ((value == null) && (_translet != null)) {
	    if (name.equals(OutputKeys.ENCODING))
		value = _translet._encoding;
	    else if (name.equals(OutputKeys.METHOD))
		value = _translet._method;
	    else if (name.equals(OutputKeys.INDENT))
		value = (new Boolean(_translet._indent)).toString();
	    else if (name.equals(OutputKeys.DOCTYPE_PUBLIC))
		value = _translet._doctypePublic;
	    else if (name.equals(OutputKeys.DOCTYPE_SYSTEM))
		value = _translet._doctypeSystem;
	    else if (name.equals(OutputKeys.CDATA_SECTION_ELEMENTS))
		value = makeCDATAString(_translet._cdata);
	    else if (name.equals(OutputKeys.MEDIA_TYPE))
		value = _translet._mediaType;
	    else if (name.equals(OutputKeys.OMIT_XML_DECLARATION))
		value = (new Boolean(_translet._omitHeader)).toString();
	    else if (name.equals(OutputKeys.STANDALONE))
		value = _translet._standalone;
	    else if (name.equals(OutputKeys.VERSION))
		value = _translet._version;
	}

	// Level3: Return the default property value
	if (value == null) {
	    if (name.equals(OutputKeys.ENCODING))
		value = "utf-8";
	    else if (name.equals(OutputKeys.METHOD))
		value = XML_STRING;
	    else if (name.equals(OutputKeys.INDENT))
		value = NO_STRING;
	    else if (name.equals(OutputKeys.DOCTYPE_PUBLIC))
		value = EMPTY_STRING;
	    else if (name.equals(OutputKeys.DOCTYPE_SYSTEM))
		value = EMPTY_STRING;
	    else if (name.equals(OutputKeys.CDATA_SECTION_ELEMENTS))
		value = EMPTY_STRING;
	    else if (name.equals(OutputKeys.MEDIA_TYPE))
		value = "text/xml";
	    else if (name.equals(OutputKeys.OMIT_XML_DECLARATION))
		value = NO_STRING;
	    else if (name.equals(OutputKeys.STANDALONE))
		value = NO_STRING;
	    else if (name.equals(OutputKeys.VERSION))
		value = "1.0";
	}

	return value;
    }

    /**
     * Implements JAXP's Transformer.setOutputProperties().
     * Set the output properties for the transformation. These properties
     * will override properties set in the Templates with xsl:output.
     * Unrecognised properties will be quitely ignored.
     *
     * @param properties The properties to use for the Transformer
     * @throws IllegalArgumentException Never, errors are ignored
     */
    public void setOutputProperties(Properties properties)
	throws IllegalArgumentException {
	_properties = properties;
    }

    /**
     * Implements JAXP's Transformer.setOutputProperty().
     * Get an output property that is in effect for the transformation. The
     * property specified may be a property that was set with 
     * setOutputProperty(), or it may be a property specified in the stylesheet.
     *
     * @param name The name of the property to set
     * @param value The value to assign to the property
     * @throws IllegalArgumentException Never, errors are ignored
     */
    public void setOutputProperty(String name, String value)
	throws IllegalArgumentException {
	if (_properties == null) _properties = new Properties();
	_properties.setProperty(name, value);
    }

    /**
     * Internal method to pass any properties to the translet prior to
     * initiating the transformation
     */
    private void setOutputProperties(AbstractTranslet translet,
				     Properties properties) {
	// Return right now if no properties are set
	if (properties == null) return;

	// Get a list of all the defined properties
	Enumeration names = properties.propertyNames();
	while (names.hasMoreElements()) {
	    // Get the next property name and value
	    String name = (String)names.nextElement();
	    String value = properties.getProperty(name);

	    // Pass property value to translet - override previous setting
	    if (name.equals(OutputKeys.ENCODING))
		translet._encoding = value;
	    else if (name.equals(OutputKeys.METHOD))
		translet._method = value;
	    else if (name.equals(OutputKeys.DOCTYPE_PUBLIC))
		translet._doctypePublic = value;
	    else if (name.equals(OutputKeys.DOCTYPE_SYSTEM))
		translet._doctypeSystem = value;
	    else if (name.equals(OutputKeys.MEDIA_TYPE))
		translet._mediaType = value;
	    else if (name.equals(OutputKeys.STANDALONE))
		translet._standalone = value;
	    else if (name.equals(OutputKeys.VERSION))
		translet._version = value;
	    else if (name.equals(OutputKeys.OMIT_XML_DECLARATION)) {
		if ((value != null) == (value.toLowerCase().equals("true"))) {
		    translet._omitHeader = true;
		}
	    }
	    else if (name.equals(OutputKeys.INDENT)) {
		if ((value != null) == (value.toLowerCase().equals("true"))) {
		    translet._indent = true;
		}
	    }
	    else if (name.equals(OutputKeys.CDATA_SECTION_ELEMENTS)) {
		translet._cdata = null; // Important - clear previous setting
		StringTokenizer e = new StringTokenizer(value);
		while (e.hasMoreTokens()) {
		    translet.addCdataElement(e.nextToken());
		}
	    }

	}
    }

    /**
     * Implements JAXP's Transformer.setParameter()
     * Add a parameter for the transformation. The parameter is simply passed
     * on to the translet - no validation is performed - so any unused
     * parameters are quitely ignored by the translet.
     *
     * @param name The name of the parameter
     * @param value The value to assign to the parameter
     */
    public void setParameter(String name, Object value) { 
	_translet.addParameter(name, value, false);
    }

    /**
     * Implements JAXP's Transformer.clearParameters()
     * Clear all parameters set with setParameter. Clears the translet's
     * parameter stack.
     */
    public void clearParameters() {  
	_translet.clearParameters();
    }

    /**
     * Implements JAXP's Transformer.getParameter()
     * Returns the value of a given parameter. Note that the translet will not
     * keep values for parameters that were not defined in the stylesheet.
     *
     * @param name The name of the parameter
     * @return An object that contains the value assigned to the parameter
     */
    public final Object getParameter(String name) {
	return(_translet.getParameter(name));
    }

    /**
     * Implements JAXP's Transformer.getURIResolver()
     * Set the object currently used to resolve URIs used in document().
     *
     * @returns The URLResolver object currently in use
     */
    public URIResolver getURIResolver() {
	return _uriResolver;
    }

    /**
     * Implements JAXP's Transformer.setURIResolver()
     * Set an object that will be used to resolve URIs used in document().
     *
     * @param resolver The URIResolver to use in document()
     */
    public void setURIResolver(URIResolver resolver) { 
	_uriResolver = resolver;
    }

    /**
     * This class should only be used as a DOMCache for the translet if the
     * URIResolver has been set.
     *
     * The method implements XSLTC's DOMCache interface, which is used to
     * plug in an external document loader into a translet. This method acts
     * as an adapter between TrAX's URIResolver interface and XSLTC's
     * DOMCache interface. This approach is simple, but removes the
     * possibility of using external document caches with XSLTC.
     *
     * @param uri  An URI pointing to the document location
     * @param mask Contains a document ID (passed from the translet)
     * @param translet A reference to the translet requesting the document
     */
    public DOMImpl retrieveDocument(String uri, int mask, Translet translet) {
	try {
	    return(getDOM(_uriResolver.resolve(uri, ""), mask));
	}
	catch (TransformerException e) {
	    if (_errorListener != null)
		postErrorToListener("File not found: " + e.getMessage());
	    return(null);
	}
    }
}