| /* SAXParser.java -- |
| Copyright (C) 2005, 2006 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.EntityResolver2; |
| 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 |
| 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 SAXNotSupportedException(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); |
| } |
| } |
| } |
| if (lexicalHandler != null) |
| lexicalHandler.endDTD(); |
| } |
| } |
| reset(); |
| if (opened) |
| in.close(); |
| } |
| catch (Exception e) |
| { |
| SAXParseException e2 = new SAXParseException(e.getMessage(), this); |
| e2.initCause(e); |
| try |
| { |
| if (!startDocumentDone && contentHandler != null) |
| contentHandler.startDocument(); |
| if (errorHandler != null) |
| errorHandler.fatalError(e2); |
| if (contentHandler != null) |
| contentHandler.endDocument(); |
| } |
| catch (SAXException sex) |
| { |
| // Ignored, we will rethrow the original exception. |
| } |
| reset(); |
| if (opened) |
| in.close(); |
| if (e instanceof SAXException) |
| throw (SAXException) e; |
| if (e instanceof IOException) |
| throw (IOException) e; |
| else |
| throw e2; |
| } |
| } |
| |
| /** |
| * Indicates whether the specified characters are ignorable whitespace. |
| */ |
| private boolean isIgnorableWhitespace(XMLParser reader, char[] b, |
| boolean testCharacters) |
| throws XMLStreamException |
| { |
| XMLParser.Doctype doctype = reader.doctype; |
| if (doctype == null) |
| return false; |
| String currentElement = reader.getCurrentElement(); |
| // check for xml:space |
| int ac = reader.getAttributeCount(); |
| for (int i = 0; i < ac; i++) |
| { |
| QName aname = reader.getAttributeName(i); |
| if ("space".equals(aname.getLocalPart()) && |
| XMLConstants.XML_NS_URI.equals(aname.getNamespaceURI())) |
| { |
| if ("preserve".equals(reader.getAttributeValue(i))) |
| return false; |
| } |
| } |
| XMLParser.ContentModel model = doctype.getElementModel(currentElement); |
| if (model == null || model.type != XMLParser.ContentModel.ELEMENT) |
| return false; |
| if (model.external && xmlStandalone) |
| return false; |
| boolean white = true; |
| if (testCharacters) |
| { |
| for (int i = 0; i < b.length; i++) |
| { |
| if (b[i] != ' ' && b[i] != '\t' && b[i] != '\n' && b[i] != '\r') |
| { |
| white = false; |
| break; |
| } |
| } |
| } |
| return white; |
| } |
| |
| public void parse(String systemId) |
| throws IOException, SAXException |
| { |
| parse(new InputSource(systemId)); |
| } |
| |
| // -- Attributes2 -- |
| |
| public int getIndex(String qName) |
| { |
| int len = reader.getAttributeCount(); |
| for (int i = 0; i < len; i++) |
| { |
| QName q = reader.getAttributeName(i); |
| String localName = q.getLocalPart(); |
| String prefix = q.getPrefix(); |
| String qn = ("".equals(prefix)) ? localName : prefix + ":" + localName; |
| if (qName.equals(qn)) |
| return i; |
| } |
| return -1; |
| } |
| |
| public int getIndex(String uri, String localName) |
| { |
| int len = reader.getAttributeCount(); |
| for (int i = 0; i < len; i++) |
| { |
| QName q = reader.getAttributeName(i); |
| String ln = q.getLocalPart(); |
| String u = q.getNamespaceURI(); |
| if (u == null && uri != null) |
| continue; |
| if (u != null && !u.equals(uri)) |
| continue; |
| if (ln.equals(localName)) |
| return i; |
| } |
| return -1; |
| } |
| |
| public int getLength() |
| { |
| return reader.getAttributeCount(); |
| } |
| |
| public String getLocalName(int index) |
| { |
| return reader.getAttributeLocalName(index); |
| } |
| |
| public String getQName(int index) |
| { |
| QName q = reader.getAttributeName(index); |
| String localName = q.getLocalPart(); |
| String prefix = q.getPrefix(); |
| return ("".equals(prefix)) ? localName : prefix + ":" + localName; |
| } |
| |
| public String getType(int index) |
| { |
| String ret = reader.getAttributeType(index); |
| // SAX doesn't permit ENUMERATION? |
| return ("ENUMERATION".equals(ret)) ? "NMTOKEN" : ret; |
| } |
| |
| public String getType(String qName) |
| { |
| int index = getIndex(qName); |
| return (index == -1) ? null : getType(index); |
| } |
| |
| public String getType(String uri, String localName) |
| { |
| int index = getIndex(uri, localName); |
| return (index == -1) ? null : getType(index); |
| } |
| |
| public String getURI(int index) |
| { |
| String ret = reader.getAttributeNamespace(index); |
| return (ret == null) ? "" : ret; |
| } |
| |
| public String getValue(int index) |
| { |
| return reader.getAttributeValue(index); |
| } |
| |
| public String getValue(String qName) |
| { |
| int index = getIndex(qName); |
| return (index == -1) ? null : getValue(index); |
| } |
| |
| public String getValue(String uri, String localName) |
| { |
| int index = getIndex(uri, localName); |
| return (index == -1) ? null : getValue(index); |
| } |
| |
| public boolean isDeclared(int index) |
| { |
| return parser.isAttributeDeclared(index); |
| } |
| |
| public boolean isDeclared(String qName) |
| { |
| int index = getIndex(qName); |
| return (index == -1) ? false : isDeclared(index); |
| } |
| |
| public boolean isDeclared(String uri, String localName) |
| { |
| int index = getIndex(uri, localName); |
| return (index == -1) ? false : isDeclared(index); |
| } |
| |
| public boolean isSpecified(int index) |
| { |
| return reader.isAttributeSpecified(index); |
| } |
| |
| public boolean isSpecified(String qName) |
| { |
| int index = getIndex(qName); |
| return (index == -1) ? false : isSpecified(index); |
| } |
| |
| public boolean isSpecified(String uri, String localName) |
| { |
| int index = getIndex(uri, localName); |
| return (index == -1) ? false : isSpecified(index); |
| } |
| |
| // -- Locator2 -- |
| |
| public int getColumnNumber() |
| { |
| Location l = reader.getLocation(); |
| return l.getColumnNumber(); |
| } |
| |
| public int getLineNumber() |
| { |
| Location l = reader.getLocation(); |
| return l.getLineNumber(); |
| } |
| |
| public String getPublicId() |
| { |
| Location l = reader.getLocation(); |
| return l.getPublicId(); |
| } |
| |
| public String getSystemId() |
| { |
| Location l = reader.getLocation(); |
| return l.getSystemId(); |
| } |
| |
| public String getEncoding() |
| { |
| return encoding; |
| } |
| |
| public String getXMLVersion() |
| { |
| return xmlVersion; |
| } |
| |
| // -- XMLResolver -- |
| |
| public Object resolveEntity(String publicId, String systemId, |
| String baseURI, String namespace) |
| throws XMLStreamException |
| { |
| if (entityResolver != null) |
| { |
| try |
| { |
| InputSource input = |
| entityResolver.resolveEntity(publicId, systemId); |
| if (input != null) |
| { |
| InputStream in = input.getByteStream(); |
| if (in == null) |
| { |
| String newSystemId = input.getSystemId(); |
| if (newSystemId != null && !newSystemId.equals(systemId)) |
| in = XMLParser.resolve(newSystemId); |
| } |
| return in; |
| } |
| } |
| catch (SAXException e) |
| { |
| XMLStreamException e2 = new XMLStreamException(e.getMessage()); |
| e2.initCause(e); |
| throw e2; |
| } |
| catch (IOException e) |
| { |
| XMLStreamException e2 = new XMLStreamException(e.getMessage()); |
| e2.initCause(e); |
| throw e2; |
| } |
| } |
| return null; |
| } |
| |
| public XMLEventReader resolveAsXMLEventReader(String uri) |
| throws XMLStreamException |
| { |
| // unused |
| return null; |
| } |
| |
| public XMLStreamReader resolveAsXMLStreamReader(String uri) |
| throws XMLStreamException |
| { |
| // unused |
| return null; |
| } |
| |
| // -- XMLReporter -- |
| |
| public void report(String message, String errorType, |
| Object relatedInformation, Location location) |
| throws XMLStreamException |
| { |
| if (errorHandler != null) |
| { |
| try |
| { |
| errorHandler.warning(new SAXParseException(message, this)); |
| } |
| catch (SAXException e) |
| { |
| XMLStreamException e2 = new XMLStreamException(e.getMessage()); |
| e2.initCause(e); |
| throw e2; |
| } |
| } |
| } |
| |
| public static void main(String[] args) |
| throws Exception |
| { |
| boolean validating = false; |
| boolean namespaceAware = false; |
| boolean xIncludeAware = false; |
| boolean expectCallbackClass = false; |
| String callbackClass = null; |
| int pos = 0; |
| while (pos < args.length && (args[pos].startsWith("-") || expectCallbackClass)) |
| { |
| if ("-x".equals(args[pos])) |
| xIncludeAware = true; |
| else if ("-v".equals(args[pos])) |
| validating = true; |
| else if ("-n".equals(args[pos])) |
| namespaceAware = true; |
| else if ("-c".equals(args[pos])) |
| expectCallbackClass = true; |
| else if (expectCallbackClass) |
| { |
| callbackClass = args[pos]; |
| expectCallbackClass = false; |
| } |
| pos++; |
| } |
| if (pos >= args.length || expectCallbackClass) |
| { |
| System.out.println("Syntax: SAXParser [-n] [-v] [-x] [-c <class>] <file> [<file2> [...]]"); |
| System.out.println("\t-n: use namespace aware mode"); |
| System.out.println("\t-v: use validating parser"); |
| System.out.println("\t-x: use XInclude aware mode"); |
| System.out.println("\t-c <class>: use specified class as callback handler (must have a no-arg public constructor)"); |
| System.exit(2); |
| } |
| while (pos < args.length) |
| { |
| ContentHandler handler = null; |
| if (callbackClass != null) |
| { |
| Class t = Class.forName(callbackClass); |
| handler = (ContentHandler) t.newInstance(); |
| } |
| else |
| handler = new org.xml.sax.helpers.DefaultHandler(); |
| SAXParser parser = new SAXParser(validating, namespaceAware, |
| xIncludeAware); |
| InputSource input = new InputSource(args[pos]); |
| XMLReader reader = parser.getXMLReader(); |
| reader.setContentHandler(handler); |
| reader.parse(input); |
| pos++; |
| } |
| } |
| |
| } |
