aoqi@0: /*
aoqi@0:  * Copyright (c) 2009, Oracle and/or its affiliates. All rights reserved.
aoqi@0:  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
aoqi@0:  *
aoqi@0:  * This code is free software; you can redistribute it and/or modify it
aoqi@0:  * under the terms of the GNU General Public License version 2 only, as
aoqi@0:  * published by the Free Software Foundation.  Oracle designates this
aoqi@0:  * particular file as subject to the "Classpath" exception as provided
aoqi@0:  * by Oracle in the LICENSE file that accompanied this code.
aoqi@0:  *
aoqi@0:  * This code is distributed in the hope that it will be useful, but WITHOUT
aoqi@0:  * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
aoqi@0:  * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
aoqi@0:  * version 2 for more details (a copy is included in the LICENSE file that
aoqi@0:  * accompanied this code).
aoqi@0:  *
aoqi@0:  * You should have received a copy of the GNU General Public License version
aoqi@0:  * 2 along with this work; if not, write to the Free Software Foundation,
aoqi@0:  * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
aoqi@0:  *
aoqi@0:  * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
aoqi@0:  * or visit www.oracle.com if you need additional information or have any
aoqi@0:  * questions.
aoqi@0:  */
aoqi@0: 
aoqi@0: package com.sun.xml.internal.dtdparser;
aoqi@0: 
aoqi@0: import org.xml.sax.EntityResolver;
aoqi@0: import org.xml.sax.InputSource;
aoqi@0: import org.xml.sax.Locator;
aoqi@0: import org.xml.sax.SAXException;
aoqi@0: import org.xml.sax.SAXParseException;
aoqi@0: 
aoqi@0: import java.io.IOException;
aoqi@0: import java.util.ArrayList;
aoqi@0: import java.util.Enumeration;
aoqi@0: import java.util.Hashtable;
aoqi@0: import java.util.Locale;
aoqi@0: import java.util.Set;
aoqi@0: import java.util.Vector;
aoqi@0: 
aoqi@0: /**
aoqi@0:  * This implements parsing of XML 1.0 DTDs.
aoqi@0:  * <p/>
aoqi@0:  * This conforms to the portion of the XML 1.0 specification related
aoqi@0:  * to the external DTD subset.
aoqi@0:  * <p/>
aoqi@0:  * For multi-language applications (such as web servers using XML
aoqi@0:  * processing to create dynamic content), a method supports choosing
aoqi@0:  * a locale for parser diagnostics which is both understood by the
aoqi@0:  * message recipient and supported by the parser.
aoqi@0:  * <p/>
aoqi@0:  * This parser produces a stream of parse events.  It supports some
aoqi@0:  * features (exposing comments, CDATA sections, and entity references)
aoqi@0:  * which are not required to be reported by conformant XML processors.
aoqi@0:  *
aoqi@0:  * @author David Brownell
aoqi@0:  * @author Janet Koenig
aoqi@0:  * @author Kohsuke KAWAGUCHI
aoqi@0:  * @version $Id: DTDParser.java,v 1.2 2009/04/16 15:25:49 snajper Exp $
aoqi@0:  */
aoqi@0: public class DTDParser {
aoqi@0:     public final static String TYPE_CDATA = "CDATA";
aoqi@0:     public final static String TYPE_ID = "ID";
aoqi@0:     public final static String TYPE_IDREF = "IDREF";
aoqi@0:     public final static String TYPE_IDREFS = "IDREFS";
aoqi@0:     public final static String TYPE_ENTITY = "ENTITY";
aoqi@0:     public final static String TYPE_ENTITIES = "ENTITIES";
aoqi@0:     public final static String TYPE_NMTOKEN = "NMTOKEN";
aoqi@0:     public final static String TYPE_NMTOKENS = "NMTOKENS";
aoqi@0:     public final static String TYPE_NOTATION = "NOTATION";
aoqi@0:     public final static String TYPE_ENUMERATION = "ENUMERATION";
aoqi@0: 
aoqi@0: 
aoqi@0:     // stack of input entities being merged
aoqi@0:     private InputEntity in;
aoqi@0: 
aoqi@0:     // temporaries reused during parsing
aoqi@0:     private StringBuffer strTmp;
aoqi@0:     private char nameTmp [];
aoqi@0:     private NameCache nameCache;
aoqi@0:     private char charTmp [] = new char[2];
aoqi@0: 
aoqi@0:     // temporary DTD parsing state
aoqi@0:     private boolean doLexicalPE;
aoqi@0: 
aoqi@0:     // DTD state, used during parsing
aoqi@0: //    private SimpleHashtable    elements = new SimpleHashtable (47);
aoqi@0:     protected final Set declaredElements = new java.util.HashSet();
aoqi@0:     private SimpleHashtable params = new SimpleHashtable(7);
aoqi@0: 
aoqi@0:     // exposed to package-private subclass
aoqi@0:     Hashtable notations = new Hashtable(7);
aoqi@0:     SimpleHashtable entities = new SimpleHashtable(17);
aoqi@0: 
aoqi@0:     private SimpleHashtable ids = new SimpleHashtable();
aoqi@0: 
aoqi@0:     // listeners for DTD parsing events
aoqi@0:     private DTDEventListener dtdHandler;
aoqi@0: 
aoqi@0:     private EntityResolver resolver;
aoqi@0:     private Locale locale;
aoqi@0: 
aoqi@0:     // string constants -- use these copies so "==" works
aoqi@0:     // package private
aoqi@0:     static final String strANY = "ANY";
aoqi@0:     static final String strEMPTY = "EMPTY";
aoqi@0: 
aoqi@0:     /**
aoqi@0:      * Used by applications to request locale for diagnostics.
aoqi@0:      *
aoqi@0:      * @param l The locale to use, or null to use system defaults
aoqi@0:      *          (which may include only message IDs).
aoqi@0:      */
aoqi@0:     public void setLocale(Locale l) throws SAXException {
aoqi@0: 
aoqi@0:         if (l != null && !messages.isLocaleSupported(l.toString())) {
aoqi@0:             throw new SAXException(messages.getMessage(locale,
aoqi@0:                     "P-078", new Object[]{l}));
aoqi@0:         }
aoqi@0:         locale = l;
aoqi@0:     }
aoqi@0: 
aoqi@0:     /**
aoqi@0:      * Returns the diagnostic locale.
aoqi@0:      */
aoqi@0:     public Locale getLocale() {
aoqi@0:         return locale;
aoqi@0:     }
aoqi@0: 
aoqi@0:     /**
aoqi@0:      * Chooses a client locale to use for diagnostics, using the first
aoqi@0:      * language specified in the list that is supported by this parser.
aoqi@0:      * That locale is then set using <a href="#setLocale(java.util.Locale)">
aoqi@0:      * setLocale()</a>.  Such a list could be provided by a variety of user
aoqi@0:      * preference mechanisms, including the HTTP <em>Accept-Language</em>
aoqi@0:      * header field.
aoqi@0:      *
aoqi@0:      * @param languages Array of language specifiers, ordered with the most
aoqi@0:      *                  preferable one at the front.  For example, "en-ca" then "fr-ca",
aoqi@0:      *                  followed by "zh_CN".  Both RFC 1766 and Java styles are supported.
aoqi@0:      * @return The chosen locale, or null.
aoqi@0:      * @see MessageCatalog
aoqi@0:      */
aoqi@0:     public Locale chooseLocale(String languages [])
aoqi@0:             throws SAXException {
aoqi@0: 
aoqi@0:         Locale l = messages.chooseLocale(languages);
aoqi@0: 
aoqi@0:         if (l != null) {
aoqi@0:             setLocale(l);
aoqi@0:         }
aoqi@0:         return l;
aoqi@0:     }
aoqi@0: 
aoqi@0:     /**
aoqi@0:      * Lets applications control entity resolution.
aoqi@0:      */
aoqi@0:     public void setEntityResolver(EntityResolver r) {
aoqi@0: 
aoqi@0:         resolver = r;
aoqi@0:     }
aoqi@0: 
aoqi@0:     /**
aoqi@0:      * Returns the object used to resolve entities
aoqi@0:      */
aoqi@0:     public EntityResolver getEntityResolver() {
aoqi@0: 
aoqi@0:         return resolver;
aoqi@0:     }
aoqi@0: 
aoqi@0:     /**
aoqi@0:      * Used by applications to set handling of DTD parsing events.
aoqi@0:      */
aoqi@0:     public void setDtdHandler(DTDEventListener handler) {
aoqi@0:         dtdHandler = handler;
aoqi@0:         if (handler != null)
aoqi@0:             handler.setDocumentLocator(new Locator() {
aoqi@0:                 public String getPublicId() {
aoqi@0:                     return DTDParser.this.getPublicId();
aoqi@0:                 }
aoqi@0: 
aoqi@0:                 public String getSystemId() {
aoqi@0:                     return DTDParser.this.getSystemId();
aoqi@0:                 }
aoqi@0: 
aoqi@0:                 public int getLineNumber() {
aoqi@0:                     return DTDParser.this.getLineNumber();
aoqi@0:                 }
aoqi@0: 
aoqi@0:                 public int getColumnNumber() {
aoqi@0:                     return DTDParser.this.getColumnNumber();
aoqi@0:                 }
aoqi@0:             });
aoqi@0:     }
aoqi@0: 
aoqi@0:     /**
aoqi@0:      * Returns the handler used to for DTD parsing events.
aoqi@0:      */
aoqi@0:     public DTDEventListener getDtdHandler() {
aoqi@0:         return dtdHandler;
aoqi@0:     }
aoqi@0: 
aoqi@0:     /**
aoqi@0:      * Parse a DTD.
aoqi@0:      */
aoqi@0:     public void parse(InputSource in)
aoqi@0:             throws IOException, SAXException {
aoqi@0:         init();
aoqi@0:         parseInternal(in);
aoqi@0:     }
aoqi@0: 
aoqi@0:     /**
aoqi@0:      * Parse a DTD.
aoqi@0:      */
aoqi@0:     public void parse(String uri)
aoqi@0:             throws IOException, SAXException {
aoqi@0:         InputSource in;
aoqi@0: 
aoqi@0:         init();
aoqi@0:         // System.out.println ("parse (\"" + uri + "\")");
aoqi@0:         in = resolver.resolveEntity(null, uri);
aoqi@0: 
aoqi@0:         // If custom resolver punts resolution to parser, handle it ...
aoqi@0:         if (in == null) {
aoqi@0:             in = Resolver.createInputSource(new java.net.URL(uri), false);
aoqi@0: 
aoqi@0:             // ... or if custom resolver doesn't correctly construct the
aoqi@0:             // input entity, patch it up enough so relative URIs work, and
aoqi@0:             // issue a warning to minimize later confusion.
aoqi@0:         } else if (in.getSystemId() == null) {
aoqi@0:             warning("P-065", null);
aoqi@0:             in.setSystemId(uri);
aoqi@0:         }
aoqi@0: 
aoqi@0:         parseInternal(in);
aoqi@0:     }
aoqi@0: 
aoqi@0:     // makes sure the parser is reset to "before a document"
aoqi@0:     private void init() {
aoqi@0:         in = null;
aoqi@0: 
aoqi@0:         // alloc temporary data used in parsing
aoqi@0:         strTmp = new StringBuffer();
aoqi@0:         nameTmp = new char[20];
aoqi@0:         nameCache = new NameCache();
aoqi@0: 
aoqi@0:         // reset doc info
aoqi@0: //        isInAttribute = false;
aoqi@0: 
aoqi@0:         doLexicalPE = false;
aoqi@0: 
aoqi@0:         entities.clear();
aoqi@0:         notations.clear();
aoqi@0:         params.clear();
aoqi@0:         //    elements.clear ();
aoqi@0:         declaredElements.clear();
aoqi@0: 
aoqi@0:         // initialize predefined references ... re-interpreted later
aoqi@0:         builtin("amp", "&#38;");
aoqi@0:         builtin("lt", "&#60;");
aoqi@0:         builtin("gt", ">");
aoqi@0:         builtin("quot", "\"");
aoqi@0:         builtin("apos", "'");
aoqi@0: 
aoqi@0:         if (locale == null)
aoqi@0:             locale = Locale.getDefault();
aoqi@0:         if (resolver == null)
aoqi@0:             resolver = new Resolver();
aoqi@0:         if (dtdHandler == null)
aoqi@0:             dtdHandler = new DTDHandlerBase();
aoqi@0:     }
aoqi@0: 
aoqi@0:     private void builtin(String entityName, String entityValue) {
aoqi@0:         InternalEntity entity;
aoqi@0:         entity = new InternalEntity(entityName, entityValue.toCharArray());
aoqi@0:         entities.put(entityName, entity);
aoqi@0:     }
aoqi@0: 
aoqi@0: 
aoqi@0:     ////////////////////////////////////////////////////////////////
aoqi@0:     //
aoqi@0:     // parsing is by recursive descent, code roughly
aoqi@0:     // following the BNF rules except tweaked for simple
aoqi@0:     // lookahead.  rules are more or less in numeric order,
aoqi@0:     // except where code sharing suggests other structures.
aoqi@0:     //
aoqi@0:     // a classic benefit of recursive descent parsers:  it's
aoqi@0:     // relatively easy to get diagnostics that make sense.
aoqi@0:     //
aoqi@0:     ////////////////////////////////////////////////////////////////
aoqi@0: 
aoqi@0: 
aoqi@0:     private void parseInternal(InputSource input)
aoqi@0:             throws IOException, SAXException {
aoqi@0: 
aoqi@0:         if (input == null)
aoqi@0:             fatal("P-000");
aoqi@0: 
aoqi@0:         try {
aoqi@0:             in = InputEntity.getInputEntity(dtdHandler, locale);
aoqi@0:             in.init(input, null, null, false);
aoqi@0: 
aoqi@0:             dtdHandler.startDTD(in);
aoqi@0: 
aoqi@0:             // [30] extSubset ::= TextDecl? extSubsetDecl
aoqi@0:             // [31] extSubsetDecl ::= ( markupdecl | conditionalSect
aoqi@0:             //        | PEReference | S )*
aoqi@0:             //    ... same as [79] extPE, which is where the code is
aoqi@0: 
aoqi@0:             ExternalEntity externalSubset = new ExternalEntity(in);
aoqi@0:             externalParameterEntity(externalSubset);
aoqi@0: 
aoqi@0:             if (!in.isEOF()) {
aoqi@0:                 fatal("P-001", new Object[]
aoqi@0:                 {Integer.toHexString(((int) getc()))});
aoqi@0:             }
aoqi@0:             afterRoot();
aoqi@0:             dtdHandler.endDTD();
aoqi@0: 
aoqi@0:         } catch (EndOfInputException e) {
aoqi@0:             if (!in.isDocument()) {
aoqi@0:                 String name = in.getName();
aoqi@0:                 do {    // force a relevant URI and line number
aoqi@0:                     in = in.pop();
aoqi@0:                 } while (in.isInternal());
aoqi@0:                 fatal("P-002", new Object[]{name});
aoqi@0:             } else {
aoqi@0:                 fatal("P-003", null);
aoqi@0:             }
aoqi@0:         } catch (RuntimeException e) {
aoqi@0:             // Don't discard location that triggered the exception
aoqi@0:             // ## Should properly wrap exception
aoqi@0:             System.err.print("Internal DTD parser error: "); // ##
aoqi@0:             e.printStackTrace();
aoqi@0:             throw new SAXParseException(e.getMessage() != null
aoqi@0:                     ? e.getMessage() : e.getClass().getName(),
aoqi@0:                     getPublicId(), getSystemId(),
aoqi@0:                     getLineNumber(), getColumnNumber());
aoqi@0: 
aoqi@0:         } finally {
aoqi@0:             // recycle temporary data used during parsing
aoqi@0:             strTmp = null;
aoqi@0:             nameTmp = null;
aoqi@0:             nameCache = null;
aoqi@0: 
aoqi@0:             // ditto input sources etc
aoqi@0:             if (in != null) {
aoqi@0:                 in.close();
aoqi@0:                 in = null;
aoqi@0:             }
aoqi@0: 
aoqi@0:             // get rid of all DTD info ... some of it would be
aoqi@0:             // useful for editors etc, investigate later.
aoqi@0: 
aoqi@0:             params.clear();
aoqi@0:             entities.clear();
aoqi@0:             notations.clear();
aoqi@0:             declaredElements.clear();
aoqi@0: //        elements.clear();
aoqi@0:             ids.clear();
aoqi@0:         }
aoqi@0:     }
aoqi@0: 
aoqi@0:     void afterRoot() throws SAXException {
aoqi@0:         // Make sure all IDREFs match declared ID attributes.  We scan
aoqi@0:         // after the document element is parsed, since XML allows forward
aoqi@0:         // references, and only now can we know if they're all resolved.
aoqi@0: 
aoqi@0:         for (Enumeration e = ids.keys();
aoqi@0:              e.hasMoreElements();
aoqi@0:                 ) {
aoqi@0:             String id = (String) e.nextElement();
aoqi@0:             Boolean value = (Boolean) ids.get(id);
aoqi@0:             if (Boolean.FALSE == value)
aoqi@0:                 error("V-024", new Object[]{id});
aoqi@0:         }
aoqi@0:     }
aoqi@0: 
aoqi@0: 
aoqi@0:     // role is for diagnostics
aoqi@0:     private void whitespace(String roleId)
aoqi@0:             throws IOException, SAXException {
aoqi@0: 
aoqi@0:         // [3] S ::= (#x20 | #x9 | #xd | #xa)+
aoqi@0:         if (!maybeWhitespace()) {
aoqi@0:             fatal("P-004", new Object[]
aoqi@0:             {messages.getMessage(locale, roleId)});
aoqi@0:         }
aoqi@0:     }
aoqi@0: 
aoqi@0:     // S?
aoqi@0:     private boolean maybeWhitespace()
aoqi@0:             throws IOException, SAXException {
aoqi@0: 
aoqi@0:         if (!doLexicalPE)
aoqi@0:             return in.maybeWhitespace();
aoqi@0: 
aoqi@0:         // see getc() for the PE logic -- this lets us splice
aoqi@0:         // expansions of PEs in "anywhere".  getc() has smarts,
aoqi@0:         // so for external PEs we don't bypass it.
aoqi@0: 
aoqi@0:         // XXX we can marginally speed PE handling, and certainly
aoqi@0:         // be cleaner (hence potentially more correct), by using
aoqi@0:         // the observations that expanded PEs only start and stop
aoqi@0:         // where whitespace is allowed.  getc wouldn't need any
aoqi@0:         // "lexical" PE expansion logic, and no other method needs
aoqi@0:         // to handle termination of PEs.  (parsing of literals would
aoqi@0:         // still need to pop entities, but not parsing of references
aoqi@0:         // in content.)
aoqi@0: 
aoqi@0:         char c = getc();
aoqi@0:         boolean saw = false;
aoqi@0: 
aoqi@0:         while (c == ' ' || c == '\t' || c == '\n' || c == '\r') {
aoqi@0:             saw = true;
aoqi@0: 
aoqi@0:             // this gracefully ends things when we stop playing
aoqi@0:             // with internal parameters.  caller should have a
aoqi@0:             // grammar rule allowing whitespace at end of entity.
aoqi@0:             if (in.isEOF() && !in.isInternal())
aoqi@0:                 return saw;
aoqi@0:             c = getc();
aoqi@0:         }
aoqi@0:         ungetc();
aoqi@0:         return saw;
aoqi@0:     }
aoqi@0: 
aoqi@0:     private String maybeGetName()
aoqi@0:             throws IOException, SAXException {
aoqi@0: 
aoqi@0:         NameCacheEntry entry = maybeGetNameCacheEntry();
aoqi@0:         return (entry == null) ? null : entry.name;
aoqi@0:     }
aoqi@0: 
aoqi@0:     private NameCacheEntry maybeGetNameCacheEntry()
aoqi@0:             throws IOException, SAXException {
aoqi@0: 
aoqi@0:         // [5] Name ::= (Letter|'_'|':') (Namechar)*
aoqi@0:         char c = getc();
aoqi@0: 
aoqi@0:         if (!XmlChars.isLetter(c) && c != ':' && c != '_') {
aoqi@0:             ungetc();
aoqi@0:             return null;
aoqi@0:         }
aoqi@0:         return nameCharString(c);
aoqi@0:     }
aoqi@0: 
aoqi@0:     // Used when parsing enumerations
aoqi@0:     private String getNmtoken()
aoqi@0:             throws IOException, SAXException {
aoqi@0: 
aoqi@0:         // [7] Nmtoken ::= (Namechar)+
aoqi@0:         char c = getc();
aoqi@0:         if (!XmlChars.isNameChar(c))
aoqi@0:             fatal("P-006", new Object[]{new Character(c)});
aoqi@0:         return nameCharString(c).name;
aoqi@0:     }
aoqi@0: 
aoqi@0:     // n.b. this gets used when parsing attribute values (for
aoqi@0:     // internal references) so we can't use strTmp; it's also
aoqi@0:     // a hotspot for CPU and memory in the parser (called at least
aoqi@0:     // once for each element) so this has been optimized a bit.
aoqi@0: 
aoqi@0:     private NameCacheEntry nameCharString(char c)
aoqi@0:             throws IOException, SAXException {
aoqi@0: 
aoqi@0:         int i = 1;
aoqi@0: 
aoqi@0:         nameTmp[0] = c;
aoqi@0:         for (; ;) {
aoqi@0:             if ((c = in.getNameChar()) == 0)
aoqi@0:                 break;
aoqi@0:             if (i >= nameTmp.length) {
aoqi@0:                 char tmp [] = new char[nameTmp.length + 10];
aoqi@0:                 System.arraycopy(nameTmp, 0, tmp, 0, nameTmp.length);
aoqi@0:                 nameTmp = tmp;
aoqi@0:             }
aoqi@0:             nameTmp[i++] = c;
aoqi@0:         }
aoqi@0:         return nameCache.lookupEntry(nameTmp, i);
aoqi@0:     }
aoqi@0: 
aoqi@0:     //
aoqi@0:     // much similarity between parsing entity values in DTD
aoqi@0:     // and attribute values (in DTD or content) ... both follow
aoqi@0:     // literal parsing rules, newline canonicalization, etc
aoqi@0:     //
aoqi@0:     // leaves value in 'strTmp' ... either a "replacement text" (4.5),
aoqi@0:     // or else partially normalized attribute value (the first bit
aoqi@0:     // of 3.3.3's spec, without the "if not CDATA" bits).
aoqi@0:     //
aoqi@0:     private void parseLiteral(boolean isEntityValue)
aoqi@0:             throws IOException, SAXException {
aoqi@0: 
aoqi@0:         // [9] EntityValue ::=
aoqi@0:         //    '"' ([^"&%] | Reference | PEReference)* '"'
aoqi@0:         //    |    "'" ([^'&%] | Reference | PEReference)* "'"
aoqi@0:         // [10] AttValue ::=
aoqi@0:         //    '"' ([^"&]  | Reference             )* '"'
aoqi@0:         //    |    "'" ([^'&]  | Reference             )* "'"
aoqi@0:         char quote = getc();
aoqi@0:         char c;
aoqi@0:         InputEntity source = in;
aoqi@0: 
aoqi@0:         if (quote != '\'' && quote != '"') {
aoqi@0:             fatal("P-007");
aoqi@0:         }
aoqi@0: 
aoqi@0:         // don't report entity expansions within attributes,
aoqi@0:         // they're reported "fully expanded" via SAX
aoqi@0: //    isInAttribute = !isEntityValue;
aoqi@0: 
aoqi@0:         // get value into strTmp
aoqi@0:         strTmp = new StringBuffer();
aoqi@0: 
aoqi@0:         // scan, allowing entity push/pop wherever ...
aoqi@0:         // expanded entities can't terminate the literal!
aoqi@0:         for (; ;) {
aoqi@0:             if (in != source && in.isEOF()) {
aoqi@0:                 // we don't report end of parsed entities
aoqi@0:                 // within attributes (no SAX hooks)
aoqi@0:                 in = in.pop();
aoqi@0:                 continue;
aoqi@0:             }
aoqi@0:             if ((c = getc()) == quote && in == source) {
aoqi@0:                 break;
aoqi@0:             }
aoqi@0: 
aoqi@0:             //
aoqi@0:             // Basically the "reference in attribute value"
aoqi@0:             // row of the chart in section 4.4 of the spec
aoqi@0:             //
aoqi@0:             if (c == '&') {
aoqi@0:                 String entityName = maybeGetName();
aoqi@0: 
aoqi@0:                 if (entityName != null) {
aoqi@0:                     nextChar(';', "F-020", entityName);
aoqi@0: 
aoqi@0:                     // 4.4 says:  bypass these here ... we'll catch
aoqi@0:                     // forbidden refs to unparsed entities on use
aoqi@0:                     if (isEntityValue) {
aoqi@0:                         strTmp.append('&');
aoqi@0:                         strTmp.append(entityName);
aoqi@0:                         strTmp.append(';');
aoqi@0:                         continue;
aoqi@0:                     }
aoqi@0:                     expandEntityInLiteral(entityName, entities, isEntityValue);
aoqi@0: 
aoqi@0: 
aoqi@0:                     // character references are always included immediately
aoqi@0:                 } else if ((c = getc()) == '#') {
aoqi@0:                     int tmp = parseCharNumber();
aoqi@0: 
aoqi@0:                     if (tmp > 0xffff) {
aoqi@0:                         tmp = surrogatesToCharTmp(tmp);
aoqi@0:                         strTmp.append(charTmp[0]);
aoqi@0:                         if (tmp == 2)
aoqi@0:                             strTmp.append(charTmp[1]);
aoqi@0:                     } else
aoqi@0:                         strTmp.append((char) tmp);
aoqi@0:                 } else
aoqi@0:                     fatal("P-009");
aoqi@0:                 continue;
aoqi@0: 
aoqi@0:             }
aoqi@0: 
aoqi@0:             // expand parameter entities only within entity value literals
aoqi@0:             if (c == '%' && isEntityValue) {
aoqi@0:                 String entityName = maybeGetName();
aoqi@0: 
aoqi@0:                 if (entityName != null) {
aoqi@0:                     nextChar(';', "F-021", entityName);
aoqi@0:                     expandEntityInLiteral(entityName, params, isEntityValue);
aoqi@0:                     continue;
aoqi@0:                 } else
aoqi@0:                     fatal("P-011");
aoqi@0:             }
aoqi@0: 
aoqi@0:             // For attribute values ...
aoqi@0:             if (!isEntityValue) {
aoqi@0:                 // 3.3.3 says whitespace normalizes to space...
aoqi@0:                 if (c == ' ' || c == '\t' || c == '\n' || c == '\r') {
aoqi@0:                     strTmp.append(' ');
aoqi@0:                     continue;
aoqi@0:                 }
aoqi@0: 
aoqi@0:                 // "<" not legal in parsed literals ...
aoqi@0:                 if (c == '<')
aoqi@0:                     fatal("P-012");
aoqi@0:             }
aoqi@0: 
aoqi@0:             strTmp.append(c);
aoqi@0:         }
aoqi@0: //    isInAttribute = false;
aoqi@0:     }
aoqi@0: 
aoqi@0:     // does a SINGLE expansion of the entity (often reparsed later)
aoqi@0:     private void expandEntityInLiteral(String name, SimpleHashtable table,
aoqi@0:                                        boolean isEntityValue)
aoqi@0:             throws IOException, SAXException {
aoqi@0: 
aoqi@0:         Object entity = table.get(name);
aoqi@0: 
aoqi@0:         if (entity instanceof InternalEntity) {
aoqi@0:             InternalEntity value = (InternalEntity) entity;
aoqi@0:             pushReader(value.buf, name, !value.isPE);
aoqi@0: 
aoqi@0:         } else if (entity instanceof ExternalEntity) {
aoqi@0:             if (!isEntityValue)    // must be a PE ...
aoqi@0:                 fatal("P-013", new Object[]{name});
aoqi@0:             // XXX if this returns false ...
aoqi@0:             pushReader((ExternalEntity) entity);
aoqi@0: 
aoqi@0:         } else if (entity == null) {
aoqi@0:             //
aoqi@0:             // Note:  much confusion about whether spec requires such
aoqi@0:             // errors to be fatal in many cases, but none about whether
aoqi@0:             // it allows "normal" errors to be unrecoverable!
aoqi@0:             //
aoqi@0:             fatal((table == params) ? "V-022" : "P-014",
aoqi@0:                     new Object[]{name});
aoqi@0:         }
aoqi@0:     }
aoqi@0: 
aoqi@0:     // [11] SystemLiteral ::= ('"' [^"]* '"') | ("'" [^']* "'")
aoqi@0:     // for PUBLIC and SYSTEM literals, also "<?xml ...type='literal'?>'
aoqi@0: 
aoqi@0:     // NOTE:  XML spec should explicitly say that PE ref syntax is
aoqi@0:     // ignored in PIs, comments, SystemLiterals, and Pubid Literal
aoqi@0:     // values ... can't process the XML spec's own DTD without doing
aoqi@0:     // that for comments.
aoqi@0: 
aoqi@0:     private String getQuotedString(String type, String extra)
aoqi@0:             throws IOException, SAXException {
aoqi@0: 
aoqi@0:         // use in.getc to bypass PE processing
aoqi@0:         char quote = in.getc();
aoqi@0: 
aoqi@0:         if (quote != '\'' && quote != '"')
aoqi@0:             fatal("P-015", new Object[]{
aoqi@0:                 messages.getMessage(locale, type, new Object[]{extra})
aoqi@0:             });
aoqi@0: 
aoqi@0:         char c;
aoqi@0: 
aoqi@0:         strTmp = new StringBuffer();
aoqi@0:         while ((c = in.getc()) != quote)
aoqi@0:             strTmp.append((char) c);
aoqi@0:         return strTmp.toString();
aoqi@0:     }
aoqi@0: 
aoqi@0: 
aoqi@0:     private String parsePublicId() throws IOException, SAXException {
aoqi@0: 
aoqi@0:         // [12] PubidLiteral ::= ('"' PubidChar* '"') | ("'" PubidChar* "'")
aoqi@0:         // [13] PubidChar ::= #x20|#xd|#xa|[a-zA-Z0-9]|[-'()+,./:=?;!*#@$_%]
aoqi@0:         String retval = getQuotedString("F-033", null);
aoqi@0:         for (int i = 0; i < retval.length(); i++) {
aoqi@0:             char c = retval.charAt(i);
aoqi@0:             if (" \r\n-'()+,./:=?;!*#@$_%0123456789".indexOf(c) == -1
aoqi@0:                     && !(c >= 'A' && c <= 'Z')
aoqi@0:                     && !(c >= 'a' && c <= 'z'))
aoqi@0:                 fatal("P-016", new Object[]{new Character(c)});
aoqi@0:         }
aoqi@0:         strTmp = new StringBuffer();
aoqi@0:         strTmp.append(retval);
aoqi@0:         return normalize(false);
aoqi@0:     }
aoqi@0: 
aoqi@0:     // [14] CharData ::= [^<&]* - ([^<&]* ']]>' [^<&]*)
aoqi@0:     // handled by:  InputEntity.parsedContent()
aoqi@0: 
aoqi@0:     private boolean maybeComment(boolean skipStart)
aoqi@0:             throws IOException, SAXException {
aoqi@0: 
aoqi@0:         // [15] Comment ::= '<!--'
aoqi@0:         //        ( (Char - '-') | ('-' (Char - '-'))*
aoqi@0:         //        '-->'
aoqi@0:         if (!in.peek(skipStart ? "!--" : "<!--", null))
aoqi@0:             return false;
aoqi@0: 
aoqi@0:         boolean savedLexicalPE = doLexicalPE;
aoqi@0:         boolean saveCommentText;
aoqi@0: 
aoqi@0:         doLexicalPE = false;
aoqi@0:         saveCommentText = false;
aoqi@0:         if (saveCommentText)
aoqi@0:             strTmp = new StringBuffer();
aoqi@0: 
aoqi@0:         oneComment:
aoqi@0:         for (; ;) {
aoqi@0:             try {
aoqi@0:                 // bypass PE expansion, but permit PEs
aoqi@0:                 // to complete ... valid docs won't care.
aoqi@0:                 for (; ;) {
aoqi@0:                     int c = getc();
aoqi@0:                     if (c == '-') {
aoqi@0:                         c = getc();
aoqi@0:                         if (c != '-') {
aoqi@0:                             if (saveCommentText)
aoqi@0:                                 strTmp.append('-');
aoqi@0:                             ungetc();
aoqi@0:                             continue;
aoqi@0:                         }
aoqi@0:                         nextChar('>', "F-022", null);
aoqi@0:                         break oneComment;
aoqi@0:                     }
aoqi@0:                     if (saveCommentText)
aoqi@0:                         strTmp.append((char) c);
aoqi@0:                 }
aoqi@0:             } catch (EndOfInputException e) {
aoqi@0:                 //
aoqi@0:                 // This is fatal EXCEPT when we're processing a PE...
aoqi@0:                 // in which case a validating processor reports an error.
aoqi@0:                 // External PEs are easy to detect; internal ones we
aoqi@0:                 // infer by being an internal entity outside an element.
aoqi@0:                 //
aoqi@0:                 if (in.isInternal()) {
aoqi@0:                     error("V-021", null);
aoqi@0:                 }
aoqi@0:                 fatal("P-017");
aoqi@0:             }
aoqi@0:         }
aoqi@0:         doLexicalPE = savedLexicalPE;
aoqi@0:         if (saveCommentText)
aoqi@0:             dtdHandler.comment(strTmp.toString());
aoqi@0:         return true;
aoqi@0:     }
aoqi@0: 
aoqi@0:     private boolean maybePI(boolean skipStart)
aoqi@0:             throws IOException, SAXException {
aoqi@0: 
aoqi@0:         // [16] PI ::= '<?' PITarget
aoqi@0:         //        (S (Char* - (Char* '?>' Char*)))?
aoqi@0:         //        '?>'
aoqi@0:         // [17] PITarget ::= Name - (('X'|'x')('M'|'m')('L'|'l')
aoqi@0:         boolean savedLexicalPE = doLexicalPE;
aoqi@0: 
aoqi@0:         if (!in.peek(skipStart ? "?" : "<?", null))
aoqi@0:             return false;
aoqi@0:         doLexicalPE = false;
aoqi@0: 
aoqi@0:         String target = maybeGetName();
aoqi@0: 
aoqi@0:         if (target == null) {
aoqi@0:             fatal("P-018");
aoqi@0:         }
aoqi@0:         if ("xml".equals(target)) {
aoqi@0:             fatal("P-019");
aoqi@0:         }
aoqi@0:         if ("xml".equalsIgnoreCase(target)) {
aoqi@0:             fatal("P-020", new Object[]{target});
aoqi@0:         }
aoqi@0: 
aoqi@0:         if (maybeWhitespace()) {
aoqi@0:             strTmp = new StringBuffer();
aoqi@0:             try {
aoqi@0:                 for (; ;) {
aoqi@0:                     // use in.getc to bypass PE processing
aoqi@0:                     char c = in.getc();
aoqi@0:                     //Reached the end of PI.
aoqi@0:                     if (c == '?' && in.peekc('>'))
aoqi@0:                         break;
aoqi@0:                     strTmp.append(c);
aoqi@0:                 }
aoqi@0:             } catch (EndOfInputException e) {
aoqi@0:                 fatal("P-021");
aoqi@0:             }
aoqi@0:             dtdHandler.processingInstruction(target, strTmp.toString());
aoqi@0:         } else {
aoqi@0:             if (!in.peek("?>", null)) {
aoqi@0:                 fatal("P-022");
aoqi@0:             }
aoqi@0:             dtdHandler.processingInstruction(target, "");
aoqi@0:         }
aoqi@0: 
aoqi@0:         doLexicalPE = savedLexicalPE;
aoqi@0:         return true;
aoqi@0:     }
aoqi@0: 
aoqi@0:     // [18] CDSect ::= CDStart CData CDEnd
aoqi@0:     // [19] CDStart ::= '<![CDATA['
aoqi@0:     // [20] CData ::= (Char* - (Char* ']]>' Char*))
aoqi@0:     // [21] CDEnd ::= ']]>'
aoqi@0:     //
aoqi@0:     //    ... handled by InputEntity.unparsedContent()
aoqi@0: 
aoqi@0:     // collapsing several rules together ...
aoqi@0:     // simpler than attribute literals -- no reference parsing!
aoqi@0:     private String maybeReadAttribute(String name, boolean must)
aoqi@0:             throws IOException, SAXException {
aoqi@0: 
aoqi@0:         // [24] VersionInfo ::= S 'version' Eq \'|\" versionNum \'|\"
aoqi@0:         // [80] EncodingDecl ::= S 'encoding' Eq \'|\" EncName \'|\"
aoqi@0:         // [32] SDDecl ::=  S 'standalone' Eq \'|\" ... \'|\"
aoqi@0:         if (!maybeWhitespace()) {
aoqi@0:             if (!must) {
aoqi@0:                 return null;
aoqi@0:             }
aoqi@0:             fatal("P-024", new Object[]{name});
aoqi@0:             // NOTREACHED
aoqi@0:         }
aoqi@0: 
aoqi@0:         if (!peek(name)) {
aoqi@0:             if (must) {
aoqi@0:                 fatal("P-024", new Object[]{name});
aoqi@0:             } else {
aoqi@0:                 // To ensure that the whitespace is there so that when we
aoqi@0:                 // check for the next attribute we assure that the
aoqi@0:                 // whitespace still exists.
aoqi@0:                 ungetc();
aoqi@0:                 return null;
aoqi@0:             }
aoqi@0:         }
aoqi@0: 
aoqi@0:         // [25] Eq ::= S? '=' S?
aoqi@0:         maybeWhitespace();
aoqi@0:         nextChar('=', "F-023", null);
aoqi@0:         maybeWhitespace();
aoqi@0: 
aoqi@0:         return getQuotedString("F-035", name);
aoqi@0:     }
aoqi@0: 
aoqi@0:     private void readVersion(boolean must, String versionNum)
aoqi@0:             throws IOException, SAXException {
aoqi@0: 
aoqi@0:         String value = maybeReadAttribute("version", must);
aoqi@0: 
aoqi@0:         // [26] versionNum ::= ([a-zA-Z0-9_.:]| '-')+
aoqi@0: 
aoqi@0:         if (must && value == null)
aoqi@0:             fatal("P-025", new Object[]{versionNum});
aoqi@0:         if (value != null) {
aoqi@0:             int length = value.length();
aoqi@0:             for (int i = 0; i < length; i++) {
aoqi@0:                 char c = value.charAt(i);
aoqi@0:                 if (!((c >= '0' && c <= '9')
aoqi@0:                         || c == '_' || c == '.'
aoqi@0:                         || (c >= 'a' && c <= 'z')
aoqi@0:                         || (c >= 'A' && c <= 'Z')
aoqi@0:                         || c == ':' || c == '-')
aoqi@0:                 )
aoqi@0:                     fatal("P-026", new Object[]{value});
aoqi@0:             }
aoqi@0:         }
aoqi@0:         if (value != null && !value.equals(versionNum))
aoqi@0:             error("P-027", new Object[]{versionNum, value});
aoqi@0:     }
aoqi@0: 
aoqi@0:     // common code used by most markup declarations
aoqi@0:     // ... S (Q)Name ...
aoqi@0:     private String getMarkupDeclname(String roleId, boolean qname)
aoqi@0:             throws IOException, SAXException {
aoqi@0: 
aoqi@0:         String name;
aoqi@0: 
aoqi@0:         whitespace(roleId);
aoqi@0:         name = maybeGetName();
aoqi@0:         if (name == null)
aoqi@0:             fatal("P-005", new Object[]
aoqi@0:             {messages.getMessage(locale, roleId)});
aoqi@0:         return name;
aoqi@0:     }
aoqi@0: 
aoqi@0:     private boolean maybeMarkupDecl()
aoqi@0:             throws IOException, SAXException {
aoqi@0: 
aoqi@0:         // [29] markupdecl ::= elementdecl | Attlistdecl
aoqi@0:         //           | EntityDecl | NotationDecl | PI | Comment
aoqi@0:         return maybeElementDecl()
aoqi@0:                 || maybeAttlistDecl()
aoqi@0:                 || maybeEntityDecl()
aoqi@0:                 || maybeNotationDecl()
aoqi@0:                 || maybePI(false)
aoqi@0:                 || maybeComment(false);
aoqi@0:     }
aoqi@0: 
aoqi@0:     private static final String XmlLang = "xml:lang";
aoqi@0: 
aoqi@0:     private boolean isXmlLang(String value) {
aoqi@0: 
aoqi@0:         // [33] LanguageId ::= Langcode ('-' Subcode)*
aoqi@0:         // [34] Langcode ::= ISO639Code | IanaCode | UserCode
aoqi@0:         // [35] ISO639Code ::= [a-zA-Z] [a-zA-Z]
aoqi@0:         // [36] IanaCode ::= [iI] '-' SubCode
aoqi@0:         // [37] UserCode ::= [xX] '-' SubCode
aoqi@0:         // [38] SubCode ::= [a-zA-Z]+
aoqi@0: 
aoqi@0:         // the ISO and IANA codes (and subcodes) are registered,
aoqi@0:         // but that's neither a WF nor a validity constraint.
aoqi@0: 
aoqi@0:         int nextSuffix;
aoqi@0:         char c;
aoqi@0: 
aoqi@0:         if (value.length() < 2)
aoqi@0:             return false;
aoqi@0:         c = value.charAt(1);
aoqi@0:         if (c == '-') {        // IANA, or user, code
aoqi@0:             c = value.charAt(0);
aoqi@0:             if (!(c == 'i' || c == 'I' || c == 'x' || c == 'X'))
aoqi@0:                 return false;
aoqi@0:             nextSuffix = 1;
aoqi@0:         } else if ((c >= 'a' && c <= 'z') || (c >= 'A' && c <= 'Z')) {
aoqi@0:             // 2 letter ISO code, or error
aoqi@0:             c = value.charAt(0);
aoqi@0:             if (!((c >= 'a' && c <= 'z') || (c >= 'A' && c <= 'Z')))
aoqi@0:                 return false;
aoqi@0:             nextSuffix = 2;
aoqi@0:         } else
aoqi@0:             return false;
aoqi@0: 
aoqi@0:         // here "suffix" ::= '-' [a-zA-Z]+ suffix*
aoqi@0:         while (nextSuffix < value.length()) {
aoqi@0:             c = value.charAt(nextSuffix);
aoqi@0:             if (c != '-')
aoqi@0:                 break;
aoqi@0:             while (++nextSuffix < value.length()) {
aoqi@0:                 c = value.charAt(nextSuffix);
aoqi@0:                 if (!((c >= 'a' && c <= 'z') || (c >= 'A' && c <= 'Z')))
aoqi@0:                     break;
aoqi@0:             }
aoqi@0:         }
aoqi@0:         return value.length() == nextSuffix && c != '-';
aoqi@0:     }
aoqi@0: 
aoqi@0: 
aoqi@0:     //
aoqi@0:     // CHAPTER 3:  Logical Structures
aoqi@0:     //
aoqi@0: 
aoqi@0:     /**
aoqi@0:      * To validate, subclassers should at this time make sure that
aoqi@0:      * values are of the declared types:<UL>
aoqi@0:      * <LI> ID and IDREF(S) values are Names
aoqi@0:      * <LI> NMTOKEN(S) are Nmtokens
aoqi@0:      * <LI> ENUMERATION values match one of the tokens
aoqi@0:      * <LI> NOTATION values match a notation name
aoqi@0:      * <LI> ENTITIY(IES) values match an unparsed external entity
aoqi@0:      * </UL>
aoqi@0:      * <p/>
aoqi@0:      * <P> Separately, make sure IDREF values match some ID
aoqi@0:      * provided in the document (in the afterRoot method).
aoqi@0:      */
aoqi@0: /*    void validateAttributeSyntax (Attribute attr, String value)
aoqi@0:          throws DTDParseException {
aoqi@0:         // ID, IDREF(S) ... values are Names
aoqi@0:         if (Attribute.ID == attr.type()) {
aoqi@0:             if (!XmlNames.isName (value))
aoqi@0:                 error ("V-025", new Object [] { value });
aoqi@0: 
aoqi@0:             Boolean             b = (Boolean) ids.getNonInterned (value);
aoqi@0:             if (b == null || b.equals (Boolean.FALSE))
aoqi@0:                 ids.put (value.intern (), Boolean.TRUE);
aoqi@0:             else
aoqi@0:                 error ("V-026", new Object [] { value });
aoqi@0: 
aoqi@0:         } else if (Attribute.IDREF == attr.type()) {
aoqi@0:             if (!XmlNames.isName (value))
aoqi@0:                 error ("V-027", new Object [] { value });
aoqi@0: 
aoqi@0:             Boolean             b = (Boolean) ids.getNonInterned (value);
aoqi@0:             if (b == null)
aoqi@0:                 ids.put (value.intern (), Boolean.FALSE);
aoqi@0: 
aoqi@0:         } else if (Attribute.IDREFS == attr.type()) {
aoqi@0:             StringTokenizer     tokenizer = new StringTokenizer (value);
aoqi@0:             Boolean             b;
aoqi@0:             boolean             sawValue = false;
aoqi@0: 
aoqi@0:             while (tokenizer.hasMoreTokens ()) {
aoqi@0:                 value = tokenizer.nextToken ();
aoqi@0:                 if (!XmlNames.isName (value))
aoqi@0:                     error ("V-027", new Object [] { value });
aoqi@0:                 b = (Boolean) ids.getNonInterned (value);
aoqi@0:                 if (b == null)
aoqi@0:                     ids.put (value.intern (), Boolean.FALSE);
aoqi@0:                 sawValue = true;
aoqi@0:             }
aoqi@0:             if (!sawValue)
aoqi@0:                 error ("V-039", null);
aoqi@0: 
aoqi@0: 
aoqi@0:         // NMTOKEN(S) ... values are Nmtoken(s)
aoqi@0:         } else if (Attribute.NMTOKEN == attr.type()) {
aoqi@0:             if (!XmlNames.isNmtoken (value))
aoqi@0:                 error ("V-028", new Object [] { value });
aoqi@0: 
aoqi@0:         } else if (Attribute.NMTOKENS == attr.type()) {
aoqi@0:             StringTokenizer     tokenizer = new StringTokenizer (value);
aoqi@0:             boolean             sawValue = false;
aoqi@0: 
aoqi@0:             while (tokenizer.hasMoreTokens ()) {
aoqi@0:                 value = tokenizer.nextToken ();
aoqi@0:                 if (!XmlNames.isNmtoken (value))
aoqi@0:                     error ("V-028", new Object [] { value });
aoqi@0:                 sawValue = true;
aoqi@0:             }
aoqi@0:             if (!sawValue)
aoqi@0:                 error ("V-032", null);
aoqi@0: 
aoqi@0:         // ENUMERATION ... values match one of the tokens
aoqi@0:         } else if (Attribute.ENUMERATION == attr.type()) {
aoqi@0:             for (int i = 0; i < attr.values().length; i++)
aoqi@0:                 if (value.equals (attr.values()[i]))
aoqi@0:                     return;
aoqi@0:             error ("V-029", new Object [] { value });
aoqi@0: 
aoqi@0:         // NOTATION values match a notation name
aoqi@0:         } else if (Attribute.NOTATION == attr.type()) {
aoqi@0:             //
aoqi@0:             // XXX XML 1.0 spec should probably list references to
aoqi@0:             // externally defined notations in standalone docs as
aoqi@0:             // validity errors.  Ditto externally defined unparsed
aoqi@0:             // entities; neither should show up in attributes, else
aoqi@0:             // one needs to read the external declarations in order
aoqi@0:             // to make sense of the document (exactly what tagging
aoqi@0:             // a doc as "standalone" intends you won't need to do).
aoqi@0:             //
aoqi@0:             for (int i = 0; i < attr.values().length; i++)
aoqi@0:                 if (value.equals (attr.values()[i]))
aoqi@0:                     return;
aoqi@0:             error ("V-030", new Object [] { value });
aoqi@0: 
aoqi@0:         // ENTITY(IES) values match an unparsed entity(ies)
aoqi@0:         } else if (Attribute.ENTITY == attr.type()) {
aoqi@0:             // see note above re standalone
aoqi@0:             if (!isUnparsedEntity (value))
aoqi@0:                 error ("V-031", new Object [] { value });
aoqi@0: 
aoqi@0:         } else if (Attribute.ENTITIES == attr.type()) {
aoqi@0:             StringTokenizer     tokenizer = new StringTokenizer (value);
aoqi@0:             boolean             sawValue = false;
aoqi@0: 
aoqi@0:             while (tokenizer.hasMoreTokens ()) {
aoqi@0:                 value = tokenizer.nextToken ();
aoqi@0:                 // see note above re standalone
aoqi@0:                 if (!isUnparsedEntity (value))
aoqi@0:                     error ("V-031", new Object [] { value });
aoqi@0:                 sawValue = true;
aoqi@0:             }
aoqi@0:             if (!sawValue)
aoqi@0:                 error ("V-040", null);
aoqi@0: 
aoqi@0:         } else if (Attribute.CDATA != attr.type())
aoqi@0:             throw new InternalError (attr.type());
aoqi@0:     }
aoqi@0: */
aoqi@0: /*
aoqi@0:     private boolean isUnparsedEntity (String name)
aoqi@0:     {
aoqi@0:         Object e = entities.getNonInterned (name);
aoqi@0:         if (e == null || !(e instanceof ExternalEntity))
aoqi@0:             return false;
aoqi@0:         return ((ExternalEntity)e).notation != null;
aoqi@0:     }
aoqi@0: */
aoqi@0:     private boolean maybeElementDecl()
aoqi@0:             throws IOException, SAXException {
aoqi@0: 
aoqi@0:         // [45] elementDecl ::= '<!ELEMENT' S Name S contentspec S? '>'
aoqi@0:         // [46] contentspec ::= 'EMPTY' | 'ANY' | Mixed | children
aoqi@0:         InputEntity start = peekDeclaration("!ELEMENT");
aoqi@0: 
aoqi@0:         if (start == null)
aoqi@0:             return false;
aoqi@0: 
aoqi@0:         // n.b. for content models where inter-element whitespace is
aoqi@0:         // ignorable, we mark that fact here.
aoqi@0:         String name = getMarkupDeclname("F-015", true);
aoqi@0: //    Element        element = (Element) elements.get (name);
aoqi@0: //    boolean        declEffective = false;
aoqi@0: 
aoqi@0: /*
aoqi@0:     if (element != null) {
aoqi@0:         if (element.contentModel() != null) {
aoqi@0:             error ("V-012", new Object [] { name });
aoqi@0:         } // else <!ATTLIST name ...> came first
aoqi@0:     } else {
aoqi@0:         element = new Element(name);
aoqi@0:         elements.put (element.name(), element);
aoqi@0:         declEffective = true;
aoqi@0:     }
aoqi@0: */
aoqi@0:         if (declaredElements.contains(name))
aoqi@0:             error("V-012", new Object[]{name});
aoqi@0:         else {
aoqi@0:             declaredElements.add(name);
aoqi@0: //        declEffective = true;
aoqi@0:         }
aoqi@0: 
aoqi@0:         short modelType;
aoqi@0:         whitespace("F-000");
aoqi@0:         if (peek(strEMPTY)) {
aoqi@0: ///        // leave element.contentModel as null for this case.
aoqi@0:             dtdHandler.startContentModel(name, modelType = DTDEventListener.CONTENT_MODEL_EMPTY);
aoqi@0:         } else if (peek(strANY)) {
aoqi@0: ///        element.setContentModel(new StringModel(StringModelType.ANY));
aoqi@0:             dtdHandler.startContentModel(name, modelType = DTDEventListener.CONTENT_MODEL_ANY);
aoqi@0:         } else {
aoqi@0:             modelType = getMixedOrChildren(name);
aoqi@0:         }
aoqi@0: 
aoqi@0:         dtdHandler.endContentModel(name, modelType);
aoqi@0: 
aoqi@0:         maybeWhitespace();
aoqi@0:         char c = getc();
aoqi@0:         if (c != '>')
aoqi@0:             fatal("P-036", new Object[]{name, new Character(c)});
aoqi@0:         if (start != in)
aoqi@0:             error("V-013", null);
aoqi@0: 
aoqi@0: ///        dtdHandler.elementDecl(element);
aoqi@0: 
aoqi@0:         return true;
aoqi@0:     }
aoqi@0: 
aoqi@0:     // We're leaving the content model as a regular expression;
aoqi@0:     // it's an efficient natural way to express such things, and
aoqi@0:     // libraries often interpret them.  No whitespace in the
aoqi@0:     // model we store, though!
aoqi@0: 
aoqi@0:     /**
aoqi@0:      * returns content model type.
aoqi@0:      */
aoqi@0:     private short getMixedOrChildren(String elementName/*Element element*/)
aoqi@0:             throws IOException, SAXException {
aoqi@0: 
aoqi@0:         InputEntity start;
aoqi@0: 
aoqi@0:         // [47] children ::= (choice|seq) ('?'|'*'|'+')?
aoqi@0:         strTmp = new StringBuffer();
aoqi@0: 
aoqi@0:         nextChar('(', "F-028", elementName);
aoqi@0:         start = in;
aoqi@0:         maybeWhitespace();
aoqi@0:         strTmp.append('(');
aoqi@0: 
aoqi@0:         short modelType;
aoqi@0:         if (peek("#PCDATA")) {
aoqi@0:             strTmp.append("#PCDATA");
aoqi@0:             dtdHandler.startContentModel(elementName, modelType = DTDEventListener.CONTENT_MODEL_MIXED);
aoqi@0:             getMixed(elementName, start);
aoqi@0:         } else {
aoqi@0:             dtdHandler.startContentModel(elementName, modelType = DTDEventListener.CONTENT_MODEL_CHILDREN);
aoqi@0:             getcps(elementName, start);
aoqi@0:         }
aoqi@0: 
aoqi@0:         return modelType;
aoqi@0:     }
aoqi@0: 
aoqi@0:     // '(' S? already consumed
aoqi@0:     // matching ')' must be in "start" entity if validating
aoqi@0:     private void getcps(/*Element element,*/String elementName, InputEntity start)
aoqi@0:             throws IOException, SAXException {
aoqi@0: 
aoqi@0:         // [48] cp ::= (Name|choice|seq) ('?'|'*'|'+')?
aoqi@0:         // [49] choice ::= '(' S? cp (S? '|' S? cp)* S? ')'
aoqi@0:         // [50] seq    ::= '(' S? cp (S? ',' S? cp)* S? ')'
aoqi@0:         boolean decided = false;
aoqi@0:         char type = 0;
aoqi@0: //        ContentModel       retval, temp, current;
aoqi@0: 
aoqi@0: //        retval = temp = current = null;
aoqi@0: 
aoqi@0:         dtdHandler.startModelGroup();
aoqi@0: 
aoqi@0:         do {
aoqi@0:             String tag;
aoqi@0: 
aoqi@0:             tag = maybeGetName();
aoqi@0:             if (tag != null) {
aoqi@0:                 strTmp.append(tag);
aoqi@0: //                temp = new ElementModel(tag);
aoqi@0: //                getFrequency((RepeatableContent)temp);
aoqi@0: ///->
aoqi@0:                 dtdHandler.childElement(tag, getFrequency());
aoqi@0: ///<-
aoqi@0:             } else if (peek("(")) {
aoqi@0:                 InputEntity next = in;
aoqi@0:                 strTmp.append('(');
aoqi@0:                 maybeWhitespace();
aoqi@0: //                temp = getcps(element, next);
aoqi@0: //                getFrequency(temp);
aoqi@0: ///->
aoqi@0:                 getcps(elementName, next);
aoqi@0: ///                getFrequency();        <- this looks like a bug
aoqi@0: ///<-
aoqi@0:             } else
aoqi@0:                 fatal((type == 0) ? "P-039" :
aoqi@0:                         ((type == ',') ? "P-037" : "P-038"),
aoqi@0:                         new Object[]{new Character(getc())});
aoqi@0: 
aoqi@0:             maybeWhitespace();
aoqi@0:             if (decided) {
aoqi@0:                 char c = getc();
aoqi@0: 
aoqi@0: //                if (current != null) {
aoqi@0: //                    current.addChild(temp);
aoqi@0: //                }
aoqi@0:                 if (c == type) {
aoqi@0:                     strTmp.append(type);
aoqi@0:                     maybeWhitespace();
aoqi@0:                     reportConnector(type);
aoqi@0:                     continue;
aoqi@0:                 } else if (c == '\u0029') {    // rparen
aoqi@0:                     ungetc();
aoqi@0:                     continue;
aoqi@0:                 } else {
aoqi@0:                     fatal((type == 0) ? "P-041" : "P-040",
aoqi@0:                             new Object[]{
aoqi@0:                                 new Character(c),
aoqi@0:                                 new Character(type)
aoqi@0:                             });
aoqi@0:                 }
aoqi@0:             } else {
aoqi@0:                 type = getc();
aoqi@0:                 switch (type) {
aoqi@0:                 case '|':
aoqi@0:                 case ',':
aoqi@0:                     reportConnector(type);
aoqi@0:                     break;
aoqi@0:                 default:
aoqi@0: //                        retval = temp;
aoqi@0:                     ungetc();
aoqi@0:                     continue;
aoqi@0:                 }
aoqi@0: //                retval = (ContentModel)current;
aoqi@0:                 decided = true;
aoqi@0: //                current.addChild(temp);
aoqi@0:                 strTmp.append(type);
aoqi@0:             }
aoqi@0:             maybeWhitespace();
aoqi@0:         } while (!peek(")"));
aoqi@0: 
aoqi@0:         if (in != start)
aoqi@0:             error("V-014", new Object[]{elementName});
aoqi@0:         strTmp.append(')');
aoqi@0: 
aoqi@0:         dtdHandler.endModelGroup(getFrequency());
aoqi@0: //        return retval;
aoqi@0:     }
aoqi@0: 
aoqi@0:     private void reportConnector(char type) throws SAXException {
aoqi@0:         switch (type) {
aoqi@0:         case '|':
aoqi@0:             dtdHandler.connector(DTDEventListener.CHOICE);    ///<-
aoqi@0:             return;
aoqi@0:         case ',':
aoqi@0:             dtdHandler.connector(DTDEventListener.SEQUENCE); ///<-
aoqi@0:             return;
aoqi@0:         default:
aoqi@0:             throw new Error();    //assertion failed.
aoqi@0:         }
aoqi@0:     }
aoqi@0: 
aoqi@0:     private short getFrequency()
aoqi@0:             throws IOException, SAXException {
aoqi@0: 
aoqi@0:         final char c = getc();
aoqi@0: 
aoqi@0:         if (c == '?') {
aoqi@0:             strTmp.append(c);
aoqi@0:             return DTDEventListener.OCCURENCE_ZERO_OR_ONE;
aoqi@0:             //        original.setRepeat(Repeat.ZERO_OR_ONE);
aoqi@0:         } else if (c == '+') {
aoqi@0:             strTmp.append(c);
aoqi@0:             return DTDEventListener.OCCURENCE_ONE_OR_MORE;
aoqi@0:             //        original.setRepeat(Repeat.ONE_OR_MORE);
aoqi@0:         } else if (c == '*') {
aoqi@0:             strTmp.append(c);
aoqi@0:             return DTDEventListener.OCCURENCE_ZERO_OR_MORE;
aoqi@0:             //        original.setRepeat(Repeat.ZERO_OR_MORE);
aoqi@0:         } else {
aoqi@0:             ungetc();
aoqi@0:             return DTDEventListener.OCCURENCE_ONCE;
aoqi@0:         }
aoqi@0:     }
aoqi@0: 
aoqi@0:     // '(' S? '#PCDATA' already consumed
aoqi@0:     // matching ')' must be in "start" entity if validating
aoqi@0:     private void getMixed(String elementName, /*Element element,*/ InputEntity start)
aoqi@0:             throws IOException, SAXException {
aoqi@0: 
aoqi@0:         // [51] Mixed ::= '(' S? '#PCDATA' (S? '|' S? Name)* S? ')*'
aoqi@0:         //        | '(' S? '#PCDATA'                   S? ')'
aoqi@0:         maybeWhitespace();
aoqi@0:         if (peek("\u0029*") || peek("\u0029")) {
aoqi@0:             if (in != start)
aoqi@0:                 error("V-014", new Object[]{elementName});
aoqi@0:             strTmp.append(')');
aoqi@0: //            element.setContentModel(new StringModel(StringModelType.PCDATA));
aoqi@0:             return;
aoqi@0:         }
aoqi@0: 
aoqi@0:         ArrayList l = new ArrayList();
aoqi@0: //    l.add(new StringModel(StringModelType.PCDATA));
aoqi@0: 
aoqi@0: 
aoqi@0:         while (peek("|")) {
aoqi@0:             String name;
aoqi@0: 
aoqi@0:             strTmp.append('|');
aoqi@0:             maybeWhitespace();
aoqi@0: 
aoqi@0:             doLexicalPE = true;
aoqi@0:             name = maybeGetName();
aoqi@0:             if (name == null)
aoqi@0:                 fatal("P-042", new Object[]
aoqi@0:                 {elementName, Integer.toHexString(getc())});
aoqi@0:             if (l.contains(name)) {
aoqi@0:                 error("V-015", new Object[]{name});
aoqi@0:             } else {
aoqi@0:                 l.add(name);
aoqi@0:                 dtdHandler.mixedElement(name);
aoqi@0:             }
aoqi@0:             strTmp.append(name);
aoqi@0:             maybeWhitespace();
aoqi@0:         }
aoqi@0: 
aoqi@0:         if (!peek("\u0029*"))    // right paren
aoqi@0:             fatal("P-043", new Object[]
aoqi@0:             {elementName, new Character(getc())});
aoqi@0:         if (in != start)
aoqi@0:             error("V-014", new Object[]{elementName});
aoqi@0:         strTmp.append(')');
aoqi@0: //        ChoiceModel cm = new ChoiceModel((Collection)l);
aoqi@0: //    cm.setRepeat(Repeat.ZERO_OR_MORE);
aoqi@0: //       element.setContentModel(cm);
aoqi@0:     }
aoqi@0: 
aoqi@0:     private boolean maybeAttlistDecl()
aoqi@0:             throws IOException, SAXException {
aoqi@0: 
aoqi@0:         // [52] AttlistDecl ::= '<!ATTLIST' S Name AttDef* S? '>'
aoqi@0:         InputEntity start = peekDeclaration("!ATTLIST");
aoqi@0: 
aoqi@0:         if (start == null)
aoqi@0:             return false;
aoqi@0: 
aoqi@0:         String elementName = getMarkupDeclname("F-016", true);
aoqi@0: //    Element    element = (Element) elements.get (name);
aoqi@0: 
aoqi@0: //    if (element == null) {
aoqi@0: //        // not yet declared -- no problem.
aoqi@0: //        element = new Element(name);
aoqi@0: //        elements.put(name, element);
aoqi@0: //    }
aoqi@0: 
aoqi@0:         while (!peek(">")) {
aoqi@0: 
aoqi@0:             // [53] AttDef ::= S Name S AttType S DefaultDecl
aoqi@0:             // [54] AttType ::= StringType | TokenizedType | EnumeratedType
aoqi@0: 
aoqi@0:             // look for global attribute definitions, don't expand for now...
aoqi@0:             maybeWhitespace();
aoqi@0:             char c = getc();
aoqi@0:             if (c == '%') {
aoqi@0:                 String entityName = maybeGetName();
aoqi@0:                 if (entityName != null) {
aoqi@0:                     nextChar(';', "F-021", entityName);
aoqi@0:                     whitespace("F-021");
aoqi@0:                     continue;
aoqi@0:                 } else
aoqi@0:                     fatal("P-011");
aoqi@0:             }
aoqi@0: 
aoqi@0:             ungetc();
aoqi@0:             // look for attribute name otherwise
aoqi@0:             String attName = maybeGetName();
aoqi@0:             if (attName == null) {
aoqi@0:                 fatal("P-044", new Object[]{new Character(getc())});
aoqi@0:             }
aoqi@0:             whitespace("F-001");
aoqi@0: 
aoqi@0: ///        Attribute    a = new Attribute (name);
aoqi@0: 
aoqi@0:             String typeName;
aoqi@0:             Vector values = null;    // notation/enumeration values
aoqi@0: 
aoqi@0:             // Note:  use the type constants from Attribute
aoqi@0:             // so that "==" may be used (faster)
aoqi@0: 
aoqi@0:             // [55] StringType ::= 'CDATA'
aoqi@0:             if (peek(TYPE_CDATA))
aoqi@0: ///            a.setType(Attribute.CDATA);
aoqi@0:                 typeName = TYPE_CDATA;
aoqi@0: 
aoqi@0:             // [56] TokenizedType ::= 'ID' | 'IDREF' | 'IDREFS'
aoqi@0:             //        | 'ENTITY' | 'ENTITIES'
aoqi@0:             //        | 'NMTOKEN' | 'NMTOKENS'
aoqi@0:             // n.b. if "IDREFS" is there, both "ID" and "IDREF"
aoqi@0:             // match peekahead ... so this order matters!
aoqi@0:             else if (peek(TYPE_IDREFS))
aoqi@0:                 typeName = TYPE_IDREFS;
aoqi@0:             else if (peek(TYPE_IDREF))
aoqi@0:                 typeName = TYPE_IDREF;
aoqi@0:             else if (peek(TYPE_ID)) {
aoqi@0:                 typeName = TYPE_ID;
aoqi@0: // TODO: should implement this error check?
aoqi@0: ///        if (element.id() != null) {
aoqi@0: ///                    error ("V-016", new Object [] { element.id() });
aoqi@0: ///        } else
aoqi@0: ///            element.setId(name);
aoqi@0:             } else if (peek(TYPE_ENTITY))
aoqi@0:                 typeName = TYPE_ENTITY;
aoqi@0:             else if (peek(TYPE_ENTITIES))
aoqi@0:                 typeName = TYPE_ENTITIES;
aoqi@0:             else if (peek(TYPE_NMTOKENS))
aoqi@0:                 typeName = TYPE_NMTOKENS;
aoqi@0:             else if (peek(TYPE_NMTOKEN))
aoqi@0:                 typeName = TYPE_NMTOKEN;
aoqi@0: 
aoqi@0:             // [57] EnumeratedType ::= NotationType | Enumeration
aoqi@0:             // [58] NotationType ::= 'NOTATION' S '(' S? Name
aoqi@0:             //        (S? '|' S? Name)* S? ')'
aoqi@0:             else if (peek(TYPE_NOTATION)) {
aoqi@0:                 typeName = TYPE_NOTATION;
aoqi@0:                 whitespace("F-002");
aoqi@0:                 nextChar('(', "F-029", null);
aoqi@0:                 maybeWhitespace();
aoqi@0: 
aoqi@0:                 values = new Vector();
aoqi@0:                 do {
aoqi@0:                     String name;
aoqi@0:                     if ((name = maybeGetName()) == null)
aoqi@0:                         fatal("P-068");
aoqi@0:                     // permit deferred declarations
aoqi@0:                     if (notations.get(name) == null)
aoqi@0:                         notations.put(name, name);
aoqi@0:                     values.addElement(name);
aoqi@0:                     maybeWhitespace();
aoqi@0:                     if (peek("|"))
aoqi@0:                         maybeWhitespace();
aoqi@0:                 } while (!peek(")"));
aoqi@0: ///            a.setValues(new String [v.size ()]);
aoqi@0: ///            for (int i = 0; i < v.size (); i++)
aoqi@0: ///                a.setValue(i, (String)v.elementAt(i));
aoqi@0: 
aoqi@0:                 // [59] Enumeration ::= '(' S? Nmtoken (S? '|' Nmtoken)* S? ')'
aoqi@0:             } else if (peek("(")) {
aoqi@0: ///            a.setType(Attribute.ENUMERATION);
aoqi@0:                 typeName = TYPE_ENUMERATION;
aoqi@0: 
aoqi@0:                 maybeWhitespace();
aoqi@0: 
aoqi@0: ///            Vector v = new Vector ();
aoqi@0:                 values = new Vector();
aoqi@0:                 do {
aoqi@0:                     String name = getNmtoken();
aoqi@0: ///                v.addElement (name);
aoqi@0:                     values.addElement(name);
aoqi@0:                     maybeWhitespace();
aoqi@0:                     if (peek("|"))
aoqi@0:                         maybeWhitespace();
aoqi@0:                 } while (!peek(")"));
aoqi@0: ///            a.setValues(new String [v.size ()]);
aoqi@0: ///            for (int i = 0; i < v.size (); i++)
aoqi@0: ///                a.setValue(i, (String)v.elementAt(i));
aoqi@0:             } else {
aoqi@0:                 fatal("P-045",
aoqi@0:                         new Object[]{attName, new Character(getc())});
aoqi@0:                 typeName = null;
aoqi@0:             }
aoqi@0: 
aoqi@0:             short attributeUse;
aoqi@0:             String defaultValue = null;
aoqi@0: 
aoqi@0:             // [60] DefaultDecl ::= '#REQUIRED' | '#IMPLIED'
aoqi@0:             //        | (('#FIXED' S)? AttValue)
aoqi@0:             whitespace("F-003");
aoqi@0:             if (peek("#REQUIRED"))
aoqi@0:                 attributeUse = DTDEventListener.USE_REQUIRED;
aoqi@0: ///            a.setIsRequired(true);
aoqi@0:             else if (peek("#FIXED")) {
aoqi@0: ///            if (a.type() == Attribute.ID)
aoqi@0:                 if (typeName == TYPE_ID)
aoqi@0:                     error("V-017", new Object[]{attName});
aoqi@0: ///            a.setIsFixed(true);
aoqi@0:                 attributeUse = DTDEventListener.USE_FIXED;
aoqi@0:                 whitespace("F-004");
aoqi@0:                 parseLiteral(false);
aoqi@0: ///            if (a.type() != Attribute.CDATA)
aoqi@0: ///                a.setDefaultValue(normalize(false));
aoqi@0: ///            else
aoqi@0: ///                a.setDefaultValue(strTmp.toString());
aoqi@0: 
aoqi@0:                 if (typeName == TYPE_CDATA)
aoqi@0:                     defaultValue = normalize(false);
aoqi@0:                 else
aoqi@0:                     defaultValue = strTmp.toString();
aoqi@0: 
aoqi@0: // TODO: implement this check
aoqi@0: ///            if (a.type() != Attribute.CDATA)
aoqi@0: ///                validateAttributeSyntax (a, a.defaultValue());
aoqi@0:             } else if (!peek("#IMPLIED")) {
aoqi@0:                 attributeUse = DTDEventListener.USE_IMPLIED;
aoqi@0: 
aoqi@0: ///            if (a.type() == Attribute.ID)
aoqi@0:                 if (typeName == TYPE_ID)
aoqi@0:                     error("V-018", new Object[]{attName});
aoqi@0:                 parseLiteral(false);
aoqi@0: ///            if (a.type() != Attribute.CDATA)
aoqi@0: ///                a.setDefaultValue(normalize(false));
aoqi@0: ///            else
aoqi@0: ///                a.setDefaultValue(strTmp.toString());
aoqi@0:                 if (typeName == TYPE_CDATA)
aoqi@0:                     defaultValue = normalize(false);
aoqi@0:                 else
aoqi@0:                     defaultValue = strTmp.toString();
aoqi@0: 
aoqi@0: // TODO: implement this check
aoqi@0: ///            if (a.type() != Attribute.CDATA)
aoqi@0: ///                validateAttributeSyntax (a, a.defaultValue());
aoqi@0:             } else {
aoqi@0:                 // TODO: this looks like an fatal error.
aoqi@0:                 attributeUse = DTDEventListener.USE_NORMAL;
aoqi@0:             }
aoqi@0: 
aoqi@0:             if (XmlLang.equals(attName)
aoqi@0:                     && defaultValue/* a.defaultValue()*/ != null
aoqi@0:                     && !isXmlLang(defaultValue/*a.defaultValue()*/))
aoqi@0:                 error("P-033", new Object[]{defaultValue /*a.defaultValue()*/});
aoqi@0: 
aoqi@0: // TODO: isn't it an error to specify the same attribute twice?
aoqi@0: ///        if (!element.attributes().contains(a)) {
aoqi@0: ///            element.addAttribute(a);
aoqi@0: ///            dtdHandler.attributeDecl(a);
aoqi@0: ///        }
aoqi@0: 
aoqi@0:             String[] v = (values != null) ? (String[]) values.toArray(new String[0]) : null;
aoqi@0:             dtdHandler.attributeDecl(elementName, attName, typeName, v, attributeUse, defaultValue);
aoqi@0:             maybeWhitespace();
aoqi@0:         }
aoqi@0:         if (start != in)
aoqi@0:             error("V-013", null);
aoqi@0:         return true;
aoqi@0:     }
aoqi@0: 
aoqi@0:     // used when parsing literal attribute values,
aoqi@0:     // or public identifiers.
aoqi@0:     //
aoqi@0:     // input in strTmp
aoqi@0:     private String normalize(boolean invalidIfNeeded) {
aoqi@0: 
aoqi@0:         // this can allocate an extra string...
aoqi@0: 
aoqi@0:         String s = strTmp.toString();
aoqi@0:         String s2 = s.trim();
aoqi@0:         boolean didStrip = false;
aoqi@0: 
aoqi@0:         if (s != s2) {
aoqi@0:             s = s2;
aoqi@0:             s2 = null;
aoqi@0:             didStrip = true;
aoqi@0:         }
aoqi@0:         strTmp = new StringBuffer();
aoqi@0:         for (int i = 0; i < s.length(); i++) {
aoqi@0:             char c = s.charAt(i);
aoqi@0:             if (!XmlChars.isSpace(c)) {
aoqi@0:                 strTmp.append(c);
aoqi@0:                 continue;
aoqi@0:             }
aoqi@0:             strTmp.append(' ');
aoqi@0:             while (++i < s.length() && XmlChars.isSpace(s.charAt(i)))
aoqi@0:                 didStrip = true;
aoqi@0:             i--;
aoqi@0:         }
aoqi@0:         if (didStrip)
aoqi@0:             return strTmp.toString();
aoqi@0:         else
aoqi@0:             return s;
aoqi@0:     }
aoqi@0: 
aoqi@0:     private boolean maybeConditionalSect()
aoqi@0:             throws IOException, SAXException {
aoqi@0: 
aoqi@0:         // [61] conditionalSect ::= includeSect | ignoreSect
aoqi@0: 
aoqi@0:         if (!peek("<!["))
aoqi@0:             return false;
aoqi@0: 
aoqi@0:         String keyword;
aoqi@0:         InputEntity start = in;
aoqi@0: 
aoqi@0:         maybeWhitespace();
aoqi@0: 
aoqi@0:         if ((keyword = maybeGetName()) == null)
aoqi@0:             fatal("P-046");
aoqi@0:         maybeWhitespace();
aoqi@0:         nextChar('[', "F-030", null);
aoqi@0: 
aoqi@0:         // [62] includeSect ::= '<![' S? 'INCLUDE' S? '['
aoqi@0:         //                extSubsetDecl ']]>'
aoqi@0:         if ("INCLUDE".equals(keyword)) {
aoqi@0:             for (; ;) {
aoqi@0:                 while (in.isEOF() && in != start)
aoqi@0:                     in = in.pop();
aoqi@0:                 if (in.isEOF()) {
aoqi@0:                     error("V-020", null);
aoqi@0:                 }
aoqi@0:                 if (peek("]]>"))
aoqi@0:                     break;
aoqi@0: 
aoqi@0:                 doLexicalPE = false;
aoqi@0:                 if (maybeWhitespace())
aoqi@0:                     continue;
aoqi@0:                 if (maybePEReference())
aoqi@0:                     continue;
aoqi@0:                 doLexicalPE = true;
aoqi@0:                 if (maybeMarkupDecl() || maybeConditionalSect())
aoqi@0:                     continue;
aoqi@0: 
aoqi@0:                 fatal("P-047");
aoqi@0:             }
aoqi@0: 
aoqi@0:             // [63] ignoreSect ::= '<![' S? 'IGNORE' S? '['
aoqi@0:             //            ignoreSectcontents ']]>'
aoqi@0:             // [64] ignoreSectcontents ::= Ignore ('<!['
aoqi@0:             //            ignoreSectcontents ']]>' Ignore)*
aoqi@0:             // [65] Ignore ::= Char* - (Char* ('<![' | ']]>') Char*)
aoqi@0:         } else if ("IGNORE".equals(keyword)) {
aoqi@0:             int nestlevel = 1;
aoqi@0:             // ignoreSectcontents
aoqi@0:             doLexicalPE = false;
aoqi@0:             while (nestlevel > 0) {
aoqi@0:                 char c = getc();    // will pop input entities
aoqi@0:                 if (c == '<') {
aoqi@0:                     if (peek("!["))
aoqi@0:                         nestlevel++;
aoqi@0:                 } else if (c == ']') {
aoqi@0:                     if (peek("]>"))
aoqi@0:                         nestlevel--;
aoqi@0:                 } else
aoqi@0:                     continue;
aoqi@0:             }
aoqi@0:         } else
aoqi@0:             fatal("P-048", new Object[]{keyword});
aoqi@0:         return true;
aoqi@0:     }
aoqi@0: 
aoqi@0: 
aoqi@0:     //
aoqi@0:     // CHAPTER 4:  Physical Structures
aoqi@0:     //
aoqi@0: 
aoqi@0:     // parse decimal or hex numeric character reference
aoqi@0:     private int parseCharNumber()
aoqi@0:             throws IOException, SAXException {
aoqi@0: 
aoqi@0:         char c;
aoqi@0:         int retval = 0;
aoqi@0: 
aoqi@0:         // n.b. we ignore overflow ...
aoqi@0:         if (getc() != 'x') {
aoqi@0:             ungetc();
aoqi@0:             for (; ;) {
aoqi@0:                 c = getc();
aoqi@0:                 if (c >= '0' && c <= '9') {
aoqi@0:                     retval *= 10;
aoqi@0:                     retval += (c - '0');
aoqi@0:                     continue;
aoqi@0:                 }
aoqi@0:                 if (c == ';')
aoqi@0:                     return retval;
aoqi@0:                 fatal("P-049");
aoqi@0:             }
aoqi@0:         } else
aoqi@0:             for (; ;) {
aoqi@0:                 c = getc();
aoqi@0:                 if (c >= '0' && c <= '9') {
aoqi@0:                     retval <<= 4;
aoqi@0:                     retval += (c - '0');
aoqi@0:                     continue;
aoqi@0:                 }
aoqi@0:                 if (c >= 'a' && c <= 'f') {
aoqi@0:                     retval <<= 4;
aoqi@0:                     retval += 10 + (c - 'a');
aoqi@0:                     continue;
aoqi@0:                 }
aoqi@0:                 if (c >= 'A' && c <= 'F') {
aoqi@0:                     retval <<= 4;
aoqi@0:                     retval += 10 + (c - 'A');
aoqi@0:                     continue;
aoqi@0:                 }
aoqi@0:                 if (c == ';')
aoqi@0:                     return retval;
aoqi@0:                 fatal("P-050");
aoqi@0:             }
aoqi@0:     }
aoqi@0: 
aoqi@0:     // parameter is a UCS-4 character ... i.e. not just 16 bit UNICODE,
aoqi@0:     // though still subject to the 'Char' construct in XML
aoqi@0:     private int surrogatesToCharTmp(int ucs4)
aoqi@0:             throws SAXException {
aoqi@0: 
aoqi@0:         if (ucs4 <= 0xffff) {
aoqi@0:             if (XmlChars.isChar(ucs4)) {
aoqi@0:                 charTmp[0] = (char) ucs4;
aoqi@0:                 return 1;
aoqi@0:             }
aoqi@0:         } else if (ucs4 <= 0x0010ffff) {
aoqi@0:             // we represent these as UNICODE surrogate pairs
aoqi@0:             ucs4 -= 0x10000;
aoqi@0:             charTmp[0] = (char) (0xd800 | ((ucs4 >> 10) & 0x03ff));
aoqi@0:             charTmp[1] = (char) (0xdc00 | (ucs4 & 0x03ff));
aoqi@0:             return 2;
aoqi@0:         }
aoqi@0:         fatal("P-051", new Object[]{Integer.toHexString(ucs4)});
aoqi@0:         // NOTREACHED
aoqi@0:         return -1;
aoqi@0:     }
aoqi@0: 
aoqi@0:     private boolean maybePEReference()
aoqi@0:             throws IOException, SAXException {
aoqi@0: 
aoqi@0:         // This is the SYNTACTIC version of this construct.
aoqi@0:         // When processing external entities, there is also
aoqi@0:         // a LEXICAL version; see getc() and doLexicalPE.
aoqi@0: 
aoqi@0:         // [69] PEReference ::= '%' Name ';'
aoqi@0:         if (!in.peekc('%'))
aoqi@0:             return false;
aoqi@0: 
aoqi@0:         String name = maybeGetName();
aoqi@0:         Object entity;
aoqi@0: 
aoqi@0:         if (name == null)
aoqi@0:             fatal("P-011");
aoqi@0:         nextChar(';', "F-021", name);
aoqi@0:         entity = params.get(name);
aoqi@0: 
aoqi@0:         if (entity instanceof InternalEntity) {
aoqi@0:             InternalEntity value = (InternalEntity) entity;
aoqi@0:             pushReader(value.buf, name, false);
aoqi@0: 
aoqi@0:         } else if (entity instanceof ExternalEntity) {
aoqi@0:             pushReader((ExternalEntity) entity);
aoqi@0:             externalParameterEntity((ExternalEntity) entity);
aoqi@0: 
aoqi@0:         } else if (entity == null) {
aoqi@0:             error("V-022", new Object[]{name});
aoqi@0:         }
aoqi@0:         return true;
aoqi@0:     }
aoqi@0: 
aoqi@0:     private boolean maybeEntityDecl()
aoqi@0:             throws IOException, SAXException {
aoqi@0: 
aoqi@0:         // [70] EntityDecl ::= GEDecl | PEDecl
aoqi@0:         // [71] GEDecl ::= '<!ENTITY' S       Name S EntityDef S? '>'
aoqi@0:         // [72] PEDecl ::= '<!ENTITY' S '%' S Name S PEDEF     S? '>'
aoqi@0:         // [73] EntityDef ::= EntityValue | (ExternalID NDataDecl?)
aoqi@0:         // [74] PEDef     ::= EntityValue |  ExternalID
aoqi@0:         //
aoqi@0:         InputEntity start = peekDeclaration("!ENTITY");
aoqi@0: 
aoqi@0:         if (start == null)
aoqi@0:             return false;
aoqi@0: 
aoqi@0:         String entityName;
aoqi@0:         SimpleHashtable defns;
aoqi@0:         ExternalEntity externalId;
aoqi@0:         boolean doStore;
aoqi@0: 
aoqi@0:         // PE expansion gets selectively turned off several places:
aoqi@0:         // in ENTITY declarations (here), in comments, in PIs.
aoqi@0: 
aoqi@0:         // Here, we allow PE entities to be declared, and allows
aoqi@0:         // literals to include PE refs without the added spaces
aoqi@0:         // required with their expansion in markup decls.
aoqi@0: 
aoqi@0:         doLexicalPE = false;
aoqi@0:         whitespace("F-005");
aoqi@0:         if (in.peekc('%')) {
aoqi@0:             whitespace("F-006");
aoqi@0:             defns = params;
aoqi@0:         } else
aoqi@0:             defns = entities;
aoqi@0: 
aoqi@0:         ungetc();    // leave some whitespace
aoqi@0:         doLexicalPE = true;
aoqi@0:         entityName = getMarkupDeclname("F-017", false);
aoqi@0:         whitespace("F-007");
aoqi@0:         externalId = maybeExternalID();
aoqi@0: 
aoqi@0:         //
aoqi@0:         // first definition sticks ... e.g. internal subset PEs are used
aoqi@0:         // to override DTD defaults.  It's also an "error" to incorrectly
aoqi@0:         // redefine builtin internal entities, but since reporting such
aoqi@0:         // errors is optional we only give warnings ("just in case") for
aoqi@0:         // non-parameter entities.
aoqi@0:         //
aoqi@0:         doStore = (defns.get(entityName) == null);
aoqi@0:         if (!doStore && defns == entities)
aoqi@0:             warning("P-054", new Object[]{entityName});
aoqi@0: 
aoqi@0:         // internal entities
aoqi@0:         if (externalId == null) {
aoqi@0:             char value [];
aoqi@0:             InternalEntity entity;
aoqi@0: 
aoqi@0:             doLexicalPE = false;        // "ab%bar;cd" -maybe-> "abcd"
aoqi@0:             parseLiteral(true);
aoqi@0:             doLexicalPE = true;
aoqi@0:             if (doStore) {
aoqi@0:                 value = new char[strTmp.length()];
aoqi@0:                 if (value.length != 0)
aoqi@0:                     strTmp.getChars(0, value.length, value, 0);
aoqi@0:                 entity = new InternalEntity(entityName, value);
aoqi@0:                 entity.isPE = (defns == params);
aoqi@0:                 entity.isFromInternalSubset = false;
aoqi@0:                 defns.put(entityName, entity);
aoqi@0:                 if (defns == entities)
aoqi@0:                     dtdHandler.internalGeneralEntityDecl(entityName,
aoqi@0:                             new String(value));
aoqi@0:             }
aoqi@0: 
aoqi@0:             // external entities (including unparsed)
aoqi@0:         } else {
aoqi@0:             // [76] NDataDecl ::= S 'NDATA' S Name
aoqi@0:             if (defns == entities && maybeWhitespace()
aoqi@0:                     && peek("NDATA")) {
aoqi@0:                 externalId.notation = getMarkupDeclname("F-018", false);
aoqi@0: 
aoqi@0:                 // flag undeclared notation for checking after
aoqi@0:                 // the DTD is fully processed
aoqi@0:                 if (notations.get(externalId.notation) == null)
aoqi@0:                     notations.put(externalId.notation, Boolean.TRUE);
aoqi@0:             }
aoqi@0:             externalId.name = entityName;
aoqi@0:             externalId.isPE = (defns == params);
aoqi@0:             externalId.isFromInternalSubset = false;
aoqi@0:             if (doStore) {
aoqi@0:                 defns.put(entityName, externalId);
aoqi@0:                 if (externalId.notation != null)
aoqi@0:                     dtdHandler.unparsedEntityDecl(entityName,
aoqi@0:                             externalId.publicId, externalId.systemId,
aoqi@0:                             externalId.notation);
aoqi@0:                 else if (defns == entities)
aoqi@0:                     dtdHandler.externalGeneralEntityDecl(entityName,
aoqi@0:                             externalId.publicId, externalId.systemId);
aoqi@0:             }
aoqi@0:         }
aoqi@0:         maybeWhitespace();
aoqi@0:         nextChar('>', "F-031", entityName);
aoqi@0:         if (start != in)
aoqi@0:             error("V-013", null);
aoqi@0:         return true;
aoqi@0:     }
aoqi@0: 
aoqi@0:     private ExternalEntity maybeExternalID()
aoqi@0:             throws IOException, SAXException {
aoqi@0: 
aoqi@0:         // [75] ExternalID ::= 'SYSTEM' S SystemLiteral
aoqi@0:         //        | 'PUBLIC' S' PubidLiteral S Systemliteral
aoqi@0:         String temp = null;
aoqi@0:         ExternalEntity retval;
aoqi@0: 
aoqi@0:         if (peek("PUBLIC")) {
aoqi@0:             whitespace("F-009");
aoqi@0:             temp = parsePublicId();
aoqi@0:         } else if (!peek("SYSTEM"))
aoqi@0:             return null;
aoqi@0: 
aoqi@0:         retval = new ExternalEntity(in);
aoqi@0:         retval.publicId = temp;
aoqi@0:         whitespace("F-008");
aoqi@0:         retval.systemId = parseSystemId();
aoqi@0:         return retval;
aoqi@0:     }
aoqi@0: 
aoqi@0:     private String parseSystemId()
aoqi@0:             throws IOException, SAXException {
aoqi@0: 
aoqi@0:         String uri = getQuotedString("F-034", null);
aoqi@0:         int temp = uri.indexOf(':');
aoqi@0: 
aoqi@0:         // resolve relative URIs ... must do it here since
aoqi@0:         // it's relative to the source file holding the URI!
aoqi@0: 
aoqi@0:         // "new java.net.URL (URL, string)" conforms to RFC 1630,
aoqi@0:         // but we can't use that except when the URI is a URL.
aoqi@0:         // The entity resolver is allowed to handle URIs that are
aoqi@0:         // not URLs, so we pass URIs through with scheme intact
aoqi@0:         if (temp == -1 || uri.indexOf('/') < temp) {
aoqi@0:             String baseURI;
aoqi@0: 
aoqi@0:             baseURI = in.getSystemId();
aoqi@0:             if (baseURI == null)
aoqi@0:                 fatal("P-055", new Object[]{uri});
aoqi@0:             if (uri.length() == 0)
aoqi@0:                 uri = ".";
aoqi@0:             baseURI = baseURI.substring(0, baseURI.lastIndexOf('/') + 1);
aoqi@0:             if (uri.charAt(0) != '/')
aoqi@0:                 uri = baseURI + uri;
aoqi@0:             else {
aoqi@0:                 // XXX slashes at the beginning of a relative URI are
aoqi@0:                 // a special case we don't handle.
aoqi@0:                 throw new InternalError();
aoqi@0:             }
aoqi@0: 
aoqi@0:             // letting other code map any "/xxx/../" or "/./" to "/",
aoqi@0:             // since all URIs must handle it the same.
aoqi@0:         }
aoqi@0:         // check for fragment ID in URI
aoqi@0:         if (uri.indexOf('#') != -1)
aoqi@0:             error("P-056", new Object[]{uri});
aoqi@0:         return uri;
aoqi@0:     }
aoqi@0: 
aoqi@0:     private void maybeTextDecl()
aoqi@0:             throws IOException, SAXException {
aoqi@0: 
aoqi@0:         // [77] TextDecl ::= '<?xml' VersionInfo? EncodingDecl S? '?>'
aoqi@0:         if (peek("<?xml")) {
aoqi@0:             readVersion(false, "1.0");
aoqi@0:             readEncoding(true);
aoqi@0:             maybeWhitespace();
aoqi@0:             if (!peek("?>"))
aoqi@0:                 fatal("P-057");
aoqi@0:         }
aoqi@0:     }
aoqi@0: 
aoqi@0:     private void externalParameterEntity(ExternalEntity next)
aoqi@0:             throws IOException, SAXException {
aoqi@0: 
aoqi@0:         //
aoqi@0:         // Reap the intended benefits of standalone declarations:
aoqi@0:         // don't deal with external parameter entities, except to
aoqi@0:         // validate the standalone declaration.
aoqi@0:         //
aoqi@0: 
aoqi@0:         // n.b. "in external parameter entities" (and external
aoqi@0:         // DTD subset, same grammar) parameter references can
aoqi@0:         // occur "within" markup declarations ... expansions can
aoqi@0:         // cross syntax rules.  Flagged here; affects getc().
aoqi@0: 
aoqi@0:         // [79] ExtPE ::= TextDecl? extSubsetDecl
aoqi@0:         // [31] extSubsetDecl ::= ( markupdecl | conditionalSect
aoqi@0:         //        | PEReference | S )*
aoqi@0:         InputEntity pe;
aoqi@0: 
aoqi@0:         // XXX if this returns false ...
aoqi@0: 
aoqi@0:         pe = in;
aoqi@0:         maybeTextDecl();
aoqi@0:         while (!pe.isEOF()) {
aoqi@0:             // pop internal PEs (and whitespace before/after)
aoqi@0:             if (in.isEOF()) {
aoqi@0:                 in = in.pop();
aoqi@0:                 continue;
aoqi@0:             }
aoqi@0:             doLexicalPE = false;
aoqi@0:             if (maybeWhitespace())
aoqi@0:                 continue;
aoqi@0:             if (maybePEReference())
aoqi@0:                 continue;
aoqi@0:             doLexicalPE = true;
aoqi@0:             if (maybeMarkupDecl() || maybeConditionalSect())
aoqi@0:                 continue;
aoqi@0:             break;
aoqi@0:         }
aoqi@0:         // if (in != pe) throw new InternalError("who popped my PE?");
aoqi@0:         if (!pe.isEOF())
aoqi@0:             fatal("P-059", new Object[]{in.getName()});
aoqi@0:     }
aoqi@0: 
aoqi@0:     private void readEncoding(boolean must)
aoqi@0:             throws IOException, SAXException {
aoqi@0: 
aoqi@0:         // [81] EncName ::= [A-Za-z] ([A-Za-z0-9._] | '-')*
aoqi@0:         String name = maybeReadAttribute("encoding", must);
aoqi@0: 
aoqi@0:         if (name == null)
aoqi@0:             return;
aoqi@0:         for (int i = 0; i < name.length(); i++) {
aoqi@0:             char c = name.charAt(i);
aoqi@0:             if ((c >= 'A' && c <= 'Z')
aoqi@0:                     || (c >= 'a' && c <= 'z'))
aoqi@0:                 continue;
aoqi@0:             if (i != 0
aoqi@0:                     && ((c >= '0' && c <= '9')
aoqi@0:                     || c == '-'
aoqi@0:                     || c == '_'
aoqi@0:                     || c == '.'
aoqi@0:                     ))
aoqi@0:                 continue;
aoqi@0:             fatal("P-060", new Object[]{new Character(c)});
aoqi@0:         }
aoqi@0: 
aoqi@0:         //
aoqi@0:         // This should be the encoding in use, and it's even an error for
aoqi@0:         // it to be anything else (in certain cases that are impractical to
aoqi@0:         // to test, and may even be insufficient).  So, we do the best we
aoqi@0:         // can, and warn if things look suspicious.  Note that Java doesn't
aoqi@0:         // uniformly expose the encodings, and that the names it uses
aoqi@0:         // internally are nonstandard.  Also, that the XML spec allows
aoqi@0:         // such "errors" not to be reported at all.
aoqi@0:         //
aoqi@0:         String currentEncoding = in.getEncoding();
aoqi@0: 
aoqi@0:         if (currentEncoding != null
aoqi@0:                 && !name.equalsIgnoreCase(currentEncoding))
aoqi@0:             warning("P-061", new Object[]{name, currentEncoding});
aoqi@0:     }
aoqi@0: 
aoqi@0:     private boolean maybeNotationDecl()
aoqi@0:             throws IOException, SAXException {
aoqi@0: 
aoqi@0:         // [82] NotationDecl ::= '<!NOTATION' S Name S
aoqi@0:         //        (ExternalID | PublicID) S? '>'
aoqi@0:         // [83] PublicID ::= 'PUBLIC' S PubidLiteral
aoqi@0:         InputEntity start = peekDeclaration("!NOTATION");
aoqi@0: 
aoqi@0:         if (start == null)
aoqi@0:             return false;
aoqi@0: 
aoqi@0:         String name = getMarkupDeclname("F-019", false);
aoqi@0:         ExternalEntity entity = new ExternalEntity(in);
aoqi@0: 
aoqi@0:         whitespace("F-011");
aoqi@0:         if (peek("PUBLIC")) {
aoqi@0:             whitespace("F-009");
aoqi@0:             entity.publicId = parsePublicId();
aoqi@0:             if (maybeWhitespace()) {
aoqi@0:                 if (!peek(">"))
aoqi@0:                     entity.systemId = parseSystemId();
aoqi@0:                 else
aoqi@0:                     ungetc();
aoqi@0:             }
aoqi@0:         } else if (peek("SYSTEM")) {
aoqi@0:             whitespace("F-008");
aoqi@0:             entity.systemId = parseSystemId();
aoqi@0:         } else
aoqi@0:             fatal("P-062");
aoqi@0:         maybeWhitespace();
aoqi@0:         nextChar('>', "F-032", name);
aoqi@0:         if (start != in)
aoqi@0:             error("V-013", null);
aoqi@0:         if (entity.systemId != null && entity.systemId.indexOf('#') != -1)
aoqi@0:             error("P-056", new Object[]{entity.systemId});
aoqi@0: 
aoqi@0:         Object value = notations.get(name);
aoqi@0:         if (value != null && value instanceof ExternalEntity)
aoqi@0:             warning("P-063", new Object[]{name});
aoqi@0: 
aoqi@0:         else {
aoqi@0:             notations.put(name, entity);
aoqi@0:             dtdHandler.notationDecl(name, entity.publicId,
aoqi@0:                     entity.systemId);
aoqi@0:         }
aoqi@0:         return true;
aoqi@0:     }
aoqi@0: 
aoqi@0: 
aoqi@0:     ////////////////////////////////////////////////////////////////
aoqi@0:     //
aoqi@0:     //    UTILITIES
aoqi@0:     //
aoqi@0:     ////////////////////////////////////////////////////////////////
aoqi@0: 
aoqi@0:     private char getc() throws IOException, SAXException {
aoqi@0: 
aoqi@0:         if (!doLexicalPE) {
aoqi@0:             char c = in.getc();
aoqi@0:             return c;
aoqi@0:         }
aoqi@0: 
aoqi@0:         //
aoqi@0:         // External parameter entities get funky processing of '%param;'
aoqi@0:         // references.  It's not clearly defined in the XML spec; but it
aoqi@0:         // boils down to having those refs be _lexical_ in most cases to
aoqi@0:         // include partial syntax productions.  It also needs selective
aoqi@0:         // enabling; "<!ENTITY % foo ...>" must work, for example, and
aoqi@0:         // if "bar" is an empty string PE, "ab%bar;cd" becomes "abcd"
aoqi@0:         // if it's expanded in a literal, else "ab  cd".  PEs also do
aoqi@0:         // not expand within comments or PIs, and external PEs are only
aoqi@0:         // allowed to have markup decls (and so aren't handled lexically).
aoqi@0:         //
aoqi@0:         // This PE handling should be merged into maybeWhitespace, where
aoqi@0:         // it can be dealt with more consistently.
aoqi@0:         //
aoqi@0:         // Also, there are some validity constraints in this area.
aoqi@0:         //
aoqi@0:         char c;
aoqi@0: 
aoqi@0:         while (in.isEOF()) {
aoqi@0:             if (in.isInternal() || (doLexicalPE && !in.isDocument()))
aoqi@0:                 in = in.pop();
aoqi@0:             else {
aoqi@0:                 fatal("P-064", new Object[]{in.getName()});
aoqi@0:             }
aoqi@0:         }
aoqi@0:         if ((c = in.getc()) == '%' && doLexicalPE) {
aoqi@0:             // PE ref ::= '%' name ';'
aoqi@0:             String name = maybeGetName();
aoqi@0:             Object entity;
aoqi@0: 
aoqi@0:             if (name == null)
aoqi@0:                 fatal("P-011");
aoqi@0:             nextChar(';', "F-021", name);
aoqi@0:             entity = params.get(name);
aoqi@0: 
aoqi@0:             // push a magic "entity" before and after the
aoqi@0:             // real one, so ungetc() behaves uniformly
aoqi@0:             pushReader(" ".toCharArray(), null, false);
aoqi@0:             if (entity instanceof InternalEntity)
aoqi@0:                 pushReader(((InternalEntity) entity).buf, name, false);
aoqi@0:             else if (entity instanceof ExternalEntity)
aoqi@0:             // PEs can't be unparsed!
aoqi@0:             // XXX if this returns false ...
aoqi@0:                 pushReader((ExternalEntity) entity);
aoqi@0:             else if (entity == null)
aoqi@0:             // see note in maybePEReference re making this be nonfatal.
aoqi@0:                 fatal("V-022");
aoqi@0:             else
aoqi@0:                 throw new InternalError();
aoqi@0:             pushReader(" ".toCharArray(), null, false);
aoqi@0:             return in.getc();
aoqi@0:         }
aoqi@0:         return c;
aoqi@0:     }
aoqi@0: 
aoqi@0:     private void ungetc() {
aoqi@0: 
aoqi@0:         in.ungetc();
aoqi@0:     }
aoqi@0: 
aoqi@0:     private boolean peek(String s)
aoqi@0:             throws IOException, SAXException {
aoqi@0: 
aoqi@0:         return in.peek(s, null);
aoqi@0:     }
aoqi@0: 
aoqi@0:     // Return the entity starting the specified declaration
aoqi@0:     // (for validating declaration nesting) else null.
aoqi@0: 
aoqi@0:     private InputEntity peekDeclaration(String s)
aoqi@0:             throws IOException, SAXException {
aoqi@0: 
aoqi@0:         InputEntity start;
aoqi@0: 
aoqi@0:         if (!in.peekc('<'))
aoqi@0:             return null;
aoqi@0:         start = in;
aoqi@0:         if (in.peek(s, null))
aoqi@0:             return start;
aoqi@0:         in.ungetc();
aoqi@0:         return null;
aoqi@0:     }
aoqi@0: 
aoqi@0:     private void nextChar(char c, String location, String near)
aoqi@0:             throws IOException, SAXException {
aoqi@0: 
aoqi@0:         while (in.isEOF() && !in.isDocument())
aoqi@0:             in = in.pop();
aoqi@0:         if (!in.peekc(c))
aoqi@0:             fatal("P-008", new Object[]
aoqi@0:             {new Character(c),
aoqi@0:              messages.getMessage(locale, location),
aoqi@0:              (near == null ? "" : ('"' + near + '"'))});
aoqi@0:     }
aoqi@0: 
aoqi@0: 
aoqi@0:     private void pushReader(char buf [], String name, boolean isGeneral)
aoqi@0:             throws SAXException {
aoqi@0: 
aoqi@0:         InputEntity r = InputEntity.getInputEntity(dtdHandler, locale);
aoqi@0:         r.init(buf, name, in, !isGeneral);
aoqi@0:         in = r;
aoqi@0:     }
aoqi@0: 
aoqi@0:     private boolean pushReader(ExternalEntity next)
aoqi@0:             throws IOException, SAXException {
aoqi@0: 
aoqi@0:         InputEntity r = InputEntity.getInputEntity(dtdHandler, locale);
aoqi@0:         InputSource s;
aoqi@0:         try {
aoqi@0:             s = next.getInputSource(resolver);
aoqi@0:         } catch (IOException e) {
aoqi@0:             String msg =
aoqi@0:                     "unable to open the external entity from :" + next.systemId;
aoqi@0:             if (next.publicId != null)
aoqi@0:                 msg += " (public id:" + next.publicId + ")";
aoqi@0: 
aoqi@0:             SAXParseException spe = new SAXParseException(msg,
aoqi@0:                     getPublicId(), getSystemId(), getLineNumber(), getColumnNumber(), e);
aoqi@0:             dtdHandler.fatalError(spe);
aoqi@0:             throw e;
aoqi@0:         }
aoqi@0: 
aoqi@0:         r.init(s, next.name, in, next.isPE);
aoqi@0:         in = r;
aoqi@0:         return true;
aoqi@0:     }
aoqi@0: 
aoqi@0:     public String getPublicId() {
aoqi@0: 
aoqi@0:         return (in == null) ? null : in.getPublicId();
aoqi@0:     }
aoqi@0: 
aoqi@0:     public String getSystemId() {
aoqi@0: 
aoqi@0:         return (in == null) ? null : in.getSystemId();
aoqi@0:     }
aoqi@0: 
aoqi@0:     public int getLineNumber() {
aoqi@0: 
aoqi@0:         return (in == null) ? -1 : in.getLineNumber();
aoqi@0:     }
aoqi@0: 
aoqi@0:     public int getColumnNumber() {
aoqi@0: 
aoqi@0:         return (in == null) ? -1 : in.getColumnNumber();
aoqi@0:     }
aoqi@0: 
aoqi@0:     // error handling convenience routines
aoqi@0: 
aoqi@0:     private void warning(String messageId, Object parameters [])
aoqi@0:             throws SAXException {
aoqi@0: 
aoqi@0:         SAXParseException e = new SAXParseException(messages.getMessage(locale, messageId, parameters),
aoqi@0:                 getPublicId(), getSystemId(), getLineNumber(), getColumnNumber());
aoqi@0: 
aoqi@0:         dtdHandler.warning(e);
aoqi@0:     }
aoqi@0: 
aoqi@0:     void error(String messageId, Object parameters [])
aoqi@0:             throws SAXException {
aoqi@0: 
aoqi@0:         SAXParseException e = new SAXParseException(messages.getMessage(locale, messageId, parameters),
aoqi@0:                 getPublicId(), getSystemId(), getLineNumber(), getColumnNumber());
aoqi@0: 
aoqi@0:         dtdHandler.error(e);
aoqi@0:     }
aoqi@0: 
aoqi@0:     private void fatal(String messageId) throws SAXException {
aoqi@0: 
aoqi@0:         fatal(messageId, null);
aoqi@0:     }
aoqi@0: 
aoqi@0:     private void fatal(String messageId, Object parameters [])
aoqi@0:             throws SAXException {
aoqi@0: 
aoqi@0:         SAXParseException e = new SAXParseException(messages.getMessage(locale, messageId, parameters),
aoqi@0:                 getPublicId(), getSystemId(), getLineNumber(), getColumnNumber());
aoqi@0: 
aoqi@0:         dtdHandler.fatalError(e);
aoqi@0: 
aoqi@0:         throw e;
aoqi@0:     }
aoqi@0: 
aoqi@0:     //
aoqi@0:     // Map char arrays to strings ... cuts down both on memory and
aoqi@0:     // CPU usage for element/attribute/other names that are reused.
aoqi@0:     //
aoqi@0:     // Documents typically repeat names a lot, so we more or less
aoqi@0:     // intern all the strings within the document; since some strings
aoqi@0:     // are repeated in multiple documents (e.g. stylesheets) we go
aoqi@0:     // a bit further, and intern globally.
aoqi@0:     //
aoqi@0:     static class NameCache {
aoqi@0:         //
aoqi@0:         // Unless we auto-grow this, the default size should be a
aoqi@0:         // reasonable bit larger than needed for most XML files
aoqi@0:         // we've yet seen (and be prime).  If it's too small, the
aoqi@0:         // penalty is just excess cache collisions.
aoqi@0:         //
aoqi@0:         NameCacheEntry hashtable [] = new NameCacheEntry[541];
aoqi@0: 
aoqi@0:         //
aoqi@0:         // Usually we just want to get the 'symbol' for these chars
aoqi@0:         //
aoqi@0:         String lookup(char value [], int len) {
aoqi@0: 
aoqi@0:             return lookupEntry(value, len).name;
aoqi@0:         }
aoqi@0: 
aoqi@0:         //
aoqi@0:         // Sometimes we need to scan the chars in the resulting
aoqi@0:         // string, so there's an accessor which exposes them.
aoqi@0:         // (Mostly for element end tags.)
aoqi@0:         //
aoqi@0:         NameCacheEntry lookupEntry(char value [], int len) {
aoqi@0: 
aoqi@0:             int index = 0;
aoqi@0:             NameCacheEntry entry;
aoqi@0: 
aoqi@0:             // hashing to get index
aoqi@0:             for (int i = 0; i < len; i++)
aoqi@0:                 index = index * 31 + value[i];
aoqi@0:             index &= 0x7fffffff;
aoqi@0:             index %= hashtable.length;
aoqi@0: 
aoqi@0:             // return entry if one's there ...
aoqi@0:             for (entry = hashtable[index];
aoqi@0:                  entry != null;
aoqi@0:                  entry = entry.next) {
aoqi@0:                 if (entry.matches(value, len))
aoqi@0:                     return entry;
aoqi@0:             }
aoqi@0: 
aoqi@0:             // else create new one
aoqi@0:             entry = new NameCacheEntry();
aoqi@0:             entry.chars = new char[len];
aoqi@0:             System.arraycopy(value, 0, entry.chars, 0, len);
aoqi@0:             entry.name = new String(entry.chars);
aoqi@0:             //
aoqi@0:             // NOTE:  JDK 1.1 has a fixed size string intern table,
aoqi@0:             // with non-GC'd entries.  It can panic here; that's a
aoqi@0:             // JDK problem, use 1.2 or later with many identifiers.
aoqi@0:             //
aoqi@0:             entry.name = entry.name.intern();        // "global" intern
aoqi@0:             entry.next = hashtable[index];
aoqi@0:             hashtable[index] = entry;
aoqi@0:             return entry;
aoqi@0:         }
aoqi@0:     }
aoqi@0: 
aoqi@0:     static class NameCacheEntry {
aoqi@0: 
aoqi@0:         String name;
aoqi@0:         char chars [];
aoqi@0:         NameCacheEntry next;
aoqi@0: 
aoqi@0:         boolean matches(char value [], int len) {
aoqi@0: 
aoqi@0:             if (chars.length != len)
aoqi@0:                 return false;
aoqi@0:             for (int i = 0; i < len; i++)
aoqi@0:                 if (value[i] != chars[i])
aoqi@0:                     return false;
aoqi@0:             return true;
aoqi@0:         }
aoqi@0:     }
aoqi@0: 
aoqi@0:     //
aoqi@0:     // Message catalog for diagnostics.
aoqi@0:     //
aoqi@0:     static final Catalog messages = new Catalog();
aoqi@0: 
aoqi@0:     static final class Catalog extends MessageCatalog {
aoqi@0: 
aoqi@0:         Catalog() {
aoqi@0:             super(DTDParser.class);
aoqi@0:         }
aoqi@0:     }
aoqi@0: 
aoqi@0: }