home *** CD-ROM | disk | FTP | other *** search
/ Online Today 2000 January / Onto0100.iso / pc / JAVA / MSJAVX86.EXE / xmldso.cab / com / ms / xml / parser / Parser.class (.txt) < prev    next >
Encoding:
Java Class File  |  1998-11-05  |  31.8 KB  |  2,234 lines
  1. package com.ms.xml.parser;
  2.  
  3. import com.ms.xml.om.Element;
  4. import com.ms.xml.om.ElementFactory;
  5. import com.ms.xml.util.Atom;
  6. import com.ms.xml.util.EnumWrapper;
  7. import com.ms.xml.util.Name;
  8. import com.ms.xml.util.XMLInputStream;
  9. import com.ms.xml.util.XMLOutputStream;
  10. import java.io.BufferedInputStream;
  11. import java.io.IOException;
  12. import java.io.InputStream;
  13. import java.io.OutputStream;
  14. import java.io.PrintStream;
  15. import java.net.URL;
  16. import java.util.Hashtable;
  17. import java.util.Vector;
  18.  
  19. public class Parser {
  20.    static final int TAGSTART = 60;
  21.    static final int TAGEND = 62;
  22.    static final int SLASH = 47;
  23.    // $FF: renamed from: EQ int
  24.    static final int field_0 = 61;
  25.    static final int LPAREN = 40;
  26.    static final int RPAREN = 41;
  27.    static final int BANG = 33;
  28.    static final int QMARK = 63;
  29.    static final int DASH = 45;
  30.    static final int PERCENT = 37;
  31.    static final int AMP = 38;
  32.    static final int LEFTSQB = 91;
  33.    static final int RIGHTSQB = 93;
  34.    static final int QUOTE = 39;
  35.    // $FF: renamed from: OR int
  36.    static final int field_1 = 124;
  37.    static final int ASTERISK = 42;
  38.    static final int PLUS = 43;
  39.    static final int HASH = 35;
  40.    static final int COMMA = 44;
  41.    static final int INVALIDTOKEN = 0;
  42.    static final int EOF = -1;
  43.    static final int WHITESPACE = -2;
  44.    static final int WORDCHAR = -3;
  45.    static final int NAME = -4;
  46.    static final int TEXT = -5;
  47.    static final int PITAGSTART = -6;
  48.    static final int PITAGEND = -7;
  49.    static final int DECLTAGSTART = -8;
  50.    static final int CLOSETAGSTART = -9;
  51.    static final int EMPTYTAGEND = -10;
  52.    static final int COMMENT = -11;
  53.    static final int DOCTYPE = -12;
  54.    static final int SYSTEM = -13;
  55.    static final int CDATATAGSTART = -14;
  56.    static final int ELEMENT = -15;
  57.    static final int EMPTY = -16;
  58.    static final int ANY = -17;
  59.    static final int PCDATA = -18;
  60.    static final int ATTLIST = -19;
  61.    static final int CDATA = -20;
  62.    // $FF: renamed from: ID int
  63.    static final int field_2 = -21;
  64.    static final int IDREF = -22;
  65.    static final int IDREFS = -23;
  66.    static final int ENTITY = -24;
  67.    static final int ENTITIES = -25;
  68.    static final int NMTOKEN = -26;
  69.    static final int NMTOKENS = -27;
  70.    static final int NOTATION = -28;
  71.    static final int ENUMERATION = -29;
  72.    static final int FIXED = -30;
  73.    static final int REQUIRED = -31;
  74.    static final int IMPLIED = -32;
  75.    static final int NDATA = -33;
  76.    static final int INCLUDETAGSTART = -34;
  77.    static final int IGNORETAGSTART = -35;
  78.    static final int NAMESPACE = -36;
  79.    static final int EXTENDS = -37;
  80.    static final int IMPLEMENTS = -38;
  81.    static final int XML = -39;
  82.    static final int VERSION = -40;
  83.    static final int ENCODING = -41;
  84.    static final int STANDALONE = -42;
  85.    static final int CDEND = -43;
  86.    static final int PUBLIC = -100;
  87.    ElementFactory factory;
  88.    DTD dtd;
  89.    boolean validating;
  90.    Element root;
  91.    Vector contexts = new Vector(16);
  92.    int contextAt = 0;
  93.    Context current;
  94.    EntityReader reader;
  95.    XMLInputStream xmlIn;
  96.    boolean inTag;
  97.    boolean seenWS;
  98.    int lookahead;
  99.    char quote;
  100.    char[] chars = new char[8192];
  101.    int charAt;
  102.    char[] buf = new char[8192];
  103.    int bufAt;
  104.    int nameappend;
  105.    static Hashtable tokens;
  106.    int token;
  107.    int keyword;
  108.    int nouppercase;
  109.    int substitution;
  110.    int breakText;
  111.    int nametoken;
  112.    int simplename;
  113.    int inEntityRef;
  114.    boolean expandNamedEntities;
  115.    static boolean jdk11;
  116.    Name name;
  117.    String text;
  118.    URL url;
  119.    Name docType;
  120.    boolean internalSubset;
  121.    boolean caseInsensitive;
  122.    boolean firstLine = true;
  123.    static ElementDecl XMLDecl;
  124.    Name conditionRef;
  125.    boolean standAlone;
  126.    boolean loadexternal;
  127.    static int[] chartype = new int[256];
  128.    static char[] charupper = new char[256];
  129.    static final int FWHITESPACE = 1;
  130.    static final int FDIGIT = 2;
  131.    static final int FLETTER = 4;
  132.    static final int FMISCNAME = 8;
  133.    static final int FSTARTNAME = 16;
  134.    static final char nameSpaceSeparator = ':';
  135.    static boolean strict = false;
  136.    boolean shortendtags;
  137.    static Name nameComment = Name.create("--");
  138.    static Name nameCDATA = Name.create("[CDATA[");
  139.    static Name namePCDATA = Name.create("PCDATA");
  140.    static Name nameVERSION = Name.create("version");
  141.    static Name nameENCODING = Name.create("encoding");
  142.    static Name nameDOCTYPE = Name.create("DOCTYPE");
  143.    static Name nameXML = Name.create("xml");
  144.    static Name nameStandalone = Name.create("standalone");
  145.    static Name nameYes = Name.create("yes");
  146.    static Name nameNo = Name.create("no");
  147.    static Name nameURL = Name.create("URL");
  148.    static Name namePUBLICID = Name.create("PUBLICID");
  149.    static Name nameNAME = Name.create("NAME");
  150.    static Name nameXMLSpace = Name.create("xml-space", "xml");
  151.    static Name nameXMLSpace2 = Name.create("space", "xml");
  152.    static Name nameXMLAS = Name.create("prefix", "xml");
  153.    static Name nameXMLHREF = Name.create("src", "xml");
  154.    static Name nameXMLNS = Name.create("ns", "xml");
  155.    static Name nameXMLNameSpace = Name.create("namespace", "xml");
  156.    static Atom atomXML = Atom.create("xml");
  157.    static Name nameXMLLang = Name.create("lang", "xml");
  158.  
  159.    final String scanUrl() throws ParseException {
  160.       this.parseToken(39, "Url");
  161.       this.scanString(this.quote, 65535, 65535, 65535);
  162.       return this.text;
  163.    }
  164.  
  165.    final void parseAttributes(Element var1) throws ParseException {
  166.       boolean var2 = false;
  167.  
  168.       while(this.nextToken() == -4) {
  169.          Name var3 = this.name;
  170.          if (var3.getName().equals(nameXMLSpace.getName())) {
  171.             var3 = nameXMLSpace;
  172.             var2 = true;
  173.          }
  174.  
  175.          if (var1 != null && var1.getAttribute(var3) != null) {
  176.             this.error("An attribute cannot appear more than once in the same start tag");
  177.          }
  178.  
  179.          this.parseToken(61, "=");
  180.          if (var3 == nameXMLLang) {
  181.             this.parseToken(39, "string");
  182.             this.parseToken(-4, "lang code");
  183.             Name var4 = this.name;
  184.             this.parseToken(39, "string");
  185.             this.factory.parsedAttribute(var1, var3, var4.getName());
  186.          } else if (this.current.ed != null && var1 != null) {
  187.             this.current.ed.parseAttribute(var1, var3, this);
  188.          } else {
  189.             this.parseToken(39, "string");
  190.             this.scanString(this.quote, 38, 38, 60);
  191.             this.factory.parsedAttribute(var1, var3, this.text);
  192.          }
  193.       }
  194.  
  195.       if (var2) {
  196.          Object var5 = var1.getAttribute(nameXMLSpace);
  197.          if (var5 == null) {
  198.             var5 = var1.getAttribute(nameXMLSpace2);
  199.          }
  200.  
  201.          if (var5 != null) {
  202.             String var6 = null;
  203.             if (var5 instanceof String) {
  204.                var6 = (String)var5;
  205.             } else if (var5 instanceof Atom) {
  206.                var6 = var5.toString();
  207.             } else if (var5 instanceof Name) {
  208.                var6 = ((Name)var5).getName().toString();
  209.             }
  210.  
  211.             if (var6 != null && var6.equalsIgnoreCase("preserve")) {
  212.                this.current.preserveWS = true;
  213.             } else if (var6 != null && var6.equalsIgnoreCase("default")) {
  214.                this.current.preserveWS = false;
  215.             } else {
  216.                this.error("Invalid value '" + var6 + "' for xml-space attribute.");
  217.             }
  218.          }
  219.       }
  220.  
  221.       if (this.current.ed != null) {
  222.          this.current.ed.checkAttributes(var1, this);
  223.       }
  224.  
  225.    }
  226.  
  227.    public final void parse(URL var1, ElementFactory var2, DTD var3, Element var4, boolean var5, boolean var6) throws ParseException {
  228.       this.dtd = var3;
  229.       this.root = var4;
  230.       this.loadexternal = var6;
  231.       this.setURL(var1);
  232.       this.setFactory(var2);
  233.       this.caseInsensitive = var5;
  234.       this.safeParse();
  235.    }
  236.  
  237.    public final void parse(InputStream var1, ElementFactory var2, DTD var3, Element var4, boolean var5, boolean var6) throws ParseException {
  238.       this.dtd = var3;
  239.       this.url = null;
  240.       this.root = var4;
  241.       this.loadexternal = var6;
  242.       this.setInputStream(var1);
  243.       this.setFactory(var2);
  244.       this.caseInsensitive = var5;
  245.       this.safeParse();
  246.    }
  247.  
  248.    final ElementDecl createElementDecl(Vector var1) throws ParseException {
  249.       if (this.token != -4) {
  250.          this.error("Expected " + this.tokenString(-4) + " instead of " + this.tokenString(this.token));
  251.       }
  252.  
  253.       if (this.dtd.findElementDecl(this.name) != null) {
  254.          this.error("Element '" + this.name + "' already declared.");
  255.       }
  256.  
  257.       ElementDecl var2 = new ElementDecl(this.name);
  258.       this.current.lastWasWS = false;
  259.       this.dtd.addElementDecl(var2);
  260.       var1.addElement(var2);
  261.       return var2;
  262.    }
  263.  
  264.    final Element parseNameSpaceDecl(boolean var1, boolean var2) throws ParseException {
  265.       Element var3 = this.addNewElement(10, this.name, false, (String)null);
  266.       this.push(var3, this.name, 10);
  267.       this.parseAttributes(var3);
  268.       this.pop();
  269.       if (var2 && this.token != -7) {
  270.          this.error("Expected PI tag end '?>' instead of " + this.tokenString(this.token));
  271.       } else if (!var2 && this.token != -10) {
  272.          this.error("Expected " + this.tokenString(-10) + " instead of " + this.tokenString(this.token));
  273.       }
  274.  
  275.       Object var4 = var3.getAttribute(nameXMLAS);
  276.       Object var5 = var3.getAttribute(nameXMLHREF);
  277.       Object var6 = var3.getAttribute(nameXMLNS);
  278.       if (var4 == null || var6 == null) {
  279.          this.error("Missing attribute 'ns' or 'prefix'");
  280.       }
  281.  
  282.       Atom var9 = null;
  283.       Atom var7;
  284.       Atom var8;
  285.       if (this.caseInsensitive) {
  286.          var7 = Atom.create(var4.toString().toUpperCase());
  287.          var8 = Atom.create(var6.toString().toUpperCase());
  288.          if (var5 != null) {
  289.             var9 = Atom.create(var9.toString().toUpperCase());
  290.          }
  291.       } else {
  292.          var7 = Atom.create(var4.toString());
  293.          var8 = Atom.create(var6.toString());
  294.          if (var5 != null) {
  295.             var9 = Atom.create(var9.toString());
  296.          }
  297.       }
  298.  
  299.       if (DTD.isReservedNameSpace(var7)) {
  300.          this.error(var7.toString() + " is a reserved name space.");
  301.       }
  302.  
  303.       this.addNameSpace(var7, var8, var1);
  304.       if (this.loadexternal && var9 != null && this.dtd.findLoadedNameSpace(var9) == null) {
  305.          this.dtd.addLoadedNameSpace(var9);
  306.          this.loadDTD(var9.toString(), var9);
  307.       }
  308.  
  309.       return var3;
  310.    }
  311.  
  312.    public void setShortEndTags(boolean var1) {
  313.       this.shortendtags = var1;
  314.    }
  315.  
  316.    public final XMLOutputStream createOutputStream(OutputStream var1) {
  317.       return this.xmlIn != null ? this.xmlIn.createOutputStream(var1) : null;
  318.    }
  319.  
  320.    final Element finishPI() throws ParseException {
  321.       Element var1 = this.addNewElement(5, this.name, false, (String)null);
  322.       this.charAt = 0;
  323.       boolean var2 = false;
  324.  
  325.       while(this.lookahead != -1) {
  326.          this.chars[this.charAt++] = (char)this.lookahead;
  327.          if (this.lookahead == 63) {
  328.             this.advance();
  329.             if (this.lookahead == 62) {
  330.                this.charAt += -1;
  331.                var2 = true;
  332.             }
  333.          } else {
  334.             this.advance();
  335.          }
  336.  
  337.          if (this.charAt == this.chars.length || var2) {
  338.             this.push(var1, this.name, 5);
  339.             this.addNewElement(6, (Name)null, false, new String(this.chars, 0, this.charAt));
  340.             this.pop();
  341.             this.charAt = 0;
  342.             if (var2) {
  343.                break;
  344.             }
  345.          }
  346.       }
  347.  
  348.       this.parseToken(62, "PI end");
  349.       return var1;
  350.    }
  351.  
  352.    static final boolean isNameChar(char var0) {
  353.       if (var0 < 256) {
  354.          return (chartype[var0] & 14) != 0;
  355.       } else {
  356.          return Character.isLetter(var0) || Character.isDigit(var0) || var0 == '-' || var0 == '_' || var0 == '.';
  357.       }
  358.    }
  359.  
  360.    final void addChar() throws ParseException {
  361.       if (this.lookahead == -1) {
  362.          this.error("Unexpected EOF.");
  363.       }
  364.  
  365.       this.chars[this.charAt++] = (char)this.lookahead;
  366.       if (this.charAt == this.chars.length) {
  367.          this.addNewElement(1, (Name)null, true, new String(this.chars, 0, this.charAt));
  368.          this.charAt = 0;
  369.       }
  370.  
  371.       this.advance();
  372.    }
  373.  
  374.    final char toUpperCase(char var1) {
  375.       if (this.nouppercase != 0) {
  376.          return var1;
  377.       } else {
  378.          return var1 < 256 ? charupper[var1] : Character.toUpperCase(var1);
  379.       }
  380.    }
  381.  
  382.    final void scanCharRef() throws ParseException {
  383.       int var1 = 0;
  384.       if (this.lookahead == 35) {
  385.          this.advance();
  386.          if (this.lookahead != 120 && this.lookahead != 88) {
  387.             while(this.lookahead >= 48 && this.lookahead <= 57) {
  388.                var1 = var1 * 10 + this.lookahead - 48;
  389.                this.advance();
  390.             }
  391.          } else {
  392.             this.advance();
  393.  
  394.             while(true) {
  395.                if (this.lookahead >= 48 && this.lookahead <= 57) {
  396.                   var1 = var1 * 16 + this.lookahead - 48;
  397.                } else if (this.lookahead >= 97 && this.lookahead <= 102) {
  398.                   var1 = var1 * 16 + this.lookahead - 97 + 10;
  399.                } else {
  400.                   if (this.lookahead < 65 || this.lookahead > 70) {
  401.                      break;
  402.                   }
  403.  
  404.                   var1 = var1 * 16 + this.lookahead - 65 + 10;
  405.                }
  406.  
  407.                this.advance();
  408.             }
  409.          }
  410.       }
  411.  
  412.       if (this.lookahead != 59) {
  413.          this.error("Bad character reference syntax. Expecting &#xx;");
  414.       } else {
  415.          this.chars[this.charAt++] = (char)var1;
  416.       }
  417.  
  418.       this.advance();
  419.    }
  420.  
  421.    private final void setFactory(ElementFactory var1) {
  422.       this.factory = var1;
  423.    }
  424.  
  425.    final void scanText(int var1, int var2, boolean var3) throws ParseException {
  426.       this.charAt = 0;
  427.  
  428.       while(this.lookahead != -1 && this.lookahead != 60 && this.lookahead != this.breakText && this.charAt + 1 < this.chars.length) {
  429.          if (this.lookahead == var2) {
  430.             if (this.seenWS) {
  431.                this.chars[this.charAt++] = ' ';
  432.                this.seenWS = false;
  433.             }
  434.  
  435.             this.advance();
  436.             if (this.lookahead == 35) {
  437.                this.scanCharRef();
  438.             } else if (isNameChar((char)this.lookahead)) {
  439.                this.scanEntityRef(false);
  440.             } else {
  441.                this.chars[this.charAt++] = (char)var2;
  442.             }
  443.          } else if (this.lookahead == var1) {
  444.             if (this.seenWS) {
  445.                this.chars[this.charAt++] = ' ';
  446.                this.seenWS = false;
  447.             }
  448.  
  449.             this.advance();
  450.             if (isNameChar((char)this.lookahead)) {
  451.                this.scanEntityRef(var1 == 37);
  452.             } else {
  453.                this.chars[this.charAt++] = (char)var2;
  454.             }
  455.          } else {
  456.             if (var3 && isWhiteSpaceChar((char)this.lookahead)) {
  457.                this.seenWS = true;
  458.             } else {
  459.                if (this.seenWS) {
  460.                   this.chars[this.charAt++] = ' ';
  461.                   this.seenWS = false;
  462.                }
  463.  
  464.                this.chars[this.charAt++] = (char)this.lookahead;
  465.             }
  466.  
  467.             this.advance();
  468.          }
  469.       }
  470.  
  471.       this.token = -5;
  472.    }
  473.  
  474.    final void tryMisc() throws ParseException {
  475.       while(true) {
  476.          switch (this.token) {
  477.             case -11:
  478.                this.parseComment();
  479.                break;
  480.             case -10:
  481.             case -9:
  482.             case -8:
  483.             case -7:
  484.             default:
  485.                return;
  486.             case -6:
  487.                this.parsePI(true);
  488.          }
  489.  
  490.          if (this.lookahead == -1) {
  491.             this.token = -1;
  492.             return;
  493.          }
  494.  
  495.          this.nextToken();
  496.          this.firstLine = false;
  497.       }
  498.    }
  499.  
  500.    final String tokenString(int var1) {
  501.       return this.tokenString(var1, (String)null);
  502.    }
  503.  
  504.    final String tokenString(int var1, String var2) {
  505.       switch (var1) {
  506.          case -100:
  507.             return "PUBLIC";
  508.          case -43:
  509.             return "]]>";
  510.          case -36:
  511.             return "NAMESPACE";
  512.          case -35:
  513.             return "IGNORETAGSTART";
  514.          case -34:
  515.             return "INCLUDETAGSTART";
  516.          case -33:
  517.             return "NDATA";
  518.          case -32:
  519.             return "IMPLIED";
  520.          case -31:
  521.             return "REQUIRED";
  522.          case -30:
  523.             return "FIXED";
  524.          case -29:
  525.             return "ENUMERATION";
  526.          case -28:
  527.             return "NOTATION";
  528.          case -27:
  529.             return "NMTOKENS";
  530.          case -26:
  531.             return "NMTOKEN";
  532.          case -25:
  533.             return "ENTITIES";
  534.          case -24:
  535.             return "ENTITY";
  536.          case -23:
  537.             return "IDREFS";
  538.          case -22:
  539.             return "IDREF";
  540.          case -21:
  541.             return "ID";
  542.          case -20:
  543.             return "CDATA";
  544.          case -19:
  545.             return "ATTLIST";
  546.          case -18:
  547.             return "PCDATA";
  548.          case -17:
  549.             return "ANY";
  550.          case -16:
  551.             return "EMPTY";
  552.          case -15:
  553.             return "ELEMENT";
  554.          case -14:
  555.             return "<![CDATA";
  556.          case -13:
  557.             return "SYSTEM";
  558.          case -12:
  559.             return "DOCTYPE";
  560.          case -11:
  561.             return "<!--";
  562.          case -10:
  563.             return "/>";
  564.          case -9:
  565.             return "</";
  566.          case -8:
  567.             return "<!";
  568.          case -7:
  569.             return "?>";
  570.          case -6:
  571.             return "<?";
  572.          case -5:
  573.             return "TEXT '" + this.text + "'";
  574.          case -4:
  575.             if (var2 != null) {
  576.                return var2;
  577.             }
  578.  
  579.             return "NAME '" + this.name + "'";
  580.          case -3:
  581.             return "word character";
  582.          case -2:
  583.             return "whitespace";
  584.          case -1:
  585.             return "EOF";
  586.          case 0:
  587.             return "invalidtoken";
  588.          case 33:
  589.             return "!";
  590.          case 35:
  591.             return "#";
  592.          case 37:
  593.             return "percent(%)";
  594.          case 38:
  595.             return "&";
  596.          case 39:
  597.             return "quote(' or \")";
  598.          case 40:
  599.             return "(";
  600.          case 41:
  601.             return ")";
  602.          case 42:
  603.             return "*";
  604.          case 43:
  605.             return "+";
  606.          case 44:
  607.             return ",";
  608.          case 45:
  609.             return "-";
  610.          case 47:
  611.             return "/";
  612.          case 60:
  613.             return "start tag(<)";
  614.          case 61:
  615.             return "=";
  616.          case 62:
  617.             return "tag end(>)";
  618.          case 63:
  619.             return "question mark(?)";
  620.          case 91:
  621.             return "[";
  622.          case 93:
  623.             return "]";
  624.          case 124:
  625.             return "|";
  626.          default:
  627.             return var2;
  628.       }
  629.    }
  630.  
  631.    public final void loadDTD(String var1, Atom var2) throws ParseException {
  632.       try {
  633.          URL var3 = new URL(this.url, var1);
  634.          Parser var4 = new Parser();
  635.          var4.dtd = this.dtd;
  636.          var4.setURL(var3);
  637.          var4.setFactory(this.factory);
  638.          var4.caseInsensitive = this.caseInsensitive;
  639.          var4.loadexternal = this.loadexternal;
  640.          Element var5 = this.factory.createElement((Element)null, 0, nameDOCTYPE, (String)null);
  641.          var4.newContext(var5, (Name)null, 0, false, var2, this.current.spaceTable);
  642.          var4.parseInternalSubset();
  643.          this.validating = true;
  644.       } catch (IOException var6) {
  645.          this.error("Couldn't find external DTD '" + var1 + "'");
  646.       }
  647.    }
  648.  
  649.    private void reportMismatch(int var1, String var2) throws ParseException {
  650.       if (this.current.ed == null) {
  651.          this.error("Content mismatch. Stopped at state " + var1);
  652.       }
  653.  
  654.       Vector var3 = this.current.ed.expectedElements(var1);
  655.       this.error(var2 + "  Expected elements " + var3);
  656.    }
  657.  
  658.    final int scanSimpleName(int var1, String var2) throws ParseException {
  659.       boolean var3;
  660.       if (this.lookahead < 256) {
  661.          var3 = (chartype[this.lookahead] & 20) != 0;
  662.       } else {
  663.          var3 = Character.isLetter((char)this.lookahead) || this.lookahead == 95;
  664.       }
  665.  
  666.       if (!var3 && (this.nametoken <= 0 || !Character.isDigit((char)this.lookahead))) {
  667.          this.error("Expecting " + var2 + " instead of '" + (char)this.lookahead + "'");
  668.       }
  669.  
  670.       if (this.nametoken == 0 && this.simplename == 0) {
  671.          if (this.caseInsensitive) {
  672.             this.buf[var1++] = this.toUpperCase((char)this.lookahead);
  673.             this.advance();
  674.  
  675.             while(isNameChar((char)this.lookahead)) {
  676.                this.buf[var1++] = this.toUpperCase((char)this.lookahead);
  677.                this.advance();
  678.             }
  679.          } else {
  680.             this.buf[var1++] = (char)this.lookahead;
  681.             this.advance();
  682.  
  683.             while(isNameChar((char)this.lookahead)) {
  684.                this.buf[var1++] = (char)this.lookahead;
  685.                this.advance();
  686.             }
  687.          }
  688.       } else if (this.caseInsensitive) {
  689.          this.buf[var1++] = this.toUpperCase((char)this.lookahead);
  690.          this.advance();
  691.  
  692.          while(isNameChar((char)this.lookahead) || this.lookahead == 58) {
  693.             this.buf[var1++] = this.toUpperCase((char)this.lookahead);
  694.             this.advance();
  695.          }
  696.       } else {
  697.          this.buf[var1++] = (char)this.lookahead;
  698.          this.advance();
  699.  
  700.          while(isNameChar((char)this.lookahead) || this.lookahead == 58) {
  701.             this.buf[var1++] = (char)this.lookahead;
  702.             this.advance();
  703.          }
  704.       }
  705.  
  706.       return var1;
  707.    }
  708.  
  709.    final void parseEntityDecl() throws ParseException {
  710.       boolean var1 = false;
  711.       ++this.nouppercase;
  712.       if (this.nextToken() == 37) {
  713.          var1 = true;
  714.          this.parseToken(-4, "Entity name");
  715.       } else if (this.token != -4) {
  716.          this.error("Expected entity name instead of " + this.tokenString(this.token));
  717.       }
  718.  
  719.       this.nouppercase += -1;
  720.       Entity var2 = this.dtd.findEntity(this.name);
  721.       if (var2 != null) {
  722.          System.err.println("Warning: Entity '" + this.name + "' already defined, using the first definition.");
  723.          var2 = new Entity(this.name, var1);
  724.       } else {
  725.          var2 = new Entity(this.name, var1);
  726.          this.dtd.addEntity(var2);
  727.          if (this.internalSubset) {
  728.             if (this.current.e != null) {
  729.                this.current.e.addChild(var2, (Element)null);
  730.             }
  731.  
  732.             this.current.lastWasWS = false;
  733.          }
  734.       }
  735.  
  736.       this.push(var2, this.name, 7);
  737.       this.parseKeyword(0, "String or SYSTEM");
  738.       if (this.token == -100) {
  739.          this.parseKeyword(0, "String");
  740.          if (this.token == 39) {
  741.             this.expandNamedEntities = false;
  742.             this.scanString(this.quote, 65535, 65535, 65535);
  743.             this.expandNamedEntities = true;
  744.             var2.pubid = this.text;
  745.             this.token = -13;
  746.          } else {
  747.             this.error("Expected " + this.tokenString(39) + " instead of " + this.tokenString(this.token));
  748.          }
  749.       }
  750.  
  751.       switch (this.token) {
  752.          case -13:
  753.             var2.setURL(this.scanUrl());
  754.             this.parseKeyword(0, "ndata");
  755.             if (this.token == -33) {
  756.                this.parseToken(-4, "ndata name");
  757.                Notation var6 = this.dtd.findNotation(this.name);
  758.                if (var6 == null) {
  759.                   this.error("Notation: " + this.name + " has not been declared yet");
  760.                }
  761.  
  762.                var2.setNDATA(this.name);
  763.                this.nextToken();
  764.             }
  765.             break;
  766.          case 39:
  767.             int var3 = this.reader.line;
  768.             int var4 = this.reader.column;
  769.             this.expandNamedEntities = false;
  770.             this.scanString(this.quote, 37, 38, 65535);
  771.             this.expandNamedEntities = true;
  772.             var2.setText(this.text);
  773.             var2.setPosition(var3, var4);
  774.             this.nextToken();
  775.             break;
  776.          default:
  777.             this.error("Expected " + this.tokenString(39) + " or " + this.tokenString(-13) + " instead of " + this.tokenString(this.token));
  778.       }
  779.  
  780.       this.checkToken(62, ">");
  781.       this.pop();
  782.    }
  783.  
  784.    final void checkToken(int var1, String var2) throws ParseException {
  785.       if (this.token != var1) {
  786.          this.error("Expected " + this.tokenString(var1, var2) + " instead of " + this.tokenString(this.token));
  787.       }
  788.  
  789.    }
  790.  
  791.    final void tryDocTypeDecl() throws ParseException {
  792.       if (this.token == -8) {
  793.          this.firstLine = false;
  794.          this.parseKeyword(-12, "Doctype");
  795.          Element var1 = this.addNewElement(4, nameDOCTYPE, false, (String)null);
  796.          this.parseToken(-4, "Doctype name");
  797.          this.docType = this.name;
  798.          this.dtd.docType = this.name;
  799.          this.factory.parsedAttribute(var1, nameNAME, this.docType);
  800.          this.parseKeyword(0, "ExternalID");
  801.          String var2 = null;
  802.          switch (this.token) {
  803.             case -100:
  804.                this.parseKeyword(0, "String");
  805.                if (this.token == 39) {
  806.                   this.expandNamedEntities = false;
  807.                   this.scanString(this.quote, 65535, 65535, 65535);
  808.                   this.expandNamedEntities = true;
  809.                   this.factory.parsedAttribute(var1, namePUBLICID, this.text);
  810.                } else {
  811.                   this.error("Expected " + this.tokenString(39) + " instead of " + this.tokenString(this.token));
  812.                }
  813.  
  814.                var2 = this.scanUrl();
  815.                this.factory.parsedAttribute(var1, nameURL, var2);
  816.                this.nextToken();
  817.                break;
  818.             case -13:
  819.                var2 = this.scanUrl();
  820.                this.factory.parsedAttribute(var1, nameURL, var2);
  821.                this.nextToken();
  822.          }
  823.  
  824.          if (this.token == 91) {
  825.             this.inTag = false;
  826.             this.breakText = 93;
  827.             this.internalSubset = true;
  828.             this.push(var1, nameDOCTYPE, 4);
  829.             this.parseInternalSubset();
  830.             if (this.token != 93) {
  831.                this.error("Expected " + this.tokenString(93));
  832.             }
  833.  
  834.             this.inTag = true;
  835.             this.internalSubset = false;
  836.             this.breakText = 0;
  837.             this.pop();
  838.             this.nextToken();
  839.          }
  840.  
  841.          if (var2 != null && this.loadexternal) {
  842.             this.loadDTD(var2.toString(), (Atom)null);
  843.          }
  844.  
  845.          if (this.token != 62) {
  846.             this.error("Expected " + this.tokenString(62) + " instead of " + this.tokenString(this.token));
  847.          }
  848.  
  849.          if (this.lookahead != -1) {
  850.             this.nextToken();
  851.          }
  852.       }
  853.  
  854.    }
  855.  
  856.    final void parseElementDecl() throws ParseException {
  857.       Vector var1 = new Vector();
  858.       this.nextToken();
  859.       ElementDecl var2 = this.createElementDecl(var1);
  860.       if (this.internalSubset && this.current.e != null) {
  861.          this.current.e.addChild(var2, (Element)null);
  862.       }
  863.  
  864.       this.push(var2, this.name, 9);
  865.       var2.parseModel(this);
  866.       this.checkToken(62, ">");
  867.       this.pop();
  868.    }
  869.  
  870.    final void parseNotation() throws ParseException {
  871.       this.parseToken(-4, "Notation name");
  872.       Notation var1 = this.dtd.findNotation(this.name);
  873.       if (var1 != null) {
  874.          this.error("Notation already declared " + this.name);
  875.       }
  876.  
  877.       var1 = new Notation(this.name);
  878.       this.dtd.addNotation(var1);
  879.       if (this.internalSubset) {
  880.          if (this.current.e != null) {
  881.             this.current.e.addChild(var1, (Element)null);
  882.          }
  883.  
  884.          this.current.lastWasWS = false;
  885.       }
  886.  
  887.       this.push(var1, this.name, 8);
  888.       this.parseKeyword(0, "SYSTEM or PUBLIC");
  889.       if (this.token != -13 && this.token != -100) {
  890.          this.error("Expected " + this.tokenString(-13) + " or " + this.tokenString(-100) + " instead of " + this.tokenString(this.token));
  891.       }
  892.  
  893.       var1.type = this.token;
  894.       if (var1.type == -100) {
  895.          this.parseKeyword(0, "String");
  896.          if (this.token == 39) {
  897.             this.expandNamedEntities = false;
  898.             this.scanString(this.quote, 65535, 65535, 65535);
  899.             this.expandNamedEntities = true;
  900.             var1.pubid = this.text;
  901.          } else {
  902.             this.error("Expected " + this.tokenString(39) + " instead of " + this.tokenString(this.token));
  903.          }
  904.       }
  905.  
  906.       var1.setURL(this.scanUrl());
  907.       this.parseToken(62, ">");
  908.       this.pop();
  909.    }
  910.  
  911.    final void parseToken(int var1, String var2) throws ParseException {
  912.       if (this.nextToken() != var1) {
  913.          this.error("Expected " + this.tokenString(var1, var2) + " instead of " + this.tokenString(this.token));
  914.       }
  915.  
  916.    }
  917.  
  918.    final Element addNewElement(int var1, Name var2, boolean var3, String var4) throws ParseException {
  919.       if (var1 == 12) {
  920.          this.current.lastWasWS = true;
  921.       } else {
  922.          this.current.lastWasWS = false;
  923.       }
  924.  
  925.       Element var5 = this.factory.createElement(this.current.e, var1, var2, var4);
  926.       if (var3 && var5 != null) {
  927.          Context var6 = this.current;
  928.          if (this.current.parent != null) {
  929.             var6 = this.current.parent;
  930.          }
  931.  
  932.          if (var6.ed != null) {
  933.             var6.ed.checkContent(var6, var5, this);
  934.          }
  935.       }
  936.  
  937.       return var5;
  938.    }
  939.  
  940.    final void parseElement() throws ParseException {
  941.       boolean var1 = false;
  942.  
  943.       while(true) {
  944.          if (var1 && this.token != -9) {
  945.             this.error("Expected " + this.tokenString(-9) + " instead of " + this.tokenString(this.token));
  946.          }
  947.  
  948.          var1 = false;
  949.          switch (this.token) {
  950.             case -14:
  951.                this.parseCDATA();
  952.                break;
  953.             case -11:
  954.                this.parseComment();
  955.                break;
  956.             case -9:
  957.                if (!this.current.matched) {
  958.                   this.reportMismatch(this.current.state, this.current.e.getTagName().getName() + " is not complete.");
  959.                }
  960.  
  961.                if (!this.shortendtags || this.lookahead != 62) {
  962.                   if (this.lookahead == 47) {
  963.                      this.advance();
  964.                   } else {
  965.                      Context var4 = this.current;
  966.                      this.current = (Context)this.contexts.elementAt(this.contextAt - 1);
  967.                      this.scanName("element close tag");
  968.                      this.current = var4;
  969.                      if (this.name != this.current.tagName) {
  970.                         this.error("Close tag " + this.name + " does not match start tag " + this.current.e.getTagName());
  971.                      }
  972.                   }
  973.                }
  974.  
  975.                this.parseToken(62, ">");
  976.                this.factory.parsed(this.current.e);
  977.                this.pop();
  978.                break;
  979.             case -6:
  980.                this.parsePI(false);
  981.                break;
  982.             case -5:
  983.                this.parseText(38, 38);
  984.                break;
  985.             case -1:
  986.                if (this.contextAt == 1) {
  987.                   this.error("Expected the end of root element instead of end of file.");
  988.                   break;
  989.                }
  990.             default:
  991.                this.error("Bad token in element content: " + this.tokenString(this.token));
  992.                break;
  993.             case 60:
  994.                this.scanName("element tag");
  995.                ElementDecl var2 = null;
  996.                Element var3 = this.addNewElement(0, this.name, true, (String)null);
  997.                this.push(var3, this.name, 0);
  998.                if (this.validating) {
  999.                   var2 = this.dtd.findElementDecl(this.name);
  1000.                   if (var2 != null) {
  1001.                      if (var2.getContent().type == 1) {
  1002.                         var1 = true;
  1003.                      }
  1004.  
  1005.                      var2.initContent(this.current, this);
  1006.                   } else {
  1007.                      this.error("Element '" + this.name + "' used but not declared in the DTD.");
  1008.                   }
  1009.                } else {
  1010.                   this.current.matched = true;
  1011.                }
  1012.  
  1013.                this.parseAttributes(var3);
  1014.                if (this.token == -10) {
  1015.                   if (var2 != null && !var2.acceptEmpty(this.current)) {
  1016.                      this.reportMismatch(0, var2.name.getName() + " cannot be empty.");
  1017.                   }
  1018.  
  1019.                   this.factory.parsed(this.current.e);
  1020.                   this.pop();
  1021.                   var1 = false;
  1022.                } else if (this.token != 62) {
  1023.                   this.error("Expected " + this.tokenString(62) + " instead of " + this.tokenString(this.token));
  1024.                } else if (this.lookahead != 60 && var1) {
  1025.                   this.error("Expected " + this.tokenString(62) + " instead of '" + (char)this.lookahead + "'");
  1026.                }
  1027.          }
  1028.  
  1029.          if (this.contextAt == 0) {
  1030.             return;
  1031.          }
  1032.  
  1033.          this.nextToken();
  1034.       }
  1035.    }
  1036.  
  1037.    final void parseRootElement() throws ParseException {
  1038.       if (this.token != 60) {
  1039.          this.error("Start of root element expected instead of " + this.tokenString(this.token));
  1040.       }
  1041.  
  1042.       this.scanName("element tag");
  1043.       if (this.docType != null && this.name != this.docType) {
  1044.          this.error("Root element name must match the DOCTYPE name");
  1045.       }
  1046.  
  1047.       if (this.name == nameXMLNameSpace) {
  1048.          this.parseNameSpaceDecl(false, false);
  1049.       } else {
  1050.          ElementDecl var1 = null;
  1051.          Element var2 = this.addNewElement(0, this.name, false, (String)null);
  1052.          this.push(var2, this.name, 0);
  1053.          boolean var3 = false;
  1054.          if (this.validating) {
  1055.             var1 = this.dtd.findElementDecl(this.name);
  1056.             if (var1 != null) {
  1057.                if (var1.getContent().type == 1) {
  1058.                   var3 = true;
  1059.                }
  1060.  
  1061.                var1.initContent(this.current, this);
  1062.             } else {
  1063.                this.error("Element '" + this.name + "' used but not declared in the DTD.");
  1064.             }
  1065.          } else {
  1066.             this.current.matched = true;
  1067.          }
  1068.  
  1069.          this.parseAttributes(var2);
  1070.          if (this.token == -10) {
  1071.             if (var1 != null && !var1.acceptEmpty(this.current)) {
  1072.                this.reportMismatch(0, "Root element " + var2.getTagName().getName() + " cannot be empty.");
  1073.             }
  1074.  
  1075.             var3 = true;
  1076.          } else if (this.token != 62) {
  1077.             if (var2.getAttributes() == EnumWrapper.emptyEnumeration) {
  1078.                this.error("No attribute is declared for element '" + var2.getTagName() + "', expected " + this.tokenString(62));
  1079.             }
  1080.  
  1081.             this.error("Expected " + this.tokenString(62) + " instead of " + this.tokenString(this.token));
  1082.          }
  1083.  
  1084.          if (var3) {
  1085.             this.pop();
  1086.             this.nextToken();
  1087.          } else {
  1088.             this.nextToken();
  1089.             this.parseElement();
  1090.          }
  1091.       }
  1092.    }
  1093.  
  1094.    final void parseContent(Element var1) throws ParseException {
  1095.       while(this.nextToken() != -9) {
  1096.          switch (this.token) {
  1097.             case -14:
  1098.                this.parseCDATA();
  1099.                break;
  1100.             case -11:
  1101.                this.parseComment();
  1102.                break;
  1103.             case -8:
  1104.                this.parseElement();
  1105.                break;
  1106.             case -6:
  1107.                this.parsePI(false);
  1108.                break;
  1109.             case -5:
  1110.                this.parseText(38, 38);
  1111.                break;
  1112.             case 60:
  1113.                this.parseElement();
  1114.                break;
  1115.             default:
  1116.                this.error("Bad token in element content: " + this.tokenString(this.token));
  1117.          }
  1118.       }
  1119.  
  1120.       if (!this.current.matched) {
  1121.          this.error("Content mismatch, stopped at state " + this.current.state);
  1122.       }
  1123.  
  1124.       if (this.lookahead != 62) {
  1125.          this.scanName("element close tag");
  1126.          if (this.name != this.current.e.getTagName()) {
  1127.             this.error("Close tag mismatch: " + this.name + " instead of " + this.current.e.getTagName());
  1128.          }
  1129.       }
  1130.  
  1131.       this.parseToken(62, ">");
  1132.    }
  1133.  
  1134.    final void error(String var1) throws ParseException {
  1135.       int var2 = 1;
  1136.       if (this.token == -4) {
  1137.          var2 = this.name.toString().length();
  1138.       }
  1139.  
  1140.       throw new ParseException(var1, this.reader.line, this.reader.column - 1 - var2, this.reader.owner);
  1141.    }
  1142.  
  1143.    static final boolean isWhiteSpaceChar(char var0) {
  1144.       if (var0 < 256) {
  1145.          return (chartype[var0] & 1) != 0;
  1146.       } else {
  1147.          return jdk11 ? Character.isWhitespace(var0) : Character.isSpace(var0);
  1148.       }
  1149.    }
  1150.  
  1151.    final void parseDocument() throws ParseException {
  1152.       this.expandNamedEntities = true;
  1153.       this.internalSubset = false;
  1154.       this.seenWS = false;
  1155.       this.contextAt = 0;
  1156.       this.standAlone = false;
  1157.       this.validating = false;
  1158.       this.newContext(this.root, (Name)null, 0, false, (Atom)null, (Hashtable)null);
  1159.       this.parseProlog();
  1160.       this.parseRootElement();
  1161.       if (this.lookahead != -1) {
  1162.          this.nextToken();
  1163.          this.tryMisc();
  1164.          if (this.lookahead != -1) {
  1165.             this.error("Expected comments, PI, or EOF instead of " + this.tokenString(this.token));
  1166.          }
  1167.       }
  1168.  
  1169.       this.dtd.checkIDs();
  1170.    }
  1171.  
  1172.    final void parseIgnoreSectContent() throws ParseException {
  1173.       boolean var1 = false;
  1174.  
  1175.       while(this.lookahead != 93) {
  1176.          switch (this.lookahead) {
  1177.             case 34:
  1178.             case 39:
  1179.                int var2 = this.lookahead;
  1180.                this.addChar();
  1181.  
  1182.                while(this.lookahead != var2) {
  1183.                   this.checkCDEND(false);
  1184.                   this.addChar();
  1185.                }
  1186.  
  1187.                this.addChar();
  1188.                break;
  1189.             case 60:
  1190.                this.addChar();
  1191.                switch (this.lookahead) {
  1192.                   case 33:
  1193.                      this.addChar();
  1194.                      switch (this.lookahead) {
  1195.                         case 45:
  1196.                            this.addChar();
  1197.                            if (this.lookahead != 45) {
  1198.                               this.error("Bad comment syntax. Expected '-'.");
  1199.                            }
  1200.  
  1201.                            this.addChar();
  1202.  
  1203.                            while(!var1) {
  1204.                               if (this.lookahead == 45) {
  1205.                                  this.addChar();
  1206.                                  if (this.lookahead == 45) {
  1207.                                     this.addChar();
  1208.                                     if (this.lookahead == 62) {
  1209.                                        this.addChar();
  1210.                                        var1 = true;
  1211.                                     } else {
  1212.                                        this.error("Bad comment syntax. Expected '>'.");
  1213.                                     }
  1214.                                  }
  1215.                               } else {
  1216.                                  this.addChar();
  1217.                               }
  1218.                            }
  1219.  
  1220.                            var1 = false;
  1221.                            continue;
  1222.                         case 91:
  1223.                            this.addChar();
  1224.                            this.parseIgnoreSectContent();
  1225.                            continue;
  1226.                         default:
  1227.                            this.addChar();
  1228.                            continue;
  1229.                      }
  1230.                   case 63:
  1231.                      this.addChar();
  1232.  
  1233.                      while(!var1) {
  1234.                         if (this.lookahead == 63) {
  1235.                            this.addChar();
  1236.                            if (this.lookahead == 62) {
  1237.                               this.addChar();
  1238.                               var1 = true;
  1239.                            }
  1240.                         } else {
  1241.                            this.addChar();
  1242.                         }
  1243.                      }
  1244.  
  1245.                      var1 = false;
  1246.                      continue;
  1247.                   default:
  1248.                      this.error("Bad character in IGNORE conditional section.");
  1249.                      continue;
  1250.                }
  1251.             default:
  1252.                this.addChar();
  1253.          }
  1254.       }
  1255.  
  1256.       this.checkCDEND(true);
  1257.    }
  1258.  
  1259.    private final void setInputStream(InputStream var1) throws ParseException {
  1260.       this.xmlIn = new XMLInputStream(var1);
  1261.       this.reader = new EntityReader(this.xmlIn, 1, 1, (EntityReader)null, this);
  1262.       this.advance();
  1263.    }
  1264.  
  1265.    public final void report(ParseException var1, OutputStream var2) {
  1266.       PrintStream var3 = new PrintStream(var2);
  1267.       String var4 = null;
  1268.       var3.println(((Throwable)var1).getMessage());
  1269.       if (var1.owner instanceof Parser) {
  1270.          URL var5 = ((Parser)var1.owner).url;
  1271.          if (var5 != null) {
  1272.             var4 = var5.toString();
  1273.          }
  1274.       } else if (var1.owner instanceof Entity) {
  1275.          var4 = "Parsing <" + ((Entity)var1.owner).name + ">";
  1276.       } else {
  1277.          var4 = "Parsing";
  1278.       }
  1279.  
  1280.       var3.println("Location: " + var4 + "(" + var1.line + "," + var1.column + ")");
  1281.       var3.print("Context: ");
  1282.  
  1283.       for(int var7 = 0; var7 < this.contextAt; ++var7) {
  1284.          Name var6 = ((Context)this.contexts.elementAt(var7)).e.getTagName();
  1285.          if (var6 != null) {
  1286.             var3.print("<" + var6 + ">");
  1287.          }
  1288.       }
  1289.  
  1290.       var3.print("<");
  1291.       if (this.current != null) {
  1292.          var3.print(this.current.e.getTagName());
  1293.       }
  1294.  
  1295.       var3.println(">");
  1296.    }
  1297.  
  1298.    void newContext(Element var1, Name var2, int var3, boolean var4, Atom var5, Hashtable var6) {
  1299.       if (this.contextAt == this.contexts.size()) {
  1300.          this.current = new Context(var1, var2, var3, var4, var5, var6);
  1301.          this.contexts.addElement(this.current);
  1302.       } else {
  1303.          this.current = (Context)this.contexts.elementAt(this.contextAt);
  1304.          this.current.reset(var1, var2, var3, var4, var5, var6);
  1305.       }
  1306.    }
  1307.  
  1308.    final int parseNames(Vector var1, int var2, StringBuffer var3) throws ParseException {
  1309.       int var4 = 0;
  1310.       this.bufAt = 0;
  1311.       if (var3 != null) {
  1312.          ++this.nameappend;
  1313.       }
  1314.  
  1315.       while(this.nextToken() == -4) {
  1316.          if (var4 > 0) {
  1317.             this.buf[this.bufAt++] = ' ';
  1318.          }
  1319.  
  1320.          var1.addElement(this.name);
  1321.          ++var4;
  1322.          if (var2 != 0 && this.nextToken() != 124) {
  1323.             break;
  1324.          }
  1325.       }
  1326.  
  1327.       if (var3 != null) {
  1328.          var3.append(this.buf, 0, this.bufAt);
  1329.          this.nameappend += -1;
  1330.       }
  1331.  
  1332.       return var4;
  1333.    }
  1334.  
  1335.    final void advance() throws ParseException {
  1336.       for(this.lookahead = this.reader.read(); this.lookahead == -1 && this.reader.owner != this; this.lookahead = this.reader.read()) {
  1337.          if (this.charAt != 0) {
  1338.             this.addPCDATA();
  1339.          }
  1340.  
  1341.          this.reader = this.reader.prev;
  1342.          this.pop();
  1343.          if (!this.inTag) {
  1344.             this.charAt = 0;
  1345.          }
  1346.       }
  1347.  
  1348.    }
  1349.  
  1350.    private void addNameSpace(Atom var1, Atom var2, boolean var3) throws ParseException {
  1351.       if (var1 == null || var2 == null) {
  1352.          this.error("Name space syntax error.");
  1353.       }
  1354.  
  1355.       if (DTD.isReservedNameSpace(var1)) {
  1356.          this.error(var1.toString() + " is a reserved name space.");
  1357.       }
  1358.  
  1359.       if (var3) {
  1360.          Atom var4 = this.dtd.findShortNameSpace(var2);
  1361.          if (var4 == null) {
  1362.             var4 = this.dtd.findLongNameSpace(var1);
  1363.             if (var4 != null) {
  1364.                this.error("Short reference '" + var1.toString() + "' is used by name space '" + var4.toString() + "'");
  1365.             }
  1366.  
  1367.             this.dtd.addNameSpace(var1, var2);
  1368.             return;
  1369.          }
  1370.  
  1371.          if (var4 != var1) {
  1372.             this.error("Cannot give two short references '" + var4.toString() + "' and '" + var1.toString() + "' to the same name space: '" + var2.toString() + "'");
  1373.             return;
  1374.          }
  1375.       } else {
  1376.          this.current.addNameSpace(var1, var2);
  1377.       }
  1378.  
  1379.    }
  1380.  
  1381.    final void safeParse() throws ParseException {
  1382.       try {
  1383.          this.parseDocument();
  1384.       } catch (ParseException var4) {
  1385.          if (this.xmlIn != null) {
  1386.             try {
  1387.                this.xmlIn.close();
  1388.             } catch (Exception var2) {
  1389.             }
  1390.          }
  1391.  
  1392.          throw var4;
  1393.       }
  1394.  
  1395.       try {
  1396.          this.xmlIn.close();
  1397.       } catch (Exception var3) {
  1398.       }
  1399.    }
  1400.  
  1401.    final Element addPCDATA() throws ParseException {
  1402.       if (this.charAt <= 0 && !this.seenWS) {
  1403.          this.seenWS = false;
  1404.          return null;
  1405.       } else {
  1406.          if (this.seenWS) {
  1407.             this.chars[this.charAt++] = ' ';
  1408.             this.seenWS = false;
  1409.          }
  1410.  
  1411.          this.text = new String(this.chars, 0, this.charAt);
  1412.          Element var1 = this.addNewElement(1, (Name)null, true, this.text);
  1413.          return var1;
  1414.       }
  1415.    }
  1416.  
  1417.    final void parseXMLDecl() throws ParseException {
  1418.       Element var1 = this.addNewElement(5, this.name, false, (String)null);
  1419.       this.push(var1, this.name, 5);
  1420.       ElementDecl var2 = this.current.ed;
  1421.       this.current.ed = XMLDecl;
  1422.       this.parseKeyword(-40, nameVERSION.toString());
  1423.       this.parseToken(61, "=");
  1424.       this.parseToken(39, "string");
  1425.       this.scanString(this.quote, 65535, 65535, 65535);
  1426.       if (!this.text.equals("1.0")) {
  1427.          this.error("Expected version 1.0 instead of " + this.text);
  1428.       }
  1429.  
  1430.       this.factory.parsedAttribute(var1, nameVERSION, this.text);
  1431.       this.parseKeyword(0, "encoding or standalone");
  1432.       String var3 = null;
  1433.       if (this.token == -41) {
  1434.          this.parseToken(61, "=");
  1435.          this.parseToken(39, "string");
  1436.          this.scanString(this.quote, 65535, 65535, 65535);
  1437.          this.factory.parsedAttribute(var1, nameENCODING, this.text);
  1438.          var3 = this.text;
  1439.          this.parseKeyword(0, nameStandalone.toString());
  1440.       }
  1441.  
  1442.       if (this.token == -42) {
  1443.          this.parseToken(61, "=");
  1444.          this.parseToken(39, "string");
  1445.          this.scanString(this.quote, 65535, 65535, 65535);
  1446.          if (this.caseInsensitive) {
  1447.             this.text = this.text.toUpperCase();
  1448.          }
  1449.  
  1450.          Name var4 = Name.create(this.text);
  1451.          if (var4 == nameYes) {
  1452.             this.standAlone = true;
  1453.          } else if (var4 == nameNo) {
  1454.             this.standAlone = false;
  1455.          } else {
  1456.             this.error("Expected 'yes' or 'no' instead of " + var4);
  1457.          }
  1458.  
  1459.          this.factory.parsedAttribute(var1, nameStandalone, var4.toString());
  1460.          this.nextToken();
  1461.       }
  1462.  
  1463.       if (var3 != null) {
  1464.          try {
  1465.             this.xmlIn.setEncoding(var3);
  1466.          } catch (IOException var5) {
  1467.             this.error("Unsupported XML encoding: \"" + var3 + "\"" + "\nLow level error: " + ((Throwable)var5).getMessage());
  1468.          }
  1469.       }
  1470.  
  1471.       if (this.token != -7) {
  1472.          this.error("Expected " + this.tokenString(-7) + " instead of " + this.tokenString(this.token));
  1473.       }
  1474.  
  1475.       this.current.ed = var2;
  1476.       this.pop();
  1477.    }
  1478.  
  1479.    final void parseProlog() throws ParseException {
  1480.       if (this.lookahead != -1) {
  1481.          this.nextToken();
  1482.          if (this.token == -6) {
  1483.             this.parseToken(-4, "PI tag");
  1484.             if (this.name == nameXML) {
  1485.                this.parseXMLDecl();
  1486.             } else if (this.name == nameXMLNameSpace) {
  1487.                this.parseNameSpaceDecl(true, true);
  1488.             } else {
  1489.                this.finishPI();
  1490.             }
  1491.  
  1492.             this.nextToken();
  1493.             this.firstLine = false;
  1494.          }
  1495.       }
  1496.  
  1497.       this.tryMisc();
  1498.       this.tryDocTypeDecl();
  1499.       this.tryMisc();
  1500.    }
  1501.  
  1502.    final ElementDecl findElementDecl(Vector var1) throws ParseException {
  1503.       if (this.token != -4) {
  1504.          this.error("Expected " + this.tokenString(-4) + " instead of " + this.tokenString(this.token));
  1505.       }
  1506.  
  1507.       ElementDecl var2 = this.dtd.findElementDecl(this.name);
  1508.       if (var2 == null) {
  1509.          this.error("Missing Element declaration '" + this.name + "'");
  1510.       }
  1511.  
  1512.       var1.addElement(var2);
  1513.       return var2;
  1514.    }
  1515.  
  1516.    final void parseAttListDecl() throws ParseException {
  1517.       Vector var1 = new Vector();
  1518.       this.nextToken();
  1519.       ElementDecl var2 = this.findElementDecl(var1);
  1520.       this.push(var2, this.name, 9);
  1521.       var2.parseAttList(this);
  1522.       this.checkToken(62, ">");
  1523.       this.pop();
  1524.    }
  1525.  
  1526.    final void parseCDATA() throws ParseException {
  1527.       this.charAt = 0;
  1528.       boolean var1 = false;
  1529.  
  1530.       while(this.lookahead != -1) {
  1531.          this.chars[this.charAt++] = (char)this.lookahead;
  1532.          if (this.lookahead == 93) {
  1533.             this.advance();
  1534.             if (this.lookahead == 93) {
  1535.                this.advance();
  1536.                if (this.lookahead == 62) {
  1537.                   this.charAt += -1;
  1538.                   var1 = true;
  1539.                } else {
  1540.                   this.reader.push((char)this.lookahead);
  1541.                   this.lookahead = 93;
  1542.                }
  1543.             }
  1544.          } else {
  1545.             this.advance();
  1546.          }
  1547.  
  1548.          if (this.charAt == this.chars.length || var1) {
  1549.             this.addNewElement(6, nameCDATA, false, new String(this.chars, 0, this.charAt));
  1550.             this.charAt = 0;
  1551.             if (var1) {
  1552.                break;
  1553.             }
  1554.          }
  1555.       }
  1556.  
  1557.       this.parseToken(62, "CDATA end");
  1558.    }
  1559.  
  1560.    final void checkCDEND(boolean var1) throws ParseException {
  1561.       boolean var2 = false;
  1562.       if (this.lookahead == 93) {
  1563.          this.addChar();
  1564.          if (this.lookahead == 93) {
  1565.             this.addChar();
  1566.             if (this.lookahead == 62) {
  1567.                if (!var1) {
  1568.                   this.error("Bad Ignore conditional section syntex. ']]>' is not allowed here.");
  1569.                }
  1570.  
  1571.                var2 = true;
  1572.                this.addChar();
  1573.             }
  1574.          }
  1575.       }
  1576.  
  1577.       if (!var2 && var1) {
  1578.          this.error("Bad Ignore conditional section syntex. Expected ']]>'.");
  1579.       }
  1580.  
  1581.    }
  1582.  
  1583.    final void pop() {
  1584.       this.current = (Context)this.contexts.elementAt(this.contextAt += -1);
  1585.    }
  1586.  
  1587.    final void parseIncludeSection() throws ParseException {
  1588.       Element var1 = this.addNewElement(13, this.conditionRef, false, (String)null);
  1589.       this.push(var1, this.conditionRef, 13);
  1590.       this.parseInternalSubset();
  1591.       this.pop();
  1592.    }
  1593.  
  1594.    final void parseIgnoreSection() throws ParseException {
  1595.       Element var1 = this.addNewElement(14, this.conditionRef, false, (String)null);
  1596.       this.charAt = 0;
  1597.       this.push(var1, this.conditionRef, 14);
  1598.       this.parseIgnoreSectContent();
  1599.       if (this.charAt > 0) {
  1600.          this.addNewElement(1, (Name)null, true, new String(this.chars, 0, this.charAt));
  1601.          this.charAt = 0;
  1602.       }
  1603.  
  1604.       this.pop();
  1605.    }
  1606.  
  1607.    final int nextToken() throws ParseException {
  1608.       this.bufAt = 0;
  1609.       int var1 = this.bufAt;
  1610.       if (this.inTag || !this.current.preserveWS) {
  1611.          for(; isWhiteSpaceChar((char)this.lookahead); this.advance()) {
  1612.             if (!this.inTag) {
  1613.                this.buf[this.bufAt++] = (char)this.lookahead;
  1614.                this.seenWS = true;
  1615.             }
  1616.          }
  1617.       }
  1618.  
  1619.       if (this.inTag) {
  1620.          switch (this.lookahead) {
  1621.             case -1:
  1622.                this.token = -1;
  1623.                break;
  1624.             case 34:
  1625.             case 39:
  1626.                this.quote = (char)this.lookahead;
  1627.                this.token = 39;
  1628.                this.advance();
  1629.                break;
  1630.             case 35:
  1631.             case 40:
  1632.             case 41:
  1633.             case 42:
  1634.             case 43:
  1635.             case 44:
  1636.             case 61:
  1637.             case 91:
  1638.             case 93:
  1639.             case 124:
  1640.                this.token = this.lookahead;
  1641.                this.advance();
  1642.                break;
  1643.             case 37:
  1644.                this.advance();
  1645.                if (this.substitution > 0 && isNameChar((char)this.lookahead)) {
  1646.                   this.scanEntityRef(true);
  1647.                   return this.nextToken();
  1648.                }
  1649.  
  1650.                this.token = 37;
  1651.                break;
  1652.             case 47:
  1653.                this.advance();
  1654.                if (this.lookahead == 62) {
  1655.                   this.token = -10;
  1656.                   this.inTag = false;
  1657.                   this.advance();
  1658.                }
  1659.                break;
  1660.             case 62:
  1661.                this.token = 62;
  1662.                this.inTag = false;
  1663.                this.advance();
  1664.                break;
  1665.             case 63:
  1666.                this.advance();
  1667.                if (this.current.type == 9) {
  1668.                   this.token = 63;
  1669.                } else if (this.lookahead == 62) {
  1670.                   this.token = -7;
  1671.                   this.inTag = false;
  1672.                   this.advance();
  1673.                } else {
  1674.                   this.token = 63;
  1675.                }
  1676.                break;
  1677.             default:
  1678.                if (!isNameChar((char)this.lookahead) && ':' != (char)this.lookahead) {
  1679.                   this.error("Unexpected token '" + (char)this.lookahead + "' inside tag <" + this.current.e.getTagName() + ">");
  1680.                } else {
  1681.                   this.scanName("name");
  1682.                   if (this.keyword > 0) {
  1683.                      this.token = this.lookup(this.name.getName());
  1684.                   }
  1685.                }
  1686.          }
  1687.       } else {
  1688.          if (this.seenWS && !this.current.lastWasWS && (this.lookahead == -1 || this.lookahead == 60)) {
  1689.             this.addNewElement(12, (Name)null, false, new String(this.buf, var1, this.bufAt - var1));
  1690.          }
  1691.  
  1692.          switch (this.lookahead) {
  1693.             case -1:
  1694.                this.token = -1;
  1695.                break;
  1696.             case 60:
  1697.                this.inTag = true;
  1698.                this.seenWS = false;
  1699.                this.advance();
  1700.                switch (this.lookahead) {
  1701.                   case 33:
  1702.                      this.token = -8;
  1703.                      this.advance();
  1704.                      if (this.lookahead == 45) {
  1705.                         this.advance();
  1706.                         if (this.lookahead == 45) {
  1707.                            this.token = -11;
  1708.                            this.advance();
  1709.                         } else {
  1710.                            this.error("Bad comment start syntax.  Expected '<!--'");
  1711.                         }
  1712.  
  1713.                         return this.token;
  1714.                      } else {
  1715.                         if (this.lookahead == 91) {
  1716.                            this.advance();
  1717.                            boolean var2 = false;
  1718.                            if (this.lookahead == 37) {
  1719.                               this.advance();
  1720.                               Entity var3 = this.scanEntityRef(true);
  1721.                               this.conditionRef = var3.getName();
  1722.                               var2 = true;
  1723.                            } else {
  1724.                               this.conditionRef = null;
  1725.                            }
  1726.  
  1727.                            this.parseKeyword(0, "CDATA or Conditional section start tag");
  1728.                            if (this.token == -34 || this.token == -35 || this.token == -20 && !var2) {
  1729.                               if (this.token == -20) {
  1730.                                  this.token = -14;
  1731.                               } else {
  1732.                                  this.inTag = false;
  1733.                               }
  1734.  
  1735.                               if (this.lookahead == 91) {
  1736.                                  this.advance();
  1737.                                  return this.token;
  1738.                               } else {
  1739.                                  if (this.token == -14) {
  1740.                                     this.error("Bad CDATA start syntax. Expected '['");
  1741.                                  } else {
  1742.                                     this.error("Bad conditional section start syntax. Expected '['");
  1743.                                  }
  1744.  
  1745.                                  return this.token;
  1746.                               }
  1747.                            } else {
  1748.                               this.error("Bad start tag: '<!['" + this.tokenString(this.token) + this.token);
  1749.                               return this.token;
  1750.                            }
  1751.                         }
  1752.  
  1753.                         return this.token;
  1754.                      }
  1755.                   case 47:
  1756.                      this.token = -9;
  1757.                      this.advance();
  1758.                      return this.token;
  1759.                   case 63:
  1760.                      this.token = -6;
  1761.                      this.advance();
  1762.                      return this.token;
  1763.                   default:
  1764.                      this.token = 60;
  1765.                      return this.token;
  1766.                }
  1767.             case 93:
  1768.                this.advance();
  1769.                if (this.lookahead == 93) {
  1770.                   this.advance();
  1771.                   if (this.lookahead == 62) {
  1772.                      this.advance();
  1773.                      this.token = -43;
  1774.                      break;
  1775.                   }
  1776.  
  1777.                   this.reader.push((char)this.lookahead);
  1778.                   this.reader.push(']');
  1779.                   this.lookahead = 93;
  1780.                } else {
  1781.                   this.reader.push((char)this.lookahead);
  1782.                   this.lookahead = 93;
  1783.                }
  1784.  
  1785.                if (this.breakText == this.lookahead) {
  1786.                   this.advance();
  1787.                   this.token = 93;
  1788.                   break;
  1789.                }
  1790.             default:
  1791.                this.token = -5;
  1792.          }
  1793.       }
  1794.  
  1795.       return this.token;
  1796.    }
  1797.  
  1798.    final void parseInternalSubset() throws ParseException {
  1799.       ++this.substitution;
  1800.       this.validating = true;
  1801.  
  1802.       while(true) {
  1803.          switch (this.nextToken()) {
  1804.             case -35:
  1805.                this.parseIgnoreSection();
  1806.                break;
  1807.             case -34:
  1808.                this.parseIncludeSection();
  1809.                break;
  1810.             case -11:
  1811.                this.parseComment();
  1812.                break;
  1813.             case -8:
  1814.                this.parseKeyword(0, "ENTITY|...");
  1815.                switch (this.token) {
  1816.                   case -28:
  1817.                      this.parseNotation();
  1818.                      continue;
  1819.                   case -24:
  1820.                      this.parseEntityDecl();
  1821.                      continue;
  1822.                   case -19:
  1823.                      this.parseAttListDecl();
  1824.                      continue;
  1825.                   case -15:
  1826.                      this.parseElementDecl();
  1827.                      continue;
  1828.                   default:
  1829.                      this.error("Unknown DTD keyword " + this.name);
  1830.                      continue;
  1831.                }
  1832.             case -6:
  1833.                this.parsePI(true);
  1834.                break;
  1835.             case -5:
  1836.                if (this.lookahead != 37) {
  1837.                   this.error("Unexpected text in DTD.");
  1838.                   return;
  1839.                }
  1840.  
  1841.                this.advance();
  1842.                this.scanEntityRef(true);
  1843.                break;
  1844.             case 93:
  1845.                if (!this.internalSubset) {
  1846.                   System.out.println("Illegal token in DTD: " + this.token);
  1847.                }
  1848.             case -1:
  1849.                this.substitution += -1;
  1850.                return;
  1851.             default:
  1852.                return;
  1853.          }
  1854.       }
  1855.    }
  1856.  
  1857.    public Parser() {
  1858.       jdk11 = true;
  1859.       this.caseInsensitive = false;
  1860.       this.shortendtags = false;
  1861.    }
  1862.  
  1863.    final Element parseComment() throws ParseException {
  1864.       Element var1 = this.addNewElement(2, nameComment, false, (String)null);
  1865.       this.charAt = 0;
  1866.       boolean var2 = false;
  1867.  
  1868.       while(this.lookahead != -1) {
  1869.          this.chars[this.charAt++] = (char)this.lookahead;
  1870.          if (this.lookahead == 45) {
  1871.             this.advance();
  1872.             if (this.lookahead == 45) {
  1873.                this.advance();
  1874.                if (this.lookahead == 62) {
  1875.                   this.charAt += -1;
  1876.                   var2 = true;
  1877.                } else if (strict) {
  1878.                   this.error("Bad comment syntax. Expected '>'.");
  1879.                } else {
  1880.                   this.reader.push((char)this.lookahead);
  1881.                   this.lookahead = 45;
  1882.                }
  1883.             }
  1884.          } else {
  1885.             this.advance();
  1886.          }
  1887.  
  1888.          if (this.charAt == this.chars.length || var2) {
  1889.             this.push(var1, nameComment, 2);
  1890.             this.addNewElement(6, (Name)null, false, new String(this.chars, 0, this.charAt));
  1891.             this.pop();
  1892.             this.charAt = 0;
  1893.             if (var2) {
  1894.                break;
  1895.             }
  1896.          }
  1897.       }
  1898.  
  1899.       this.parseToken(62, "comment end");
  1900.       return var1;
  1901.    }
  1902.  
  1903.    final void parseKeyword(int var1, String var2) throws ParseException {
  1904.       ++this.keyword;
  1905.       if (var1 == 0) {
  1906.          this.nextToken();
  1907.       } else {
  1908.          this.parseToken(var1, var2);
  1909.       }
  1910.  
  1911.       this.keyword += -1;
  1912.    }
  1913.  
  1914.    final void push(Element var1, Name var2, int var3) {
  1915.       ++this.contextAt;
  1916.       this.newContext(var1, var2, var3, this.current.preserveWS, this.current.nameSpace, this.current.spaceTable);
  1917.    }
  1918.  
  1919.    final void scanString(int var1, int var2, int var3, int var4) throws ParseException {
  1920.       this.charAt = 0;
  1921.  
  1922.       while(this.lookahead != -1 && this.lookahead != var1) {
  1923.          if (this.lookahead == var4) {
  1924.             this.error("Illegal character in string " + (char)this.lookahead);
  1925.          } else if (this.lookahead == var3) {
  1926.             this.advance();
  1927.             if (this.lookahead == 35) {
  1928.                this.scanCharRef();
  1929.             } else if (isNameChar((char)this.lookahead)) {
  1930.                if (this.expandNamedEntities) {
  1931.                   this.scanEntityRef(false);
  1932.                } else {
  1933.                   this.chars[this.charAt++] = (char)var3;
  1934.                }
  1935.             } else {
  1936.                this.chars[this.charAt++] = (char)this.lookahead;
  1937.             }
  1938.          } else if (this.lookahead == var2) {
  1939.             this.advance();
  1940.             if (isNameChar((char)this.lookahead)) {
  1941.                boolean var5 = var2 == 37;
  1942.                if (this.expandNamedEntities) {
  1943.                   this.scanEntityRef(var5);
  1944.                } else {
  1945.                   this.chars[this.charAt++] = (char)var2;
  1946.                }
  1947.             } else {
  1948.                this.chars[this.charAt++] = (char)this.lookahead;
  1949.             }
  1950.          } else {
  1951.             this.chars[this.charAt++] = (char)this.lookahead;
  1952.             this.advance();
  1953.          }
  1954.       }
  1955.  
  1956.       if (this.lookahead == var1) {
  1957.          this.advance();
  1958.       } else {
  1959.          this.error("Unterminated string");
  1960.       }
  1961.  
  1962.       this.text = new String(this.chars, 0, this.charAt);
  1963.    }
  1964.  
  1965.    static {
  1966.       XMLDecl = new ElementDecl(nameXML);
  1967.       XMLDecl.addAttDef(new AttDef(nameVERSION, 0, "1.0", 3));
  1968.       XMLDecl.addAttDef(new AttDef(nameENCODING, 0, "UTF-8", 2));
  1969.       Vector var0 = new Vector(2);
  1970.       var0.addElement(nameYes);
  1971.       var0.addElement(nameNo);
  1972.       XMLDecl.addAttDef(new AttDef(nameStandalone, 9, (Name)var0.elementAt(0), 2, var0));
  1973.       tokens = new Hashtable();
  1974.       tokens.put("DOCTYPE", new Integer(-12));
  1975.       tokens.put("SYSTEM", new Integer(-13));
  1976.       tokens.put("PUBLIC", new Integer(-100));
  1977.       tokens.put("ENTITY", new Integer(-24));
  1978.       tokens.put("ELEMENT", new Integer(-15));
  1979.       tokens.put("EMPTY", new Integer(-16));
  1980.       tokens.put("ANY", new Integer(-17));
  1981.       tokens.put("PCDATA", new Integer(-18));
  1982.       tokens.put("ATTLIST", new Integer(-19));
  1983.       tokens.put("CDATA", new Integer(-20));
  1984.       tokens.put("ID", new Integer(-21));
  1985.       tokens.put("IDREF", new Integer(-22));
  1986.       tokens.put("IDREFS", new Integer(-23));
  1987.       tokens.put("ENTITY", new Integer(-24));
  1988.       tokens.put("ENTITIES", new Integer(-25));
  1989.       tokens.put("NMTOKEN", new Integer(-26));
  1990.       tokens.put("NMTOKENS", new Integer(-27));
  1991.       tokens.put("FIXED", new Integer(-30));
  1992.       tokens.put("REQUIRED", new Integer(-31));
  1993.       tokens.put("IMPLIED", new Integer(-32));
  1994.       tokens.put("NDATA", new Integer(-33));
  1995.       tokens.put("NOTATION", new Integer(-28));
  1996.       tokens.put("INCLUDE", new Integer(-34));
  1997.       tokens.put("IGNORE", new Integer(-35));
  1998.       tokens.put("namespace", new Integer(-36));
  1999.       tokens.put("EXTENDS", new Integer(-37));
  2000.       tokens.put("IMPLEMENTS", new Integer(-38));
  2001.       tokens.put("xml", new Integer(-39));
  2002.       tokens.put("version", new Integer(-40));
  2003.       tokens.put("encoding", new Integer(-41));
  2004.       tokens.put("standalone", new Integer(-42));
  2005.       int var1 = 0;
  2006.  
  2007.       do {
  2008.          char var2 = (char)var1;
  2009.          chartype[var1] = 0;
  2010.          if (jdk11 && Character.isWhitespace(var2) || Character.isSpace(var2) || var2 == '\r') {
  2011.             chartype[var1] = 1;
  2012.          }
  2013.  
  2014.          if (Character.isLetter(var2)) {
  2015.             int[] var10000 = chartype;
  2016.             var10000[var1] |= 4;
  2017.          }
  2018.  
  2019.          if (Character.isDigit(var2)) {
  2020.             int[] var3 = chartype;
  2021.             var3[var1] |= 2;
  2022.          }
  2023.  
  2024.          charupper[var1] = Character.toUpperCase(var2);
  2025.          ++var1;
  2026.       } while(var1 < 256);
  2027.  
  2028.       int[] var4 = chartype;
  2029.       var4[46] |= 8;
  2030.       var4 = chartype;
  2031.       var4[45] |= 8;
  2032.       var4 = chartype;
  2033.       var4[95] |= 24;
  2034.       var4 = chartype;
  2035.       var4[183] |= 8;
  2036.    }
  2037.  
  2038.    final Entity scanEntityRef(boolean var1) throws ParseException {
  2039.       ++this.nouppercase;
  2040.       ++this.inEntityRef;
  2041.       this.scanName("entity ref");
  2042.       this.inEntityRef += -1;
  2043.       this.nouppercase += -1;
  2044.       if (this.lookahead != 59) {
  2045.          this.error("Entity reference syntax error " + this.name);
  2046.       }
  2047.  
  2048.       Entity var2 = this.dtd.findEntity(this.name);
  2049.       if (var2 == null) {
  2050.          String var3 = "Missing entity '" + this.name + "'.";
  2051.          if (!this.loadexternal) {
  2052.             var3 = var3 + "\nPerhaps you need to change the loadexternal flag to 'true'.";
  2053.          }
  2054.  
  2055.          this.error(var3);
  2056.       }
  2057.  
  2058.       if (var1 != var2.par) {
  2059.          if (var1) {
  2060.             this.error("Entity '" + this.name + "' is not a parameter entity.");
  2061.          } else {
  2062.             this.error("Entity '" + this.name + "' is a parameter entity.");
  2063.          }
  2064.       }
  2065.  
  2066.       if (var1) {
  2067.          if (!this.inTag) {
  2068.             this.addNewElement(11, this.name, false, (String)null);
  2069.          }
  2070.  
  2071.          if (var2.getURL() == null) {
  2072.             this.push(var2, this.name, 7);
  2073.             this.reader = var2.getReader(this.reader);
  2074.          } else {
  2075.             if (var2.ndata != null) {
  2076.                this.error("Binary parameter entity " + this.name.toString() + "cannot be used in DTD");
  2077.             }
  2078.  
  2079.             if (this.loadexternal) {
  2080.                this.loadDTD(var2.getURL(), this.current.defaultNameSpace);
  2081.             }
  2082.          }
  2083.       } else {
  2084.          if (!this.inTag) {
  2085.             this.addPCDATA();
  2086.             this.charAt = 0;
  2087.             this.addNewElement(11, this.name, true, (String)null);
  2088.          }
  2089.  
  2090.          if (var2.getLength() != -1 && !var2.parsed) {
  2091.             Context var6 = this.current;
  2092.             if (var6.parent != null) {
  2093.                var6 = var6.parent;
  2094.             }
  2095.  
  2096.             if (var2.getURL() == null) {
  2097.                var2.parsed = true;
  2098.                this.push(var2, this.name, 7);
  2099.                this.current.parent = var6;
  2100.                this.reader = var2.getReader(this.reader);
  2101.             } else if (var2.ndata == null && this.loadexternal) {
  2102.                var2.parsed = true;
  2103.                this.push(var2, this.name, 7);
  2104.                this.current.parent = var6;
  2105.  
  2106.                try {
  2107.                   URL var4 = new URL(this.url, var2.getURL());
  2108.                   this.reader = new EntityReader(var4.openStream(), this.reader.line, this.reader.column, this.reader, var2);
  2109.                } catch (Exception var5) {
  2110.                   this.error("Cannot load external text entity: " + this.name.toString());
  2111.                }
  2112.             }
  2113.          }
  2114.       }
  2115.  
  2116.       this.advance();
  2117.       return var2;
  2118.    }
  2119.  
  2120.    final Element parsePI(boolean var1) throws ParseException {
  2121.       this.parseKeyword(0, "PI name");
  2122.       if (this.token == -39) {
  2123.          if (this.firstLine) {
  2124.             this.parseXMLDecl();
  2125.             return null;
  2126.          }
  2127.  
  2128.          this.error("An XML declaration can only appear in the very beginning of the document.");
  2129.       } else {
  2130.          if (this.token == -36) {
  2131.             return this.parseNameSpaceDecl(var1, true);
  2132.          }
  2133.  
  2134.          if (this.token != -4) {
  2135.             this.error("Expecting PI name instead of " + this.tokenString(this.token));
  2136.          }
  2137.       }
  2138.  
  2139.       return this.finishPI();
  2140.    }
  2141.  
  2142.    final Element parseText(int var1, int var2) throws ParseException {
  2143.       this.scanText(var1, var2, !this.current.preserveWS);
  2144.       return this.addPCDATA();
  2145.    }
  2146.  
  2147.    private final void setURL(URL var1) throws ParseException {
  2148.       this.url = var1;
  2149.  
  2150.       try {
  2151.          this.setInputStream(new BufferedInputStream(this.url.openStream()));
  2152.       } catch (IOException var3) {
  2153.          throw new ParseException("Error opening input stream for \"" + this.url.toString() + "\": " + ((Throwable)var3).toString());
  2154.       }
  2155.    }
  2156.  
  2157.    final int lookup(String var1) {
  2158.       Object var2 = tokens.get(var1);
  2159.       if (var2 != null) {
  2160.          this.token = (Integer)var2;
  2161.       } else {
  2162.          this.token = -4;
  2163.       }
  2164.  
  2165.       return this.token;
  2166.    }
  2167.  
  2168.    final void scanName(String var1) throws ParseException {
  2169.       Object var2 = null;
  2170.       Atom var3 = null;
  2171.       boolean var4 = false;
  2172.       if (this.nameappend == 0) {
  2173.          this.bufAt = 0;
  2174.       }
  2175.  
  2176.       int var5 = this.bufAt;
  2177.       if (':' != (char)this.lookahead) {
  2178.          this.bufAt = this.scanSimpleName(this.bufAt, var1);
  2179.          var4 = true;
  2180.       }
  2181.  
  2182.       if (this.nametoken == 0 && this.simplename == 0 && ':' == (char)this.lookahead) {
  2183.          int var6 = 1;
  2184.          ++this.bufAt;
  2185.          this.advance();
  2186.          if (':' == (char)this.lookahead) {
  2187.             ++var6;
  2188.             ++this.bufAt;
  2189.             this.advance();
  2190.          }
  2191.  
  2192.          if (var4) {
  2193.             String var8;
  2194.             if (this.caseInsensitive) {
  2195.                var8 = (new String(this.buf, var5, this.bufAt - var5 - var6)).toUpperCase();
  2196.             } else {
  2197.                var8 = new String(this.buf, var5, this.bufAt - var5 - var6);
  2198.             }
  2199.  
  2200.             Atom var7 = Atom.create(var8);
  2201.             if (DTD.isReservedNameSpace(var7)) {
  2202.                var3 = var7;
  2203.             } else {
  2204.                var3 = this.current.findNameSpace(var7);
  2205.                if (var3 == null) {
  2206.                   var3 = this.dtd.findLongNameSpace(var7);
  2207.                   if (var3 == null) {
  2208.                      var3 = var7;
  2209.                      this.addNameSpace(var7, var7, false);
  2210.                   }
  2211.                }
  2212.             }
  2213.          }
  2214.  
  2215.          var5 = this.bufAt;
  2216.          this.bufAt = this.scanSimpleName(this.bufAt, var1);
  2217.       } else if (this.nametoken == 0 && this.simplename == 0 || this.inEntityRef > 0) {
  2218.          var3 = this.current.defaultNameSpace;
  2219.       }
  2220.  
  2221.       if (this.nametoken == 0 && this.simplename == 0 || this.inEntityRef > 0) {
  2222.          this.current.nameSpace = var3;
  2223.       }
  2224.  
  2225.       if ((this.keyword <= 0 || this.inEntityRef != 0) && var3 != null) {
  2226.          this.name = Name.create(new String(this.buf, var5, this.bufAt - var5), var3);
  2227.       } else {
  2228.          this.name = Name.create(this.buf, var5, this.bufAt - var5);
  2229.       }
  2230.  
  2231.       this.token = -4;
  2232.    }
  2233. }
  2234.