Subversion Repositories openrisc

/* SAXParser.java --

   Copyright (C) 2005, 2006, 2007  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.stream;

import java.io.InputStream;

import java.io.IOException;

import java.io.Reader;

import java.net.URL;

import java.util.Iterator;

import java.util.Map;

import javax.xml.XMLConstants;

import javax.xml.namespace.QName;

import javax.xml.stream.Location;

import javax.xml.stream.XMLEventReader;

import javax.xml.stream.XMLReporter;

import javax.xml.stream.XMLResolver;

import javax.xml.stream.XMLStreamConstants;

import javax.xml.stream.XMLStreamException;

import javax.xml.stream.XMLStreamReader;

import org.xml.sax.ContentHandler;

import org.xml.sax.DTDHandler;

import org.xml.sax.EntityResolver;

import org.xml.sax.ErrorHandler;

import org.xml.sax.InputSource;

import org.xml.sax.Parser;

import org.xml.sax.SAXException;

import org.xml.sax.SAXNotRecognizedException;

import org.xml.sax.SAXNotSupportedException;

import org.xml.sax.SAXParseException;

import org.xml.sax.XMLReader;

import org.xml.sax.ext.Attributes2;

import org.xml.sax.ext.DeclHandler;

import org.xml.sax.ext.LexicalHandler;

import org.xml.sax.ext.Locator2;

/**

 * JAXP SAX parser using an underlying StAX parser.

 * This parser supports the following additional SAX features and

 * properties:

 * <table>

 * <tr><th colspan='4'>Features</th></tr>

 * <tr><td>http://gnu.org/sax/features/xml-base</td>

 * <td colspan='2'>read/write</td>

 * <td>Indicates or sets whether XML Base processing is enabled</td></tr>

 * <tr><th colspan='4'>Properties</th></tr>

 * <tr><td>http://gnu.org/sax/properties/base-uri</td>

 * <td>read-only</td><td>String</td>

 * <td>Returns the base URI of the current event</td></tr>

 * <tr><td>http://gnu.org/sax/properties/document-xml-encoding</td>

 * <td>read-only</td><td>String</td>

 * <td>Returns the encoding specified in the XML declaration</td></tr>

 * </table>

 *

 * @author <a href='mailto:dog@gnu.org'>Chris Burdess</a>

 */

public class SAXParser

  extends javax.xml.parsers.SAXParser

  implements XMLReader, Attributes2, Locator2, XMLReporter, XMLResolver

{

  ContentHandler contentHandler;

  DeclHandler declHandler;

  DTDHandler dtdHandler;

  EntityResolver entityResolver;

  ErrorHandler errorHandler;

  LexicalHandler lexicalHandler;

  boolean validating = false;

  boolean namespaceAware = true;

  boolean xIncludeAware = false;

  boolean stringInterning = true;

  boolean coalescing = true;

  boolean replaceERefs = true;

  boolean externalEntities = true;

  boolean supportDTD = true;

  boolean baseAware = true;

  XMLParser parser;

  XMLStreamReader reader;

  String encoding;

  String xmlVersion;

  boolean xmlStandalone;

  String xmlEncoding;

  String baseURI;

  public SAXParser()

  {

  }

  SAXParser(boolean validating, boolean namespaceAware, boolean xIncludeAware)

  {

    this.validating = validating;

    this.namespaceAware = namespaceAware;

    this.xIncludeAware = xIncludeAware;

  }

  // -- SAXParser --

  public Parser getParser()

    throws SAXException

  {

    return null;

  }

  public XMLReader getXMLReader()

    throws SAXException

  {

    return this;

  }

  public boolean isNamespaceAware()

  {

    return namespaceAware;

  }

  public boolean isValidating()

  {

    return validating;

  }

  public void setProperty(String name, Object value)

    throws SAXNotRecognizedException, SAXNotSupportedException

  {

    if (parser != null)

      throw new IllegalStateException("parsing in progress");

    final String FEATURES = "http://xml.org/sax/features/";

    final String PROPERTIES = "http://xml.org/sax/properties/";

    final String GNU_FEATURES = "http://gnu.org/sax/features/";

    if ((FEATURES + "namespaces").equals(name))

      namespaceAware = Boolean.TRUE.equals(value);

    else if ((FEATURES + "namespace-prefixes").equals(name))

      {

        // NOOP

      }

    else if ((FEATURES + "string-interning").equals(name))

      stringInterning = Boolean.TRUE.equals(value);

    else if ((FEATURES + "use-attributes2").equals(name))

      {

        // NOOP

      }

    else if ((FEATURES + "validation").equals(name))

      validating = Boolean.TRUE.equals(value);

    else if ((FEATURES + "external-general-entities").equals(name))

      externalEntities = Boolean.TRUE.equals(value);

    else if ((FEATURES + "external-parameter-entities").equals(name))

      externalEntities = Boolean.TRUE.equals(value);

    else if ((PROPERTIES + "declaration-handler").equals(name))

      declHandler = (DeclHandler) value;

    else if ((PROPERTIES + "lexical-handler").equals(name))

      lexicalHandler = (LexicalHandler) value;

    else if ((GNU_FEATURES + "xml-base").equals(name))

      baseAware = Boolean.TRUE.equals(value);

    else if ((GNU_FEATURES + "coalescing").equals(name))

      coalescing = Boolean.TRUE.equals(value);

    else

      throw new SAXNotSupportedException(name);

  }

  public Object getProperty(String name)

    throws SAXNotRecognizedException, SAXNotSupportedException

  {

    final String FEATURES = "http://xml.org/sax/features/";

    final String PROPERTIES = "http://xml.org/sax/properties/";

    final String GNU_FEATURES = "http://gnu.org/sax/features/";

    final String GNU_PROPERTIES = "http://gnu.org/sax/properties/";

    if ((GNU_FEATURES + "base-uri").equals(name))

      return baseURI;

    if ((FEATURES + "is-standalone").equals(name))

      return xmlStandalone ? Boolean.TRUE : Boolean.FALSE;

    if ((FEATURES + "namespaces").equals(name))

      return namespaceAware ? Boolean.TRUE : Boolean.FALSE;

    if ((FEATURES + "namespace-prefixes").equals(name))

      return Boolean.TRUE;

    if ((FEATURES + "string-interning").equals(name))

      return stringInterning ? Boolean.TRUE : Boolean.FALSE;

    if ((FEATURES + "use-attributes2").equals(name))

      return Boolean.TRUE;

    if ((FEATURES + "use-locator2").equals(name))

      return Boolean.TRUE;

    if ((FEATURES + "use-entity-resolver2").equals(name))

      return Boolean.FALSE;

    if ((FEATURES + "validation").equals(name))

      return validating ? Boolean.TRUE : Boolean.FALSE;

    if ((FEATURES + "external-general-entities").equals(name))

      return externalEntities ? Boolean.TRUE : Boolean.FALSE;

    if ((FEATURES + "external-parameter-entities").equals(name))

      return externalEntities ? Boolean.TRUE : Boolean.FALSE;

    if ((FEATURES + "xml-1.1").equals(name))

      return Boolean.TRUE;

    if ((PROPERTIES + "declaration-handler").equals(name))

      return declHandler;

    if ((PROPERTIES + "document-xml-version").equals(name))

      return xmlVersion;

    if ((PROPERTIES + "lexical-handler").equals(name))

      return lexicalHandler;

    if ((GNU_FEATURES + "xml-base").equals(name))

      return baseAware ? Boolean.TRUE : Boolean.FALSE;

    if ((GNU_PROPERTIES + "document-xml-encoding").equals(name))

      return xmlEncoding;

    throw new SAXNotRecognizedException(name);

  }

  public boolean isXIncludeAware()

  {

    return xIncludeAware;

  }

  public void reset()

  {

    parser = null;

    encoding = null;

    xmlVersion = null;

    xmlStandalone = false;

  }

  // -- XMLReader --

  public boolean getFeature(String name)

    throws SAXNotRecognizedException, SAXNotSupportedException

  {

    Object ret = getProperty(name);

    if (ret instanceof Boolean)

      return ((Boolean) ret).booleanValue();

    throw new SAXNotSupportedException(name);

  }

  public void setFeature(String name, boolean value)

    throws SAXNotRecognizedException, SAXNotSupportedException

  {

    setProperty(name, value ? Boolean.TRUE : Boolean.FALSE);

  }

  public void setEntityResolver(EntityResolver resolver)

  {

    entityResolver = resolver;

  }

  public EntityResolver getEntityResolver()

  {

    return entityResolver;

  }

  public void setDTDHandler(DTDHandler handler)

  {

    dtdHandler = handler;

  }

  public DTDHandler getDTDHandler()

  {

    return dtdHandler;

  }

  public void setContentHandler(ContentHandler handler)

  {

    contentHandler = handler;

  }

  public ContentHandler getContentHandler()

  {

    return contentHandler;

  }

  public void setErrorHandler(ErrorHandler handler)

  {

    errorHandler = handler;

  }

  public ErrorHandler getErrorHandler()

  {

    return errorHandler;

  }

  public synchronized void parse(InputSource input)

    throws IOException, SAXException

  {

    reset();

    String systemId = input.getSystemId();

    InputStream in = input.getByteStream();

    boolean opened = false;

    if (in != null)

      parser = new XMLParser(in, systemId,

                             validating,

                             namespaceAware,

                             coalescing,

                             replaceERefs,

                             externalEntities,

                             supportDTD,

                             baseAware,

                             stringInterning,

                             true,

                             this,

                             this);

    else

      {

        Reader r = input.getCharacterStream();

        if (r != null)

          parser = new XMLParser(r, systemId,

                                 validating,

                                 namespaceAware,

                                 coalescing,

                                 replaceERefs,

                                 externalEntities,

                                 supportDTD,

                                 baseAware,

                                 stringInterning,

                                 true,

                                 this,

                                 this);

      }

    if (parser == null)

      {

        if (systemId == null)

          throw new SAXException("No stream or system ID specified");

        systemId = XMLParser.absolutize(null, systemId);

        in = new URL(systemId).openStream();

        opened = true;

        parser = new XMLParser(in, systemId,

                               validating,

                               namespaceAware,

                               coalescing,

                               replaceERefs,

                               externalEntities,

                               supportDTD,

                               baseAware,

                               stringInterning,

                               true,

                               this,

                               this);

      }

    reader = parser;

    baseURI = systemId;

    if (xIncludeAware)

      reader = new XIncludeFilter(parser, systemId, namespaceAware,

                                  validating, true);

    if (contentHandler != null)

      contentHandler.setDocumentLocator(this);

    boolean startDocumentDone = false;

    try

      {

        while (parser.hasNext())

          {

            int event = parser.next();

            if (baseAware)

              baseURI = parser.getXMLBase();

            switch (event)

              {

              case XMLStreamConstants.CHARACTERS:

                if (contentHandler != null)

                  {

                    char[] b = reader.getTextCharacters();

                    contentHandler.characters(b, 0, b.length);

                  }

                break;

              case XMLStreamConstants.SPACE:

                if (contentHandler != null)

                  {

                    char[] b = reader.getTextCharacters();

                    if (isIgnorableWhitespace(parser, b, false))

                      contentHandler.ignorableWhitespace(b, 0, b.length);

                    else

                      contentHandler.characters(b, 0, b.length);

                  }

                break;

              case XMLStreamConstants.CDATA:

                if (lexicalHandler != null)

                  lexicalHandler.startCDATA();

                if (contentHandler != null)

                  {

                    char[] b = reader.getTextCharacters();

                    if (isIgnorableWhitespace(parser, b, true))

                      contentHandler.ignorableWhitespace(b, 0, b.length);

                    else

                      contentHandler.characters(b, 0, b.length);

                  }

                if (lexicalHandler != null)

                  lexicalHandler.endCDATA();

                break;

              case XMLStreamConstants.START_ELEMENT:

                if (contentHandler != null)

                  {

                    QName name = reader.getName();

                    String uri = name.getNamespaceURI();

                    String localName = name.getLocalPart();

                    String prefix = name.getPrefix();

                    String qName = localName;

                    if (!"".equals(prefix))

                      qName = prefix + ":" + localName;

                    if (!namespaceAware)

                      {

                        uri = "";

                        localName = "";

                      }

                    else

                      {

                        int nc = reader.getNamespaceCount();

                        for (int i = 0; i < nc; i++)

                          {

                            String nsuri = reader.getNamespaceURI(i);

                            String nsprefix = reader.getNamespacePrefix(i);

                            if ("xml".equals(nsprefix))

                              continue;

                            contentHandler.startPrefixMapping(nsprefix, nsuri);

                          }

                      }

                    contentHandler.startElement(uri, localName, qName, this);

                  }

                break;

              case XMLStreamConstants.END_ELEMENT:

                if (contentHandler != null)

                  {

                    QName name = reader.getName();

                    String uri = name.getNamespaceURI();

                    String localName = name.getLocalPart();

                    String prefix = name.getPrefix();

                    String qName = localName;

                    if (!"".equals(prefix))

                      qName = prefix + ":" + localName;

                    if (!namespaceAware)

                      {

                        uri = "";

                        localName = "";

                      }

                    contentHandler.endElement(uri, localName, qName);

                    if (namespaceAware)

                      {

                        int nc = reader.getNamespaceCount();

                        for (int i = 0; i < nc; i++)

                          {

                            String nsprefix = reader.getNamespacePrefix(i);

                            if ("xml".equals(nsprefix))

                              continue;

                            contentHandler.endPrefixMapping(nsprefix);

                          }

                      }

                  }

                break;

              case XMLStreamConstants.COMMENT:

                if (lexicalHandler != null)

                  {

                    char[] b = reader.getTextCharacters();

                    lexicalHandler.comment(b, 0, b.length);

                  }

                break;

              case XMLStreamConstants.PROCESSING_INSTRUCTION:

                if (contentHandler != null)

                  {

                    String target = reader.getPITarget();

                    String data = reader.getPIData();

                    if (data == null)

                      data = "";

                    contentHandler.processingInstruction(target, data);

                  }

                break;

              case XMLParser.START_ENTITY:

                if (lexicalHandler != null)

                  {

                    String name = reader.getText();

                    lexicalHandler.startEntity(name);

                  }

                break;

              case XMLParser.END_ENTITY:

                if (lexicalHandler != null)

                  {

                    String name = reader.getText();

                    lexicalHandler.endEntity(name);

                  }

                break;

              case XMLStreamConstants.START_DOCUMENT:

                encoding = reader.getEncoding();

                xmlVersion = reader.getVersion();

                xmlStandalone = reader.isStandalone();

                xmlEncoding = reader.getCharacterEncodingScheme();

                if (contentHandler != null)

                  contentHandler.startDocument();

                startDocumentDone = true;

                break;

              case XMLStreamConstants.END_DOCUMENT:

                if (contentHandler != null)

                  contentHandler.endDocument();

                break;

              case XMLStreamConstants.DTD:

                XMLParser.Doctype doctype = parser.doctype;

                if (lexicalHandler != null)

                  {

                    String rootName = doctype.rootName;

                    String publicId = doctype.publicId;

                    String systemId2 = doctype.systemId;

                    lexicalHandler.startDTD(rootName, publicId, systemId2);

                  }

                for (Iterator i = doctype.entryIterator(); i.hasNext(); )

                  {

                    String entry = (String) i.next();

                    char c = entry.charAt(0);

                    String name = entry.substring(1);

                    if ('E' == c)

                      {

                        // Element decl

                        if (declHandler != null)

                          {

                            XMLParser.ContentModel model =

                              doctype.getElementModel(name);

                            declHandler.elementDecl(name, model.text);

                          }

                      }

                    else if ('A' == c)

                      {

                        // Attlist decl

                        if (declHandler != null)

                          {

                            for (Iterator j = doctype.attlistIterator(name);

                                 j.hasNext(); )

                              {

                                Map.Entry att = (Map.Entry) j.next();

                                String aname = (String) att.getKey();

                                XMLParser.AttributeDecl decl =

                                  (XMLParser.AttributeDecl) att.getValue();

                                String type = decl.type;

                                String value = decl.value;

                                String mode = null;

                                switch (decl.valueType)

                                  {

                                  case XMLParser.ATTRIBUTE_DEFAULT_FIXED:

                                    mode = "#FIXED";

                                    break;

                                  case XMLParser.ATTRIBUTE_DEFAULT_REQUIRED:

                                    mode = "#REQUIRED";

                                    break;

                                  case XMLParser.ATTRIBUTE_DEFAULT_IMPLIED:

                                    mode = "#IMPLIED";

                                    break;

                                  }

                                declHandler.attributeDecl(name, aname,

                                                          type, mode, value);

                              }

                          }

                      }

                    else if ('e' == c)

                      {

                        // Entity decl

                        Object entity = doctype.getEntity(name);

                        if (entity instanceof String)

                          {

                            if (declHandler != null)

                              declHandler.internalEntityDecl(name,

                                                             (String) entity);

                          }

                        else

                          {

                            XMLParser.ExternalIds ids =

                              (XMLParser.ExternalIds) entity;

                            if (ids.notationName != null)

                              {

                                if (dtdHandler != null)

                                  {

                                    String pub = ids.publicId;

                                    String url = ids.systemId;

                                    String not = ids.notationName;

                                    dtdHandler.unparsedEntityDecl(name,

                                                                  pub,

                                                                  url,

                                                                  not);

                                  }

                              }

                            else

                              {

                                if (declHandler != null)

                                  {

                                    String pub = ids.publicId;

                                    String url = ids.systemId;

                                    declHandler.externalEntityDecl(name,

                                                                   pub,

                                                                   url);

                                  }

                              }

                          }

                      }

                    else if ('n' == c)

                      {

                        // Notation decl

                        if (dtdHandler != null)

                          {

                            XMLParser.ExternalIds ids =

                              doctype.getNotation(name);

                            String pub = ids.publicId;

                            String url = ids.systemId;

                            dtdHandler.notationDecl(name, pub, url);

                          }

                      }

                    else if ('c' == c)

                      {

                        // Comment

                        if (lexicalHandler != null)

                          {

                            String comment = doctype.getComment(name);

                            char[] b = comment.toCharArray();

                            lexicalHandler.comment(b, 0, b.length);

                          }

                      }

                    else if ('p' == c)

                      {

                        // Processing instruction

                        if (contentHandler != null)

                          {

                            String[] pi = doctype.getPI(name);

                            String target = pi[0];

                            String data = pi[1];

                            if (data == null)

                              data = "";

                            contentHandler.processingInstruction(target, data);