/* SAXDriver.java -- Copyright (C) 1999,2000,2001,2004 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., 59 Temple Place, Suite 330, Boston, MA 02111-1307 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. Portions derived from code which carried the following notice: Copyright (c) 1997, 1998 by Microstar Software Ltd. AElfred is free for both commercial and non-commercial use and redistribution, provided that Microstar's copyright and disclaimer are retained intact. You are free to modify AElfred for your own use and to redistribute AElfred with your modifications, provided that the modifications are clearly documented. This program 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. Please use it AT YOUR OWN RISK. */ package gnu.xml.aelfred2; import java.io.*; import java.net.MalformedURLException; import java.net.URL; import java.util.Locale; import java.util.Stack; // maintaining 1.1 compatibility for now ... more portable, PJava, etc // Iterator, Hashmap and ArrayList ought to be faster import java.util.ArrayList; import java.util.Collections; import java.util.Enumeration; import java.util.Hashtable; import java.util.Iterator; import java.util.List; import java.util.Vector; import org.xml.sax.*; import org.xml.sax.ext.*; import org.xml.sax.helpers.NamespaceSupport; /** * An enhanced SAX2 version of Microstar's Ælfred XML parser. * The enhancements primarily relate to significant improvements in * conformance to the XML specification, and SAX2 support. Performance * has been improved. See the package level documentation for more * information. * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
NameNotes
Features ... URL prefix is * http://xml.org/sax/features/
(URL)/external-general-entitiesValue defaults to true
(URL)/external-parameter-entitiesValue defaults to true
(URL)/is-standalone(PRELIMINARY) Returns true iff the document's parsing * has started (some non-error event after startDocument() * was reported) and the document's standalone flag is set.
(URL)/namespace-prefixesValue defaults to false (but XML 1.0 names are * always reported)
(URL)/lexical-handler/parameter-entitiesValue is fixed at true
(URL)/namespacesValue defaults to true
(URL)/resolve-dtd-uris(PRELIMINARY) Value defaults to true
(URL)/string-interningValue is fixed at true
(URL)/use-attributes2(PRELIMINARY) Value is fixed at true
(URL)/use-entity-resolver2(PRELIMINARY) Value defaults to true
(URL)/validationValue is fixed at false
Handler Properties ... URL prefix is * http://xml.org/sax/properties/
(URL)/declaration-handlerA declaration handler may be provided.
(URL)/lexical-handlerA lexical handler may be provided.
* *

This parser currently implements the SAX1 Parser API, but * it may not continue to do so in the future. * * @author Written by David Megginson (version 1.2a from Microstar) * @author Updated by David Brownell <dbrownell@users.sourceforge.net> * @see org.xml.sax.Parser */ final public class SAXDriver implements Locator, Attributes2, XMLReader, Parser, AttributeList { private final DefaultHandler2 base = new DefaultHandler2 (); private XmlParser parser; private EntityResolver entityResolver = base; private EntityResolver2 resolver2 = null; private ContentHandler contentHandler = base; private DTDHandler dtdHandler = base; private ErrorHandler errorHandler = base; private DeclHandler declHandler = base; private LexicalHandler lexicalHandler = base; private String elementName; private Stack entityStack; // one vector (of object/struct): faster, smaller private List attributesList = Collections.synchronizedList(new ArrayList()); private boolean attributeSpecified [] = new boolean[10]; private boolean attributeDeclared [] = new boolean[10]; private boolean namespaces = true; private boolean xmlNames = false; private boolean extGE = true; private boolean extPE = true; private boolean resolveAll = true; private boolean useResolver2 = true; private boolean stringInterning = true; private int attributeCount; private boolean attributes; private String nsTemp []; private NamespaceSupport prefixStack; // // Constructor. // /** Constructs a SAX Parser. */ public SAXDriver () { reset (); } private void reset () { elementName = null; entityStack = new Stack (); attributesList = Collections.synchronizedList(new ArrayList()); attributeSpecified = new boolean[10]; attributeDeclared = new boolean[10]; attributeCount = 0; attributes = false; nsTemp = new String[3]; prefixStack = null; } // // Implementation of org.xml.sax.Parser. // /** * SAX1: Sets the locale used for diagnostics; currently, * only locales using the English language are supported. * @param locale The locale for which diagnostics will be generated */ public void setLocale (Locale locale) throws SAXException { if ("en".equals (locale.getLanguage ())) return ; throw new SAXException ("AElfred2 only supports English locales."); } /** * SAX2: Returns the object used when resolving external * entities during parsing (both general and parameter entities). */ public EntityResolver getEntityResolver () { return (entityResolver == base) ? null : entityResolver; } /** * SAX1, SAX2: Set the entity resolver for this parser. * @param handler The object to receive entity events. */ public void setEntityResolver (EntityResolver resolver) { if (resolver instanceof EntityResolver2) resolver2 = (EntityResolver2) resolver; else resolver2 = null; if (resolver == null) resolver = base; entityResolver = resolver; } /** * SAX2: Returns the object used to process declarations related * to notations and unparsed entities. */ public DTDHandler getDTDHandler () { return (dtdHandler == base) ? null : dtdHandler; } /** * SAX1, SAX2: Set the DTD handler for this parser. * @param handler The object to receive DTD events. */ public void setDTDHandler (DTDHandler handler) { if (handler == null) handler = base; this.dtdHandler = handler; } /** * SAX1: Set the document handler for this parser. If a * content handler was set, this document handler will supplant it. * The parser is set to report all XML 1.0 names rather than to * filter out "xmlns" attributes (the "namespace-prefixes" feature * is set to true). * * @deprecated SAX2 programs should use the XMLReader interface * and a ContentHandler. * * @param handler The object to receive document events. */ public void setDocumentHandler (DocumentHandler handler) { contentHandler = new Adapter (handler); xmlNames = true; } /** * SAX2: Returns the object used to report the logical * content of an XML document. */ public ContentHandler getContentHandler () { return contentHandler == base ? null : contentHandler; } /** * SAX2: Assigns the object used to report the logical * content of an XML document. If a document handler was set, * this content handler will supplant it (but XML 1.0 style name * reporting may remain enabled). */ public void setContentHandler (ContentHandler handler) { if (handler == null) handler = base; contentHandler = handler; } /** * SAX1, SAX2: Set the error handler for this parser. * @param handler The object to receive error events. */ public void setErrorHandler (ErrorHandler handler) { if (handler == null) handler = base; this.errorHandler = handler; } /** * SAX2: Returns the object used to receive callbacks for XML * errors of all levels (fatal, nonfatal, warning); this is never null; */ public ErrorHandler getErrorHandler () { return errorHandler == base ? null : errorHandler; } /** * SAX1, SAX2: Auxiliary API to parse an XML document, used mostly * when no URI is available. * If you want anything useful to happen, you should set * at least one type of handler. * @param source The XML input source. Don't set 'encoding' unless * you know for a fact that it's correct. * @see #setEntityResolver * @see #setDTDHandler * @see #setContentHandler * @see #setErrorHandler * @exception SAXException The handlers may throw any SAXException, * and the parser normally throws SAXParseException objects. * @exception IOException IOExceptions are normally through through * the parser if there are problems reading the source document. */ public void parse (InputSource source) throws SAXException, IOException { synchronized (base) { parser = new XmlParser (); if (namespaces) prefixStack = new NamespaceSupport (); else if (!xmlNames) throw new IllegalStateException (); parser.setHandler (this); try { Reader r = source.getCharacterStream(); InputStream in = source.getByteStream(); parser.doParse (source.getSystemId (), source.getPublicId (), r, in, source.getEncoding ()); } catch (SAXException e) { throw e; } catch (IOException e) { throw e; } catch (RuntimeException e) { throw e; } catch (Exception e) { throw new SAXParseException (e.getMessage (), this, e); } finally { contentHandler.endDocument (); reset(); } } } /** * SAX1, SAX2: Preferred API to parse an XML document, using a * system identifier (URI). */ public void parse (String systemId) throws SAXException, IOException { parse (new InputSource (systemId)); } // // Implementation of SAX2 "XMLReader" interface // static final String FEATURE = "http://xml.org/sax/features/"; static final String PROPERTY = "http://xml.org/sax/properties/"; /** * SAX2: Tells the value of the specified feature flag. * * @exception SAXNotRecognizedException thrown if the feature flag * is neither built in, nor yet assigned. */ public boolean getFeature (String featureId) throws SAXNotRecognizedException, SAXNotSupportedException { if ((FEATURE + "validation").equals (featureId)) return false; // external entities (both types) are optionally included if ((FEATURE + "external-general-entities").equals (featureId)) return extGE; if ((FEATURE + "external-parameter-entities") .equals (featureId)) return extPE; // element/attribute names are as written in document; no mangling if ((FEATURE + "namespace-prefixes").equals (featureId)) return xmlNames; // report element/attribute namespaces? if ((FEATURE + "namespaces").equals (featureId)) return namespaces; // all PEs and GEs are reported if ((FEATURE + "lexical-handler/parameter-entities").equals (featureId)) return true; // default is true if ((FEATURE + "string-interning").equals (featureId)) return stringInterning; // EXTENSIONS 1.1 // always returns isSpecified info if ((FEATURE + "use-attributes2").equals (featureId)) return true; // meaningful between startDocument/endDocument if ((FEATURE + "is-standalone").equals (featureId)) { if (parser == null) throw new SAXNotSupportedException (featureId); return parser.isStandalone (); } // optionally don't absolutize URIs in declarations if ((FEATURE + "resolve-dtd-uris").equals (featureId)) return resolveAll; // optionally use resolver2 interface methods, if possible if ((FEATURE + "use-entity-resolver2").equals (featureId)) return useResolver2; throw new SAXNotRecognizedException (featureId); } // package private DeclHandler getDeclHandler () { return declHandler; } // package private boolean resolveURIs () { return resolveAll; } /** * SAX2: Returns the specified property. * * @exception SAXNotRecognizedException thrown if the property value * is neither built in, nor yet stored. */ public Object getProperty (String propertyId) throws SAXNotRecognizedException { if ((PROPERTY + "declaration-handler").equals (propertyId)) return declHandler == base ? null : declHandler; if ((PROPERTY + "lexical-handler").equals (propertyId)) return lexicalHandler == base ? null : lexicalHandler; // unknown properties throw new SAXNotRecognizedException (propertyId); } /** * SAX2: Sets the state of feature flags in this parser. Some * built-in feature flags are mutable. */ public void setFeature (String featureId, boolean value) throws SAXNotRecognizedException, SAXNotSupportedException { boolean state; // Features with a defined value, we just change it if we can. state = getFeature (featureId); if (state == value) return; if (parser != null) throw new SAXNotSupportedException ("not while parsing"); if ((FEATURE + "namespace-prefixes").equals (featureId)) { // in this implementation, this only affects xmlns reporting xmlNames = value; // forcibly prevent illegal parser state if (!xmlNames) namespaces = true; return; } if ((FEATURE + "namespaces").equals (featureId)) { namespaces = value; // forcibly prevent illegal parser state if (!namespaces) xmlNames = true; return; } if ((FEATURE + "external-general-entities").equals (featureId)) { extGE = value; return; } if ((FEATURE + "external-parameter-entities") .equals (featureId)) { extPE = value; return; } if ((FEATURE + "resolve-dtd-uris").equals (featureId)) { resolveAll = value; return; } if ((FEATURE + "use-entity-resolver2").equals (featureId)) { useResolver2 = value; return; } throw new SAXNotRecognizedException (featureId); } /** * SAX2: Assigns the specified property. Like SAX1 handlers, * these may be changed at any time. */ public void setProperty (String propertyId, Object value) throws SAXNotRecognizedException, SAXNotSupportedException { // see if the property is recognized getProperty (propertyId); // Properties with a defined value, we just change it if we can. if ((PROPERTY + "declaration-handler").equals (propertyId)) { if (value == null) declHandler = base; else if (! (value instanceof DeclHandler)) throw new SAXNotSupportedException (propertyId); else declHandler = (DeclHandler) value; return ; } if ((PROPERTY + "lexical-handler").equals (propertyId)) { if (value == null) lexicalHandler = base; else if (! (value instanceof LexicalHandler)) throw new SAXNotSupportedException (propertyId); else lexicalHandler = (LexicalHandler) value; return ; } throw new SAXNotSupportedException (propertyId); } // // This is where the driver receives XmlParser callbacks and translates // them into SAX callbacks. Some more callbacks have been added for // SAX2 support. // void startDocument () throws SAXException { contentHandler.setDocumentLocator (this); contentHandler.startDocument (); attributesList.clear (); } void xmlDecl(String version, String encoding, boolean standalone, String inputEncoding) throws SAXException { if (contentHandler instanceof ContentHandler2) { ((ContentHandler2) contentHandler).xmlDecl(version, encoding, standalone, inputEncoding); } } void skippedEntity (String name) throws SAXException { contentHandler.skippedEntity (name); } InputSource getExternalSubset (String name, String baseURI) throws SAXException, IOException { if (resolver2 == null || !useResolver2 || !extPE) return null; return resolver2.getExternalSubset (name, baseURI); } InputSource resolveEntity (boolean isPE, String name, InputSource in, String baseURI) throws SAXException, IOException { InputSource source; // external entities might be skipped if (isPE && !extPE) return null; if (!isPE && !extGE) return null; // ... or not lexicalHandler.startEntity (name); if (resolver2 != null && useResolver2) { source = resolver2.resolveEntity (name, in.getPublicId (), baseURI, in.getSystemId ()); if (source == null) { in.setSystemId (absolutize (baseURI, in.getSystemId (), false)); source = in; } } else { in.setSystemId (absolutize (baseURI, in.getSystemId (), false)); source = entityResolver.resolveEntity (in.getPublicId (), in.getSystemId ()); if (source == null) source = in; } startExternalEntity (name, source.getSystemId (), true); return source; } // absolutize a system ID relative to the specified base URI // (temporarily) package-visible for external entity decls String absolutize (String baseURI, String systemId, boolean nice) throws MalformedURLException, SAXException { // FIXME normalize system IDs -- when? // - Convert to UTF-8 // - Map reserved and non-ASCII characters to %HH try { if (baseURI == null) { warn ("No base URI; hope this SYSTEM id is absolute: " + systemId); return new URL (systemId).toString (); } else return new URL (new URL (baseURI), systemId).toString (); } catch (MalformedURLException e) { // Let unknown URI schemes pass through unless we need // the JVM to map them to i/o streams for us... if (!nice) throw e; // sometimes sysids for notations or unparsed entities // aren't really URIs... warn ("Can't absolutize SYSTEM id: " + e.getMessage ()); return systemId; } } void startExternalEntity (String name, String systemId, boolean stackOnly) throws SAXException { // The following warning was deleted because the application has the // option of not setting systemId. Sun's JAXP or Xerces seems to // ignore this case. /* if (systemId == null) warn ("URI was not reported to parser for entity " + name); */ if (!stackOnly) // spliced [dtd] needs startEntity lexicalHandler.startEntity (name); entityStack.push (systemId); } void endExternalEntity (String name) throws SAXException { if (!"[document]".equals (name)) lexicalHandler.endEntity (name); entityStack.pop (); } void startInternalEntity (String name) throws SAXException { lexicalHandler.startEntity (name); } void endInternalEntity (String name) throws SAXException { lexicalHandler.endEntity (name); } void doctypeDecl (String name, String publicId, String systemId) throws SAXException { lexicalHandler.startDTD (name, publicId, systemId); // ... the "name" is a declaration and should be given // to the DeclHandler (but sax2 doesn't). // the IDs for the external subset are lexical details, // as are the contents of the internal subset; but sax2 // doesn't provide the internal subset "pre-parse" } void notationDecl (String name, String ids []) throws SAXException { try { dtdHandler.notationDecl (name, ids [0], (resolveAll && ids [1] != null) ? absolutize (ids [2], ids [1], true) : ids [1]); } catch (IOException e) { // "can't happen" throw new SAXParseException (e.getMessage (), this, e); } } void unparsedEntityDecl (String name, String ids [], String notation) throws SAXException { try { dtdHandler.unparsedEntityDecl (name, ids [0], resolveAll ? absolutize (ids [2], ids [1], true) : ids [1], notation); } catch (IOException e) { // "can't happen" throw new SAXParseException (e.getMessage (), this, e); } } void endDoctype () throws SAXException { lexicalHandler.endDTD (); } private void declarePrefix (String prefix, String uri) throws SAXException { int index = uri.indexOf (':'); // many versions of nwalsh docbook stylesheets // have bogus URLs; so this can't be an error... if (index < 1 && uri.length () != 0) warn ("relative URI for namespace: " + uri); // FIXME: char [0] must be ascii alpha; chars [1..index] // must be ascii alphanumeric or in "+-." [RFC 2396] //Namespace Constraints //name for xml prefix must be http://www.w3.org/XML/1998/namespace boolean prefixEquality = prefix.equals("xml"); boolean uriEquality = uri.equals("http://www.w3.org/XML/1998/namespace"); if ((prefixEquality || uriEquality) && !(prefixEquality && uriEquality)) fatal ("xml is by definition bound to the namespace name " + "http://www.w3.org/XML/1998/namespace"); //xmlns prefix declaration is illegal but xml prefix declaration is llegal... if (prefixEquality && uriEquality) return; //name for xmlns prefix must be http://www.w3.org/2000/xmlns/ prefixEquality = prefix.equals("xmlns"); uriEquality = uri.equals("http://www.w3.org/2000/xmlns/"); if ((prefixEquality || uriEquality) && !(prefixEquality && uriEquality)) fatal("http://www.w3.org/2000/xmlns/ is by definition bound" + " to prefix xmlns"); //even if the uri is http://www.w3.org/2000/xmlns/ it is illegal to declare it if (prefixEquality && uriEquality) fatal ("declaring the xmlns prefix is illegal"); uri = uri.intern (); prefixStack.declarePrefix (prefix, uri); contentHandler.startPrefixMapping (prefix, uri); } void attribute (String qname, String value, boolean isSpecified) throws SAXException { if (!attributes) { attributes = true; if (namespaces) prefixStack.pushContext (); } // process namespace decls immediately; // then maybe forget this as an attribute if (namespaces) { int index; // default NS declaration? if (getFeature (FEATURE + "string-interning")) { if ("xmlns" == qname) { declarePrefix ("", value); if (!xmlNames) return; } // NS prefix declaration? else if ((index = qname.indexOf (':')) == 5 && qname.startsWith ("xmlns")) { String prefix = qname.substring (6); if (prefix.equals("")) fatal ("missing prefix in namespace declaration attribute"); if (value.length () == 0) { verror ("missing URI in namespace declaration attribute: " + qname); } else declarePrefix (prefix, value); if (!xmlNames) return; } } else { if ("xmlns".equals(qname)) { declarePrefix ("", value); if (!xmlNames) return; } // NS prefix declaration? else if ((index = qname.indexOf (':')) == 5 && qname.startsWith ("xmlns")) { String prefix = qname.substring (6); if (value.length () == 0) { verror ("missing URI in namespace decl attribute: " + qname); } else declarePrefix (prefix, value); if (!xmlNames) return; } } } // remember this attribute ... if (attributeCount == attributeSpecified.length) { // grow array? boolean temp [] = new boolean [attributeSpecified.length + 5]; System.arraycopy (attributeSpecified, 0, temp, 0, attributeCount); attributeSpecified = temp; } attributeSpecified [attributeCount] = isSpecified; attributeCount++; // attribute type comes from querying parser's DTD records attributesList.add(new Attribute(qname, value)); } void startElement (String elname) throws SAXException { ContentHandler handler = contentHandler; // // NOTE: this implementation of namespace support adds something // like six percent to parsing CPU time, in a large (~50 MB) // document that doesn't use namespaces at all. (Measured by PC // sampling, with a bug where endElement processing was omitted.) // [Measurement referred to older implementation, older JVM ...] // // It ought to become notably faster in such cases. Most // costs are the prefix stack calling Hashtable.get() (2%), // String.hashCode() (1.5%) and about 1.3% each for pushing // the context, and two chunks of name processing. // if (!attributes) { if (namespaces) prefixStack.pushContext (); } else if (namespaces) { // now we can patch up namespace refs; we saw all the // declarations, so now we'll do the Right Thing Iterator itt = attributesList.iterator (); while(itt.hasNext()) { Attribute attribute = (Attribute) itt.next(); String qname = attribute.name; int index; // default NS declaration? if (getFeature (FEATURE + "string-interning")) { if ("xmlns" == qname) continue; } else { if ("xmlns".equals(qname)) continue; } //Illegal in the new Namespaces Draft //should it be only in 1.1 docs?? if (qname.equals (":")) fatal ("namespace names consisting of a single colon " + "character are invalid"); index = qname.indexOf (':'); // NS prefix declaration? if (index == 5 && qname.startsWith ("xmlns")) continue; // it's not a NS decl; patch namespace info items if (prefixStack.processName (qname, nsTemp, true) == null) fatal ("undeclared attribute prefix in: " + qname); else { attribute.nameSpace = nsTemp[0]; attribute.localName = nsTemp[1]; } } } // save element name so attribute callbacks work elementName = elname; if (namespaces) { if (prefixStack.processName (elname, nsTemp, false) == null) { fatal ("undeclared element prefix in: " + elname); nsTemp [0] = nsTemp [1] = ""; } handler.startElement (nsTemp [0], nsTemp [1], elname, this); } else handler.startElement ("", "", elname, this); // elementName = null; // elements with no attributes are pretty common! if (attributes) { attributesList.clear(); attributeCount = 0; attributes = false; } } void endElement (String elname) throws SAXException { ContentHandler handler = contentHandler; if (!namespaces) { handler.endElement ("", "", elname); return; } prefixStack.processName (elname, nsTemp, false); handler.endElement (nsTemp [0], nsTemp [1], elname); Enumeration prefixes = prefixStack.getDeclaredPrefixes (); while (prefixes.hasMoreElements ()) handler.endPrefixMapping ((String) prefixes.nextElement ()); prefixStack.popContext (); } void startCDATA () throws SAXException { lexicalHandler.startCDATA (); } void charData (char ch[], int start, int length) throws SAXException { contentHandler.characters (ch, start, length); } void endCDATA () throws SAXException { lexicalHandler.endCDATA (); } void ignorableWhitespace (char ch[], int start, int length) throws SAXException { contentHandler.ignorableWhitespace (ch, start, length); } void processingInstruction (String target, String data) throws SAXException { contentHandler.processingInstruction (target, data); } void comment (char ch[], int start, int length) throws SAXException { if (lexicalHandler != base) lexicalHandler.comment (ch, start, length); } void fatal (String message) throws SAXException { SAXParseException fatal; fatal = new SAXParseException (message, this); errorHandler.fatalError (fatal); // Even if the application can continue ... we can't! throw fatal; } // We can safely report a few validity errors that // make layered SAX2 DTD validation more conformant void verror (String message) throws SAXException { SAXParseException err; err = new SAXParseException (message, this); errorHandler.error (err); } void warn (String message) throws SAXException { SAXParseException err; err = new SAXParseException (message, this); errorHandler.warning (err); } // // Implementation of org.xml.sax.Attributes. // /** * SAX1 AttributeList, SAX2 Attributes method * (don't invoke on parser); */ public int getLength () { return attributesList.size (); } /** * SAX2 Attributes method (don't invoke on parser); */ public String getURI (int index) { return ((Attribute) attributesList.get (index)).nameSpace; } /** * SAX2 Attributes method (don't invoke on parser); */ public String getLocalName (int index) { Attribute attr = (Attribute) attributesList.get (index); // FIXME attr.localName is sometimes null, why? if (namespaces && attr.localName == null) { // XXX fix this here for now int ci = attr.name.indexOf(':'); attr.localName = (ci == -1) ? attr.name : attr.name.substring(ci + 1); } return attr.localName; } /** * SAX2 Attributes method (don't invoke on parser); */ public String getQName (int i) { return ((Attribute) attributesList.get (i)).name; } /** * SAX1 AttributeList method (don't invoke on parser); */ public String getName (int i) { return ((Attribute) attributesList.get (i)).name; } /** * SAX1 AttributeList, SAX2 Attributes method * (don't invoke on parser); */ public String getType (int i) { String type = parser.getAttributeType (elementName, getQName (i)); if (type == null) return "CDATA"; // ... use DeclHandler.attributeDecl to see enumerations if (type == "ENUMERATION") return "NMTOKEN"; return type; } /** * SAX1 AttributeList, SAX2 Attributes method * (don't invoke on parser); */ public String getValue (int i) { return ((Attribute) attributesList.get (i)).value; } /** * SAX2 Attributes method (don't invoke on parser); */ public int getIndex (String uri, String local) { int length = getLength (); for (int i = 0; i < length; i++) { if (!getURI (i).equals (uri)) continue; if (getLocalName (i).equals (local)) return i; } return -1; } /** * SAX2 Attributes method (don't invoke on parser); */ public int getIndex (String xmlName) { int length = getLength (); for (int i = 0; i < length; i++) { if (getQName (i).equals (xmlName)) return i; } return -1; } /** * SAX2 Attributes method (don't invoke on parser); */ public String getType (String uri, String local) { int index = getIndex (uri, local); if (index < 0) return null; return getType (index); } /** * SAX1 AttributeList, SAX2 Attributes method * (don't invoke on parser); */ public String getType (String xmlName) { int index = getIndex (xmlName); if (index < 0) return null; return getType (index); } /** * SAX Attributes method (don't invoke on parser); */ public String getValue (String uri, String local) { int index = getIndex (uri, local); if (index < 0) return null; return getValue (index); } /** * SAX1 AttributeList, SAX2 Attributes method * (don't invoke on parser); */ public String getValue (String xmlName) { int index = getIndex (xmlName); if (index < 0) return null; return getValue (index); } // // Implementation of org.xml.sax.ext.Attributes2 // /** @return false unless the attribute was declared in the DTD. * @throws java.lang.ArrayIndexOutOfBoundsException * When the supplied index does not identify an attribute. */ public boolean isDeclared (int index) { if (index < 0 || index >= attributeCount) throw new ArrayIndexOutOfBoundsException (); return attributeDeclared [index]; } /** @return false unless the attribute was declared in the DTD. * @throws java.lang.IllegalArgumentException * When the supplied names do not identify an attribute. */ public boolean isDeclared (java.lang.String qName) { int index = getIndex (qName); if (index < 0) throw new IllegalArgumentException (); return attributeDeclared [index]; } /** @return false unless the attribute was declared in the DTD. * @throws java.lang.IllegalArgumentException * When the supplied names do not identify an attribute. */ public boolean isDeclared (java.lang.String uri, java.lang.String localName) { int index = getIndex (uri, localName); if (index < 0) throw new IllegalArgumentException (); return attributeDeclared [index]; } /** * SAX-ext Attributes2 method (don't invoke on parser); */ public boolean isSpecified (int index) { if (index < 0 || index >= attributeCount) throw new ArrayIndexOutOfBoundsException (); return attributeSpecified [index]; } /** * SAX-ext Attributes2 method (don't invoke on parser); */ public boolean isSpecified (String uri, String local) { int index = getIndex (uri, local); if (index < 0) throw new IllegalArgumentException (); return attributeSpecified [index]; } /** * SAX-ext Attributes2 method (don't invoke on parser); */ public boolean isSpecified (String xmlName) { int index = getIndex (xmlName); if (index < 0) throw new IllegalArgumentException (); return attributeSpecified [index]; } // // Implementation of org.xml.sax.Locator. // /** * SAX Locator method (don't invoke on parser); */ public String getPublicId () { return null; // FIXME track public IDs too } /** * SAX Locator method (don't invoke on parser); */ public String getSystemId () { if (entityStack.empty ()) return null; else return (String) entityStack.peek (); } /** * SAX Locator method (don't invoke on parser); */ public int getLineNumber () { return parser.getLineNumber (); } /** * SAX Locator method (don't invoke on parser); */ public int getColumnNumber () { return parser.getColumnNumber (); } // adapter between SAX2 content handler and SAX1 document handler callbacks private static class Adapter implements ContentHandler { private DocumentHandler docHandler; Adapter (DocumentHandler dh) { docHandler = dh; } public void setDocumentLocator (Locator l) { docHandler.setDocumentLocator (l); } public void startDocument () throws SAXException { docHandler.startDocument (); } public void processingInstruction (String target, String data) throws SAXException { docHandler.processingInstruction (target, data); } public void startPrefixMapping (String prefix, String uri) { /* ignored */ } public void startElement ( String namespace, String local, String name, Attributes attrs ) throws SAXException { docHandler.startElement (name, (AttributeList) attrs); } public void characters (char buf [], int offset, int len) throws SAXException { docHandler.characters (buf, offset, len); } public void ignorableWhitespace (char buf [], int offset, int len) throws SAXException { docHandler.ignorableWhitespace (buf, offset, len); } public void skippedEntity (String name) { /* ignored */ } public void endElement (String u, String l, String name) throws SAXException { docHandler.endElement (name); } public void endPrefixMapping (String prefix) { /* ignored */ } public void endDocument () throws SAXException { docHandler.endDocument (); } } } class Attribute { String name; String value; String nameSpace; String localName; Attribute(String name, String value) { this.name = name; this.value = value; this.nameSpace = ""; } }