mirror of git://gcc.gnu.org/git/gcc.git
677 lines
19 KiB
Java
677 lines
19 KiB
Java
/* SAXNullTransformerFactory.java --
|
|
Copyright (C) 2001 Free Software Foundation, Inc.
|
|
|
|
This file is part of GNU Classpath.
|
|
|
|
GNU Classpath is free software; you can redistribute it and/or modify
|
|
it under the terms of the GNU General Public License as published by
|
|
the Free Software Foundation; either version 2, or (at your option)
|
|
any later version.
|
|
|
|
GNU Classpath is distributed in the hope that it will be useful, but
|
|
WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
|
|
General Public License for more details.
|
|
|
|
You should have received a copy of the GNU General Public License
|
|
along with GNU Classpath; see the file COPYING. If not, write to the
|
|
Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
|
|
02110-1301 USA.
|
|
|
|
Linking this library statically or dynamically with other modules is
|
|
making a combined work based on this library. Thus, the terms and
|
|
conditions of the GNU General Public License cover the whole
|
|
combination.
|
|
|
|
As a special exception, the copyright holders of this library give you
|
|
permission to link this library with independent modules to produce an
|
|
executable, regardless of the license terms of these independent
|
|
modules, and to copy and distribute the resulting executable under
|
|
terms of your choice, provided that you also meet, for each linked
|
|
independent module, the terms and conditions of the license of that
|
|
module. An independent module is a module which is not derived from
|
|
or based on this library. If you modify this library, you may extend
|
|
this exception to your version of the library, but you are not
|
|
obligated to do so. If you do not wish to do so, delete this
|
|
exception statement from your version. */
|
|
|
|
package gnu.xml.util;
|
|
|
|
import java.io.FileOutputStream;
|
|
import java.io.IOException;
|
|
import java.io.OutputStream;
|
|
import java.net.URL;
|
|
import java.net.URLConnection;
|
|
import java.util.Hashtable;
|
|
import java.util.Properties;
|
|
|
|
import gnu.xml.dom.Consumer;
|
|
import gnu.xml.dom.DomDocument;
|
|
import gnu.xml.pipeline.DomConsumer;
|
|
import gnu.xml.pipeline.EventFilter;
|
|
|
|
import javax.xml.transform.*;
|
|
import javax.xml.transform.dom.*;
|
|
import javax.xml.transform.sax.*;
|
|
import javax.xml.transform.stream.*;
|
|
|
|
import org.xml.sax.*;
|
|
import org.xml.sax.helpers.XMLReaderFactory;
|
|
import org.xml.sax.helpers.LocatorImpl;
|
|
|
|
|
|
/**
|
|
* Implements null transforms. XSLT stylesheets are not supported.
|
|
* This class provides a way to translate three representations of
|
|
* XML data (SAX event stream, DOM tree, and XML text) into each other.
|
|
* In essence it's a thinnish wrapper around basic SAX event
|
|
* <a href="../pipeline/package-summary.html">pipeline</a> facilities, which
|
|
* exposes only limited functionality. The <em>javax.xml.transform</em>
|
|
* functionality is implemented as follows: <ul>
|
|
*
|
|
* <li>The {@link javax.xml.transform.sax.SAXSource SAXSource} class
|
|
* just wraps an {@link XMLReader} and {@link InputSource}, while the
|
|
* {@link javax.xml.transform.sax.SAXResult SAXResult} class is less
|
|
* functional than a {@link gnu.xml.pipeline.EventConsumer EventConsumer}.
|
|
* (Notably, it drops all but one declaration from any DTD.)</li>
|
|
*
|
|
* <li>The {@link javax.xml.transform.dom.DOMSource DOMSource} class
|
|
* corresponds to special SAX parsers like {@link DomParser}, and the
|
|
* {@link javax.xml.transform.dom.DOMResult DOMResult} class corresponds
|
|
* to a {@link gnu.xml.pipeline.DomConsumer DomConsumer}.</li>
|
|
*
|
|
* <li>The {@link javax.xml.transform.stream.StreamSource StreamSource}
|
|
* class corresponds to a SAX {@link InputSource}, and the
|
|
* {@link javax.xml.transform.stream.StreamResult StreamResult} class
|
|
* corresponds to a {@link gnu.xml.pipeline.TextConsumer TextConsumer}.</li>
|
|
*
|
|
* </ul>
|
|
*
|
|
* <p><em>This implementation is preliminary.</em>
|
|
*
|
|
* @see gnu.xml.pipeline.XsltFilter
|
|
*
|
|
* @author David Brownell
|
|
*/
|
|
public class SAXNullTransformerFactory extends SAXTransformerFactory
|
|
{
|
|
|
|
private ErrorListener errListener;
|
|
private URIResolver uriResolver;
|
|
|
|
/** Default constructor */
|
|
public SAXNullTransformerFactory () { }
|
|
|
|
//
|
|
// only has stuff that makes sense with null transforms
|
|
//
|
|
|
|
/**
|
|
* Returns true if the requested feature is supported.
|
|
* All three kinds of input and output are accepted:
|
|
* XML text, SAX events, and DOM nodes.
|
|
*/
|
|
public boolean getFeature (String feature)
|
|
{
|
|
return SAXTransformerFactory.FEATURE.equals (feature)
|
|
|| SAXResult.FEATURE.equals (feature)
|
|
|| SAXSource.FEATURE.equals (feature)
|
|
|| DOMResult.FEATURE.equals (feature)
|
|
|| DOMSource.FEATURE.equals (feature)
|
|
|| StreamResult.FEATURE.equals (feature)
|
|
|| StreamSource.FEATURE.equals (feature)
|
|
;
|
|
}
|
|
|
|
public void setFeature(String name, boolean value)
|
|
throws TransformerConfigurationException
|
|
{
|
|
throw new TransformerConfigurationException(name);
|
|
}
|
|
|
|
|
|
/** Throws an exception (no implementation attributes are supported) */
|
|
public void setAttribute (String key, Object value)
|
|
{
|
|
throw new IllegalArgumentException ();
|
|
}
|
|
|
|
/** Throws an exception (no implementation attributes are supported) */
|
|
public Object getAttribute (String key)
|
|
{
|
|
throw new IllegalArgumentException ();
|
|
}
|
|
|
|
/** (not yet implemented) */
|
|
public Source getAssociatedStylesheet (Source source,
|
|
String media,
|
|
String title,
|
|
String charset)
|
|
throws TransformerConfigurationException
|
|
{
|
|
// parse, and find the appropriate xsl-stylesheet PI contents
|
|
throw new IllegalArgumentException ();
|
|
}
|
|
|
|
public Transformer newTransformer ()
|
|
throws TransformerConfigurationException
|
|
{
|
|
return new NullTransformer ();
|
|
}
|
|
|
|
/**
|
|
* Returns a TransformerHandler that knows how to generate output
|
|
* in all three standard formats. Output text is generated using
|
|
* {@link XMLWriter}, and the GNU implementation of
|
|
* {@link DomDocument DOM} is used.
|
|
*
|
|
* @see SAXResult
|
|
* @see StreamResult
|
|
* @see DOMResult
|
|
*/
|
|
public TransformerHandler newTransformerHandler ()
|
|
throws TransformerConfigurationException
|
|
{
|
|
NullTransformer transformer = new NullTransformer ();
|
|
return transformer.handler;
|
|
}
|
|
|
|
//
|
|
// Stuff that depends on XSLT support, which we don't provide
|
|
//
|
|
private static final String noXSLT = "No XSLT support";
|
|
|
|
/** Throws an exception (XSLT is not supported). */
|
|
public Transformer newTransformer (Source stylesheet)
|
|
throws TransformerConfigurationException
|
|
{
|
|
throw new TransformerConfigurationException (noXSLT);
|
|
}
|
|
|
|
/** Throws an exception (XSLT is not supported). */
|
|
public Templates newTemplates (Source stylesheet)
|
|
throws TransformerConfigurationException
|
|
{
|
|
throw new TransformerConfigurationException (noXSLT);
|
|
}
|
|
|
|
/** Throws an exception (XSLT is not supported). */
|
|
public TemplatesHandler newTemplatesHandler ()
|
|
throws TransformerConfigurationException
|
|
{
|
|
throw new TransformerConfigurationException (noXSLT);
|
|
}
|
|
|
|
/** Throws an exception (XSLT is not supported). */
|
|
public TransformerHandler newTransformerHandler (Source stylesheet)
|
|
throws TransformerConfigurationException
|
|
{
|
|
throw new TransformerConfigurationException (noXSLT);
|
|
}
|
|
|
|
/** Throws an exception (XSLT is not supported). */
|
|
public TransformerHandler newTransformerHandler (Templates stylesheet)
|
|
throws TransformerConfigurationException
|
|
{
|
|
throw new TransformerConfigurationException (noXSLT);
|
|
}
|
|
|
|
/** Throws an exception (XSLT is not supported). */
|
|
public XMLFilter newXMLFilter (Source stylesheet)
|
|
throws TransformerConfigurationException
|
|
{
|
|
throw new TransformerConfigurationException (noXSLT);
|
|
}
|
|
|
|
/** Throws an exception (XSLT is not supported). */
|
|
public XMLFilter newXMLFilter (Templates stylesheet)
|
|
throws TransformerConfigurationException
|
|
{
|
|
throw new TransformerConfigurationException (noXSLT);
|
|
}
|
|
|
|
/** Returns the value assigned by {@link #setErrorListener}. */
|
|
public ErrorListener getErrorListener ()
|
|
{
|
|
return errListener;
|
|
}
|
|
|
|
/** Assigns a value that would be used when parsing stylesheets */
|
|
public void setErrorListener (ErrorListener e)
|
|
{
|
|
errListener = e;
|
|
}
|
|
|
|
/** Returns the value assigned by {@link #setURIResolver}. */
|
|
public URIResolver getURIResolver ()
|
|
{
|
|
return uriResolver;
|
|
}
|
|
|
|
/** Assigns a value that would be used when parsing stylesheets */
|
|
public void setURIResolver (URIResolver u)
|
|
{
|
|
uriResolver = u;
|
|
}
|
|
|
|
|
|
//
|
|
// Helper classes. These might in theory be subclassed
|
|
// by an XSLT implementation, if they were exported.
|
|
//
|
|
|
|
static class DomTerminus
|
|
extends DomConsumer
|
|
{
|
|
|
|
DomTerminus (DOMResult result)
|
|
throws SAXException
|
|
{
|
|
// won't really throw SAXException
|
|
super (DomDocument.class);
|
|
setHandler (new DomHandler (this, result));
|
|
}
|
|
|
|
}
|
|
|
|
static class DomHandler
|
|
extends Consumer.Backdoor
|
|
{
|
|
|
|
private DOMResult result;
|
|
|
|
DomHandler (DomConsumer c, DOMResult r)
|
|
throws SAXException
|
|
{
|
|
// won't really throw SAXException
|
|
super (c);
|
|
result = r;
|
|
}
|
|
|
|
public void endDocument ()
|
|
throws SAXException
|
|
{
|
|
super.endDocument ();
|
|
result.setNode (getDocument ());
|
|
}
|
|
|
|
}
|
|
|
|
private static OutputStream getOutputStream (String uri)
|
|
throws IOException
|
|
{
|
|
// JDK stupidity: file "protocol does not support output" ...
|
|
if (uri.startsWith ("file:"))
|
|
return new FileOutputStream (uri.substring (5));
|
|
|
|
// Otherwise ...
|
|
URL url = new URL (uri);
|
|
URLConnection conn = url.openConnection ();
|
|
|
|
conn.setDoOutput (true);
|
|
return conn.getOutputStream ();
|
|
}
|
|
|
|
|
|
static class NullHandler
|
|
extends EventFilter
|
|
implements TransformerHandler
|
|
{
|
|
|
|
private String systemId;
|
|
private Transformer transformer;
|
|
|
|
NullHandler (Transformer t)
|
|
{
|
|
transformer = t;
|
|
}
|
|
|
|
public Transformer getTransformer ()
|
|
{
|
|
return transformer;
|
|
}
|
|
|
|
public String getSystemId ()
|
|
{
|
|
return systemId;
|
|
}
|
|
|
|
public void setSystemId (String id)
|
|
{
|
|
systemId = id;
|
|
}
|
|
|
|
public void setResult (Result result)
|
|
{
|
|
if (result.getSystemId () != null)
|
|
systemId = result.getSystemId ();
|
|
|
|
try
|
|
{
|
|
|
|
// output to partial SAX event stream?
|
|
if (result instanceof SAXResult)
|
|
{
|
|
SAXResult r = (SAXResult) result;
|
|
|
|
setContentHandler (r.getHandler ());
|
|
setProperty (LEXICAL_HANDLER, r.getLexicalHandler ());
|
|
// DTD info is filtered out by javax.transform
|
|
|
|
// output to DOM tree?
|
|
}
|
|
else if (result instanceof DOMResult)
|
|
{
|
|
DomTerminus out = new DomTerminus ((DOMResult) result);
|
|
|
|
setContentHandler (out.getContentHandler ());
|
|
setProperty (LEXICAL_HANDLER,
|
|
out.getProperty (LEXICAL_HANDLER));
|
|
// save DTD-derived info, if any.
|
|
setDTDHandler (out.getDTDHandler ());
|
|
setProperty (DECL_HANDLER,
|
|
out.getProperty (DECL_HANDLER));
|
|
|
|
// node is saved into result on endDocument()
|
|
|
|
// output to (XML) text?
|
|
}
|
|
else if (result instanceof StreamResult)
|
|
{
|
|
StreamResult r = (StreamResult) result;
|
|
XMLWriter out;
|
|
|
|
// FIXME: when do output properties take effect?
|
|
// encoding, standalone decl, xml/xhtml/... ...
|
|
|
|
// FIXME: maybe put nsfix filter up front
|
|
|
|
try
|
|
{
|
|
if (r.getWriter () != null)
|
|
out = new XMLWriter (r.getWriter ());
|
|
else if (r.getOutputStream () != null)
|
|
out = new XMLWriter (r.getOutputStream ());
|
|
else if (r.getSystemId () != null)
|
|
out = new XMLWriter (
|
|
getOutputStream (r.getSystemId ()));
|
|
else
|
|
throw new IllegalArgumentException (
|
|
"bad StreamResult");
|
|
}
|
|
catch (IOException e)
|
|
{
|
|
e.printStackTrace ();
|
|
// on jdk 1.4, pass the root cause ...
|
|
throw new IllegalArgumentException (e.getMessage ());
|
|
}
|
|
|
|
// out.setExpandingEntities (true);
|
|
// out.setPrettyPrinting (true);
|
|
// out.setXhtml (true);
|
|
|
|
setContentHandler (out);
|
|
setProperty (LEXICAL_HANDLER, out);
|
|
// save DTD info, if any; why not?
|
|
setDTDHandler (out);
|
|
setProperty (DECL_HANDLER, out);
|
|
}
|
|
|
|
}
|
|
catch (SAXException e)
|
|
{
|
|
// SAXNotSupportedException or SAXNotRecognizedException:
|
|
// "can't happen" ... but SAXException for DOM build probs
|
|
// could happen, so ...
|
|
// on jdk 1.4, pass the root cause ...
|
|
throw new IllegalArgumentException (e.getMessage ());
|
|
}
|
|
}
|
|
}
|
|
|
|
// an interface that adds no value
|
|
static class LocatorAdapter
|
|
extends LocatorImpl
|
|
implements SourceLocator
|
|
{
|
|
|
|
LocatorAdapter (SAXParseException e)
|
|
{
|
|
setSystemId (e.getSystemId ());
|
|
setPublicId (e.getPublicId ());
|
|
setLineNumber (e.getLineNumber ());
|
|
setColumnNumber (e.getColumnNumber ());
|
|
}
|
|
|
|
}
|
|
|
|
// another interface that adds no value
|
|
static class ListenerAdapter
|
|
implements ErrorHandler
|
|
{
|
|
|
|
NullTransformer transformer;
|
|
|
|
ListenerAdapter (NullTransformer t)
|
|
{
|
|
transformer = t;
|
|
}
|
|
|
|
private TransformerException map (SAXParseException e)
|
|
{
|
|
return new TransformerException (
|
|
e.getMessage (),
|
|
new LocatorAdapter (e),
|
|
e);
|
|
}
|
|
|
|
public void error (SAXParseException e)
|
|
throws SAXParseException
|
|
{
|
|
try
|
|
{
|
|
if (transformer.errListener != null)
|
|
transformer.errListener.error (map (e));
|
|
}
|
|
catch (TransformerException ex)
|
|
{
|
|
transformer.ex = ex;
|
|
throw e;
|
|
}
|
|
}
|
|
|
|
public void fatalError (SAXParseException e)
|
|
throws SAXParseException
|
|
{
|
|
try
|
|
{
|
|
if (transformer.errListener != null)
|
|
transformer.errListener.fatalError (map (e));
|
|
else
|
|
throw map (e);
|
|
} catch (TransformerException ex) {
|
|
transformer.ex = ex;
|
|
throw e;
|
|
}
|
|
}
|
|
|
|
public void warning (SAXParseException e)
|
|
throws SAXParseException
|
|
{
|
|
try
|
|
{
|
|
if (transformer.errListener != null)
|
|
transformer.errListener.warning (map (e));
|
|
}
|
|
catch (TransformerException ex)
|
|
{
|
|
transformer.ex = ex;
|
|
throw e;
|
|
}
|
|
}
|
|
}
|
|
|
|
static class NullTransformer
|
|
extends Transformer
|
|
{
|
|
|
|
private URIResolver uriResolver;
|
|
private Properties props = new Properties ();
|
|
private Hashtable params = new Hashtable (7);
|
|
|
|
ErrorListener errListener = null;
|
|
TransformerException ex = null;
|
|
NullHandler handler;
|
|
|
|
NullTransformer ()
|
|
{
|
|
super ();
|
|
handler = new NullHandler (this);
|
|
}
|
|
|
|
public ErrorListener getErrorListener ()
|
|
{
|
|
return errListener;
|
|
}
|
|
|
|
public void setErrorListener (ErrorListener e)
|
|
{
|
|
errListener = e;
|
|
}
|
|
|
|
public URIResolver getURIResolver ()
|
|
{
|
|
return uriResolver;
|
|
}
|
|
|
|
public void setURIResolver (URIResolver u)
|
|
{
|
|
uriResolver = u;
|
|
}
|
|
|
|
public void setOutputProperties (Properties p)
|
|
{
|
|
props = (Properties) p.clone ();
|
|
}
|
|
|
|
public Properties getOutputProperties ()
|
|
{
|
|
return (Properties) props.clone ();
|
|
}
|
|
|
|
public void setOutputProperty (String name, String value)
|
|
{
|
|
props.setProperty (name, value);
|
|
}
|
|
|
|
public String getOutputProperty (String name)
|
|
{
|
|
return props.getProperty (name);
|
|
}
|
|
|
|
public void clearParameters ()
|
|
{
|
|
params.clear ();
|
|
}
|
|
|
|
public void setParameter (String name, Object value)
|
|
{
|
|
props.put (name, value);
|
|
}
|
|
|
|
public Object getParameter (String name)
|
|
{
|
|
return props.get (name);
|
|
}
|
|
|
|
public void transform (Source in, Result out)
|
|
throws TransformerException
|
|
{
|
|
try
|
|
{
|
|
XMLReader producer;
|
|
InputSource input;
|
|
|
|
// Input from DOM?
|
|
if (in instanceof DOMSource)
|
|
{
|
|
DOMSource source = (DOMSource) in;
|
|
|
|
if (source.getNode () == null)
|
|
throw new IllegalArgumentException ("no DOM node");
|
|
producer = new DomParser (source.getNode ());
|
|
input = null;
|
|
|
|
// Input from SAX?
|
|
}
|
|
else if (in instanceof SAXSource)
|
|
{
|
|
SAXSource source = (SAXSource) in;
|
|
|
|
producer = source.getXMLReader ();
|
|
if (producer == null)
|
|
producer = XMLReaderFactory.createXMLReader ();
|
|
|
|
input = source.getInputSource ();
|
|
if (input == null)
|
|
{
|
|
if (source.getSystemId () != null)
|
|
input = new InputSource (source.getSystemId ());
|
|
else
|
|
throw new IllegalArgumentException (
|
|
"missing SAX input");
|
|
}
|
|
|
|
// Input from a stream or something?
|
|
}
|
|
else
|
|
{
|
|
producer = XMLReaderFactory.createXMLReader ();
|
|
input = SAXSource.sourceToInputSource (in);
|
|
if (input == null)
|
|
throw new IllegalArgumentException ("missing input");
|
|
}
|
|
|
|
// preserve original namespace prefixes
|
|
try
|
|
{
|
|
producer.setFeature(EventFilter.FEATURE_URI +
|
|
"namespace-prefixes",
|
|
true);
|
|
}
|
|
catch (Exception e)
|
|
{
|
|
/* ignore */
|
|
// FIXME if we couldn't, "NsFix" stage before the output ..
|
|
}
|
|
|
|
// arrange the output
|
|
handler.setResult (out);
|
|
EventFilter.bind (producer, handler);
|
|
|
|
// then parse ... single element pipeline
|
|
producer.parse (input);
|
|
|
|
}
|
|
catch (IOException e)
|
|
{
|
|
throw new TransformerException ("transform failed", e);
|
|
|
|
}
|
|
catch (SAXException e)
|
|
{
|
|
if (ex == null && ex.getCause () == e)
|
|
throw ex;
|
|
else
|
|
throw new TransformerException ("transform failed", e);
|
|
|
|
}
|
|
finally
|
|
{
|
|
ex = null;
|
|
}
|
|
}
|
|
}
|
|
|
|
}
|