1 /*
   2  * Copyright (c) 1998, 2015, Oracle and/or its affiliates. All rights reserved.
   3  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
   4  *
   5  * This code is free software; you can redistribute it and/or modify it
   6  * under the terms of the GNU General Public License version 2 only, as
   7  * published by the Free Software Foundation.  Oracle designates this
   8  * particular file as subject to the "Classpath" exception as provided
   9  * by Oracle in the LICENSE file that accompanied this code.
  10  *
  11  * This code is distributed in the hope that it will be useful, but WITHOUT
  12  * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
  13  * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
  14  * version 2 for more details (a copy is included in the LICENSE file that
  15  * accompanied this code).
  16  *
  17  * You should have received a copy of the GNU General Public License version
  18  * 2 along with this work; if not, write to the Free Software Foundation,
  19  * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
  20  *
  21  * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
  22  * or visit www.oracle.com if you need additional information or have any
  23  * questions.
  24  */
  25 
  26 package com.sun.xml.internal.dtdparser;
  27 
  28 import org.xml.sax.EntityResolver;
  29 import org.xml.sax.InputSource;
  30 import org.xml.sax.Locator;
  31 import org.xml.sax.SAXException;
  32 import org.xml.sax.SAXParseException;
  33 
  34 import java.io.IOException;
  35 import java.util.ArrayList;
  36 import java.util.Enumeration;
  37 import java.util.Hashtable;
  38 import java.util.Locale;
  39 import java.util.Set;
  40 import java.util.Vector;
  41 import java.util.logging.Level;
  42 import java.util.logging.Logger;
  43 
  44 /**
  45  * This implements parsing of XML 1.0 DTDs.
  46  * <p>
  47  * This conforms to the portion of the XML 1.0 specification related to the
  48  * external DTD subset.
  49  * <p>
  50  * For multi-language applications (such as web servers using XML processing to
  51  * create dynamic content), a method supports choosing a locale for parser
  52  * diagnostics which is both understood by the message recipient and supported
  53  * by the parser.
  54  * <p>
  55  * This parser produces a stream of parse events. It supports some features
  56  * (exposing comments, CDATA sections, and entity references) which are not
  57  * required to be reported by conformant XML processors.
  58  *
  59  * @author David Brownell
  60  * @author Janet Koenig
  61  * @author Kohsuke KAWAGUCHI
  62  * @version $Id: DTDParser.java,v 1.2 2009-04-16 15:25:49 snajper Exp $
  63  */
  64 public class DTDParser {
  65 
  66     public final static String TYPE_CDATA = "CDATA";
  67     public final static String TYPE_ID = "ID";
  68     public final static String TYPE_IDREF = "IDREF";
  69     public final static String TYPE_IDREFS = "IDREFS";
  70     public final static String TYPE_ENTITY = "ENTITY";
  71     public final static String TYPE_ENTITIES = "ENTITIES";
  72     public final static String TYPE_NMTOKEN = "NMTOKEN";
  73     public final static String TYPE_NMTOKENS = "NMTOKENS";
  74     public final static String TYPE_NOTATION = "NOTATION";
  75     public final static String TYPE_ENUMERATION = "ENUMERATION";


  76     // stack of input entities being merged
  77     private InputEntity in;

  78     // temporaries reused during parsing
  79     private StringBuffer strTmp;
  80     private char nameTmp[];
  81     private NameCache nameCache;
  82     private char charTmp[] = new char[2];

  83     // temporary DTD parsing state
  84     private boolean doLexicalPE;

  85     // DTD state, used during parsing
  86 //    private SimpleHashtable    elements = new SimpleHashtable (47);
  87     protected final Set declaredElements = new java.util.HashSet();
  88     private SimpleHashtable params = new SimpleHashtable(7);

  89     // exposed to package-private subclass
  90     Hashtable notations = new Hashtable(7);
  91     SimpleHashtable entities = new SimpleHashtable(17);

  92     private SimpleHashtable ids = new SimpleHashtable();

  93     // listeners for DTD parsing events
  94     private DTDEventListener dtdHandler;

  95     private EntityResolver resolver;
  96     private Locale locale;

  97     // string constants -- use these copies so "==" works
  98     // package private
  99     static final String strANY = "ANY";
 100     static final String strEMPTY = "EMPTY";
 101 
 102     private static final Logger LOGGER = Logger.getLogger(DTDParser.class.getName());
 103 
 104     /**
 105      * Used by applications to request locale for diagnostics.
 106      *
 107      * @param l The locale to use, or null to use system defaults (which may
 108      * include only message IDs).
 109      */
 110     public void setLocale(Locale l) throws SAXException {
 111 
 112         if (l != null && !messages.isLocaleSupported(l.toString())) {
 113             throw new SAXException(messages.getMessage(locale,
 114                     "P-078", new Object[]{l}));
 115         }
 116         locale = l;
 117     }
 118 
 119     /**
 120      * Returns the diagnostic locale.
 121      */
 122     public Locale getLocale() {
 123         return locale;
 124     }
 125 
 126     /**
 127      * Chooses a client locale to use for diagnostics, using the first language
 128      * specified in the list that is supported by this parser. That locale is
 129      * then set using <a href="#setLocale(java.util.Locale)"> setLocale()</a>.
 130      * Such a list could be provided by a variety of user preference mechanisms,
 131      * including the HTTP <em>Accept-Language</em> header field.

 132      *
 133      * @param languages Array of language specifiers, ordered with the most
 134      * preferable one at the front. For example, "en-ca" then "fr-ca", followed
 135      * by "zh_CN". Both RFC 1766 and Java styles are supported.
 136      * @return The chosen locale, or null.
 137      * @see MessageCatalog
 138      */
 139     public Locale chooseLocale(String languages[])
 140             throws SAXException {
 141 
 142         Locale l = messages.chooseLocale(languages);
 143 
 144         if (l != null) {
 145             setLocale(l);
 146         }
 147         return l;
 148     }
 149 
 150     /**
 151      * Lets applications control entity resolution.
 152      */
 153     public void setEntityResolver(EntityResolver r) {
 154 
 155         resolver = r;
 156     }
 157 
 158     /**
 159      * Returns the object used to resolve entities
 160      */
 161     public EntityResolver getEntityResolver() {
 162 
 163         return resolver;
 164     }
 165 
 166     /**
 167      * Used by applications to set handling of DTD parsing events.
 168      */
 169     public void setDtdHandler(DTDEventListener handler) {
 170         dtdHandler = handler;
 171         if (handler != null) {
 172             handler.setDocumentLocator(new Locator() {
 173                 @Override
 174                 public String getPublicId() {
 175                     return DTDParser.this.getPublicId();
 176                 }
 177 
 178                 @Override
 179                 public String getSystemId() {
 180                     return DTDParser.this.getSystemId();
 181                 }
 182 
 183                 @Override
 184                 public int getLineNumber() {
 185                     return DTDParser.this.getLineNumber();
 186                 }
 187 
 188                 @Override
 189                 public int getColumnNumber() {
 190                     return DTDParser.this.getColumnNumber();
 191                 }
 192             });
 193         }
 194     }
 195 
 196     /**
 197      * Returns the handler used to for DTD parsing events.
 198      */
 199     public DTDEventListener getDtdHandler() {
 200         return dtdHandler;
 201     }
 202 
 203     /**
 204      * Parse a DTD.
 205      */
 206     public void parse(InputSource in)
 207             throws IOException, SAXException {
 208         init();
 209         parseInternal(in);
 210     }
 211 
 212     /**
 213      * Parse a DTD.
 214      */
 215     public void parse(String uri)
 216             throws IOException, SAXException {
 217         InputSource inSource;
 218 
 219         init();
 220         // System.out.println ("parse (\"" + uri + "\")");
 221         inSource = resolver.resolveEntity(null, uri);
 222 
 223         // If custom resolver punts resolution to parser, handle it ...
 224         if (inSource == null) {
 225             inSource = Resolver.createInputSource(new java.net.URL(uri), false);
 226 
 227             // ... or if custom resolver doesn't correctly construct the
 228             // input entity, patch it up enough so relative URIs work, and
 229             // issue a warning to minimize later confusion.
 230         } else if (inSource.getSystemId() == null) {
 231             warning("P-065", null);
 232             inSource.setSystemId(uri);
 233         }
 234 
 235         parseInternal(inSource);
 236     }
 237 
 238     // makes sure the parser is reset to "before a document"
 239     private void init() {
 240         in = null;
 241 
 242         // alloc temporary data used in parsing
 243         strTmp = new StringBuffer();
 244         nameTmp = new char[20];
 245         nameCache = new NameCache();
 246 
 247         // reset doc info
 248 //        isInAttribute = false;
 249 
 250         doLexicalPE = false;
 251 
 252         entities.clear();
 253         notations.clear();
 254         params.clear();
 255         //    elements.clear ();
 256         declaredElements.clear();
 257 
 258         // initialize predefined references ... re-interpreted later
 259         builtin("amp", "&");
 260         builtin("lt", "<");
 261         builtin("gt", ">");
 262         builtin("quot", "\"");
 263         builtin("apos", "'");
 264 
 265         if (locale == null) {
 266             locale = Locale.getDefault();
 267         }
 268         if (resolver == null) {
 269             resolver = new Resolver();
 270         }
 271         if (dtdHandler == null) {
 272             dtdHandler = new DTDHandlerBase();
 273         }
 274     }
 275 
 276     private void builtin(String entityName, String entityValue) {
 277         InternalEntity entity;
 278         entity = new InternalEntity(entityName, entityValue.toCharArray());
 279         entities.put(entityName, entity);
 280     }
 281 

 282     ////////////////////////////////////////////////////////////////
 283     //
 284     // parsing is by recursive descent, code roughly
 285     // following the BNF rules except tweaked for simple
 286     // lookahead.  rules are more or less in numeric order,
 287     // except where code sharing suggests other structures.
 288     //
 289     // a classic benefit of recursive descent parsers:  it's
 290     // relatively easy to get diagnostics that make sense.
 291     //
 292     ////////////////////////////////////////////////////////////////
 293     @SuppressWarnings("CallToThreadDumpStack")

 294     private void parseInternal(InputSource input)
 295             throws IOException, SAXException {
 296 
 297         if (input == null) {
 298             fatal("P-000");
 299         }
 300 
 301         try {
 302             in = InputEntity.getInputEntity(dtdHandler, locale);
 303             in.init(input, null, null, false);
 304 
 305             dtdHandler.startDTD(in);
 306 
 307             // [30] extSubset ::= TextDecl? extSubsetDecl
 308             // [31] extSubsetDecl ::= ( markupdecl | conditionalSect
 309             //        | PEReference | S )*
 310             //    ... same as [79] extPE, which is where the code is
 311 
 312             ExternalEntity externalSubset = new ExternalEntity(in);
 313             externalParameterEntity(externalSubset);
 314 
 315             if (!in.isEOF()) {
 316                 fatal("P-001", new Object[]{Integer.toHexString(((int) getc()))});

 317             }
 318             afterRoot();
 319             dtdHandler.endDTD();
 320 
 321         } catch (EndOfInputException e) {
 322             if (!in.isDocument()) {
 323                 String name = in.getName();
 324                 do {    // force a relevant URI and line number
 325                     in = in.pop();
 326                 } while (in.isInternal());
 327                 fatal("P-002", new Object[]{name});
 328             } else {
 329                 fatal("P-003", null);
 330             }
 331         } catch (RuntimeException e) {
 332             LOGGER.log(Level.SEVERE, "Internal DTD parser error.", e);



 333             throw new SAXParseException(e.getMessage() != null
 334                     ? e.getMessage() : e.getClass().getName(),
 335                     getPublicId(), getSystemId(),
 336                     getLineNumber(), getColumnNumber());
 337 
 338         } finally {
 339             // recycle temporary data used during parsing
 340             strTmp = null;
 341             nameTmp = null;
 342             nameCache = null;
 343 
 344             // ditto input sources etc
 345             if (in != null) {
 346                 in.close();
 347                 in = null;
 348             }
 349 
 350             // get rid of all DTD info ... some of it would be
 351             // useful for editors etc, investigate later.
 352 
 353             params.clear();
 354             entities.clear();
 355             notations.clear();
 356             declaredElements.clear();
 357 //        elements.clear();
 358             ids.clear();
 359         }
 360     }
 361 
 362     void afterRoot() throws SAXException {
 363         // Make sure all IDREFs match declared ID attributes.  We scan
 364         // after the document element is parsed, since XML allows forward
 365         // references, and only now can we know if they're all resolved.
 366 
 367         for (Enumeration e = ids.keys();
 368                 e.hasMoreElements();) {

 369             String id = (String) e.nextElement();
 370             Boolean value = (Boolean) ids.get(id);
 371             if (Boolean.FALSE.equals(value)) {
 372                 error("V-024", new Object[]{id});
 373             }
 374         }
 375     }
 376 
 377     // role is for diagnostics
 378     private void whitespace(String roleId)
 379             throws IOException, SAXException {
 380 
 381         // [3] S ::= (#x20 | #x9 | #xd | #xa)+
 382         if (!maybeWhitespace()) {
 383             fatal("P-004", new Object[]{messages.getMessage(locale, roleId)});

 384         }
 385     }
 386 
 387     // S?
 388     private boolean maybeWhitespace()
 389             throws IOException, SAXException {
 390 
 391         if (!doLexicalPE) {
 392             return in.maybeWhitespace();
 393         }
 394 
 395         // see getc() for the PE logic -- this lets us splice
 396         // expansions of PEs in "anywhere".  getc() has smarts,
 397         // so for external PEs we don't bypass it.
 398 
 399         // XXX we can marginally speed PE handling, and certainly
 400         // be cleaner (hence potentially more correct), by using
 401         // the observations that expanded PEs only start and stop
 402         // where whitespace is allowed.  getc wouldn't need any
 403         // "lexical" PE expansion logic, and no other method needs
 404         // to handle termination of PEs.  (parsing of literals would
 405         // still need to pop entities, but not parsing of references
 406         // in content.)
 407 
 408         char c = getc();
 409         boolean saw = false;
 410 
 411         while (c == ' ' || c == '\t' || c == '\n' || c == '\r') {
 412             saw = true;
 413 
 414             // this gracefully ends things when we stop playing
 415             // with internal parameters.  caller should have a
 416             // grammar rule allowing whitespace at end of entity.
 417             if (in.isEOF() && !in.isInternal()) {
 418                 return saw;
 419             }
 420             c = getc();
 421         }
 422         ungetc();
 423         return saw;
 424     }
 425 
 426     private String maybeGetName()
 427             throws IOException, SAXException {
 428 
 429         NameCacheEntry entry = maybeGetNameCacheEntry();
 430         return (entry == null) ? null : entry.name;
 431     }
 432 
 433     private NameCacheEntry maybeGetNameCacheEntry()
 434             throws IOException, SAXException {
 435 
 436         // [5] Name ::= (Letter|'_'|':') (Namechar)*
 437         char c = getc();
 438 
 439         if (!XmlChars.isLetter(c) && c != ':' && c != '_') {
 440             ungetc();
 441             return null;
 442         }
 443         return nameCharString(c);
 444     }
 445 
 446     // Used when parsing enumerations
 447     private String getNmtoken()
 448             throws IOException, SAXException {
 449 
 450         // [7] Nmtoken ::= (Namechar)+
 451         char c = getc();
 452         if (!XmlChars.isNameChar(c)) {
 453             fatal("P-006", new Object[]{Character.valueOf(c)});
 454         }
 455         return nameCharString(c).name;
 456     }
 457 
 458     // n.b. this gets used when parsing attribute values (for
 459     // internal references) so we can't use strTmp; it's also
 460     // a hotspot for CPU and memory in the parser (called at least
 461     // once for each element) so this has been optimized a bit.

 462     private NameCacheEntry nameCharString(char c)
 463             throws IOException, SAXException {
 464 
 465         int i = 1;
 466 
 467         nameTmp[0] = c;
 468         for (;;) {
 469             if ((c = in.getNameChar()) == 0) {
 470                 break;
 471             }
 472             if (i >= nameTmp.length) {
 473                 char tmp[] = new char[nameTmp.length + 10];
 474                 System.arraycopy(nameTmp, 0, tmp, 0, nameTmp.length);
 475                 nameTmp = tmp;
 476             }
 477             nameTmp[i++] = c;
 478         }
 479         return nameCache.lookupEntry(nameTmp, i);
 480     }
 481 
 482     //
 483     // much similarity between parsing entity values in DTD
 484     // and attribute values (in DTD or content) ... both follow
 485     // literal parsing rules, newline canonicalization, etc
 486     //
 487     // leaves value in 'strTmp' ... either a "replacement text" (4.5),
 488     // or else partially normalized attribute value (the first bit
 489     // of 3.3.3's spec, without the "if not CDATA" bits).
 490     //
 491     @SuppressWarnings("UnusedAssignment")
 492     private void parseLiteral(boolean isEntityValue)
 493             throws IOException, SAXException {
 494 
 495         // [9] EntityValue ::=
 496         //    '"' ([^"&%] | Reference | PEReference)* '"'
 497         //    |    "'" ([^'&%] | Reference | PEReference)* "'"
 498         // [10] AttValue ::=
 499         //    '"' ([^"&]  | Reference             )* '"'
 500         //    |    "'" ([^'&]  | Reference             )* "'"
 501         char quote = getc();
 502         char c;
 503         InputEntity source = in;
 504 
 505         if (quote != '\'' && quote != '"') {
 506             fatal("P-007");
 507         }
 508 
 509         // don't report entity expansions within attributes,
 510         // they're reported "fully expanded" via SAX
 511 //    isInAttribute = !isEntityValue;
 512 
 513         // get value into strTmp
 514         strTmp = new StringBuffer();
 515 
 516         // scan, allowing entity push/pop wherever ...
 517         // expanded entities can't terminate the literal!
 518         for (;;) {
 519             if (in != source && in.isEOF()) {
 520                 // we don't report end of parsed entities
 521                 // within attributes (no SAX hooks)
 522                 in = in.pop();
 523                 continue;
 524             }
 525             if ((c = getc()) == quote && in == source) {
 526                 break;
 527             }
 528 
 529             //
 530             // Basically the "reference in attribute value"
 531             // row of the chart in section 4.4 of the spec
 532             //
 533             if (c == '&') {
 534                 String entityName = maybeGetName();
 535 
 536                 if (entityName != null) {
 537                     nextChar(';', "F-020", entityName);
 538 
 539                     // 4.4 says:  bypass these here ... we'll catch
 540                     // forbidden refs to unparsed entities on use
 541                     if (isEntityValue) {
 542                         strTmp.append('&');
 543                         strTmp.append(entityName);
 544                         strTmp.append(';');
 545                         continue;
 546                     }
 547                     expandEntityInLiteral(entityName, entities, isEntityValue);
 548 

 549                     // character references are always included immediately
 550                 } else if ((getc()) == '#') {
 551                     int tmp = parseCharNumber();
 552 
 553                     if (tmp > 0xffff) {
 554                         tmp = surrogatesToCharTmp(tmp);
 555                         strTmp.append(charTmp[0]);
 556                         if (tmp == 2) {
 557                             strTmp.append(charTmp[1]);
 558                         }
 559                     } else {
 560                         strTmp.append((char) tmp);
 561                     }
 562                 } else {
 563                     fatal("P-009");
 564                 }
 565                 continue;
 566 
 567             }
 568 
 569             // expand parameter entities only within entity value literals
 570             if (c == '%' && isEntityValue) {
 571                 String entityName = maybeGetName();
 572 
 573                 if (entityName != null) {
 574                     nextChar(';', "F-021", entityName);
 575                     expandEntityInLiteral(entityName, params, isEntityValue);
 576                     continue;
 577                 } else {
 578                     fatal("P-011");
 579                 }
 580             }
 581 
 582             // For attribute values ...
 583             if (!isEntityValue) {
 584                 // 3.3.3 says whitespace normalizes to space...
 585                 if (c == ' ' || c == '\t' || c == '\n' || c == '\r') {
 586                     strTmp.append(' ');
 587                     continue;
 588                 }
 589 
 590                 // "<" not legal in parsed literals ...
 591                 if (c == '<') {
 592                     fatal("P-012");
 593                 }
 594             }
 595 
 596             strTmp.append(c);
 597         }
 598 //    isInAttribute = false;
 599     }
 600 
 601     // does a SINGLE expansion of the entity (often reparsed later)
 602     private void expandEntityInLiteral(String name, SimpleHashtable table,
 603             boolean isEntityValue)
 604             throws IOException, SAXException {
 605 
 606         Object entity = table.get(name);
 607 
 608         if (entity instanceof InternalEntity) {
 609             InternalEntity value = (InternalEntity) entity;
 610             pushReader(value.buf, name, !value.isPE);
 611 
 612         } else if (entity instanceof ExternalEntity) {
 613             if (!isEntityValue) // must be a PE ...
 614             {
 615                 fatal("P-013", new Object[]{name});
 616             }
 617             // XXX if this returns false ...
 618             pushReader((ExternalEntity) entity);
 619 
 620         } else if (entity == null) {
 621             //
 622             // Note:  much confusion about whether spec requires such
 623             // errors to be fatal in many cases, but none about whether
 624             // it allows "normal" errors to be unrecoverable!
 625             //
 626             fatal((table == params) ? "V-022" : "P-014",
 627                     new Object[]{name});
 628         }
 629     }
 630 
 631     // [11] SystemLiteral ::= ('"' [^"]* '"') | ("'" [^']* "'")
 632     // for PUBLIC and SYSTEM literals, also "<?xml ...type='literal'?>'

 633     // NOTE:  XML spec should explicitly say that PE ref syntax is
 634     // ignored in PIs, comments, SystemLiterals, and Pubid Literal
 635     // values ... can't process the XML spec's own DTD without doing
 636     // that for comments.

 637     private String getQuotedString(String type, String extra)
 638             throws IOException, SAXException {
 639 
 640         // use in.getc to bypass PE processing
 641         char quote = in.getc();
 642 
 643         if (quote != '\'' && quote != '"') {
 644             fatal("P-015", new Object[]{
 645                         messages.getMessage(locale, type, new Object[]{extra})
 646                     });
 647         }
 648 
 649         char c;
 650 
 651         strTmp = new StringBuffer();
 652         while ((c = in.getc()) != quote) {
 653             strTmp.append((char) c);
 654         }
 655         return strTmp.toString();
 656     }
 657 

 658     private String parsePublicId() throws IOException, SAXException {
 659 
 660         // [12] PubidLiteral ::= ('"' PubidChar* '"') | ("'" PubidChar* "'")
 661         // [13] PubidChar ::= #x20|#xd|#xa|[a-zA-Z0-9]|[-'()+,./:=?;!*#@$_%]
 662         String retval = getQuotedString("F-033", null);
 663         for (int i = 0; i < retval.length(); i++) {
 664             char c = retval.charAt(i);
 665             if (" \r\n-'()+,./:=?;!*#@$_%0123456789".indexOf(c) == -1
 666                     && !(c >= 'A' && c <= 'Z')
 667                     && !(c >= 'a' && c <= 'z')) {
 668                 fatal("P-016", new Object[]{Character.valueOf(c)});
 669             }
 670         }
 671         strTmp = new StringBuffer();
 672         strTmp.append(retval);
 673         return normalize(false);
 674     }
 675 
 676     // [14] CharData ::= [^<&]* - ([^<&]* ']]>' [^<&]*)
 677     // handled by:  InputEntity.parsedContent()

 678     private boolean maybeComment(boolean skipStart)
 679             throws IOException, SAXException {
 680 
 681         // [15] Comment ::= '<!--'
 682         //        ( (Char - '-') | ('-' (Char - '-'))*
 683         //        '-->'
 684         if (!in.peek(skipStart ? "!--" : "<!--", null)) {
 685             return false;
 686         }
 687 
 688         boolean savedLexicalPE = doLexicalPE;
 689         boolean saveCommentText;
 690 
 691         doLexicalPE = false;
 692         saveCommentText = false;
 693         if (saveCommentText) {
 694             strTmp = new StringBuffer();
 695         }
 696 
 697         oneComment:
 698         for (;;) {
 699             try {
 700                 // bypass PE expansion, but permit PEs
 701                 // to complete ... valid docs won't care.
 702                 for (;;) {
 703                     int c = getc();
 704                     if (c == '-') {
 705                         c = getc();
 706                         if (c != '-') {
 707                             if (saveCommentText) {
 708                                 strTmp.append('-');
 709                             }
 710                             ungetc();
 711                             continue;
 712                         }
 713                         nextChar('>', "F-022", null);
 714                         break oneComment;
 715                     }
 716                     if (saveCommentText) {
 717                         strTmp.append((char) c);
 718                     }
 719                 }
 720             } catch (EndOfInputException e) {
 721                 //
 722                 // This is fatal EXCEPT when we're processing a PE...
 723                 // in which case a validating processor reports an error.
 724                 // External PEs are easy to detect; internal ones we
 725                 // infer by being an internal entity outside an element.
 726                 //
 727                 if (in.isInternal()) {
 728                     error("V-021", null);
 729                 }
 730                 fatal("P-017");
 731             }
 732         }
 733         doLexicalPE = savedLexicalPE;
 734         if (saveCommentText) {
 735             dtdHandler.comment(strTmp.toString());
 736         }
 737         return true;
 738     }
 739 
 740     private boolean maybePI(boolean skipStart)
 741             throws IOException, SAXException {
 742 
 743         // [16] PI ::= '<?' PITarget
 744         //        (S (Char* - (Char* '?>' Char*)))?
 745         //        '?>'
 746         // [17] PITarget ::= Name - (('X'|'x')('M'|'m')('L'|'l')
 747         boolean savedLexicalPE = doLexicalPE;
 748 
 749         if (!in.peek(skipStart ? "?" : "<?", null)) {
 750             return false;
 751         }
 752         doLexicalPE = false;
 753 
 754         String target = maybeGetName();
 755 
 756         if (target == null) {
 757             fatal("P-018");
 758         }
 759         if ("xml".equals(target)) {
 760             fatal("P-019");
 761         }
 762         if ("xml".equalsIgnoreCase(target)) {
 763             fatal("P-020", new Object[]{target});
 764         }
 765 
 766         if (maybeWhitespace()) {
 767             strTmp = new StringBuffer();
 768             try {
 769                 for (;;) {
 770                     // use in.getc to bypass PE processing
 771                     char c = in.getc();
 772                     //Reached the end of PI.
 773                     if (c == '?' && in.peekc('>')) {
 774                         break;
 775                     }
 776                     strTmp.append(c);
 777                 }
 778             } catch (EndOfInputException e) {
 779                 fatal("P-021");
 780             }
 781             dtdHandler.processingInstruction(target, strTmp.toString());
 782         } else {
 783             if (!in.peek("?>", null)) {
 784                 fatal("P-022");
 785             }
 786             dtdHandler.processingInstruction(target, "");
 787         }
 788 
 789         doLexicalPE = savedLexicalPE;
 790         return true;
 791     }
 792 
 793     // [18] CDSect ::= CDStart CData CDEnd
 794     // [19] CDStart ::= '<![CDATA['
 795     // [20] CData ::= (Char* - (Char* ']]>' Char*))
 796     // [21] CDEnd ::= ']]>'
 797     //
 798     //    ... handled by InputEntity.unparsedContent()

 799     // collapsing several rules together ...
 800     // simpler than attribute literals -- no reference parsing!
 801     private String maybeReadAttribute(String name, boolean must)
 802             throws IOException, SAXException {
 803 
 804         // [24] VersionInfo ::= S 'version' Eq \'|\" versionNum \'|\"
 805         // [80] EncodingDecl ::= S 'encoding' Eq \'|\" EncName \'|\"
 806         // [32] SDDecl ::=  S 'standalone' Eq \'|\" ... \'|\"
 807         if (!maybeWhitespace()) {
 808             if (!must) {
 809                 return null;
 810             }
 811             fatal("P-024", new Object[]{name});
 812             // NOTREACHED
 813         }
 814 
 815         if (!peek(name)) {
 816             if (must) {
 817                 fatal("P-024", new Object[]{name});
 818             } else {
 819                 // To ensure that the whitespace is there so that when we
 820                 // check for the next attribute we assure that the
 821                 // whitespace still exists.
 822                 ungetc();
 823                 return null;
 824             }
 825         }
 826 
 827         // [25] Eq ::= S? '=' S?
 828         maybeWhitespace();
 829         nextChar('=', "F-023", null);
 830         maybeWhitespace();
 831 
 832         return getQuotedString("F-035", name);
 833     }
 834 
 835     private void readVersion(boolean must, String versionNum)
 836             throws IOException, SAXException {
 837 
 838         String value = maybeReadAttribute("version", must);
 839 
 840         // [26] versionNum ::= ([a-zA-Z0-9_.:]| '-')+
 841 
 842         if (must && value == null) {
 843             fatal("P-025", new Object[]{versionNum});
 844         }
 845         if (value != null) {
 846             int length = value.length();
 847             for (int i = 0; i < length; i++) {
 848                 char c = value.charAt(i);
 849                 if (!((c >= '0' && c <= '9')
 850                         || c == '_' || c == '.'
 851                         || (c >= 'a' && c <= 'z')
 852                         || (c >= 'A' && c <= 'Z')
 853                         || c == ':' || c == '-')) {

 854                     fatal("P-026", new Object[]{value});
 855                 }
 856             }
 857         }
 858         if (value != null && !value.equals(versionNum)) {
 859             error("P-027", new Object[]{versionNum, value});
 860         }
 861     }
 862 
 863     // common code used by most markup declarations
 864     // ... S (Q)Name ...
 865     private String getMarkupDeclname(String roleId, boolean qname)
 866             throws IOException, SAXException {
 867 
 868         String name;
 869 
 870         whitespace(roleId);
 871         name = maybeGetName();
 872         if (name == null) {
 873             fatal("P-005", new Object[]{messages.getMessage(locale, roleId)});
 874         }
 875         return name;
 876     }
 877 
 878     private boolean maybeMarkupDecl()
 879             throws IOException, SAXException {
 880 
 881         // [29] markupdecl ::= elementdecl | Attlistdecl
 882         //           | EntityDecl | NotationDecl | PI | Comment
 883         return maybeElementDecl()
 884                 || maybeAttlistDecl()
 885                 || maybeEntityDecl()
 886                 || maybeNotationDecl()
 887                 || maybePI(false)
 888                 || maybeComment(false);
 889     }

 890     private static final String XmlLang = "xml:lang";
 891 
 892     private boolean isXmlLang(String value) {
 893 
 894         // [33] LanguageId ::= Langcode ('-' Subcode)*
 895         // [34] Langcode ::= ISO639Code | IanaCode | UserCode
 896         // [35] ISO639Code ::= [a-zA-Z] [a-zA-Z]
 897         // [36] IanaCode ::= [iI] '-' SubCode
 898         // [37] UserCode ::= [xX] '-' SubCode
 899         // [38] SubCode ::= [a-zA-Z]+
 900 
 901         // the ISO and IANA codes (and subcodes) are registered,
 902         // but that's neither a WF nor a validity constraint.
 903 
 904         int nextSuffix;
 905         char c;
 906 
 907         if (value.length() < 2) {
 908             return false;
 909         }
 910         c = value.charAt(1);
 911         if (c == '-') {        // IANA, or user, code
 912             c = value.charAt(0);
 913             if (!(c == 'i' || c == 'I' || c == 'x' || c == 'X')) {
 914                 return false;
 915             }
 916             nextSuffix = 1;
 917         } else if ((c >= 'a' && c <= 'z') || (c >= 'A' && c <= 'Z')) {
 918             // 2 letter ISO code, or error
 919             c = value.charAt(0);
 920             if (!((c >= 'a' && c <= 'z') || (c >= 'A' && c <= 'Z'))) {
 921                 return false;
 922             }
 923             nextSuffix = 2;
 924         } else {
 925             return false;
 926         }
 927 
 928         // here "suffix" ::= '-' [a-zA-Z]+ suffix*
 929         while (nextSuffix < value.length()) {
 930             c = value.charAt(nextSuffix);
 931             if (c != '-') {
 932                 break;
 933             }
 934             while (++nextSuffix < value.length()) {
 935                 c = value.charAt(nextSuffix);
 936                 if (!((c >= 'a' && c <= 'z') || (c >= 'A' && c <= 'Z'))) {
 937                     break;
 938                 }
 939             }
 940         }
 941         return value.length() == nextSuffix && c != '-';
 942     }
 943 

 944     //
 945     // CHAPTER 3:  Logical Structures
 946     //

 947     /**
 948      * To validate, subclassers should at this time make sure that values are of
 949      * the declared types:<UL> <LI> ID and IDREF(S) values are Names <LI>
 950      * NMTOKEN(S) are Nmtokens <LI> ENUMERATION values match one of the tokens
 951      * <LI> NOTATION values match a notation name <LI> ENTITIY(IES) values match
 952      * an unparsed external entity </UL>
 953      * <p>
 954      * <P> Separately, make sure IDREF values match some ID provided in the
 955      * document (in the afterRoot method).



 956      */
 957     /*    void validateAttributeSyntax (Attribute attr, String value)
 958      throws DTDParseException {
 959      // ID, IDREF(S) ... values are Names
 960      if (Attribute.ID == attr.type()) {
 961      if (!XmlNames.isName (value))
 962      error ("V-025", new Object [] { value });
 963 
 964      Boolean             b = (Boolean) ids.getNonInterned (value);
 965      if (b == null || b.equals (Boolean.FALSE))
 966      ids.put (value.intern (), Boolean.TRUE);
 967      else
 968      error ("V-026", new Object [] { value });
 969 
 970      } else if (Attribute.IDREF == attr.type()) {
 971      if (!XmlNames.isName (value))
 972      error ("V-027", new Object [] { value });
 973 
 974      Boolean             b = (Boolean) ids.getNonInterned (value);
 975      if (b == null)
 976      ids.put (value.intern (), Boolean.FALSE);
 977 
 978      } else if (Attribute.IDREFS == attr.type()) {
 979      StringTokenizer     tokenizer = new StringTokenizer (value);
 980      Boolean             b;
 981      boolean             sawValue = false;
 982 
 983      while (tokenizer.hasMoreTokens ()) {
 984      value = tokenizer.nextToken ();
 985      if (!XmlNames.isName (value))
 986      error ("V-027", new Object [] { value });
 987      b = (Boolean) ids.getNonInterned (value);
 988      if (b == null)
 989      ids.put (value.intern (), Boolean.FALSE);
 990      sawValue = true;
 991      }
 992      if (!sawValue)
 993      error ("V-039", null);
 994 
 995 
 996      // NMTOKEN(S) ... values are Nmtoken(s)
 997      } else if (Attribute.NMTOKEN == attr.type()) {
 998      if (!XmlNames.isNmtoken (value))
 999      error ("V-028", new Object [] { value });
1000 
1001      } else if (Attribute.NMTOKENS == attr.type()) {
1002      StringTokenizer     tokenizer = new StringTokenizer (value);
1003      boolean             sawValue = false;
1004 
1005      while (tokenizer.hasMoreTokens ()) {
1006      value = tokenizer.nextToken ();
1007      if (!XmlNames.isNmtoken (value))
1008      error ("V-028", new Object [] { value });
1009      sawValue = true;
1010      }
1011      if (!sawValue)
1012      error ("V-032", null);
1013 
1014      // ENUMERATION ... values match one of the tokens
1015      } else if (Attribute.ENUMERATION == attr.type()) {
1016      for (int i = 0; i < attr.values().length; i++)
1017      if (value.equals (attr.values()[i]))
1018      return;
1019      error ("V-029", new Object [] { value });
1020 
1021      // NOTATION values match a notation name
1022      } else if (Attribute.NOTATION == attr.type()) {
1023      //
1024      // XXX XML 1.0 spec should probably list references to
1025      // externally defined notations in standalone docs as
1026      // validity errors.  Ditto externally defined unparsed
1027      // entities; neither should show up in attributes, else
1028      // one needs to read the external declarations in order
1029      // to make sense of the document (exactly what tagging
1030      // a doc as "standalone" intends you won't need to do).
1031      //
1032      for (int i = 0; i < attr.values().length; i++)
1033      if (value.equals (attr.values()[i]))
1034      return;
1035      error ("V-030", new Object [] { value });
1036 
1037      // ENTITY(IES) values match an unparsed entity(ies)
1038      } else if (Attribute.ENTITY == attr.type()) {
1039      // see note above re standalone
1040      if (!isUnparsedEntity (value))
1041      error ("V-031", new Object [] { value });
1042 
1043      } else if (Attribute.ENTITIES == attr.type()) {
1044      StringTokenizer     tokenizer = new StringTokenizer (value);
1045      boolean             sawValue = false;
1046 
1047      while (tokenizer.hasMoreTokens ()) {
1048      value = tokenizer.nextToken ();
1049      // see note above re standalone
1050      if (!isUnparsedEntity (value))
1051      error ("V-031", new Object [] { value });
1052      sawValue = true;
1053      }
1054      if (!sawValue)
1055      error ("V-040", null);
1056 
1057      } else if (Attribute.CDATA != attr.type())
1058      throw new InternalError (attr.type());
1059      }
1060      */
1061     /*
1062      private boolean isUnparsedEntity (String name)
1063      {
1064      Object e = entities.getNonInterned (name);
1065      if (e == null || !(e instanceof ExternalEntity))
1066      return false;
1067      return ((ExternalEntity)e).notation != null;
1068      }
1069      */
1070     private boolean maybeElementDecl()
1071             throws IOException, SAXException {
1072 
1073         // [45] elementDecl ::= '<!ELEMENT' S Name S contentspec S? '>'
1074         // [46] contentspec ::= 'EMPTY' | 'ANY' | Mixed | children
1075         InputEntity start = peekDeclaration("!ELEMENT");
1076 
1077         if (start == null) {
1078             return false;
1079         }
1080 
1081         // n.b. for content models where inter-element whitespace is
1082         // ignorable, we mark that fact here.
1083         String name = getMarkupDeclname("F-015", true);
1084 //    Element        element = (Element) elements.get (name);
1085 //    boolean        declEffective = false;
1086 
1087         /*
1088          if (element != null) {
1089          if (element.contentModel() != null) {
1090          error ("V-012", new Object [] { name });
1091          } // else <!ATTLIST name ...> came first
1092          } else {
1093          element = new Element(name);
1094          elements.put (element.name(), element);
1095          declEffective = true;
1096          }
1097          */
1098         if (declaredElements.contains(name)) {
1099             error("V-012", new Object[]{name});
1100         } else {
1101             declaredElements.add(name);
1102 //        declEffective = true;
1103         }
1104 
1105         short modelType;
1106         whitespace("F-000");
1107         if (peek(strEMPTY)) {
1108 ///        // leave element.contentModel as null for this case.
1109             dtdHandler.startContentModel(name, modelType = DTDEventListener.CONTENT_MODEL_EMPTY);
1110         } else if (peek(strANY)) {
1111 ///        element.setContentModel(new StringModel(StringModelType.ANY));
1112             dtdHandler.startContentModel(name, modelType = DTDEventListener.CONTENT_MODEL_ANY);
1113         } else {
1114             modelType = getMixedOrChildren(name);
1115         }
1116 
1117         dtdHandler.endContentModel(name, modelType);
1118 
1119         maybeWhitespace();
1120         char c = getc();
1121         if (c != '>') {
1122             fatal("P-036", new Object[]{name, Character.valueOf(c)});
1123         }
1124         if (start != in) {
1125             error("V-013", null);
1126         }
1127 
1128 ///        dtdHandler.elementDecl(element);
1129 
1130         return true;
1131     }
1132 
1133     // We're leaving the content model as a regular expression;
1134     // it's an efficient natural way to express such things, and
1135     // libraries often interpret them.  No whitespace in the
1136     // model we store, though!

1137     /**
1138      * returns content model type.
1139      */
1140     private short getMixedOrChildren(String elementName/*Element element*/)
1141             throws IOException, SAXException {
1142 
1143         InputEntity start;
1144 
1145         // [47] children ::= (choice|seq) ('?'|'*'|'+')?
1146         strTmp = new StringBuffer();
1147 
1148         nextChar('(', "F-028", elementName);
1149         start = in;
1150         maybeWhitespace();
1151         strTmp.append('(');
1152 
1153         short modelType;
1154         if (peek("#PCDATA")) {
1155             strTmp.append("#PCDATA");
1156             dtdHandler.startContentModel(elementName, modelType = DTDEventListener.CONTENT_MODEL_MIXED);
1157             getMixed(elementName, start);
1158         } else {
1159             dtdHandler.startContentModel(elementName, modelType = DTDEventListener.CONTENT_MODEL_CHILDREN);
1160             getcps(elementName, start);
1161         }
1162 
1163         return modelType;
1164     }
1165 
1166     // '(' S? already consumed
1167     // matching ')' must be in "start" entity if validating
1168     private void getcps(/*Element element,*/String elementName, InputEntity start)
1169             throws IOException, SAXException {
1170 
1171         // [48] cp ::= (Name|choice|seq) ('?'|'*'|'+')?
1172         // [49] choice ::= '(' S? cp (S? '|' S? cp)* S? ')'
1173         // [50] seq    ::= '(' S? cp (S? ',' S? cp)* S? ')'
1174         boolean decided = false;
1175         char type = 0;
1176 //        ContentModel       retval, temp, current;
1177 
1178 //        retval = temp = current = null;
1179 
1180         dtdHandler.startModelGroup();
1181 
1182         do {
1183             String tag;
1184 
1185             tag = maybeGetName();
1186             if (tag != null) {
1187                 strTmp.append(tag);
1188 //                temp = new ElementModel(tag);
1189 //                getFrequency((RepeatableContent)temp);
1190 ///->
1191                 dtdHandler.childElement(tag, getFrequency());
1192 ///<-
1193             } else if (peek("(")) {
1194                 InputEntity next = in;
1195                 strTmp.append('(');
1196                 maybeWhitespace();
1197 //                temp = getcps(element, next);
1198 //                getFrequency(temp);
1199 ///->
1200                 getcps(elementName, next);
1201 ///                getFrequency();        <- this looks like a bug
1202 ///<-
1203             } else {
1204                 fatal((type == 0) ? "P-039"
1205                         : ((type == ',') ? "P-037" : "P-038"),
1206                         new Object[]{Character.valueOf(getc())});
1207             }
1208 
1209             maybeWhitespace();
1210             if (decided) {
1211                 char c = getc();
1212 
1213 //                if (current != null) {
1214 //                    current.addChild(temp);
1215 //                }
1216                 if (c == type) {
1217                     strTmp.append(type);
1218                     maybeWhitespace();
1219                     reportConnector(type);
1220                     continue;
1221                 } else if (c == '\u0029') {    // rparen
1222                     ungetc();
1223                     continue;
1224                 } else {
1225                     fatal((type == 0) ? "P-041" : "P-040",
1226                             new Object[]{
1227                                 Character.valueOf(c),
1228                                 Character.valueOf(type)
1229                             });
1230                 }
1231             } else {
1232                 type = getc();
1233                 switch (type) {
1234                     case '|':
1235                     case ',':
1236                         reportConnector(type);
1237                         break;
1238                     default:
1239 //                        retval = temp;
1240                         ungetc();
1241                         continue;
1242                 }
1243 //                retval = (ContentModel)current;
1244                 decided = true;
1245 //                current.addChild(temp);
1246                 strTmp.append(type);
1247             }
1248             maybeWhitespace();
1249         } while (!peek(")"));
1250 
1251         if (in != start) {
1252             error("V-014", new Object[]{elementName});
1253         }
1254         strTmp.append(')');
1255 
1256         dtdHandler.endModelGroup(getFrequency());
1257 //        return retval;
1258     }
1259 
1260     private void reportConnector(char type) throws SAXException {
1261         switch (type) {
1262             case '|':
1263                 dtdHandler.connector(DTDEventListener.CHOICE);    ///<-
1264                 return;
1265             case ',':
1266                 dtdHandler.connector(DTDEventListener.SEQUENCE); ///<-
1267                 return;
1268             default:
1269                 throw new Error();    //assertion failed.
1270         }
1271     }
1272 
1273     private short getFrequency()
1274             throws IOException, SAXException {
1275 
1276         final char c = getc();
1277 
1278         if (c == '?') {
1279             strTmp.append(c);
1280             return DTDEventListener.OCCURENCE_ZERO_OR_ONE;
1281             //        original.setRepeat(Repeat.ZERO_OR_ONE);
1282         } else if (c == '+') {
1283             strTmp.append(c);
1284             return DTDEventListener.OCCURENCE_ONE_OR_MORE;
1285             //        original.setRepeat(Repeat.ONE_OR_MORE);
1286         } else if (c == '*') {
1287             strTmp.append(c);
1288             return DTDEventListener.OCCURENCE_ZERO_OR_MORE;
1289             //        original.setRepeat(Repeat.ZERO_OR_MORE);
1290         } else {
1291             ungetc();
1292             return DTDEventListener.OCCURENCE_ONCE;
1293         }
1294     }
1295 
1296     // '(' S? '#PCDATA' already consumed
1297     // matching ')' must be in "start" entity if validating
1298     private void getMixed(String elementName, /*Element element,*/ InputEntity start)
1299             throws IOException, SAXException {
1300 
1301         // [51] Mixed ::= '(' S? '#PCDATA' (S? '|' S? Name)* S? ')*'
1302         //        | '(' S? '#PCDATA'                   S? ')'
1303         maybeWhitespace();
1304         if (peek("\u0029*") || peek("\u0029")) {
1305             if (in != start) {
1306                 error("V-014", new Object[]{elementName});
1307             }
1308             strTmp.append(')');
1309 //            element.setContentModel(new StringModel(StringModelType.PCDATA));
1310             return;
1311         }
1312 
1313         ArrayList l = new ArrayList();
1314 //    l.add(new StringModel(StringModelType.PCDATA));
1315 
1316 
1317         while (peek("|")) {
1318             String name;
1319 
1320             strTmp.append('|');
1321             maybeWhitespace();
1322 
1323             doLexicalPE = true;
1324             name = maybeGetName();
1325             if (name == null) {
1326                 fatal("P-042", new Object[]{elementName, Integer.toHexString(getc())});
1327             }
1328             if (l.contains(name)) {
1329                 error("V-015", new Object[]{name});
1330             } else {
1331                 l.add(name);
1332                 dtdHandler.mixedElement(name);
1333             }
1334             strTmp.append(name);
1335             maybeWhitespace();
1336         }
1337 
1338         if (!peek("\u0029*")) // right paren
1339         {
1340             fatal("P-043", new Object[]{elementName, Character.valueOf(getc())});
1341         }
1342         if (in != start) {
1343             error("V-014", new Object[]{elementName});
1344         }
1345         strTmp.append(')');
1346 //        ChoiceModel cm = new ChoiceModel((Collection)l);
1347 //    cm.setRepeat(Repeat.ZERO_OR_MORE);
1348 //       element.setContentModel(cm);
1349     }
1350 
1351     private boolean maybeAttlistDecl()
1352             throws IOException, SAXException {
1353 
1354         // [52] AttlistDecl ::= '<!ATTLIST' S Name AttDef* S? '>'
1355         InputEntity start = peekDeclaration("!ATTLIST");
1356 
1357         if (start == null) {
1358             return false;
1359         }
1360 
1361         String elementName = getMarkupDeclname("F-016", true);
1362 //    Element    element = (Element) elements.get (name);
1363 
1364 //    if (element == null) {
1365 //        // not yet declared -- no problem.
1366 //        element = new Element(name);
1367 //        elements.put(name, element);
1368 //    }
1369 
1370         while (!peek(">")) {
1371 
1372             // [53] AttDef ::= S Name S AttType S DefaultDecl
1373             // [54] AttType ::= StringType | TokenizedType | EnumeratedType
1374 
1375             // look for global attribute definitions, don't expand for now...
1376             maybeWhitespace();
1377             char c = getc();
1378             if (c == '%') {
1379                 String entityName = maybeGetName();
1380                 if (entityName != null) {
1381                     nextChar(';', "F-021", entityName);
1382                     whitespace("F-021");
1383                     continue;
1384                 } else {
1385                     fatal("P-011");
1386                 }
1387             }
1388 
1389             ungetc();
1390             // look for attribute name otherwise
1391             String attName = maybeGetName();
1392             if (attName == null) {
1393                 fatal("P-044", new Object[]{Character.valueOf(getc())});
1394             }
1395             whitespace("F-001");
1396 
1397 ///        Attribute    a = new Attribute (name);
1398 
1399             String typeName;
1400             Vector values = null;    // notation/enumeration values
1401 
1402             // Note:  use the type constants from Attribute
1403             // so that "==" may be used (faster)
1404 
1405             // [55] StringType ::= 'CDATA'
1406             if (peek(TYPE_CDATA)) ///            a.setType(Attribute.CDATA);
1407             {
1408                 typeName = TYPE_CDATA;
1409             } // [56] TokenizedType ::= 'ID' | 'IDREF' | 'IDREFS'

1410             //        | 'ENTITY' | 'ENTITIES'
1411             //        | 'NMTOKEN' | 'NMTOKENS'
1412             // n.b. if "IDREFS" is there, both "ID" and "IDREF"
1413             // match peekahead ... so this order matters!
1414             else if (peek(TYPE_IDREFS)) {
1415                 typeName = TYPE_IDREFS;
1416             } else if (peek(TYPE_IDREF)) {
1417                 typeName = TYPE_IDREF;
1418             } else if (peek(TYPE_ID)) {
1419                 typeName = TYPE_ID;
1420 // TODO: should implement this error check?
1421 ///        if (element.id() != null) {
1422 ///                    error ("V-016", new Object [] { element.id() });
1423 ///        } else
1424 ///            element.setId(name);
1425             } else if (peek(TYPE_ENTITY)) {
1426                 typeName = TYPE_ENTITY;
1427             } else if (peek(TYPE_ENTITIES)) {
1428                 typeName = TYPE_ENTITIES;
1429             } else if (peek(TYPE_NMTOKENS)) {
1430                 typeName = TYPE_NMTOKENS;
1431             } else if (peek(TYPE_NMTOKEN)) {
1432                 typeName = TYPE_NMTOKEN;
1433             } // [57] EnumeratedType ::= NotationType | Enumeration

1434             // [58] NotationType ::= 'NOTATION' S '(' S? Name
1435             //        (S? '|' S? Name)* S? ')'
1436             else if (peek(TYPE_NOTATION)) {
1437                 typeName = TYPE_NOTATION;
1438                 whitespace("F-002");
1439                 nextChar('(', "F-029", null);
1440                 maybeWhitespace();
1441 
1442                 values = new Vector();
1443                 do {
1444                     String name;
1445                     if ((name = maybeGetName()) == null) {
1446                         fatal("P-068");
1447                     }
1448                     // permit deferred declarations
1449                     if (notations.get(name) == null) {
1450                         notations.put(name, name);
1451                     }
1452                     values.addElement(name);
1453                     maybeWhitespace();
1454                     if (peek("|")) {
1455                         maybeWhitespace();
1456                     }
1457                 } while (!peek(")"));
1458 ///            a.setValues(new String [v.size ()]);
1459 ///            for (int i = 0; i < v.size (); i++)
1460 ///                a.setValue(i, (String)v.elementAt(i));
1461 
1462                 // [59] Enumeration ::= '(' S? Nmtoken (S? '|' Nmtoken)* S? ')'
1463             } else if (peek("(")) {
1464 ///            a.setType(Attribute.ENUMERATION);
1465                 typeName = TYPE_ENUMERATION;
1466 
1467                 maybeWhitespace();
1468 
1469 ///            Vector v = new Vector ();
1470                 values = new Vector();
1471                 do {
1472                     String name = getNmtoken();
1473 ///                v.addElement (name);
1474                     values.addElement(name);
1475                     maybeWhitespace();
1476                     if (peek("|")) {
1477                         maybeWhitespace();
1478                     }
1479                 } while (!peek(")"));
1480 ///            a.setValues(new String [v.size ()]);
1481 ///            for (int i = 0; i < v.size (); i++)
1482 ///                a.setValue(i, (String)v.elementAt(i));
1483             } else {
1484                 fatal("P-045",
1485                         new Object[]{attName, Character.valueOf(getc())});
1486                 typeName = null;
1487             }
1488 
1489             short attributeUse;
1490             String defaultValue = null;
1491 
1492             // [60] DefaultDecl ::= '#REQUIRED' | '#IMPLIED'
1493             //        | (('#FIXED' S)? AttValue)
1494             whitespace("F-003");
1495             if (peek("#REQUIRED")) {
1496                 attributeUse = DTDEventListener.USE_REQUIRED;
1497             } ///            a.setIsRequired(true);
1498             else if (peek("#FIXED")) {
1499 ///            if (a.type() == Attribute.ID)
1500                 if (typeName == TYPE_ID) {
1501                     error("V-017", new Object[]{attName});
1502                 }
1503 ///            a.setIsFixed(true);
1504                 attributeUse = DTDEventListener.USE_FIXED;
1505                 whitespace("F-004");
1506                 parseLiteral(false);
1507 ///            if (a.type() != Attribute.CDATA)
1508 ///                a.setDefaultValue(normalize(false));
1509 ///            else
1510 ///                a.setDefaultValue(strTmp.toString());
1511 
1512                 if (typeName == TYPE_CDATA) {
1513                     defaultValue = normalize(false);
1514                 } else {
1515                     defaultValue = strTmp.toString();
1516                 }
1517 
1518 // TODO: implement this check
1519 ///            if (a.type() != Attribute.CDATA)
1520 ///                validateAttributeSyntax (a, a.defaultValue());
1521             } else if (!peek("#IMPLIED")) {
1522                 attributeUse = DTDEventListener.USE_IMPLIED;
1523 
1524 ///            if (a.type() == Attribute.ID)
1525                 if (typeName == TYPE_ID) {
1526                     error("V-018", new Object[]{attName});
1527                 }
1528                 parseLiteral(false);
1529 ///            if (a.type() != Attribute.CDATA)
1530 ///                a.setDefaultValue(normalize(false));
1531 ///            else
1532 ///                a.setDefaultValue(strTmp.toString());
1533                 if (typeName == TYPE_CDATA) {
1534                     defaultValue = normalize(false);
1535                 } else {
1536                     defaultValue = strTmp.toString();
1537                 }
1538 
1539 // TODO: implement this check
1540 ///            if (a.type() != Attribute.CDATA)
1541 ///                validateAttributeSyntax (a, a.defaultValue());
1542             } else {
1543                 // TODO: this looks like an fatal error.
1544                 attributeUse = DTDEventListener.USE_NORMAL;
1545             }
1546 
1547             if (XmlLang.equals(attName)
1548                     && defaultValue/* a.defaultValue()*/ != null
1549                     && !isXmlLang(defaultValue/*a.defaultValue()*/)) {
1550                 error("P-033", new Object[]{defaultValue /*a.defaultValue()*/});
1551             }
1552 
1553 // TODO: isn't it an error to specify the same attribute twice?
1554 ///        if (!element.attributes().contains(a)) {
1555 ///            element.addAttribute(a);
1556 ///            dtdHandler.attributeDecl(a);
1557 ///        }
1558 
1559             String[] v = (values != null) ? (String[]) values.toArray(new String[values.size()]) : null;
1560             dtdHandler.attributeDecl(elementName, attName, typeName, v, attributeUse, defaultValue);
1561             maybeWhitespace();
1562         }
1563         if (start != in) {
1564             error("V-013", null);
1565         }
1566         return true;
1567     }
1568 
1569     // used when parsing literal attribute values,
1570     // or public identifiers.
1571     //
1572     // input in strTmp
1573     private String normalize(boolean invalidIfNeeded) {
1574 
1575         // this can allocate an extra string...
1576 
1577         String s = strTmp.toString();
1578         String s2 = s.trim();
1579         boolean didStrip = false;
1580 
1581         if (s != s2) {
1582             s = s2;

1583             didStrip = true;
1584         }
1585         strTmp = new StringBuffer();
1586         for (int i = 0; i < s.length(); i++) {
1587             char c = s.charAt(i);
1588             if (!XmlChars.isSpace(c)) {
1589                 strTmp.append(c);
1590                 continue;
1591             }
1592             strTmp.append(' ');
1593             while (++i < s.length() && XmlChars.isSpace(s.charAt(i))) {
1594                 didStrip = true;
1595             }
1596             i--;
1597         }
1598         if (didStrip) {
1599             return strTmp.toString();
1600         } else {
1601             return s;
1602         }
1603     }
1604 
1605     private boolean maybeConditionalSect()
1606             throws IOException, SAXException {
1607 
1608         // [61] conditionalSect ::= includeSect | ignoreSect
1609 
1610         if (!peek("<![")) {
1611             return false;
1612         }
1613 
1614         String keyword;
1615         InputEntity start = in;
1616 
1617         maybeWhitespace();
1618 
1619         if ((keyword = maybeGetName()) == null) {
1620             fatal("P-046");
1621         }
1622         maybeWhitespace();
1623         nextChar('[', "F-030", null);
1624 
1625         // [62] includeSect ::= '<![' S? 'INCLUDE' S? '['
1626         //                extSubsetDecl ']]>'
1627         if ("INCLUDE".equals(keyword)) {
1628             for (;;) {
1629                 while (in.isEOF() && in != start) {
1630                     in = in.pop();
1631                 }
1632                 if (in.isEOF()) {
1633                     error("V-020", null);
1634                 }
1635                 if (peek("]]>")) {
1636                     break;
1637                 }
1638 
1639                 doLexicalPE = false;
1640                 if (maybeWhitespace()) {
1641                     continue;
1642                 }
1643                 if (maybePEReference()) {
1644                     continue;
1645                 }
1646                 doLexicalPE = true;
1647                 if (maybeMarkupDecl() || maybeConditionalSect()) {
1648                     continue;
1649                 }
1650 
1651                 fatal("P-047");
1652             }
1653 
1654             // [63] ignoreSect ::= '<![' S? 'IGNORE' S? '['
1655             //            ignoreSectcontents ']]>'
1656             // [64] ignoreSectcontents ::= Ignore ('<!['
1657             //            ignoreSectcontents ']]>' Ignore)*
1658             // [65] Ignore ::= Char* - (Char* ('<![' | ']]>') Char*)
1659         } else if ("IGNORE".equals(keyword)) {
1660             int nestlevel = 1;
1661             // ignoreSectcontents
1662             doLexicalPE = false;
1663             while (nestlevel > 0) {
1664                 char c = getc();    // will pop input entities
1665                 if (c == '<') {
1666                     if (peek("![")) {
1667                         nestlevel++;
1668                     }
1669                 } else if (c == ']') {
1670                     if (peek("]>")) {
1671                         nestlevel--;
1672                     }
1673                 } else {
1674                     continue;
1675                 }
1676             }
1677         } else {
1678             fatal("P-048", new Object[]{keyword});
1679         }
1680         return true;
1681     }
1682 

1683     //
1684     // CHAPTER 4:  Physical Structures
1685     //

1686     // parse decimal or hex numeric character reference
1687     private int parseCharNumber()
1688             throws IOException, SAXException {
1689 
1690         char c;
1691         int retval = 0;
1692 
1693         // n.b. we ignore overflow ...
1694         if (getc() != 'x') {
1695             ungetc();
1696             for (;;) {
1697                 c = getc();
1698                 if (c >= '0' && c <= '9') {
1699                     retval *= 10;
1700                     retval += (c - '0');
1701                     continue;
1702                 }
1703                 if (c == ';') {
1704                     return retval;
1705                 }
1706                 fatal("P-049");
1707             }
1708         } else {
1709             for (;;) {
1710                 c = getc();
1711                 if (c >= '0' && c <= '9') {
1712                     retval <<= 4;
1713                     retval += (c - '0');
1714                     continue;
1715                 }
1716                 if (c >= 'a' && c <= 'f') {
1717                     retval <<= 4;
1718                     retval += 10 + (c - 'a');
1719                     continue;
1720                 }
1721                 if (c >= 'A' && c <= 'F') {
1722                     retval <<= 4;
1723                     retval += 10 + (c - 'A');
1724                     continue;
1725                 }
1726                 if (c == ';') {
1727                     return retval;
1728                 }
1729                 fatal("P-050");
1730             }
1731         }
1732     }
1733 
1734     // parameter is a UCS-4 character ... i.e. not just 16 bit UNICODE,
1735     // though still subject to the 'Char' construct in XML
1736     private int surrogatesToCharTmp(int ucs4)
1737             throws SAXException {
1738 
1739         if (ucs4 <= 0xffff) {
1740             if (XmlChars.isChar(ucs4)) {
1741                 charTmp[0] = (char) ucs4;
1742                 return 1;
1743             }
1744         } else if (ucs4 <= 0x0010ffff) {
1745             // we represent these as UNICODE surrogate pairs
1746             ucs4 -= 0x10000;
1747             charTmp[0] = (char) (0xd800 | ((ucs4 >> 10) & 0x03ff));
1748             charTmp[1] = (char) (0xdc00 | (ucs4 & 0x03ff));
1749             return 2;
1750         }
1751         fatal("P-051", new Object[]{Integer.toHexString(ucs4)});
1752         // NOTREACHED
1753         return -1;
1754     }
1755 
1756     private boolean maybePEReference()
1757             throws IOException, SAXException {
1758 
1759         // This is the SYNTACTIC version of this construct.
1760         // When processing external entities, there is also
1761         // a LEXICAL version; see getc() and doLexicalPE.
1762 
1763         // [69] PEReference ::= '%' Name ';'
1764         if (!in.peekc('%')) {
1765             return false;
1766         }
1767 
1768         String name = maybeGetName();
1769         Object entity;
1770 
1771         if (name == null) {
1772             fatal("P-011");
1773         }
1774         nextChar(';', "F-021", name);
1775         entity = params.get(name);
1776 
1777         if (entity instanceof InternalEntity) {
1778             InternalEntity value = (InternalEntity) entity;
1779             pushReader(value.buf, name, false);
1780 
1781         } else if (entity instanceof ExternalEntity) {
1782             pushReader((ExternalEntity) entity);
1783             externalParameterEntity((ExternalEntity) entity);
1784 
1785         } else if (entity == null) {
1786             error("V-022", new Object[]{name});
1787         }
1788         return true;
1789     }
1790 
1791     private boolean maybeEntityDecl()
1792             throws IOException, SAXException {
1793 
1794         // [70] EntityDecl ::= GEDecl | PEDecl
1795         // [71] GEDecl ::= '<!ENTITY' S       Name S EntityDef S? '>'
1796         // [72] PEDecl ::= '<!ENTITY' S '%' S Name S PEDEF     S? '>'
1797         // [73] EntityDef ::= EntityValue | (ExternalID NDataDecl?)
1798         // [74] PEDef     ::= EntityValue |  ExternalID
1799         //
1800         InputEntity start = peekDeclaration("!ENTITY");
1801 
1802         if (start == null) {
1803             return false;
1804         }
1805 
1806         String entityName;
1807         SimpleHashtable defns;
1808         ExternalEntity externalId;
1809         boolean doStore;
1810 
1811         // PE expansion gets selectively turned off several places:
1812         // in ENTITY declarations (here), in comments, in PIs.
1813 
1814         // Here, we allow PE entities to be declared, and allows
1815         // literals to include PE refs without the added spaces
1816         // required with their expansion in markup decls.
1817 
1818         doLexicalPE = false;
1819         whitespace("F-005");
1820         if (in.peekc('%')) {
1821             whitespace("F-006");
1822             defns = params;
1823         } else {
1824             defns = entities;
1825         }
1826 
1827         ungetc();    // leave some whitespace
1828         doLexicalPE = true;
1829         entityName = getMarkupDeclname("F-017", false);
1830         whitespace("F-007");
1831         externalId = maybeExternalID();
1832 
1833         //
1834         // first definition sticks ... e.g. internal subset PEs are used
1835         // to override DTD defaults.  It's also an "error" to incorrectly
1836         // redefine builtin internal entities, but since reporting such
1837         // errors is optional we only give warnings ("just in case") for
1838         // non-parameter entities.
1839         //
1840         doStore = (defns.get(entityName) == null);
1841         if (!doStore && defns == entities) {
1842             warning("P-054", new Object[]{entityName});
1843         }
1844 
1845         // internal entities
1846         if (externalId == null) {
1847             char value[];
1848             InternalEntity entity;
1849 
1850             doLexicalPE = false;        // "ab%bar;cd" -maybe-> "abcd"
1851             parseLiteral(true);
1852             doLexicalPE = true;
1853             if (doStore) {
1854                 value = new char[strTmp.length()];
1855                 if (value.length != 0) {
1856                     strTmp.getChars(0, value.length, value, 0);
1857                 }
1858                 entity = new InternalEntity(entityName, value);
1859                 entity.isPE = (defns == params);

1860                 defns.put(entityName, entity);
1861                 if (defns == entities) {
1862                     dtdHandler.internalGeneralEntityDecl(entityName,
1863                             new String(value));
1864                 }
1865             }
1866 
1867             // external entities (including unparsed)
1868         } else {
1869             // [76] NDataDecl ::= S 'NDATA' S Name
1870             if (defns == entities && maybeWhitespace()
1871                     && peek("NDATA")) {
1872                 externalId.notation = getMarkupDeclname("F-018", false);
1873 
1874                 // flag undeclared notation for checking after
1875                 // the DTD is fully processed
1876                 if (notations.get(externalId.notation) == null) {
1877                     notations.put(externalId.notation, Boolean.TRUE);
1878                 }
1879             }
1880             externalId.name = entityName;
1881             externalId.isPE = (defns == params);

1882             if (doStore) {
1883                 defns.put(entityName, externalId);
1884                 if (externalId.notation != null) {
1885                     dtdHandler.unparsedEntityDecl(entityName,
1886                             externalId.publicId, externalId.systemId,
1887                             externalId.notation);
1888                 } else if (defns == entities) {
1889                     dtdHandler.externalGeneralEntityDecl(entityName,
1890                             externalId.publicId, externalId.systemId);
1891                 }
1892             }
1893         }
1894         maybeWhitespace();
1895         nextChar('>', "F-031", entityName);
1896         if (start != in) {
1897             error("V-013", null);
1898         }
1899         return true;
1900     }
1901 
1902     private ExternalEntity maybeExternalID()
1903             throws IOException, SAXException {
1904 
1905         // [75] ExternalID ::= 'SYSTEM' S SystemLiteral
1906         //        | 'PUBLIC' S' PubidLiteral S Systemliteral
1907         String temp = null;
1908         ExternalEntity retval;
1909 
1910         if (peek("PUBLIC")) {
1911             whitespace("F-009");
1912             temp = parsePublicId();
1913         } else if (!peek("SYSTEM")) {
1914             return null;
1915         }
1916 
1917         retval = new ExternalEntity(in);
1918         retval.publicId = temp;
1919         whitespace("F-008");
1920         retval.systemId = parseSystemId();
1921         return retval;
1922     }
1923 
1924     private String parseSystemId()
1925             throws IOException, SAXException {
1926 
1927         String uri = getQuotedString("F-034", null);
1928         int temp = uri.indexOf(':');
1929 
1930         // resolve relative URIs ... must do it here since
1931         // it's relative to the source file holding the URI!
1932 
1933         // "new java.net.URL (URL, string)" conforms to RFC 1630,
1934         // but we can't use that except when the URI is a URL.
1935         // The entity resolver is allowed to handle URIs that are
1936         // not URLs, so we pass URIs through with scheme intact
1937         if (temp == -1 || uri.indexOf('/') < temp) {
1938             String baseURI;
1939 
1940             baseURI = in.getSystemId();
1941             if (baseURI == null) {
1942                 fatal("P-055", new Object[]{uri});
1943             }
1944             if (uri.length() == 0) {
1945                 uri = ".";
1946             }
1947             baseURI = baseURI.substring(0, baseURI.lastIndexOf('/') + 1);
1948             if (uri.charAt(0) != '/') {
1949                 uri = baseURI + uri;
1950             } else {
1951                 // XXX slashes at the beginning of a relative URI are
1952                 // a special case we don't handle.
1953                 throw new InternalError();
1954             }
1955 
1956             // letting other code map any "/xxx/../" or "/./" to "/",
1957             // since all URIs must handle it the same.
1958         }
1959         // check for fragment ID in URI
1960         if (uri.indexOf('#') != -1) {
1961             error("P-056", new Object[]{uri});
1962         }
1963         return uri;
1964     }
1965 
1966     private void maybeTextDecl()
1967             throws IOException, SAXException {
1968 
1969         // [77] TextDecl ::= '<?xml' VersionInfo? EncodingDecl S? '?>'
1970         if (peek("<?xml")) {
1971             readVersion(false, "1.0");
1972             readEncoding(true);
1973             maybeWhitespace();
1974             if (!peek("?>")) {
1975                 fatal("P-057");
1976             }
1977         }
1978     }
1979 
1980     private void externalParameterEntity(ExternalEntity next)
1981             throws IOException, SAXException {
1982 
1983         //
1984         // Reap the intended benefits of standalone declarations:
1985         // don't deal with external parameter entities, except to
1986         // validate the standalone declaration.
1987         //
1988 
1989         // n.b. "in external parameter entities" (and external
1990         // DTD subset, same grammar) parameter references can
1991         // occur "within" markup declarations ... expansions can
1992         // cross syntax rules.  Flagged here; affects getc().
1993 
1994         // [79] ExtPE ::= TextDecl? extSubsetDecl
1995         // [31] extSubsetDecl ::= ( markupdecl | conditionalSect
1996         //        | PEReference | S )*
1997         InputEntity pe;
1998 
1999         // XXX if this returns false ...
2000 
2001         pe = in;
2002         maybeTextDecl();
2003         while (!pe.isEOF()) {
2004             // pop internal PEs (and whitespace before/after)
2005             if (in.isEOF()) {
2006                 in = in.pop();
2007                 continue;
2008             }
2009             doLexicalPE = false;
2010             if (maybeWhitespace()) {
2011                 continue;
2012             }
2013             if (maybePEReference()) {
2014                 continue;
2015             }
2016             doLexicalPE = true;
2017             if (maybeMarkupDecl() || maybeConditionalSect()) {
2018                 continue;
2019             }
2020             break;
2021         }
2022         // if (in != pe) throw new InternalError("who popped my PE?");
2023         if (!pe.isEOF()) {
2024             fatal("P-059", new Object[]{in.getName()});
2025         }
2026     }
2027 
2028     private void readEncoding(boolean must)
2029             throws IOException, SAXException {
2030 
2031         // [81] EncName ::= [A-Za-z] ([A-Za-z0-9._] | '-')*
2032         String name = maybeReadAttribute("encoding", must);
2033 
2034         if (name == null) {
2035             return;
2036         }
2037         for (int i = 0; i < name.length(); i++) {
2038             char c = name.charAt(i);
2039             if ((c >= 'A' && c <= 'Z')
2040                     || (c >= 'a' && c <= 'z')) {
2041                 continue;
2042             }
2043             if (i != 0
2044                     && ((c >= '0' && c <= '9')
2045                     || c == '-'
2046                     || c == '_'
2047                     || c == '.')) {

2048                 continue;
2049             }
2050             fatal("P-060", new Object[]{Character.valueOf(c)});
2051         }
2052 
2053         //
2054         // This should be the encoding in use, and it's even an error for
2055         // it to be anything else (in certain cases that are impractical to
2056         // to test, and may even be insufficient).  So, we do the best we
2057         // can, and warn if things look suspicious.  Note that Java doesn't
2058         // uniformly expose the encodings, and that the names it uses
2059         // internally are nonstandard.  Also, that the XML spec allows
2060         // such "errors" not to be reported at all.
2061         //
2062         String currentEncoding = in.getEncoding();
2063 
2064         if (currentEncoding != null
2065                 && !name.equalsIgnoreCase(currentEncoding)) {
2066             warning("P-061", new Object[]{name, currentEncoding});
2067         }
2068     }
2069 
2070     private boolean maybeNotationDecl()
2071             throws IOException, SAXException {
2072 
2073         // [82] NotationDecl ::= '<!NOTATION' S Name S
2074         //        (ExternalID | PublicID) S? '>'
2075         // [83] PublicID ::= 'PUBLIC' S PubidLiteral
2076         InputEntity start = peekDeclaration("!NOTATION");
2077 
2078         if (start == null) {
2079             return false;
2080         }
2081 
2082         String name = getMarkupDeclname("F-019", false);
2083         ExternalEntity entity = new ExternalEntity(in);
2084 
2085         whitespace("F-011");
2086         if (peek("PUBLIC")) {
2087             whitespace("F-009");
2088             entity.publicId = parsePublicId();
2089             if (maybeWhitespace()) {
2090                 if (!peek(">")) {
2091                     entity.systemId = parseSystemId();
2092                 } else {
2093                     ungetc();
2094                 }
2095             }
2096         } else if (peek("SYSTEM")) {
2097             whitespace("F-008");
2098             entity.systemId = parseSystemId();
2099         } else {
2100             fatal("P-062");
2101         }
2102         maybeWhitespace();
2103         nextChar('>', "F-032", name);
2104         if (start != in) {
2105             error("V-013", null);
2106         }
2107         if (entity.systemId != null && entity.systemId.indexOf('#') != -1) {
2108             error("P-056", new Object[]{entity.systemId});
2109         }
2110 
2111         Object value = notations.get(name);
2112         if (value != null && value instanceof ExternalEntity) {
2113             warning("P-063", new Object[]{name});
2114         } else {

2115             notations.put(name, entity);
2116             dtdHandler.notationDecl(name, entity.publicId,
2117                     entity.systemId);
2118         }
2119         return true;
2120     }
2121 

2122     ////////////////////////////////////////////////////////////////
2123     //
2124     //    UTILITIES
2125     //
2126     ////////////////////////////////////////////////////////////////

2127     private char getc() throws IOException, SAXException {
2128 
2129         if (!doLexicalPE) {
2130             char c = in.getc();
2131             return c;
2132         }
2133 
2134         //
2135         // External parameter entities get funky processing of '%param;'
2136         // references.  It's not clearly defined in the XML spec; but it
2137         // boils down to having those refs be _lexical_ in most cases to
2138         // include partial syntax productions.  It also needs selective
2139         // enabling; "<!ENTITY % foo ...>" must work, for example, and
2140         // if "bar" is an empty string PE, "ab%bar;cd" becomes "abcd"
2141         // if it's expanded in a literal, else "ab  cd".  PEs also do
2142         // not expand within comments or PIs, and external PEs are only
2143         // allowed to have markup decls (and so aren't handled lexically).
2144         //
2145         // This PE handling should be merged into maybeWhitespace, where
2146         // it can be dealt with more consistently.
2147         //
2148         // Also, there are some validity constraints in this area.
2149         //
2150         char c;
2151 
2152         while (in.isEOF()) {
2153             if (in.isInternal() || (doLexicalPE && !in.isDocument())) {
2154                 in = in.pop();
2155             } else {
2156                 fatal("P-064", new Object[]{in.getName()});
2157             }
2158         }
2159         if ((c = in.getc()) == '%' && doLexicalPE) {
2160             // PE ref ::= '%' name ';'
2161             String name = maybeGetName();
2162             Object entity;
2163 
2164             if (name == null) {
2165                 fatal("P-011");
2166             }
2167             nextChar(';', "F-021", name);
2168             entity = params.get(name);
2169 
2170             // push a magic "entity" before and after the
2171             // real one, so ungetc() behaves uniformly
2172             pushReader(" ".toCharArray(), null, false);
2173             if (entity instanceof InternalEntity) {
2174                 pushReader(((InternalEntity) entity).buf, name, false);
2175             } else if (entity instanceof ExternalEntity) // PEs can't be unparsed!

2176             // XXX if this returns false ...
2177             {
2178                 pushReader((ExternalEntity) entity);
2179             } else if (entity == null) // see note in maybePEReference re making this be nonfatal.
2180             {
2181                 fatal("V-022");
2182             } else {
2183                 throw new InternalError();
2184             }
2185             pushReader(" ".toCharArray(), null, false);
2186             return in.getc();
2187         }
2188         return c;
2189     }
2190 
2191     private void ungetc() {
2192 
2193         in.ungetc();
2194     }
2195 
2196     private boolean peek(String s)
2197             throws IOException, SAXException {
2198 
2199         return in.peek(s, null);
2200     }
2201 
2202     // Return the entity starting the specified declaration
2203     // (for validating declaration nesting) else null.

2204     private InputEntity peekDeclaration(String s)
2205             throws IOException, SAXException {
2206 
2207         InputEntity start;
2208 
2209         if (!in.peekc('<')) {
2210             return null;
2211         }
2212         start = in;
2213         if (in.peek(s, null)) {
2214             return start;
2215         }
2216         in.ungetc();
2217         return null;
2218     }
2219 
2220     private void nextChar(char c, String location, String near)
2221             throws IOException, SAXException {
2222 
2223         while (in.isEOF() && !in.isDocument()) {
2224             in = in.pop();
2225         }
2226         if (!in.peekc(c)) {
2227             fatal("P-008", new Object[]{Character.valueOf(c),
2228                         messages.getMessage(locale, location),
2229                         (near == null ? "" : ('"' + near + '"'))});
2230         }
2231     }
2232 
2233     private void pushReader(char buf[], String name, boolean isGeneral)

2234             throws SAXException {
2235 
2236         InputEntity r = InputEntity.getInputEntity(dtdHandler, locale);
2237         r.init(buf, name, in, !isGeneral);
2238         in = r;
2239     }
2240 
2241     private boolean pushReader(ExternalEntity next)
2242             throws IOException, SAXException {
2243 
2244         InputEntity r = InputEntity.getInputEntity(dtdHandler, locale);
2245         InputSource s;
2246         try {
2247             s = next.getInputSource(resolver);
2248         } catch (IOException e) {
2249             String msg =
2250                     "unable to open the external entity from :" + next.systemId;
2251             if (next.publicId != null) {
2252                 msg += " (public id:" + next.publicId + ")";
2253             }
2254 
2255             SAXParseException spe = new SAXParseException(msg,
2256                     getPublicId(), getSystemId(), getLineNumber(), getColumnNumber(), e);
2257             dtdHandler.fatalError(spe);
2258             throw e;
2259         }
2260 
2261         r.init(s, next.name, in, next.isPE);
2262         in = r;
2263         return true;
2264     }
2265 
2266     public String getPublicId() {
2267 
2268         return (in == null) ? null : in.getPublicId();
2269     }
2270 
2271     public String getSystemId() {
2272 
2273         return (in == null) ? null : in.getSystemId();
2274     }
2275 
2276     public int getLineNumber() {
2277 
2278         return (in == null) ? -1 : in.getLineNumber();
2279     }
2280 
2281     public int getColumnNumber() {
2282 
2283         return (in == null) ? -1 : in.getColumnNumber();
2284     }
2285 
2286     // error handling convenience routines
2287     private void warning(String messageId, Object parameters[])

2288             throws SAXException {
2289 
2290         SAXParseException e = new SAXParseException(messages.getMessage(locale, messageId, parameters),
2291                 getPublicId(), getSystemId(), getLineNumber(), getColumnNumber());
2292 
2293         dtdHandler.warning(e);
2294     }
2295 
2296     void error(String messageId, Object parameters[])
2297             throws SAXException {
2298 
2299         SAXParseException e = new SAXParseException(messages.getMessage(locale, messageId, parameters),
2300                 getPublicId(), getSystemId(), getLineNumber(), getColumnNumber());
2301 
2302         dtdHandler.error(e);
2303     }
2304 
2305     private void fatal(String messageId) throws SAXException {
2306 
2307         fatal(messageId, null);
2308     }
2309 
2310     private void fatal(String messageId, Object parameters[])
2311             throws SAXException {
2312 
2313         SAXParseException e = new SAXParseException(messages.getMessage(locale, messageId, parameters),
2314                 getPublicId(), getSystemId(), getLineNumber(), getColumnNumber());
2315 
2316         dtdHandler.fatalError(e);
2317 
2318         throw e;
2319     }
2320 
2321     //
2322     // Map char arrays to strings ... cuts down both on memory and
2323     // CPU usage for element/attribute/other names that are reused.
2324     //
2325     // Documents typically repeat names a lot, so we more or less
2326     // intern all the strings within the document; since some strings
2327     // are repeated in multiple documents (e.g. stylesheets) we go
2328     // a bit further, and intern globally.
2329     //
2330     static class NameCache {
2331         //
2332         // Unless we auto-grow this, the default size should be a
2333         // reasonable bit larger than needed for most XML files
2334         // we've yet seen (and be prime).  If it's too small, the
2335         // penalty is just excess cache collisions.
2336         //
2337 
2338         NameCacheEntry hashtable[] = new NameCacheEntry[541];
2339 
2340         //
2341         // Usually we just want to get the 'symbol' for these chars
2342         //
2343         String lookup(char value[], int len) {
2344 
2345             return lookupEntry(value, len).name;
2346         }
2347 
2348         //
2349         // Sometimes we need to scan the chars in the resulting
2350         // string, so there's an accessor which exposes them.
2351         // (Mostly for element end tags.)
2352         //
2353         NameCacheEntry lookupEntry(char value[], int len) {
2354 
2355             int index = 0;
2356             NameCacheEntry entry;
2357 
2358             // hashing to get index
2359             for (int i = 0; i < len; i++) {
2360                 index = index * 31 + value[i];
2361             }
2362             index &= 0x7fffffff;
2363             index %= hashtable.length;
2364 
2365             // return entry if one's there ...
2366             for (entry = hashtable[index];
2367                     entry != null;
2368                     entry = entry.next) {
2369                 if (entry.matches(value, len)) {
2370                     return entry;
2371                 }
2372             }
2373 
2374             // else create new one
2375             entry = new NameCacheEntry();
2376             entry.chars = new char[len];
2377             System.arraycopy(value, 0, entry.chars, 0, len);
2378             entry.name = new String(entry.chars);
2379             //
2380             // NOTE:  JDK 1.1 has a fixed size string intern table,
2381             // with non-GC'd entries.  It can panic here; that's a
2382             // JDK problem, use 1.2 or later with many identifiers.
2383             //
2384             entry.name = entry.name.intern();        // "global" intern
2385             entry.next = hashtable[index];
2386             hashtable[index] = entry;
2387             return entry;
2388         }
2389     }
2390 
2391     static class NameCacheEntry {
2392 
2393         String name;
2394         char chars[];
2395         NameCacheEntry next;
2396 
2397         boolean matches(char value[], int len) {
2398             if (chars == null || chars.length != len) {

2399                 return false;
2400             }
2401             for (int i = 0; i < len; i++) {
2402                 if (value[i] != chars[i]) {
2403                     return false;
2404                 }
2405             }
2406             return true;
2407         }
2408     }
2409 
2410     //
2411     // Message catalog for diagnostics.
2412     //
2413     static final Catalog messages = new Catalog();
2414 
2415     static final class Catalog extends MessageCatalog {
2416 
2417         Catalog() {
2418             super(DTDParser.class);
2419         }
2420     }

2421 }
--- EOF ---