home *** CD-ROM | disk | FTP | other *** search
/ Cre@te Online 2000 December / Cre@teOnline CD05.iso / MacSoft / XML ConsoleMax.sea / XML ConsoleMax / Required / xml4j.jar / com / ibm / xml / internal / CharReader.class (.txt) next >
Encoding:
Java Class File  |  1999-08-30  |  11.1 KB  |  1,231 lines
  1. package com.ibm.xml.internal;
  2.  
  3. import com.ibm.xml.framework.ChunkyCharArray;
  4. import com.ibm.xml.framework.ParserState;
  5. import com.ibm.xml.framework.ScanContentState;
  6. import com.ibm.xml.framework.StringPool;
  7. import com.ibm.xml.framework.XMLDocumentHandler;
  8. import com.ibm.xml.framework.XMLErrorHandler;
  9. import com.ibm.xml.framework.XMLReader;
  10. import com.ibm.xml.framework.XMLScanner;
  11. import java.io.Reader;
  12.  
  13. final class CharReader extends XMLReader {
  14.    protected static final int CHUNK_SHIFT = 14;
  15.    protected static final int CHUNK_SIZE = 16384;
  16.    protected static final int CHUNK_MASK = 16383;
  17.    protected XMLScanner fScanner;
  18.    protected XMLDocumentHandler fDocumentHandler;
  19.    protected XMLErrorHandler fErrorHandler;
  20.    protected StringPool fStringPool;
  21.    protected Reader fReader;
  22.    protected CharDataChunk fCurrentChunk;
  23.    protected int fCurrentIndex;
  24.    protected char[] fMostRecentData;
  25.    protected int fMostRecentChar;
  26.    protected int fLength;
  27.    protected boolean fCheckOverflow = false;
  28.    protected char[] fOverflow;
  29.    protected int fOverflowOffset;
  30.    protected int fOverflowEnd;
  31.    protected int fOutputOffset;
  32.    protected boolean fSkipLinefeed = false;
  33.  
  34.    CharReader(ParserState var1, String var2, String var3, Reader var4) throws Exception {
  35.       super(var1, var2, var3);
  36.       this.fReader = var4;
  37.       this.fScanner = var1.getScanner();
  38.       this.fStringPool = var1.cacheStringPool();
  39.       this.fDocumentHandler = var1.getDocumentHandler();
  40.       this.fErrorHandler = var1.getErrorHandler();
  41.       this.fCurrentChunk = new CharDataChunk(this, this.fStringPool, (CharDataChunk)null);
  42.       this.fillCurrentChunk();
  43.    }
  44.  
  45.    public int addString(int var1, int var2) {
  46.       return var2 == 0 ? 0 : this.fCurrentChunk.addString(var1, var2);
  47.    }
  48.  
  49.    public int addSymbol(int var1, int var2) {
  50.       return var2 == 0 ? 0 : this.fCurrentChunk.addSymbol(var1, var2, 0);
  51.    }
  52.  
  53.    protected int addSymbol(int var1, int var2, int var3) {
  54.       return var2 == 0 ? 0 : this.fCurrentChunk.addSymbol(var1, var2, var3);
  55.    }
  56.  
  57.    public void append(ChunkyCharArray var1, int var2, int var3) {
  58.       this.fCurrentChunk.append(var1, var2, var3);
  59.    }
  60.  
  61.    protected int slowLoadNextChar() throws Exception {
  62.       CharDataChunk var1 = this.fCurrentChunk;
  63.       if (var1.fNextChunk != null) {
  64.          var1 = this.fCurrentChunk;
  65.          this.fCurrentChunk = var1.fNextChunk;
  66.          this.fCurrentIndex = 0;
  67.          var1 = this.fCurrentChunk;
  68.          this.fMostRecentData = var1.fData;
  69.          return this.fMostRecentChar = this.fMostRecentData[this.fCurrentIndex] & '\uffff';
  70.       } else {
  71.          this.fCurrentChunk = new CharDataChunk(this, this.fStringPool, this.fCurrentChunk);
  72.          return this.fillCurrentChunk();
  73.       }
  74.    }
  75.  
  76.    protected int loadNextChar() throws Exception {
  77.       ++super.fCurrentOffset;
  78.       return ++this.fCurrentIndex == 16384 ? this.slowLoadNextChar() : (this.fMostRecentChar = this.fMostRecentData[this.fCurrentIndex] & '\uffff');
  79.    }
  80.  
  81.    protected void checkEOF(int var1) {
  82.       if (var1 > this.fLength) {
  83.          throw new ArrayIndexOutOfBoundsException();
  84.       }
  85.    }
  86.  
  87.    public int skipOneChar() throws Exception {
  88.       int var1 = this.fMostRecentChar;
  89.       if (var1 == 0) {
  90.          int var2 = super.fCurrentOffset + 1;
  91.          if (var2 > this.fLength) {
  92.             throw new ArrayIndexOutOfBoundsException();
  93.          }
  94.  
  95.          ++super.fCharacterCounter;
  96.       } else if (var1 == 10) {
  97.          ++super.fLinefeedCounter;
  98.          super.fCharacterCounter = 1;
  99.       } else if (var1 >= 55296 && var1 < 56320) {
  100.          ++super.fCharacterCounter;
  101.          var1 = this.loadNextChar();
  102.          if (var1 < 56320 || var1 >= 57344) {
  103.             return super.fCurrentOffset;
  104.          }
  105.       } else {
  106.          ++super.fCharacterCounter;
  107.       }
  108.  
  109.       this.loadNextChar();
  110.       return super.fCurrentOffset;
  111.    }
  112.  
  113.    public int skipAsciiChar() throws Exception {
  114.       ++super.fCharacterCounter;
  115.       this.loadNextChar();
  116.       return super.fCurrentOffset;
  117.    }
  118.  
  119.    public int skipToChar(char var1) throws Exception {
  120.       int var2 = this.fMostRecentChar;
  121.  
  122.       while(var2 != var1) {
  123.          if (var2 == 0) {
  124.             int var3 = super.fCurrentOffset + 1;
  125.             if (var3 > this.fLength) {
  126.                throw new ArrayIndexOutOfBoundsException();
  127.             }
  128.  
  129.             ++super.fCharacterCounter;
  130.          } else if (var2 == 10) {
  131.             ++super.fLinefeedCounter;
  132.             super.fCharacterCounter = 1;
  133.          } else if (var2 >= 55296 && var2 < 56320) {
  134.             ++super.fCharacterCounter;
  135.             var2 = this.loadNextChar();
  136.             if (var2 < 56320 || var2 >= 57344) {
  137.                continue;
  138.             }
  139.          } else {
  140.             ++super.fCharacterCounter;
  141.          }
  142.  
  143.          var2 = this.loadNextChar();
  144.       }
  145.  
  146.       return super.fCurrentOffset;
  147.    }
  148.  
  149.    public int skipPastChar(char var1) throws Exception {
  150.       int var2 = this.fMostRecentChar;
  151.  
  152.       while(var2 != var1) {
  153.          if (var2 == 0) {
  154.             int var3 = super.fCurrentOffset + 1;
  155.             if (var3 > this.fLength) {
  156.                throw new ArrayIndexOutOfBoundsException();
  157.             }
  158.  
  159.             ++super.fCharacterCounter;
  160.          } else if (var2 == 10) {
  161.             ++super.fLinefeedCounter;
  162.             super.fCharacterCounter = 1;
  163.          } else if (var2 >= 55296 && var2 < 56320) {
  164.             ++super.fCharacterCounter;
  165.             var2 = this.loadNextChar();
  166.             if (var2 < 56320 || var2 >= 57344) {
  167.                continue;
  168.             }
  169.          } else {
  170.             ++super.fCharacterCounter;
  171.          }
  172.  
  173.          var2 = this.loadNextChar();
  174.       }
  175.  
  176.       ++super.fCharacterCounter;
  177.       this.loadNextChar();
  178.       return super.fCurrentOffset;
  179.    }
  180.  
  181.    public boolean skippedValidChar() throws Exception {
  182.       int var1 = this.fMostRecentChar;
  183.       if (var1 < 55296) {
  184.          if (var1 < 32 && var1 != 9) {
  185.             if (var1 == 10) {
  186.                ++super.fLinefeedCounter;
  187.                super.fCharacterCounter = 1;
  188.                this.loadNextChar();
  189.                return true;
  190.             } else {
  191.                if (var1 == 0) {
  192.                   int var2 = super.fCurrentOffset + 1;
  193.                   if (var2 > this.fLength) {
  194.                      throw new ArrayIndexOutOfBoundsException();
  195.                   }
  196.                }
  197.  
  198.                return false;
  199.             }
  200.          } else {
  201.             ++super.fCharacterCounter;
  202.             this.loadNextChar();
  203.             return true;
  204.          }
  205.       } else if (var1 > 65533) {
  206.          return false;
  207.       } else {
  208.          if (var1 < 56320) {
  209.             var1 = this.loadNextChar();
  210.             if (var1 < 56320 || var1 >= 57344) {
  211.                return false;
  212.             }
  213.          } else if (var1 < 57344) {
  214.             return false;
  215.          }
  216.  
  217.          ++super.fCharacterCounter;
  218.          this.loadNextChar();
  219.          return true;
  220.       }
  221.    }
  222.  
  223.    public boolean lookingAtValidChar() throws Exception {
  224.       int var1 = this.fMostRecentChar;
  225.       if (var1 < 32) {
  226.          if (var1 == 0) {
  227.             int var2 = super.fCurrentOffset + 1;
  228.             if (var2 > this.fLength) {
  229.                throw new ArrayIndexOutOfBoundsException();
  230.             }
  231.          }
  232.  
  233.          return var1 == 9 || var1 == 10;
  234.       } else {
  235.          return var1 <= 65533;
  236.       }
  237.    }
  238.  
  239.    public int skipInvalidChar(int var1) throws Exception {
  240.       int var2 = this.fMostRecentChar;
  241.       if (var2 == 10) {
  242.          ++super.fLinefeedCounter;
  243.          super.fCharacterCounter = 1;
  244.          this.loadNextChar();
  245.       } else {
  246.          ++super.fCharacterCounter;
  247.          if (var2 >= 55296 && var2 < 56320) {
  248.             int var3 = this.loadNextChar();
  249.             if (var3 >= 56320 && var3 < 57344) {
  250.                var2 = (var2 - '\ud800' << 10) + (var3 - '\udc00') + 65536;
  251.                this.loadNextChar();
  252.             }
  253.          } else {
  254.             this.loadNextChar();
  255.          }
  256.       }
  257.  
  258.       switch (var1) {
  259.          case 43:
  260.             String var7 = var2 < 65536 ? (new Character((char)var2)).toString() : Integer.toHexString(var2);
  261.             String var4 = Integer.toHexString(var2);
  262.             this.fErrorHandler.error2(var1, this.fStringPool.addString(var7), this.fStringPool.addString(var4));
  263.             break;
  264.          case 63:
  265.          case 85:
  266.             String var6 = Integer.toHexString(var2);
  267.             this.fErrorHandler.error1(var1, this.fStringPool.addString(var6));
  268.             break;
  269.          case 80:
  270.          case 82:
  271.          case 110:
  272.             String var5 = var2 < 65536 ? (new Character((char)var2)).toString() : Integer.toHexString(var2);
  273.             this.fErrorHandler.error1(var1, this.fStringPool.addString(var5));
  274.       }
  275.  
  276.       return super.fCurrentOffset;
  277.    }
  278.  
  279.    public boolean skippedChar(char var1) throws Exception {
  280.       int var2 = this.fMostRecentChar;
  281.       if (var2 != var1) {
  282.          return false;
  283.       } else {
  284.          ++super.fCharacterCounter;
  285.          ++super.fCurrentOffset;
  286.          if (++this.fCurrentIndex == 16384) {
  287.             this.slowLoadNextChar();
  288.          } else {
  289.             this.fMostRecentChar = this.fMostRecentData[this.fCurrentIndex] & '\uffff';
  290.          }
  291.  
  292.          return true;
  293.       }
  294.    }
  295.  
  296.    public boolean lookingAtChar(char var1) throws Exception {
  297.       int var2 = this.fMostRecentChar;
  298.       return var2 == var1;
  299.    }
  300.  
  301.    public boolean skippedSpace() throws Exception {
  302.       int var1 = this.fMostRecentChar;
  303.       if (var1 > 32) {
  304.          return false;
  305.       } else {
  306.          if (var1 != 32 && var1 != 9) {
  307.             if (var1 != 10) {
  308.                return false;
  309.             }
  310.  
  311.             ++super.fLinefeedCounter;
  312.             super.fCharacterCounter = 1;
  313.          } else {
  314.             ++super.fCharacterCounter;
  315.          }
  316.  
  317.          ++super.fCurrentOffset;
  318.          if (++this.fCurrentIndex == 16384) {
  319.             this.slowLoadNextChar();
  320.          } else {
  321.             this.fMostRecentChar = this.fMostRecentData[this.fCurrentIndex] & '\uffff';
  322.          }
  323.  
  324.          return true;
  325.       }
  326.    }
  327.  
  328.    public boolean lookingAtSpace() {
  329.       int var1 = this.fMostRecentChar;
  330.       return var1 == 32 || var1 == 9 || var1 == 10;
  331.    }
  332.  
  333.    public int skipPastSpaces() throws Exception {
  334.       int var1 = this.fMostRecentChar;
  335.  
  336.       while(true) {
  337.          if (var1 != 32 && var1 != 9) {
  338.             if (var1 != 10) {
  339.                return super.fCurrentOffset;
  340.             }
  341.  
  342.             ++super.fLinefeedCounter;
  343.             super.fCharacterCounter = 1;
  344.          } else {
  345.             ++super.fCharacterCounter;
  346.          }
  347.  
  348.          var1 = this.loadNextChar();
  349.       }
  350.    }
  351.  
  352.    public int skipDecimalDigit() throws Exception {
  353.       int var1 = this.fMostRecentChar;
  354.       if (var1 >= 48 && var1 <= 57) {
  355.          ++super.fCharacterCounter;
  356.          this.loadNextChar();
  357.          return var1 - 48;
  358.       } else {
  359.          return -1;
  360.       }
  361.    }
  362.  
  363.    public int skipHexDigit() throws Exception {
  364.       int var1 = this.fMostRecentChar;
  365.       if (var1 <= 102 && XMLReader.fgAsciiXDigitChar[var1] != 0) {
  366.          ++super.fCharacterCounter;
  367.          this.loadNextChar();
  368.          return var1 - (var1 < 65 ? 48 : (var1 < 97 ? 65 : 97) - 10);
  369.       } else {
  370.          return -1;
  371.       }
  372.    }
  373.  
  374.    public boolean skippedAlpha() throws Exception {
  375.       int var1 = this.fMostRecentChar;
  376.       if (var1 <= 122 && XMLReader.fgAsciiAlphaChar[var1] != 0) {
  377.          ++super.fCharacterCounter;
  378.          this.loadNextChar();
  379.          return true;
  380.       } else {
  381.          return false;
  382.       }
  383.    }
  384.  
  385.    protected boolean skippedAsciiCharWithFlag(byte var1) throws Exception {
  386.       int var2 = this.fMostRecentChar;
  387.       if (var2 < 128 && (XMLReader.fgCharFlags[var2] & var1) != 0) {
  388.          ++super.fCharacterCounter;
  389.          this.loadNextChar();
  390.          return true;
  391.       } else {
  392.          return false;
  393.       }
  394.    }
  395.  
  396.    public boolean skippedVersionNum() throws Exception {
  397.       return this.skippedAsciiCharWithFlag((byte)1);
  398.    }
  399.  
  400.    public boolean skippedEncName() throws Exception {
  401.       return this.skippedAsciiCharWithFlag((byte)2);
  402.    }
  403.  
  404.    public boolean skippedPubidChar() throws Exception {
  405.       int var1 = this.fMostRecentChar;
  406.       if (var1 >= 128) {
  407.          return false;
  408.       } else if ((XMLReader.fgCharFlags[var1] & 4) != 0) {
  409.          ++super.fCharacterCounter;
  410.          this.loadNextChar();
  411.          return true;
  412.       } else if (var1 == 10) {
  413.          ++super.fLinefeedCounter;
  414.          super.fCharacterCounter = 1;
  415.          this.loadNextChar();
  416.          return true;
  417.       } else {
  418.          return false;
  419.       }
  420.    }
  421.  
  422.    public boolean skippedString(char[] var1) throws Exception {
  423.       int var2 = var1.length;
  424.       char[] var3 = this.fMostRecentData;
  425.       int var4 = this.fCurrentIndex;
  426.       if (var4 + var2 <= 16384) {
  427.          for(int var11 = 0; var11 < var2; ++var11) {
  428.             if (var3[var4++] != var1[var11]) {
  429.                return false;
  430.             }
  431.          }
  432.  
  433.          super.fCharacterCounter += var2;
  434.          super.fCurrentOffset += var2;
  435.          this.fCurrentIndex = var4;
  436.          if (var4 == 16384) {
  437.             this.slowLoadNextChar();
  438.          } else {
  439.             this.fMostRecentChar = var3[var4] & '\uffff';
  440.          }
  441.  
  442.          return true;
  443.       } else {
  444.          CharDataChunk var5 = this.fCurrentChunk;
  445.          int var6 = super.fCurrentOffset;
  446.          int var7 = var4;
  447.          int var8 = 0;
  448.  
  449.          while(var4 < 16384) {
  450.             if (var3[var4++] != var1[var8++]) {
  451.                return false;
  452.             }
  453.          }
  454.  
  455.          this.slowLoadNextChar();
  456.          var3 = this.fMostRecentData;
  457.          var4 = 0;
  458.  
  459.          while(var8 < var2) {
  460.             if (var3[var4++] != var1[var8++]) {
  461.                this.fCurrentChunk = var5;
  462.                this.fCurrentIndex = var7;
  463.                super.fCurrentOffset = var6;
  464.                this.fMostRecentData = var5.fData;
  465.                this.fMostRecentChar = this.fMostRecentData[var7] & '\uffff';
  466.                return false;
  467.             }
  468.          }
  469.  
  470.          super.fCharacterCounter += var2;
  471.          super.fCurrentOffset += var2;
  472.          this.fCurrentIndex = var4;
  473.          if (var4 == 16384) {
  474.             this.slowLoadNextChar();
  475.          } else {
  476.             this.fMostRecentChar = var3[var4] & '\uffff';
  477.          }
  478.  
  479.          return true;
  480.       }
  481.    }
  482.  
  483.    public int scanName(char var1, int var2) throws Exception {
  484.       int var3 = this.fMostRecentChar;
  485.       if (var3 < 128) {
  486.          if (XMLReader.fgAsciiInitialNameChar[var3] == 0) {
  487.             return -1;
  488.          }
  489.       } else if ((XMLReader.fgCharFlags[var3] & 16) == 0) {
  490.          return -1;
  491.       }
  492.  
  493.       int var4 = super.fCurrentOffset;
  494.       int var5 = this.fCurrentIndex;
  495.       char[] var6 = this.fMostRecentData;
  496.       ++var5;
  497.       if (var5 == 16384) {
  498.          this.fCurrentChunk = new CharDataChunk(this, this.fStringPool, this.fCurrentChunk);
  499.          this.fillCurrentChunk();
  500.          var5 = 0;
  501.          var6 = this.fMostRecentData;
  502.       }
  503.  
  504.       ++super.fCharacterCounter;
  505.       ++super.fCurrentOffset;
  506.       int var7 = 0;
  507.       int var8 = 0;
  508.  
  509.       while(true) {
  510.          var7 = StringHasher.hashChar(var7, var8++, var3);
  511.          var3 = var6[var5] & '\uffff';
  512.          if (var1 == var3) {
  513.             break;
  514.          }
  515.  
  516.          if (var3 < 128) {
  517.             if (XMLReader.fgAsciiNameChar[var3] == 0) {
  518.                break;
  519.             }
  520.          } else if ((XMLReader.fgCharFlags[var3] & 32) == 0) {
  521.             break;
  522.          }
  523.  
  524.          ++var5;
  525.          if (var5 == 16384) {
  526.             this.fCurrentChunk = new CharDataChunk(this, this.fStringPool, this.fCurrentChunk);
  527.             this.fillCurrentChunk();
  528.             var5 = 0;
  529.             var6 = this.fMostRecentData;
  530.          }
  531.  
  532.          ++super.fCharacterCounter;
  533.          ++super.fCurrentOffset;
  534.       }
  535.  
  536.       this.fCurrentIndex = var5;
  537.       this.fMostRecentChar = var3;
  538.       var7 = StringHasher.finishHash(var7);
  539.       int var9 = super.fCurrentOffset - var4;
  540.       int var10 = var9 == 0 ? 0 : this.fCurrentChunk.addSymbol(var4, var9, var7);
  541.       return var2 != -1 && var2 != var10 ? -1 : var10;
  542.    }
  543.  
  544.    public int skipPastName(char var1) throws Exception {
  545.       int var2 = this.fMostRecentChar;
  546.       if (var2 < 128) {
  547.          if (XMLReader.fgAsciiInitialNameChar[var2] == 0) {
  548.             return super.fCurrentOffset;
  549.          }
  550.       } else if ((XMLReader.fgCharFlags[var2] & 16) == 0) {
  551.          return super.fCurrentOffset;
  552.       }
  553.  
  554.       while(true) {
  555.          ++super.fCharacterCounter;
  556.          var2 = this.loadNextChar();
  557.          if (var1 == var2) {
  558.             return super.fCurrentOffset;
  559.          }
  560.  
  561.          if (var2 < 128) {
  562.             if (XMLReader.fgAsciiNameChar[var2] == 0) {
  563.                return super.fCurrentOffset;
  564.             }
  565.          } else if ((XMLReader.fgCharFlags[var2] & 32) == 0) {
  566.             return super.fCurrentOffset;
  567.          }
  568.       }
  569.    }
  570.  
  571.    public int skipPastNmtoken(char var1) throws Exception {
  572.       for(int var2 = this.fMostRecentChar; var1 != var2; var2 = this.loadNextChar()) {
  573.          if (var2 < 128) {
  574.             if (XMLReader.fgAsciiNameChar[var2] == 0) {
  575.                return super.fCurrentOffset;
  576.             }
  577.          } else if ((XMLReader.fgCharFlags[var2] & 32) == 0) {
  578.             return super.fCurrentOffset;
  579.          }
  580.  
  581.          ++super.fCharacterCounter;
  582.       }
  583.  
  584.       return super.fCurrentOffset;
  585.    }
  586.  
  587.    public int scanContent(ScanContentState var1) throws Exception {
  588.       CharDataChunk var2 = this.fCurrentChunk;
  589.       if (var2.fPreviousChunk != null) {
  590.          var2.fPreviousChunk.fNextChunk = null;
  591.          var2.fPreviousChunk = null;
  592.       }
  593.  
  594.       int var4;
  595.       label246: {
  596.          label254: {
  597.             var8 = super.fCurrentOffset;
  598.             int var3 = this.fMostRecentChar;
  599.             if (var3 < 128) {
  600.                switch (XMLReader.fgAsciiWSCharData[var3]) {
  601.                   case 0:
  602.                      ++super.fCharacterCounter;
  603.                      ++super.fCurrentOffset;
  604.                      if (++this.fCurrentIndex == 16384) {
  605.                         this.slowLoadNextChar();
  606.                      } else {
  607.                         this.fMostRecentChar = this.fMostRecentData[this.fCurrentIndex] & '\uffff';
  608.                      }
  609.                      break;
  610.                   case 1:
  611.                      ++super.fCharacterCounter;
  612.                      ++super.fCurrentOffset;
  613.                      if (++this.fCurrentIndex == 16384) {
  614.                         this.slowLoadNextChar();
  615.                      } else {
  616.                         this.fMostRecentChar = this.fMostRecentData[this.fCurrentIndex] & '\uffff';
  617.                      }
  618.  
  619.                      if (!var1.inCDSect) {
  620.                         return 1;
  621.                      }
  622.                      break;
  623.                   case 2:
  624.                      ++super.fCharacterCounter;
  625.                      ++super.fCurrentOffset;
  626.                      if (++this.fCurrentIndex == 16384) {
  627.                         this.slowLoadNextChar();
  628.                      } else {
  629.                         this.fMostRecentChar = this.fMostRecentData[this.fCurrentIndex] & '\uffff';
  630.                      }
  631.  
  632.                      if (!var1.inCDSect) {
  633.                         return 2;
  634.                      }
  635.                      break;
  636.                   case 3:
  637.                      ++super.fCharacterCounter;
  638.                      var3 = this.loadNextChar();
  639.                      if (var3 == 93) {
  640.                         if (this.fCurrentIndex + 1 == 16384) {
  641.                            CharDataChunk var12 = this.fCurrentChunk;
  642.                            int var14 = this.fCurrentIndex;
  643.                            int var16 = super.fCurrentOffset;
  644.                            if (this.loadNextChar() == 62) {
  645.                               break label254;
  646.                            }
  647.  
  648.                            this.fCurrentChunk = var12;
  649.                            this.fCurrentIndex = var14;
  650.                            super.fCurrentOffset = var16;
  651.                            this.fMostRecentData = var12.fData;
  652.                            this.fMostRecentChar = 93;
  653.                         } else if (this.fMostRecentData[this.fCurrentIndex + 1] == '>') {
  654.                            ++this.fCurrentIndex;
  655.                            ++super.fCurrentOffset;
  656.                            break label254;
  657.                         }
  658.                      }
  659.                      break;
  660.                   case 4:
  661.                      return 4;
  662.                   case 5:
  663.                      label229:
  664.                      while(true) {
  665.                         if (var3 == 10) {
  666.                            ++super.fLinefeedCounter;
  667.                            super.fCharacterCounter = 1;
  668.                         } else {
  669.                            ++super.fCharacterCounter;
  670.                         }
  671.  
  672.                         ++super.fCurrentOffset;
  673.                         if (++this.fCurrentIndex == 16384) {
  674.                            var3 = this.slowLoadNextChar();
  675.                         } else {
  676.                            var3 = this.fMostRecentChar = this.fMostRecentData[this.fCurrentIndex] & '\uffff';
  677.                         }
  678.  
  679.                         if (var3 != 32 && var3 != 9 && var3 != 10) {
  680.                            if (var3 < 128) {
  681.                               switch (XMLReader.fgAsciiCharData[var3]) {
  682.                                  case 0:
  683.                                     ++super.fCharacterCounter;
  684.                                     ++super.fCurrentOffset;
  685.                                     if (++this.fCurrentIndex == 16384) {
  686.                                        this.slowLoadNextChar();
  687.                                     } else {
  688.                                        this.fMostRecentChar = this.fMostRecentData[this.fCurrentIndex] & '\uffff';
  689.                                     }
  690.                                     break label229;
  691.                                  case 1:
  692.                                     if (!var1.inCDSect) {
  693.                                        if (this.fDocumentHandler != null) {
  694.                                           this.callWSCharDataHandler(var8, super.fCurrentOffset, false);
  695.                                        }
  696.  
  697.                                        ++super.fCharacterCounter;
  698.                                        this.loadNextChar();
  699.                                        return 25;
  700.                                     }
  701.  
  702.                                     ++super.fCharacterCounter;
  703.                                     ++super.fCurrentOffset;
  704.                                     if (++this.fCurrentIndex == 16384) {
  705.                                        this.slowLoadNextChar();
  706.                                     } else {
  707.                                        this.fMostRecentChar = this.fMostRecentData[this.fCurrentIndex] & '\uffff';
  708.                                     }
  709.                                     break label229;
  710.                                  case 2:
  711.                                     if (!var1.inCDSect) {
  712.                                        if (this.fDocumentHandler != null) {
  713.                                           this.callWSCharDataHandler(var8, super.fCurrentOffset, false);
  714.                                        }
  715.  
  716.                                        ++super.fCharacterCounter;
  717.                                        this.loadNextChar();
  718.                                        return 26;
  719.                                     }
  720.  
  721.                                     ++super.fCharacterCounter;
  722.                                     this.loadNextChar();
  723.                                     break label229;
  724.                                  case 3:
  725.                                     var4 = super.fCurrentOffset;
  726.                                     var3 = this.loadNextChar();
  727.                                     if (var3 != 93) {
  728.                                        ++super.fCharacterCounter;
  729.                                     } else if (this.fCurrentIndex + 1 == 16384) {
  730.                                        CharDataChunk var5 = this.fCurrentChunk;
  731.                                        int var6 = this.fCurrentIndex;
  732.                                        int var7 = super.fCurrentOffset;
  733.                                        if (this.loadNextChar() == 62) {
  734.                                           break label246;
  735.                                        }
  736.  
  737.                                        this.fCurrentChunk = var5;
  738.                                        this.fCurrentIndex = var6;
  739.                                        super.fCurrentOffset = var7;
  740.                                        this.fMostRecentData = var5.fData;
  741.                                        this.fMostRecentChar = 93;
  742.                                        ++super.fCharacterCounter;
  743.                                     } else {
  744.                                        if (this.fMostRecentData[this.fCurrentIndex + 1] == '>') {
  745.                                           ++this.fCurrentIndex;
  746.                                           ++super.fCurrentOffset;
  747.                                           break label246;
  748.                                        }
  749.  
  750.                                        ++super.fCharacterCounter;
  751.                                     }
  752.                                     break label229;
  753.                                  case 4:
  754.                                     if (this.fDocumentHandler != null) {
  755.                                        this.callWSCharDataHandler(var8, super.fCurrentOffset, var1.inCDSect);
  756.                                     }
  757.  
  758.                                     return 28;
  759.                               }
  760.                            } else if (!this.skipMultiByteCharData(var3)) {
  761.                               if (this.fDocumentHandler != null) {
  762.                                  this.callWSCharDataHandler(var8, super.fCurrentOffset, var1.inCDSect);
  763.                               }
  764.  
  765.                               return 28;
  766.                            }
  767.                            break;
  768.                         }
  769.                      }
  770.                }
  771.             } else if (!this.skipMultiByteCharData(var3)) {
  772.                return 4;
  773.             }
  774.  
  775.             var3 = this.skipAsciiCharData();
  776.  
  777.             label199:
  778.             while(true) {
  779.                while(var3 >= 128) {
  780.                   if (!this.skipMultiByteCharData(var3)) {
  781.                      if (this.fDocumentHandler != null) {
  782.                         this.callCharDataHandler(var8, super.fCurrentOffset, var1.inCDSect);
  783.                      }
  784.  
  785.                      return 12;
  786.                   }
  787.  
  788.                   var3 = this.fMostRecentChar;
  789.                }
  790.  
  791.                switch (XMLReader.fgAsciiCharData[var3]) {
  792.                   case 0:
  793.                      ++super.fCharacterCounter;
  794.                      var3 = this.loadNextChar();
  795.                      break;
  796.                   case 1:
  797.                      if (!var1.inCDSect) {
  798.                         if (this.fDocumentHandler != null) {
  799.                            this.callCharDataHandler(var8, super.fCurrentOffset, false);
  800.                         }
  801.  
  802.                         ++super.fCharacterCounter;
  803.                         ++super.fCurrentOffset;
  804.                         if (++this.fCurrentIndex == 16384) {
  805.                            this.slowLoadNextChar();
  806.                         } else {
  807.                            this.fMostRecentChar = this.fMostRecentData[this.fCurrentIndex] & '\uffff';
  808.                         }
  809.  
  810.                         return 9;
  811.                      }
  812.  
  813.                      ++super.fCharacterCounter;
  814.                      var3 = this.loadNextChar();
  815.                      break;
  816.                   case 2:
  817.                      if (!var1.inCDSect) {
  818.                         if (this.fDocumentHandler != null) {
  819.                            this.callCharDataHandler(var8, super.fCurrentOffset, false);
  820.                         }
  821.  
  822.                         ++super.fCharacterCounter;
  823.                         this.loadNextChar();
  824.                         return 10;
  825.                      }
  826.  
  827.                      ++super.fCharacterCounter;
  828.                      var3 = this.loadNextChar();
  829.                      break;
  830.                   case 3:
  831.                      var4 = super.fCurrentOffset;
  832.                      var3 = this.loadNextChar();
  833.                      if (var3 == 93) {
  834.                         if (this.fCurrentIndex + 1 == 16384) {
  835.                            CharDataChunk var15 = this.fCurrentChunk;
  836.                            int var17 = this.fCurrentIndex;
  837.                            int var18 = super.fCurrentOffset;
  838.                            if (this.loadNextChar() == 62) {
  839.                               break label199;
  840.                            }
  841.  
  842.                            this.fCurrentChunk = var15;
  843.                            this.fCurrentIndex = var17;
  844.                            super.fCurrentOffset = var18;
  845.                            this.fMostRecentData = var15.fData;
  846.                            this.fMostRecentChar = 93;
  847.                            ++super.fCharacterCounter;
  848.                         } else {
  849.                            if (this.fMostRecentData[this.fCurrentIndex + 1] == '>') {
  850.                               ++this.fCurrentIndex;
  851.                               ++super.fCurrentOffset;
  852.                               break label199;
  853.                            }
  854.  
  855.                            ++super.fCharacterCounter;
  856.                         }
  857.                         break;
  858.                      }
  859.  
  860.                      ++super.fCharacterCounter;
  861.                      break;
  862.                   case 4:
  863.                      if (var3 != 10) {
  864.                         if (this.fDocumentHandler != null) {
  865.                            this.callCharDataHandler(var8, super.fCurrentOffset, var1.inCDSect);
  866.                         }
  867.  
  868.                         return 12;
  869.                      }
  870.  
  871.                      ++super.fLinefeedCounter;
  872.                      super.fCharacterCounter = 1;
  873.                      var3 = this.loadNextChar();
  874.                }
  875.             }
  876.  
  877.             this.loadNextChar();
  878.             if (this.fDocumentHandler != null) {
  879.                this.callCharDataHandler(var8, var4, var1.inCDSect);
  880.             }
  881.  
  882.             super.fCharacterCounter += 3;
  883.             if (var1.inCDSect) {
  884.                var1.inCDSect = false;
  885.                return this.scanContent(var1);
  886.             }
  887.  
  888.             return 11;
  889.          }
  890.  
  891.          this.loadNextChar();
  892.          super.fCharacterCounter += 2;
  893.          if (var1.inCDSect) {
  894.             var1.inCDSect = false;
  895.             return this.scanContent(var1);
  896.          }
  897.  
  898.          return 3;
  899.       }
  900.  
  901.       this.loadNextChar();
  902.       if (this.fDocumentHandler != null) {
  903.          this.callWSCharDataHandler(var8, var4, var1.inCDSect);
  904.       }
  905.  
  906.       super.fCharacterCounter += 3;
  907.       if (var1.inCDSect) {
  908.          var1.inCDSect = false;
  909.          return this.scanContent(var1);
  910.       } else {
  911.          return 27;
  912.       }
  913.    }
  914.  
  915.    protected boolean skipMultiByteCharData(int var1) throws Exception {
  916.       if (var1 > 65533) {
  917.          return false;
  918.       } else if (var1 >= 901120 && var1 < 57344) {
  919.          return false;
  920.       } else {
  921.          if (var1 >= 884736 && var1 < 56320) {
  922.             var1 = this.loadNextChar();
  923.             if (var1 < 901120 || var1 >= 57344) {
  924.                return false;
  925.             }
  926.          }
  927.  
  928.          this.loadNextChar();
  929.          return true;
  930.       }
  931.    }
  932.  
  933.    protected int skipAsciiCharData() throws Exception {
  934.       int var1 = this.fCurrentIndex;
  935.       int var2 = super.fCurrentOffset - var1;
  936.  
  937.       while(true) {
  938.          for(char[] var3 = this.fMostRecentData; var1 < 16384; ++var1) {
  939.             int var4 = var3[var1] & '\uffff';
  940.             if (var4 >= 128) {
  941.                super.fCurrentOffset = var2 + var1;
  942.                this.fCurrentIndex = var1;
  943.                this.fMostRecentChar = var4;
  944.                return var4;
  945.             }
  946.  
  947.             if (XMLReader.fgAsciiCharData[var4] != 0) {
  948.                if (var4 != 10) {
  949.                   super.fCurrentOffset = var2 + var1;
  950.                   this.fCurrentIndex = var1;
  951.                   this.fMostRecentChar = var4;
  952.                   return var4;
  953.                }
  954.  
  955.                ++super.fLinefeedCounter;
  956.                super.fCharacterCounter = 1;
  957.             } else {
  958.                ++super.fCharacterCounter;
  959.             }
  960.          }
  961.  
  962.          var2 += var1;
  963.          this.fCurrentChunk = new CharDataChunk(this, this.fStringPool, this.fCurrentChunk);
  964.          this.fillCurrentChunk();
  965.          var1 = 0;
  966.       }
  967.    }
  968.  
  969.    public void callCharDataHandler(int var1, int var2, boolean var3) throws Exception {
  970.       int var4 = var2 - var1;
  971.       if (!this.fDocumentHandler.sendCharDataAsCharArray()) {
  972.          int var9 = var4 == 0 ? 0 : this.fCurrentChunk.addString(var1, var4);
  973.          this.fDocumentHandler.characters(var9, var3);
  974.       } else {
  975.          CharDataChunk var5 = this.fCurrentChunk.chunkFor(var1);
  976.          int var6 = var1 & 16383;
  977.          if (var6 + var4 <= 16384) {
  978.             if (var4 != 0) {
  979.                this.fDocumentHandler.characters(var5.fData, var6, var4, var3);
  980.             }
  981.  
  982.          } else {
  983.             int var8 = 16384 - var6;
  984.             this.fDocumentHandler.characters(var5.fData, var6, var8, var3);
  985.             int var7 = var4 - var8;
  986.  
  987.             do {
  988.                var5 = var5.fNextChunk;
  989.                if (var5 == null) {
  990.                   this.fErrorHandler.error(167);
  991.                }
  992.  
  993.                var8 = var7 <= 16384 ? var7 : 16384;
  994.                this.fDocumentHandler.characters(var5.fData, 0, var8, var3);
  995.                var7 -= var8;
  996.             } while(var7 > 0);
  997.  
  998.          }
  999.       }
  1000.    }
  1001.  
  1002.    public void callWSCharDataHandler(int var1, int var2, boolean var3) throws Exception {
  1003.       int var4 = this.fScanner.getCurrentContentSpecType();
  1004.       if (var4 != 4) {
  1005.          this.callCharDataHandler(var1, var2, var3);
  1006.       } else {
  1007.          int var5 = var2 - var1;
  1008.          if (!this.fDocumentHandler.sendCharDataAsCharArray()) {
  1009.             int var10 = var5 == 0 ? 0 : this.fCurrentChunk.addString(var1, var5);
  1010.             this.fDocumentHandler.ignorableWhitespace(var10, var3);
  1011.          } else {
  1012.             CharDataChunk var6 = this.fCurrentChunk.chunkFor(var1);
  1013.             int var7 = var1 & 16383;
  1014.             if (var7 + var5 <= 16384) {
  1015.                if (var5 != 0) {
  1016.                   this.fDocumentHandler.ignorableWhitespace(var6.fData, var7, var5, var3);
  1017.                }
  1018.  
  1019.             } else {
  1020.                int var9 = 16384 - var7;
  1021.                this.fDocumentHandler.ignorableWhitespace(var6.fData, var7, var9, var3);
  1022.                int var8 = var5 - var9;
  1023.  
  1024.                do {
  1025.                   var6 = var6.fNextChunk;
  1026.                   var9 = var8 <= 16384 ? var8 : 16384;
  1027.                   this.fDocumentHandler.ignorableWhitespace(var6.fData, 0, var9, var3);
  1028.                   var8 -= var9;
  1029.                } while(var8 > 0);
  1030.  
  1031.             }
  1032.          }
  1033.       }
  1034.    }
  1035.  
  1036.    protected int fillCurrentChunk() throws Exception {
  1037.       this.fOutputOffset = 0;
  1038.       if (this.fCheckOverflow) {
  1039.          if (this.fOverflowEnd < 16384) {
  1040.             if (this.fOverflowEnd > 0) {
  1041.                this.fMostRecentData = new char[1 + this.fOverflowEnd - this.fOverflowOffset];
  1042.                this.copyNormalize(this.fOverflow, this.fOverflowOffset, this.fMostRecentData, this.fOutputOffset);
  1043.             } else {
  1044.                this.fMostRecentData = new char[1];
  1045.             }
  1046.  
  1047.             this.fMostRecentData[this.fOutputOffset] = 0;
  1048.             this.fOverflow = null;
  1049.             this.fLength += this.fOutputOffset;
  1050.             this.fCurrentIndex = 0;
  1051.             CharDataChunk var1 = this.fCurrentChunk;
  1052.             char[] var2 = this.fMostRecentData;
  1053.             var1.fData = var2;
  1054.             return this.fMostRecentChar = this.fMostRecentData[0];
  1055.          }
  1056.  
  1057.          this.fMostRecentData = new char[16384];
  1058.          this.copyNormalize(this.fOverflow, this.fOverflowOffset, this.fMostRecentData, this.fOutputOffset);
  1059.          this.fCheckOverflow = false;
  1060.       } else {
  1061.          if (this.fOverflow == null) {
  1062.             this.fOverflow = new char[16384];
  1063.          }
  1064.  
  1065.          this.fMostRecentData = null;
  1066.       }
  1067.  
  1068.       while(true) {
  1069.          this.fOverflowOffset = 0;
  1070.          this.fOverflowEnd = 0;
  1071.          int var4 = 16384;
  1072.          int var6 = 0;
  1073.  
  1074.          do {
  1075.             var6 = this.fReader.read(this.fOverflow, this.fOverflowEnd, var4);
  1076.             if (var6 == -1) {
  1077.                this.fReader.close();
  1078.                this.fReader = null;
  1079.                if (this.fMostRecentData == null) {
  1080.                   this.fMostRecentData = new char[1 + this.fOverflowEnd];
  1081.                   this.copyNormalize(this.fOverflow, this.fOverflowOffset, this.fMostRecentData, this.fOutputOffset);
  1082.                   this.fOverflow = null;
  1083.                   this.fMostRecentData[this.fOutputOffset] = 0;
  1084.                } else {
  1085.                   boolean var3 = this.copyNormalize(this.fOverflow, this.fOverflowOffset, this.fMostRecentData, this.fOutputOffset);
  1086.                   if (var3) {
  1087.                      if (this.fOverflowEnd == 16384) {
  1088.                         this.fCheckOverflow = true;
  1089.                         this.fOverflowOffset = 0;
  1090.                         this.fOverflowEnd = 0;
  1091.                      } else {
  1092.                         this.fOverflow = null;
  1093.                         this.fMostRecentData[this.fOutputOffset] = 0;
  1094.                      }
  1095.                   } else {
  1096.                      this.fCheckOverflow = true;
  1097.                   }
  1098.                }
  1099.                break;
  1100.             }
  1101.  
  1102.             if (var6 > 0) {
  1103.                this.fOverflowEnd += var6;
  1104.                var4 -= var6;
  1105.             }
  1106.          } while(var4 > 0);
  1107.  
  1108.          if (var6 == -1) {
  1109.             break;
  1110.          }
  1111.  
  1112.          if (this.fMostRecentData != null) {
  1113.             boolean var9 = this.copyNormalize(this.fOverflow, this.fOverflowOffset, this.fMostRecentData, this.fOutputOffset);
  1114.             if (this.fOutputOffset == 16384) {
  1115.                if (!var9) {
  1116.                   this.fCheckOverflow = true;
  1117.                }
  1118.                break;
  1119.             }
  1120.          } else {
  1121.             this.fMostRecentData = new char[16384];
  1122.             this.copyNormalize(this.fOverflow, this.fOverflowOffset, this.fMostRecentData, this.fOutputOffset);
  1123.             if (this.fOutputOffset == 16384) {
  1124.                break;
  1125.             }
  1126.          }
  1127.       }
  1128.  
  1129.       this.fLength += this.fOutputOffset;
  1130.       this.fCurrentIndex = 0;
  1131.       CharDataChunk var5 = this.fCurrentChunk;
  1132.       char[] var8 = this.fMostRecentData;
  1133.       var5.fData = var8;
  1134.       return this.fMostRecentChar = this.fMostRecentData[0];
  1135.    }
  1136.  
  1137.    protected boolean copyNormalize(char[] var1, int var2, char[] var3, int var4) throws Exception {
  1138.       int var5 = this.fOverflowEnd;
  1139.       int var6 = var3.length;
  1140.       if (var2 == var5) {
  1141.          return true;
  1142.       } else {
  1143.          char var7 = var1[var2];
  1144.          if (this.fSkipLinefeed) {
  1145.             this.fSkipLinefeed = false;
  1146.             if (var7 == '\n') {
  1147.                ++var2;
  1148.                if (var2 == var5) {
  1149.                   this.fOverflowOffset = var2;
  1150.                   this.fOutputOffset = var4;
  1151.                   return true;
  1152.                }
  1153.  
  1154.                var7 = var1[var2];
  1155.             }
  1156.          }
  1157.  
  1158.          while(var4 < var6) {
  1159.             int var8 = var5 - var2;
  1160.             int var9 = var6 - var4;
  1161.             if (var8 > var9) {
  1162.                var8 = var9;
  1163.             }
  1164.  
  1165.             ++var2;
  1166.  
  1167.             do {
  1168.                for(; var7 == '\r'; ++var2) {
  1169.                   var3[var4++] = '\n';
  1170.                   if (var2 == var5) {
  1171.                      this.fSkipLinefeed = true;
  1172.                      this.fOverflowOffset = var2;
  1173.                      this.fOutputOffset = var4;
  1174.                      return true;
  1175.                   }
  1176.  
  1177.                   var7 = var1[var2];
  1178.                   if (var7 == '\n') {
  1179.                      ++var2;
  1180.                      if (var2 == var5) {
  1181.                         this.fOverflowOffset = var2;
  1182.                         this.fOutputOffset = var4;
  1183.                         return true;
  1184.                      }
  1185.  
  1186.                      var7 = var1[var2];
  1187.                   }
  1188.  
  1189.                   if (var4 == var6) {
  1190.                      this.fOverflowOffset = var2;
  1191.                      this.fOutputOffset = var4;
  1192.                      return false;
  1193.                   }
  1194.  
  1195.                   var8 = var5 - var2;
  1196.                   var9 = var6 - var4;
  1197.                   if (var8 > var9) {
  1198.                      var8 = var9;
  1199.                   }
  1200.                }
  1201.  
  1202.                do {
  1203.                   var3[var4++] = var7;
  1204.                   --var8;
  1205.                   if (var8 == 0) {
  1206.                      break;
  1207.                   }
  1208.  
  1209.                   var7 = var1[var2++];
  1210.                } while(var7 != '\r');
  1211.             } while(var8 != 0);
  1212.  
  1213.             if (var2 == var5) {
  1214.                break;
  1215.             }
  1216.          }
  1217.  
  1218.          boolean var10 = var2 == var5;
  1219.          this.fOverflowOffset = var2;
  1220.          this.fOutputOffset = var4;
  1221.          return var10;
  1222.       }
  1223.    }
  1224.  
  1225.    protected boolean exitNormalize(int var1, int var2, boolean var3) {
  1226.       this.fOverflowOffset = var1;
  1227.       this.fOutputOffset = var2;
  1228.       return var3;
  1229.    }
  1230. }
  1231.