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 / UTF8CharReader.class (.txt) < prev    next >
Encoding:
Java Class File  |  1999-08-30  |  13.6 KB  |  1,568 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.InputStream;
  12.  
  13. final class UTF8CharReader 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 InputStream fInputStream;
  22.    protected UTF8CharDataChunk fCurrentChunk;
  23.    protected int fCurrentIndex;
  24.    protected char[] fMostRecentData;
  25.    protected int fMostRecentChar;
  26.    protected int fLength;
  27.    protected boolean fCheckOverflow = false;
  28.    protected byte[] fOverflow;
  29.    protected int fOverflowOffset;
  30.    protected int fOverflowEnd;
  31.    protected boolean fSkipLinefeed = false;
  32.    protected int fPartialMultiByteIn;
  33.    protected byte[] fPartialMultiByteChar = new byte[3];
  34.    protected int fPartialSurrogatePair;
  35.    protected boolean fPartialMultiByteResult = false;
  36.    protected int fFastCopyCount;
  37.    protected int fOutputOffset;
  38.  
  39.    UTF8CharReader(ParserState var1, String var2, String var3, InputStream var4) throws Exception {
  40.       super(var1, var2, var3);
  41.       this.fInputStream = var4;
  42.       this.fScanner = var1.getScanner();
  43.       this.fStringPool = var1.cacheStringPool();
  44.       this.fDocumentHandler = var1.getDocumentHandler();
  45.       this.fErrorHandler = var1.getErrorHandler();
  46.       this.fCurrentChunk = new UTF8CharDataChunk(this, this.fStringPool, (UTF8CharDataChunk)null);
  47.       this.fillCurrentChunk();
  48.    }
  49.  
  50.    public int addString(int var1, int var2) {
  51.       return var2 == 0 ? 0 : this.fCurrentChunk.addString(var1, var2);
  52.    }
  53.  
  54.    public int addSymbol(int var1, int var2) {
  55.       return var2 == 0 ? 0 : this.fCurrentChunk.addSymbol(var1, var2, 0);
  56.    }
  57.  
  58.    protected int addSymbol(int var1, int var2, int var3) {
  59.       return var2 == 0 ? 0 : this.fCurrentChunk.addSymbol(var1, var2, var3);
  60.    }
  61.  
  62.    public void append(ChunkyCharArray var1, int var2, int var3) {
  63.       this.fCurrentChunk.append(var1, var2, var3);
  64.    }
  65.  
  66.    protected int slowLoadNextChar() throws Exception {
  67.       UTF8CharDataChunk var1 = this.fCurrentChunk;
  68.       if (var1.fNextChunk != null) {
  69.          var1 = this.fCurrentChunk;
  70.          this.fCurrentChunk = var1.fNextChunk;
  71.          this.fCurrentIndex = 0;
  72.          var1 = this.fCurrentChunk;
  73.          this.fMostRecentData = var1.fData;
  74.          return this.fMostRecentChar = this.fMostRecentData[this.fCurrentIndex] & '\uffff';
  75.       } else {
  76.          this.fCurrentChunk = new UTF8CharDataChunk(this, this.fStringPool, this.fCurrentChunk);
  77.          return this.fillCurrentChunk();
  78.       }
  79.    }
  80.  
  81.    protected int loadNextChar() throws Exception {
  82.       ++super.fCurrentOffset;
  83.       return ++this.fCurrentIndex == 16384 ? this.slowLoadNextChar() : (this.fMostRecentChar = this.fMostRecentData[this.fCurrentIndex] & '\uffff');
  84.    }
  85.  
  86.    protected void checkEOF(int var1) {
  87.       if (var1 > this.fLength) {
  88.          throw new ArrayIndexOutOfBoundsException();
  89.       }
  90.    }
  91.  
  92.    public int skipOneChar() throws Exception {
  93.       int var1 = this.fMostRecentChar;
  94.       if (var1 == 0) {
  95.          int var2 = super.fCurrentOffset + 1;
  96.          if (var2 > this.fLength) {
  97.             throw new ArrayIndexOutOfBoundsException();
  98.          }
  99.  
  100.          ++super.fCharacterCounter;
  101.       } else if (var1 == 10) {
  102.          ++super.fLinefeedCounter;
  103.          super.fCharacterCounter = 1;
  104.       } else if (var1 >= 55296 && var1 < 56320) {
  105.          ++super.fCharacterCounter;
  106.          var1 = this.loadNextChar();
  107.          if (var1 < 56320 || var1 >= 57344) {
  108.             return super.fCurrentOffset;
  109.          }
  110.       } else {
  111.          ++super.fCharacterCounter;
  112.       }
  113.  
  114.       this.loadNextChar();
  115.       return super.fCurrentOffset;
  116.    }
  117.  
  118.    public int skipAsciiChar() throws Exception {
  119.       ++super.fCharacterCounter;
  120.       this.loadNextChar();
  121.       return super.fCurrentOffset;
  122.    }
  123.  
  124.    public int skipToChar(char var1) throws Exception {
  125.       int var2 = this.fMostRecentChar;
  126.  
  127.       while(var2 != var1) {
  128.          if (var2 == 0) {
  129.             int var3 = super.fCurrentOffset + 1;
  130.             if (var3 > this.fLength) {
  131.                throw new ArrayIndexOutOfBoundsException();
  132.             }
  133.  
  134.             ++super.fCharacterCounter;
  135.          } else if (var2 == 10) {
  136.             ++super.fLinefeedCounter;
  137.             super.fCharacterCounter = 1;
  138.          } else if (var2 >= 55296 && var2 < 56320) {
  139.             ++super.fCharacterCounter;
  140.             var2 = this.loadNextChar();
  141.             if (var2 < 56320 || var2 >= 57344) {
  142.                continue;
  143.             }
  144.          } else {
  145.             ++super.fCharacterCounter;
  146.          }
  147.  
  148.          var2 = this.loadNextChar();
  149.       }
  150.  
  151.       return super.fCurrentOffset;
  152.    }
  153.  
  154.    public int skipPastChar(char var1) throws Exception {
  155.       int var2 = this.fMostRecentChar;
  156.  
  157.       while(var2 != var1) {
  158.          if (var2 == 0) {
  159.             int var3 = super.fCurrentOffset + 1;
  160.             if (var3 > this.fLength) {
  161.                throw new ArrayIndexOutOfBoundsException();
  162.             }
  163.  
  164.             ++super.fCharacterCounter;
  165.          } else if (var2 == 10) {
  166.             ++super.fLinefeedCounter;
  167.             super.fCharacterCounter = 1;
  168.          } else if (var2 >= 55296 && var2 < 56320) {
  169.             ++super.fCharacterCounter;
  170.             var2 = this.loadNextChar();
  171.             if (var2 < 56320 || var2 >= 57344) {
  172.                continue;
  173.             }
  174.          } else {
  175.             ++super.fCharacterCounter;
  176.          }
  177.  
  178.          var2 = this.loadNextChar();
  179.       }
  180.  
  181.       ++super.fCharacterCounter;
  182.       this.loadNextChar();
  183.       return super.fCurrentOffset;
  184.    }
  185.  
  186.    public boolean skippedValidChar() throws Exception {
  187.       int var1 = this.fMostRecentChar;
  188.       if (var1 < 55296) {
  189.          if (var1 < 32 && var1 != 9) {
  190.             if (var1 == 10) {
  191.                ++super.fLinefeedCounter;
  192.                super.fCharacterCounter = 1;
  193.                this.loadNextChar();
  194.                return true;
  195.             } else {
  196.                if (var1 == 0) {
  197.                   int var2 = super.fCurrentOffset + 1;
  198.                   if (var2 > this.fLength) {
  199.                      throw new ArrayIndexOutOfBoundsException();
  200.                   }
  201.                }
  202.  
  203.                return false;
  204.             }
  205.          } else {
  206.             ++super.fCharacterCounter;
  207.             this.loadNextChar();
  208.             return true;
  209.          }
  210.       } else if (var1 > 65533) {
  211.          return false;
  212.       } else {
  213.          if (var1 < 56320) {
  214.             var1 = this.loadNextChar();
  215.             if (var1 < 56320 || var1 >= 57344) {
  216.                return false;
  217.             }
  218.          } else if (var1 < 57344) {
  219.             return false;
  220.          }
  221.  
  222.          ++super.fCharacterCounter;
  223.          this.loadNextChar();
  224.          return true;
  225.       }
  226.    }
  227.  
  228.    public boolean lookingAtValidChar() throws Exception {
  229.       int var1 = this.fMostRecentChar;
  230.       if (var1 < 32) {
  231.          if (var1 == 0) {
  232.             int var2 = super.fCurrentOffset + 1;
  233.             if (var2 > this.fLength) {
  234.                throw new ArrayIndexOutOfBoundsException();
  235.             }
  236.          }
  237.  
  238.          return var1 == 9 || var1 == 10 || var1 == 13;
  239.       } else {
  240.          return var1 <= 65533;
  241.       }
  242.    }
  243.  
  244.    public int skipInvalidChar(int var1) throws Exception {
  245.       int var2 = this.fMostRecentChar;
  246.       if (var2 == 10) {
  247.          ++super.fLinefeedCounter;
  248.          super.fCharacterCounter = 1;
  249.          this.loadNextChar();
  250.       } else {
  251.          ++super.fCharacterCounter;
  252.          if (var2 >= 55296 && var2 < 56320) {
  253.             int var3 = this.loadNextChar();
  254.             if (var3 >= 56320 && var3 < 57344) {
  255.                var2 = (var2 - '\ud800' << 10) + (var3 - '\udc00') + 65536;
  256.                this.loadNextChar();
  257.             }
  258.          } else {
  259.             this.loadNextChar();
  260.          }
  261.       }
  262.  
  263.       switch (var1) {
  264.          case 43:
  265.             String var7 = var2 < 65536 ? (new Character((char)var2)).toString() : Integer.toHexString(var2);
  266.             String var4 = Integer.toHexString(var2);
  267.             this.fErrorHandler.error2(var1, this.fStringPool.addString(var7), this.fStringPool.addString(var4));
  268.             break;
  269.          case 63:
  270.          case 85:
  271.             String var6 = Integer.toHexString(var2);
  272.             this.fErrorHandler.error1(var1, this.fStringPool.addString(var6));
  273.             break;
  274.          case 80:
  275.          case 82:
  276.          case 110:
  277.             String var5 = var2 < 65536 ? (new Character((char)var2)).toString() : Integer.toHexString(var2);
  278.             this.fErrorHandler.error1(var1, this.fStringPool.addString(var5));
  279.       }
  280.  
  281.       return super.fCurrentOffset;
  282.    }
  283.  
  284.    public boolean skippedChar(char var1) throws Exception {
  285.       int var2 = this.fMostRecentChar;
  286.       if (var2 != var1) {
  287.          if (var2 == 0) {
  288.             int var3 = super.fCurrentOffset + 1;
  289.             if (var3 > this.fLength) {
  290.                throw new ArrayIndexOutOfBoundsException();
  291.             }
  292.          }
  293.  
  294.          return false;
  295.       } else {
  296.          ++super.fCharacterCounter;
  297.          ++super.fCurrentOffset;
  298.          if (++this.fCurrentIndex == 16384) {
  299.             this.slowLoadNextChar();
  300.          } else {
  301.             this.fMostRecentChar = this.fMostRecentData[this.fCurrentIndex] & '\uffff';
  302.          }
  303.  
  304.          return true;
  305.       }
  306.    }
  307.  
  308.    public boolean lookingAtChar(char var1) throws Exception {
  309.       int var2 = this.fMostRecentChar;
  310.       return var2 == var1;
  311.    }
  312.  
  313.    public boolean skippedSpace() throws Exception {
  314.       int var1 = this.fMostRecentChar;
  315.       if (var1 > 32) {
  316.          return false;
  317.       } else {
  318.          if (var1 != 32 && var1 != 9) {
  319.             if (var1 != 10) {
  320.                if (var1 == 0) {
  321.                   int var2 = super.fCurrentOffset + 1;
  322.                   if (var2 > this.fLength) {
  323.                      throw new ArrayIndexOutOfBoundsException();
  324.                   }
  325.                }
  326.  
  327.                return false;
  328.             }
  329.  
  330.             ++super.fLinefeedCounter;
  331.             super.fCharacterCounter = 1;
  332.          } else {
  333.             ++super.fCharacterCounter;
  334.          }
  335.  
  336.          ++super.fCurrentOffset;
  337.          if (++this.fCurrentIndex == 16384) {
  338.             this.slowLoadNextChar();
  339.          } else {
  340.             this.fMostRecentChar = this.fMostRecentData[this.fCurrentIndex] & '\uffff';
  341.          }
  342.  
  343.          return true;
  344.       }
  345.    }
  346.  
  347.    public boolean lookingAtSpace() {
  348.       int var1 = this.fMostRecentChar;
  349.       return var1 == 32 || var1 == 9 || var1 == 10;
  350.    }
  351.  
  352.    public int skipPastSpaces() throws Exception {
  353.       int var1 = this.fMostRecentChar;
  354.       int var2 = super.fCurrentOffset;
  355.  
  356.       while(true) {
  357.          if (var1 != 32 && var1 != 9) {
  358.             if (var1 != 10) {
  359.                if (var1 == 0 && var2 == super.fCurrentOffset) {
  360.                   int var3 = super.fCurrentOffset + 1;
  361.                   if (var3 > this.fLength) {
  362.                      throw new ArrayIndexOutOfBoundsException();
  363.                   }
  364.                }
  365.  
  366.                return super.fCurrentOffset;
  367.             }
  368.  
  369.             ++super.fLinefeedCounter;
  370.             super.fCharacterCounter = 1;
  371.          } else {
  372.             ++super.fCharacterCounter;
  373.          }
  374.  
  375.          var1 = this.loadNextChar();
  376.       }
  377.    }
  378.  
  379.    public int skipDecimalDigit() throws Exception {
  380.       int var1 = this.fMostRecentChar;
  381.       if (var1 >= 48 && var1 <= 57) {
  382.          ++super.fCharacterCounter;
  383.          this.loadNextChar();
  384.          return var1 - 48;
  385.       } else {
  386.          return -1;
  387.       }
  388.    }
  389.  
  390.    public int skipHexDigit() throws Exception {
  391.       int var1 = this.fMostRecentChar;
  392.       if (var1 <= 102 && XMLReader.fgAsciiXDigitChar[var1] != 0) {
  393.          ++super.fCharacterCounter;
  394.          this.loadNextChar();
  395.          return var1 - (var1 < 65 ? 48 : (var1 < 97 ? 65 : 97) - 10);
  396.       } else {
  397.          return -1;
  398.       }
  399.    }
  400.  
  401.    public boolean skippedAlpha() throws Exception {
  402.       int var1 = this.fMostRecentChar;
  403.       if (var1 <= 122 && XMLReader.fgAsciiAlphaChar[var1] != 0) {
  404.          ++super.fCharacterCounter;
  405.          this.loadNextChar();
  406.          return true;
  407.       } else {
  408.          return false;
  409.       }
  410.    }
  411.  
  412.    protected boolean skippedAsciiCharWithFlag(byte var1) throws Exception {
  413.       int var2 = this.fMostRecentChar;
  414.       if (var2 < 128 && (XMLReader.fgCharFlags[var2] & var1) != 0) {
  415.          ++super.fCharacterCounter;
  416.          this.loadNextChar();
  417.          return true;
  418.       } else {
  419.          return false;
  420.       }
  421.    }
  422.  
  423.    public boolean skippedVersionNum() throws Exception {
  424.       return this.skippedAsciiCharWithFlag((byte)1);
  425.    }
  426.  
  427.    public boolean skippedEncName() throws Exception {
  428.       return this.skippedAsciiCharWithFlag((byte)2);
  429.    }
  430.  
  431.    public boolean skippedPubidChar() throws Exception {
  432.       int var1 = this.fMostRecentChar;
  433.       if (var1 >= 128) {
  434.          return false;
  435.       } else if ((XMLReader.fgCharFlags[var1] & 4) != 0) {
  436.          ++super.fCharacterCounter;
  437.          this.loadNextChar();
  438.          return true;
  439.       } else if (var1 == 10) {
  440.          ++super.fLinefeedCounter;
  441.          super.fCharacterCounter = 1;
  442.          this.loadNextChar();
  443.          return true;
  444.       } else {
  445.          return false;
  446.       }
  447.    }
  448.  
  449.    public boolean skippedString(char[] var1) throws Exception {
  450.       int var2 = var1.length;
  451.       char[] var3 = this.fMostRecentData;
  452.       int var4 = this.fCurrentIndex;
  453.       if (var4 + var2 <= 16384) {
  454.          for(int var11 = 0; var11 < var2; ++var11) {
  455.             if (var3[var4++] != var1[var11]) {
  456.                return false;
  457.             }
  458.          }
  459.  
  460.          super.fCharacterCounter += var2;
  461.          super.fCurrentOffset += var2;
  462.          this.fCurrentIndex = var4;
  463.          if (var4 == 16384) {
  464.             this.slowLoadNextChar();
  465.          } else {
  466.             this.fMostRecentChar = var3[var4] & '\uffff';
  467.          }
  468.  
  469.          return true;
  470.       } else {
  471.          UTF8CharDataChunk var5 = this.fCurrentChunk;
  472.          int var6 = super.fCurrentOffset;
  473.          int var7 = var4;
  474.          int var8 = 0;
  475.  
  476.          while(var4 < 16384) {
  477.             if (var3[var4++] != var1[var8++]) {
  478.                return false;
  479.             }
  480.          }
  481.  
  482.          this.slowLoadNextChar();
  483.          var3 = this.fMostRecentData;
  484.          var4 = 0;
  485.  
  486.          while(var8 < var2) {
  487.             if (var3[var4++] != var1[var8++]) {
  488.                this.fCurrentChunk = var5;
  489.                this.fCurrentIndex = var7;
  490.                super.fCurrentOffset = var6;
  491.                this.fMostRecentData = var5.fData;
  492.                this.fMostRecentChar = this.fMostRecentData[var7] & '\uffff';
  493.                return false;
  494.             }
  495.          }
  496.  
  497.          super.fCharacterCounter += var2;
  498.          super.fCurrentOffset += var2;
  499.          this.fCurrentIndex = var4;
  500.          if (var4 == 16384) {
  501.             this.slowLoadNextChar();
  502.          } else {
  503.             this.fMostRecentChar = var3[var4] & '\uffff';
  504.          }
  505.  
  506.          return true;
  507.       }
  508.    }
  509.  
  510.    public int scanName(char var1, int var2) throws Exception {
  511.       int var3 = this.fMostRecentChar;
  512.       if (var3 < 128) {
  513.          if (XMLReader.fgAsciiInitialNameChar[var3] == 0) {
  514.             return -1;
  515.          }
  516.       } else if ((XMLReader.fgCharFlags[var3] & 16) == 0) {
  517.          return -1;
  518.       }
  519.  
  520.       int var4 = super.fCurrentOffset;
  521.       int var5 = this.fCurrentIndex;
  522.       char[] var6 = this.fMostRecentData;
  523.       ++var5;
  524.       if (var5 == 16384) {
  525.          this.fCurrentChunk = new UTF8CharDataChunk(this, this.fStringPool, this.fCurrentChunk);
  526.          this.fillCurrentChunk();
  527.          var5 = 0;
  528.          var6 = this.fMostRecentData;
  529.       }
  530.  
  531.       ++super.fCharacterCounter;
  532.       ++super.fCurrentOffset;
  533.       int var7 = 0;
  534.       int var8 = 0;
  535.  
  536.       while(true) {
  537.          var7 = StringHasher.hashChar(var7, var8++, var3);
  538.          var3 = var6[var5] & '\uffff';
  539.          if (var1 == var3) {
  540.             break;
  541.          }
  542.  
  543.          if (var3 < 128) {
  544.             if (XMLReader.fgAsciiNameChar[var3] == 0) {
  545.                break;
  546.             }
  547.          } else if ((XMLReader.fgCharFlags[var3] & 32) == 0) {
  548.             break;
  549.          }
  550.  
  551.          ++var5;
  552.          if (var5 == 16384) {
  553.             this.fCurrentChunk = new UTF8CharDataChunk(this, this.fStringPool, this.fCurrentChunk);
  554.             this.fillCurrentChunk();
  555.             var5 = 0;
  556.             var6 = this.fMostRecentData;
  557.          }
  558.  
  559.          ++super.fCharacterCounter;
  560.          ++super.fCurrentOffset;
  561.       }
  562.  
  563.       this.fCurrentIndex = var5;
  564.       this.fMostRecentChar = var3;
  565.       var7 = StringHasher.finishHash(var7);
  566.       int var9 = super.fCurrentOffset - var4;
  567.       int var10 = var9 == 0 ? 0 : this.fCurrentChunk.addSymbol(var4, var9, var7);
  568.       return var2 != -1 && var2 != var10 ? -1 : var10;
  569.    }
  570.  
  571.    public int skipPastName(char var1) throws Exception {
  572.       int var2 = this.fMostRecentChar;
  573.       if (var2 < 128) {
  574.          if (XMLReader.fgAsciiInitialNameChar[var2] == 0) {
  575.             return super.fCurrentOffset;
  576.          }
  577.       } else if ((XMLReader.fgCharFlags[var2] & 16) == 0) {
  578.          return super.fCurrentOffset;
  579.       }
  580.  
  581.       while(true) {
  582.          ++super.fCharacterCounter;
  583.          var2 = this.loadNextChar();
  584.          if (var1 == var2) {
  585.             return super.fCurrentOffset;
  586.          }
  587.  
  588.          if (var2 < 128) {
  589.             if (XMLReader.fgAsciiNameChar[var2] == 0) {
  590.                return super.fCurrentOffset;
  591.             }
  592.          } else if ((XMLReader.fgCharFlags[var2] & 32) == 0) {
  593.             return super.fCurrentOffset;
  594.          }
  595.       }
  596.    }
  597.  
  598.    public int skipPastNmtoken(char var1) throws Exception {
  599.       for(int var2 = this.fMostRecentChar; var1 != var2; var2 = this.loadNextChar()) {
  600.          if (var2 < 128) {
  601.             if (XMLReader.fgAsciiNameChar[var2] == 0) {
  602.                return super.fCurrentOffset;
  603.             }
  604.          } else if ((XMLReader.fgCharFlags[var2] & 32) == 0) {
  605.             return super.fCurrentOffset;
  606.          }
  607.  
  608.          ++super.fCharacterCounter;
  609.       }
  610.  
  611.       return super.fCurrentOffset;
  612.    }
  613.  
  614.    public int scanContent(ScanContentState var1) throws Exception {
  615.       UTF8CharDataChunk var2 = this.fCurrentChunk;
  616.       if (var2.fPreviousChunk != null) {
  617.          var2.fPreviousChunk.fNextChunk = null;
  618.          var2.fPreviousChunk = null;
  619.       }
  620.  
  621.       int var4;
  622.       label246: {
  623.          label254: {
  624.             var8 = super.fCurrentOffset;
  625.             int var3 = this.fMostRecentChar;
  626.             if (var3 < 128) {
  627.                switch (XMLReader.fgAsciiWSCharData[var3]) {
  628.                   case 0:
  629.                      ++super.fCharacterCounter;
  630.                      ++super.fCurrentOffset;
  631.                      if (++this.fCurrentIndex == 16384) {
  632.                         this.slowLoadNextChar();
  633.                      } else {
  634.                         this.fMostRecentChar = this.fMostRecentData[this.fCurrentIndex] & '\uffff';
  635.                      }
  636.                      break;
  637.                   case 1:
  638.                      ++super.fCharacterCounter;
  639.                      ++super.fCurrentOffset;
  640.                      if (++this.fCurrentIndex == 16384) {
  641.                         this.slowLoadNextChar();
  642.                      } else {
  643.                         this.fMostRecentChar = this.fMostRecentData[this.fCurrentIndex] & '\uffff';
  644.                      }
  645.  
  646.                      if (!var1.inCDSect) {
  647.                         return 1;
  648.                      }
  649.                      break;
  650.                   case 2:
  651.                      ++super.fCharacterCounter;
  652.                      ++super.fCurrentOffset;
  653.                      if (++this.fCurrentIndex == 16384) {
  654.                         this.slowLoadNextChar();
  655.                      } else {
  656.                         this.fMostRecentChar = this.fMostRecentData[this.fCurrentIndex] & '\uffff';
  657.                      }
  658.  
  659.                      if (!var1.inCDSect) {
  660.                         return 2;
  661.                      }
  662.                      break;
  663.                   case 3:
  664.                      ++super.fCharacterCounter;
  665.                      var3 = this.loadNextChar();
  666.                      if (var3 == 93) {
  667.                         if (this.fCurrentIndex + 1 == 16384) {
  668.                            UTF8CharDataChunk var12 = this.fCurrentChunk;
  669.                            int var14 = this.fCurrentIndex;
  670.                            int var16 = super.fCurrentOffset;
  671.                            if (this.loadNextChar() == 62) {
  672.                               break label254;
  673.                            }
  674.  
  675.                            this.fCurrentChunk = var12;
  676.                            this.fCurrentIndex = var14;
  677.                            super.fCurrentOffset = var16;
  678.                            this.fMostRecentData = var12.fData;
  679.                            this.fMostRecentChar = 93;
  680.                         } else if (this.fMostRecentData[this.fCurrentIndex + 1] == '>') {
  681.                            ++this.fCurrentIndex;
  682.                            ++super.fCurrentOffset;
  683.                            break label254;
  684.                         }
  685.                      }
  686.                      break;
  687.                   case 4:
  688.                      return 4;
  689.                   case 5:
  690.                      label229:
  691.                      while(true) {
  692.                         if (var3 == 10) {
  693.                            ++super.fLinefeedCounter;
  694.                            super.fCharacterCounter = 1;
  695.                         } else {
  696.                            ++super.fCharacterCounter;
  697.                         }
  698.  
  699.                         ++super.fCurrentOffset;
  700.                         if (++this.fCurrentIndex == 16384) {
  701.                            var3 = this.slowLoadNextChar();
  702.                         } else {
  703.                            var3 = this.fMostRecentChar = this.fMostRecentData[this.fCurrentIndex] & '\uffff';
  704.                         }
  705.  
  706.                         if (var3 != 32 && var3 != 9 && var3 != 10) {
  707.                            if (var3 < 128) {
  708.                               switch (XMLReader.fgAsciiCharData[var3]) {
  709.                                  case 0:
  710.                                     ++super.fCharacterCounter;
  711.                                     ++super.fCurrentOffset;
  712.                                     if (++this.fCurrentIndex == 16384) {
  713.                                        this.slowLoadNextChar();
  714.                                     } else {
  715.                                        this.fMostRecentChar = this.fMostRecentData[this.fCurrentIndex] & '\uffff';
  716.                                     }
  717.                                     break label229;
  718.                                  case 1:
  719.                                     if (!var1.inCDSect) {
  720.                                        if (this.fDocumentHandler != null) {
  721.                                           this.callWSCharDataHandler(var8, super.fCurrentOffset, false);
  722.                                        }
  723.  
  724.                                        ++super.fCharacterCounter;
  725.                                        this.loadNextChar();
  726.                                        return 25;
  727.                                     }
  728.  
  729.                                     ++super.fCharacterCounter;
  730.                                     ++super.fCurrentOffset;
  731.                                     if (++this.fCurrentIndex == 16384) {
  732.                                        this.slowLoadNextChar();
  733.                                     } else {
  734.                                        this.fMostRecentChar = this.fMostRecentData[this.fCurrentIndex] & '\uffff';
  735.                                     }
  736.                                     break label229;
  737.                                  case 2:
  738.                                     if (!var1.inCDSect) {
  739.                                        if (this.fDocumentHandler != null) {
  740.                                           this.callWSCharDataHandler(var8, super.fCurrentOffset, false);
  741.                                        }
  742.  
  743.                                        ++super.fCharacterCounter;
  744.                                        this.loadNextChar();
  745.                                        return 26;
  746.                                     }
  747.  
  748.                                     ++super.fCharacterCounter;
  749.                                     this.loadNextChar();
  750.                                     break label229;
  751.                                  case 3:
  752.                                     var4 = super.fCurrentOffset;
  753.                                     var3 = this.loadNextChar();
  754.                                     if (var3 != 93) {
  755.                                        ++super.fCharacterCounter;
  756.                                     } else if (this.fCurrentIndex + 1 == 16384) {
  757.                                        UTF8CharDataChunk var5 = this.fCurrentChunk;
  758.                                        int var6 = this.fCurrentIndex;
  759.                                        int var7 = super.fCurrentOffset;
  760.                                        if (this.loadNextChar() == 62) {
  761.                                           break label246;
  762.                                        }
  763.  
  764.                                        this.fCurrentChunk = var5;
  765.                                        this.fCurrentIndex = var6;
  766.                                        super.fCurrentOffset = var7;
  767.                                        this.fMostRecentData = var5.fData;
  768.                                        this.fMostRecentChar = 93;
  769.                                        ++super.fCharacterCounter;
  770.                                     } else {
  771.                                        if (this.fMostRecentData[this.fCurrentIndex + 1] == '>') {
  772.                                           ++this.fCurrentIndex;
  773.                                           ++super.fCurrentOffset;
  774.                                           break label246;
  775.                                        }
  776.  
  777.                                        ++super.fCharacterCounter;
  778.                                     }
  779.                                     break label229;
  780.                                  case 4:
  781.                                     if (this.fDocumentHandler != null) {
  782.                                        this.callWSCharDataHandler(var8, super.fCurrentOffset, var1.inCDSect);
  783.                                     }
  784.  
  785.                                     return 28;
  786.                               }
  787.                            } else if (!this.skipMultiByteCharData(var3)) {
  788.                               if (this.fDocumentHandler != null) {
  789.                                  this.callWSCharDataHandler(var8, super.fCurrentOffset, var1.inCDSect);
  790.                               }
  791.  
  792.                               return 28;
  793.                            }
  794.                            break;
  795.                         }
  796.                      }
  797.                }
  798.             } else if (!this.skipMultiByteCharData(var3)) {
  799.                return 4;
  800.             }
  801.  
  802.             var3 = this.skipAsciiCharData();
  803.  
  804.             label199:
  805.             while(true) {
  806.                while(var3 >= 128) {
  807.                   if (!this.skipMultiByteCharData(var3)) {
  808.                      if (this.fDocumentHandler != null) {
  809.                         this.callCharDataHandler(var8, super.fCurrentOffset, var1.inCDSect);
  810.                      }
  811.  
  812.                      return 12;
  813.                   }
  814.  
  815.                   var3 = this.fMostRecentChar;
  816.                }
  817.  
  818.                switch (XMLReader.fgAsciiCharData[var3]) {
  819.                   case 0:
  820.                      ++super.fCharacterCounter;
  821.                      var3 = this.loadNextChar();
  822.                      break;
  823.                   case 1:
  824.                      if (!var1.inCDSect) {
  825.                         if (this.fDocumentHandler != null) {
  826.                            this.callCharDataHandler(var8, super.fCurrentOffset, false);
  827.                         }
  828.  
  829.                         ++super.fCharacterCounter;
  830.                         ++super.fCurrentOffset;
  831.                         if (++this.fCurrentIndex == 16384) {
  832.                            this.slowLoadNextChar();
  833.                         } else {
  834.                            this.fMostRecentChar = this.fMostRecentData[this.fCurrentIndex] & '\uffff';
  835.                         }
  836.  
  837.                         return 9;
  838.                      }
  839.  
  840.                      ++super.fCharacterCounter;
  841.                      var3 = this.loadNextChar();
  842.                      break;
  843.                   case 2:
  844.                      if (!var1.inCDSect) {
  845.                         if (this.fDocumentHandler != null) {
  846.                            this.callCharDataHandler(var8, super.fCurrentOffset, false);
  847.                         }
  848.  
  849.                         ++super.fCharacterCounter;
  850.                         this.loadNextChar();
  851.                         return 10;
  852.                      }
  853.  
  854.                      ++super.fCharacterCounter;
  855.                      var3 = this.loadNextChar();
  856.                      break;
  857.                   case 3:
  858.                      var4 = super.fCurrentOffset;
  859.                      var3 = this.loadNextChar();
  860.                      if (var3 == 93) {
  861.                         if (this.fCurrentIndex + 1 == 16384) {
  862.                            UTF8CharDataChunk var15 = this.fCurrentChunk;
  863.                            int var17 = this.fCurrentIndex;
  864.                            int var18 = super.fCurrentOffset;
  865.                            if (this.loadNextChar() == 62) {
  866.                               break label199;
  867.                            }
  868.  
  869.                            this.fCurrentChunk = var15;
  870.                            this.fCurrentIndex = var17;
  871.                            super.fCurrentOffset = var18;
  872.                            this.fMostRecentData = var15.fData;
  873.                            this.fMostRecentChar = 93;
  874.                            ++super.fCharacterCounter;
  875.                         } else {
  876.                            if (this.fMostRecentData[this.fCurrentIndex + 1] == '>') {
  877.                               ++this.fCurrentIndex;
  878.                               ++super.fCurrentOffset;
  879.                               break label199;
  880.                            }
  881.  
  882.                            ++super.fCharacterCounter;
  883.                         }
  884.                         break;
  885.                      }
  886.  
  887.                      ++super.fCharacterCounter;
  888.                      break;
  889.                   case 4:
  890.                      if (var3 != 10) {
  891.                         if (this.fDocumentHandler != null) {
  892.                            this.callCharDataHandler(var8, super.fCurrentOffset, var1.inCDSect);
  893.                         }
  894.  
  895.                         return 12;
  896.                      }
  897.  
  898.                      ++super.fLinefeedCounter;
  899.                      super.fCharacterCounter = 1;
  900.                      var3 = this.loadNextChar();
  901.                }
  902.             }
  903.  
  904.             this.loadNextChar();
  905.             if (this.fDocumentHandler != null) {
  906.                this.callCharDataHandler(var8, var4, var1.inCDSect);
  907.             }
  908.  
  909.             super.fCharacterCounter += 3;
  910.             if (var1.inCDSect) {
  911.                var1.inCDSect = false;
  912.                return this.scanContent(var1);
  913.             }
  914.  
  915.             return 11;
  916.          }
  917.  
  918.          this.loadNextChar();
  919.          super.fCharacterCounter += 2;
  920.          if (var1.inCDSect) {
  921.             var1.inCDSect = false;
  922.             return this.scanContent(var1);
  923.          }
  924.  
  925.          return 3;
  926.       }
  927.  
  928.       this.loadNextChar();
  929.       if (this.fDocumentHandler != null) {
  930.          this.callWSCharDataHandler(var8, var4, var1.inCDSect);
  931.       }
  932.  
  933.       super.fCharacterCounter += 3;
  934.       if (var1.inCDSect) {
  935.          var1.inCDSect = false;
  936.          return this.scanContent(var1);
  937.       } else {
  938.          return 27;
  939.       }
  940.    }
  941.  
  942.    protected boolean skipMultiByteCharData(int var1) throws Exception {
  943.       if (var1 > 65533) {
  944.          return false;
  945.       } else if (var1 >= 901120 && var1 < 57344) {
  946.          return false;
  947.       } else {
  948.          if (var1 >= 884736 && var1 < 56320) {
  949.             var1 = this.loadNextChar();
  950.             if (var1 < 901120 || var1 >= 57344) {
  951.                return false;
  952.             }
  953.          }
  954.  
  955.          this.loadNextChar();
  956.          return true;
  957.       }
  958.    }
  959.  
  960.    protected int skipAsciiCharData() throws Exception {
  961.       int var1 = this.fCurrentIndex;
  962.       int var2 = super.fCurrentOffset - var1;
  963.  
  964.       while(true) {
  965.          for(char[] var3 = this.fMostRecentData; var1 < 16384; ++var1) {
  966.             int var4 = var3[var1] & '\uffff';
  967.             if (var4 >= 128) {
  968.                super.fCurrentOffset = var2 + var1;
  969.                this.fCurrentIndex = var1;
  970.                this.fMostRecentChar = var4;
  971.                return var4;
  972.             }
  973.  
  974.             if (XMLReader.fgAsciiCharData[var4] != 0) {
  975.                if (var4 != 10) {
  976.                   super.fCurrentOffset = var2 + var1;
  977.                   this.fCurrentIndex = var1;
  978.                   this.fMostRecentChar = var4;
  979.                   return var4;
  980.                }
  981.  
  982.                ++super.fLinefeedCounter;
  983.                super.fCharacterCounter = 1;
  984.             } else {
  985.                ++super.fCharacterCounter;
  986.             }
  987.          }
  988.  
  989.          var2 += var1;
  990.          this.fCurrentChunk = new UTF8CharDataChunk(this, this.fStringPool, this.fCurrentChunk);
  991.          this.fillCurrentChunk();
  992.          var1 = 0;
  993.       }
  994.    }
  995.  
  996.    public void callCharDataHandler(int var1, int var2, boolean var3) throws Exception {
  997.       int var4 = var2 - var1;
  998.       if (!this.fDocumentHandler.sendCharDataAsCharArray()) {
  999.          int var9 = var4 == 0 ? 0 : this.fCurrentChunk.addString(var1, var4);
  1000.          this.fDocumentHandler.characters(var9, var3);
  1001.       } else {
  1002.          UTF8CharDataChunk var5 = this.fCurrentChunk.chunkFor(var1);
  1003.          int var6 = var1 & 16383;
  1004.          if (var6 + var4 <= 16384) {
  1005.             if (var4 != 0) {
  1006.                this.fDocumentHandler.characters(var5.fData, var6, var4, var3);
  1007.             }
  1008.  
  1009.          } else {
  1010.             int var8 = 16384 - var6;
  1011.             this.fDocumentHandler.characters(var5.fData, var6, var8, var3);
  1012.             int var7 = var4 - var8;
  1013.  
  1014.             do {
  1015.                var5 = var5.fNextChunk;
  1016.                if (var5 == null) {
  1017.                   this.fErrorHandler.error(167);
  1018.                }
  1019.  
  1020.                var8 = var7 <= 16384 ? var7 : 16384;
  1021.                this.fDocumentHandler.characters(var5.fData, 0, var8, var3);
  1022.                var7 -= var8;
  1023.             } while(var7 > 0);
  1024.  
  1025.          }
  1026.       }
  1027.    }
  1028.  
  1029.    public void callWSCharDataHandler(int var1, int var2, boolean var3) throws Exception {
  1030.       int var4 = this.fScanner.getCurrentContentSpecType();
  1031.       if (var4 != 4) {
  1032.          this.callCharDataHandler(var1, var2, var3);
  1033.       } else {
  1034.          int var5 = var2 - var1;
  1035.          if (!this.fDocumentHandler.sendCharDataAsCharArray()) {
  1036.             int var10 = var5 == 0 ? 0 : this.fCurrentChunk.addString(var1, var5);
  1037.             this.fDocumentHandler.ignorableWhitespace(var10, var3);
  1038.          } else {
  1039.             UTF8CharDataChunk var6 = this.fCurrentChunk.chunkFor(var1);
  1040.             int var7 = var1 & 16383;
  1041.             if (var7 + var5 <= 16384) {
  1042.                if (var5 != 0) {
  1043.                   this.fDocumentHandler.ignorableWhitespace(var6.fData, var7, var5, var3);
  1044.                }
  1045.  
  1046.             } else {
  1047.                int var9 = 16384 - var7;
  1048.                this.fDocumentHandler.ignorableWhitespace(var6.fData, var7, var9, var3);
  1049.                int var8 = var5 - var9;
  1050.  
  1051.                do {
  1052.                   var6 = var6.fNextChunk;
  1053.                   var9 = var8 <= 16384 ? var8 : 16384;
  1054.                   this.fDocumentHandler.ignorableWhitespace(var6.fData, 0, var9, var3);
  1055.                   var8 -= var9;
  1056.                } while(var8 > 0);
  1057.  
  1058.             }
  1059.          }
  1060.       }
  1061.    }
  1062.  
  1063.    protected int fillCurrentChunk() throws Exception {
  1064.       this.fOutputOffset = 0;
  1065.       if (this.fCheckOverflow) {
  1066.          if (this.fOverflowEnd < 16384) {
  1067.             if (this.fOverflowEnd > 0) {
  1068.                this.fMostRecentData = new char[1 + this.fOverflowEnd - this.fOverflowOffset];
  1069.                this.copyNormalize(this.fOverflow, this.fOverflowOffset, this.fMostRecentData, this.fOutputOffset);
  1070.             } else {
  1071.                this.fMostRecentData = new char[1];
  1072.             }
  1073.  
  1074.             this.fMostRecentData[this.fOutputOffset] = 0;
  1075.             this.fOverflow = null;
  1076.             this.fLength += this.fOutputOffset;
  1077.             this.fCurrentIndex = 0;
  1078.             UTF8CharDataChunk var1 = this.fCurrentChunk;
  1079.             char[] var2 = this.fMostRecentData;
  1080.             var1.fData = var2;
  1081.             return this.fMostRecentChar = this.fMostRecentData[0];
  1082.          }
  1083.  
  1084.          this.fMostRecentData = new char[16384];
  1085.          this.copyNormalize(this.fOverflow, this.fOverflowOffset, this.fMostRecentData, this.fOutputOffset);
  1086.          this.fCheckOverflow = false;
  1087.       } else {
  1088.          if (this.fOverflow == null) {
  1089.             this.fOverflow = new byte[16384];
  1090.          }
  1091.  
  1092.          this.fMostRecentData = null;
  1093.       }
  1094.  
  1095.       while(true) {
  1096.          this.fOverflowOffset = 0;
  1097.          this.fOverflowEnd = 0;
  1098.          int var4 = 16384;
  1099.          int var6 = 0;
  1100.  
  1101.          do {
  1102.             var6 = this.fInputStream.read(this.fOverflow, this.fOverflowEnd, var4);
  1103.             if (var6 == -1) {
  1104.                this.fInputStream.close();
  1105.                this.fInputStream = null;
  1106.                if (this.fMostRecentData == null) {
  1107.                   this.fMostRecentData = new char[1 + this.fOverflowEnd];
  1108.                   this.copyNormalize(this.fOverflow, this.fOverflowOffset, this.fMostRecentData, this.fOutputOffset);
  1109.                   this.fOverflow = null;
  1110.                   this.fMostRecentData[this.fOutputOffset] = 0;
  1111.                } else {
  1112.                   boolean var3 = this.copyNormalize(this.fOverflow, this.fOverflowOffset, this.fMostRecentData, this.fOutputOffset);
  1113.                   if (var3) {
  1114.                      if (this.fOverflowEnd == 16384) {
  1115.                         this.fCheckOverflow = true;
  1116.                         this.fOverflowOffset = 0;
  1117.                         this.fOverflowEnd = 0;
  1118.                      } else {
  1119.                         this.fOverflow = null;
  1120.                         this.fMostRecentData[this.fOutputOffset] = 0;
  1121.                      }
  1122.                   } else {
  1123.                      this.fCheckOverflow = true;
  1124.                   }
  1125.                }
  1126.                break;
  1127.             }
  1128.  
  1129.             if (var6 > 0) {
  1130.                this.fOverflowEnd += var6;
  1131.                var4 -= var6;
  1132.             }
  1133.          } while(var4 > 0);
  1134.  
  1135.          if (var6 == -1) {
  1136.             break;
  1137.          }
  1138.  
  1139.          if (this.fMostRecentData != null) {
  1140.             boolean var9 = this.copyNormalize(this.fOverflow, this.fOverflowOffset, this.fMostRecentData, this.fOutputOffset);
  1141.             if (this.fOutputOffset == 16384) {
  1142.                if (!var9) {
  1143.                   this.fCheckOverflow = true;
  1144.                }
  1145.                break;
  1146.             }
  1147.          } else {
  1148.             this.fMostRecentData = new char[16384];
  1149.             this.copyNormalize(this.fOverflow, this.fOverflowOffset, this.fMostRecentData, this.fOutputOffset);
  1150.             if (this.fOutputOffset == 16384) {
  1151.                break;
  1152.             }
  1153.          }
  1154.       }
  1155.  
  1156.       this.fLength += this.fOutputOffset;
  1157.       this.fCurrentIndex = 0;
  1158.       UTF8CharDataChunk var5 = this.fCurrentChunk;
  1159.       char[] var8 = this.fMostRecentData;
  1160.       var5.fData = var8;
  1161.       return this.fMostRecentChar = this.fMostRecentData[0];
  1162.    }
  1163.  
  1164.    protected boolean copyNormalize(byte[] var1, int var2, char[] var3, int var4) throws Exception {
  1165.       int var5 = this.fOverflowEnd;
  1166.       int var6 = var3.length;
  1167.       if (var2 == var5) {
  1168.          return true;
  1169.       } else {
  1170.          byte var7 = var1[var2];
  1171.          if (this.fSkipLinefeed) {
  1172.             this.fSkipLinefeed = false;
  1173.             if (var7 == 10) {
  1174.                ++var2;
  1175.                if (var2 == var5) {
  1176.                   this.fOverflowOffset = var2;
  1177.                   this.fOutputOffset = var4;
  1178.                   return true;
  1179.                }
  1180.  
  1181.                var7 = var1[var2];
  1182.             }
  1183.          } else if (this.fPartialMultiByteIn > 0) {
  1184.             if (!this.handlePartialMultiByteChar(var7, var1, var2, var5, var3, var4, var6)) {
  1185.                return this.fPartialMultiByteResult;
  1186.             }
  1187.  
  1188.             var2 = this.fOverflowOffset;
  1189.             var4 = this.fOutputOffset;
  1190.             var7 = var1[var2];
  1191.          }
  1192.  
  1193.          while(var4 < var6) {
  1194.             int var8 = var5 - var2;
  1195.             int var9 = var6 - var4;
  1196.             if (var8 > var9) {
  1197.                var8 = var9;
  1198.             }
  1199.  
  1200.             ++var2;
  1201.  
  1202.             do {
  1203.                for(; var7 == 13 || (var7 & 128) != 0; ++var2) {
  1204.                   if (var7 == 13) {
  1205.                      var3[var4++] = '\n';
  1206.                      if (var2 == var5) {
  1207.                         this.fSkipLinefeed = true;
  1208.                         this.fOverflowOffset = var2;
  1209.                         this.fOutputOffset = var4;
  1210.                         return true;
  1211.                      }
  1212.  
  1213.                      var7 = var1[var2];
  1214.                      if (var7 == 10) {
  1215.                         ++var2;
  1216.                         if (var2 == var5) {
  1217.                            this.fOverflowOffset = var2;
  1218.                            this.fOutputOffset = var4;
  1219.                            return true;
  1220.                         }
  1221.  
  1222.                         var7 = var1[var2];
  1223.                      }
  1224.  
  1225.                      if (var4 == var6) {
  1226.                         this.fOverflowOffset = var2;
  1227.                         this.fOutputOffset = var4;
  1228.                         return false;
  1229.                      }
  1230.                   } else {
  1231.                      if (!this.handleMultiByteChar(var7, var1, var2, var5, var3, var4, var6)) {
  1232.                         return this.fPartialMultiByteResult;
  1233.                      }
  1234.  
  1235.                      var2 = this.fOverflowOffset;
  1236.                      var4 = this.fOutputOffset;
  1237.                      var7 = var1[var2];
  1238.                   }
  1239.  
  1240.                   var8 = var5 - var2;
  1241.                   var9 = var6 - var4;
  1242.                   if (var8 > var9) {
  1243.                      var8 = var9;
  1244.                   }
  1245.                }
  1246.  
  1247.                do {
  1248.                   var3[var4++] = (char)var7;
  1249.                   --var8;
  1250.                   if (var8 == 0) {
  1251.                      break;
  1252.                   }
  1253.  
  1254.                   var7 = var1[var2++];
  1255.                } while(var7 != 13 && var7 >= 0);
  1256.             } while(var8 != 0);
  1257.  
  1258.             if (var2 == var5) {
  1259.                break;
  1260.             }
  1261.          }
  1262.  
  1263.          boolean var10 = var2 == var5;
  1264.          this.fOverflowOffset = var2;
  1265.          this.fOutputOffset = var4;
  1266.          return var10;
  1267.       }
  1268.    }
  1269.  
  1270.    protected boolean exitNormalize(int var1, int var2, boolean var3) {
  1271.       this.fOverflowOffset = var1;
  1272.       this.fOutputOffset = var2;
  1273.       return var3;
  1274.    }
  1275.  
  1276.    protected void savePartialMultiByte(int var1, byte var2, byte var3, byte var4) {
  1277.       this.fPartialMultiByteIn = var1--;
  1278.       this.fPartialMultiByteChar[var1] = var2;
  1279.       --var1;
  1280.       this.fPartialMultiByteChar[var1] = var3;
  1281.       --var1;
  1282.       this.fPartialMultiByteChar[var1] = var4;
  1283.    }
  1284.  
  1285.    protected void savePartialMultiByte(int var1, byte var2, byte var3) {
  1286.       this.fPartialMultiByteIn = var1--;
  1287.       this.fPartialMultiByteChar[var1] = var2;
  1288.       --var1;
  1289.       this.fPartialMultiByteChar[var1] = var3;
  1290.    }
  1291.  
  1292.    protected void savePartialMultiByte(int var1, byte var2) {
  1293.       this.fPartialMultiByteIn = var1--;
  1294.       this.fPartialMultiByteChar[var1] = var2;
  1295.    }
  1296.  
  1297.    protected boolean handleMultiByteChar(byte var1, byte[] var2, int var3, int var4, char[] var5, int var6, int var7) throws Exception {
  1298.       if (var3 == var4) {
  1299.          int var15 = 1;
  1300.          this.fPartialMultiByteIn = var15--;
  1301.          this.fPartialMultiByteChar[var15] = var1;
  1302.          this.fOverflowOffset = var3;
  1303.          this.fOutputOffset = var6;
  1304.          this.fPartialMultiByteResult = true;
  1305.          return false;
  1306.       } else {
  1307.          byte var8 = var2[var3++];
  1308.          if ((var8 & 192) != 128) {
  1309.             this.fErrorHandler.error2(57, this.fStringPool.addString(Integer.toHexString(var1)), this.fStringPool.addString(Integer.toHexString(var8)));
  1310.          }
  1311.  
  1312.          if ((var1 & 224) == 192) {
  1313.             int var17 = ((31 & var1) << 6) + (63 & var8);
  1314.             var5[var6++] = (char)var17;
  1315.             if (var3 == var4 || var6 == var7) {
  1316.                boolean var19 = var3 == var4;
  1317.                this.fOverflowOffset = var3;
  1318.                this.fOutputOffset = var6;
  1319.                this.fPartialMultiByteResult = var19;
  1320.                return false;
  1321.             }
  1322.          } else {
  1323.             if (var3 == var4) {
  1324.                this.savePartialMultiByte(2, var8, var1);
  1325.                this.fOverflowOffset = var3;
  1326.                this.fOutputOffset = var6;
  1327.                this.fPartialMultiByteResult = true;
  1328.                return false;
  1329.             }
  1330.  
  1331.             byte var9 = var2[var3++];
  1332.             if ((var9 & 192) != 128) {
  1333.                this.fErrorHandler.error3(58, this.fStringPool.addString(Integer.toHexString(var1)), this.fStringPool.addString(Integer.toHexString(var8)), this.fStringPool.addString(Integer.toHexString(var9)));
  1334.             }
  1335.  
  1336.             if ((var1 & 240) == 224) {
  1337.                int var18 = ((15 & var1) << 12) + ((63 & var8) << 6) + (63 & var9);
  1338.                var5[var6++] = (char)var18;
  1339.                if (var3 == var4 || var6 == var7) {
  1340.                   boolean var20 = var3 == var4;
  1341.                   this.fOverflowOffset = var3;
  1342.                   this.fOutputOffset = var6;
  1343.                   this.fPartialMultiByteResult = var20;
  1344.                   return false;
  1345.                }
  1346.             } else {
  1347.                if ((var1 & 248) != 240) {
  1348.                   this.fErrorHandler.error1(56, this.fStringPool.addString(Integer.toHexString(var1)));
  1349.                }
  1350.  
  1351.                if (var3 == var4) {
  1352.                   this.savePartialMultiByte(3, var9, var8, var1);
  1353.                   this.fOverflowOffset = var3;
  1354.                   this.fOutputOffset = var6;
  1355.                   this.fPartialMultiByteResult = true;
  1356.                   return false;
  1357.                }
  1358.  
  1359.                byte var10 = var2[var3++];
  1360.                if ((var10 & 192) != 128) {
  1361.                   this.fErrorHandler.error4(59, this.fStringPool.addString(Integer.toHexString(var1)), this.fStringPool.addString(Integer.toHexString(var8)), this.fStringPool.addString(Integer.toHexString(var9)), this.fStringPool.addString(Integer.toHexString(var10)));
  1362.                }
  1363.  
  1364.                int var11 = ((15 & var1) << 18) + ((63 & var8) << 12) + ((63 & var9) << 6) + (63 & var10);
  1365.                if (var11 >= 65536) {
  1366.                   var5[var6++] = (char)((var11 - 65536 >> 10) + '\ud800');
  1367.                   var11 = (var11 - 65536 & 1023) + '\udc00';
  1368.                   if (var6 == var7) {
  1369.                      this.fPartialSurrogatePair = var11;
  1370.                      boolean var21 = var3 == var4;
  1371.                      this.fOverflowOffset = var3;
  1372.                      this.fOutputOffset = var6;
  1373.                      this.fPartialMultiByteResult = var21;
  1374.                      return false;
  1375.                   }
  1376.                }
  1377.  
  1378.                var5[var6++] = (char)var11;
  1379.                if (var3 == var4 || var6 == var7) {
  1380.                   boolean var12 = var3 == var4;
  1381.                   this.fOverflowOffset = var3;
  1382.                   this.fOutputOffset = var6;
  1383.                   this.fPartialMultiByteResult = var12;
  1384.                   return false;
  1385.                }
  1386.             }
  1387.          }
  1388.  
  1389.          this.fOverflowOffset = var3;
  1390.          this.fOutputOffset = var6;
  1391.          return true;
  1392.       }
  1393.    }
  1394.  
  1395.    protected boolean handlePartialMultiByteChar(byte var1, byte[] var2, int var3, int var4, char[] var5, int var6, int var7) throws Exception {
  1396.       if (var6 == var7) {
  1397.          boolean var15 = var3 == var4;
  1398.          this.fOverflowOffset = var3;
  1399.          this.fOutputOffset = var6;
  1400.          this.fPartialMultiByteResult = var15;
  1401.          return false;
  1402.       } else if (this.fPartialMultiByteIn == 4) {
  1403.          var5[var6++] = (char)this.fPartialSurrogatePair;
  1404.          if (var6 == var7) {
  1405.             this.fOverflowOffset = var3;
  1406.             this.fOutputOffset = var6;
  1407.             this.fPartialMultiByteResult = false;
  1408.             return false;
  1409.          } else {
  1410.             this.fOutputOffset = var6;
  1411.             return true;
  1412.          }
  1413.       } else {
  1414.          int var8 = this.fPartialMultiByteIn;
  1415.          this.fPartialMultiByteIn = 0;
  1416.          byte var9 = 0;
  1417.          byte var10 = 0;
  1418.          byte var11 = 0;
  1419.          switch (var8) {
  1420.             case 1:
  1421.                var9 = var1;
  1422.                break;
  1423.             case 2:
  1424.                var10 = var1;
  1425.                break;
  1426.             case 3:
  1427.                var11 = var1;
  1428.          }
  1429.  
  1430.          int var12 = var8;
  1431.          switch (var8) {
  1432.             case 3:
  1433.                var12 = var8 - 1;
  1434.                var10 = this.fPartialMultiByteChar[var12];
  1435.             case 2:
  1436.                --var12;
  1437.                var9 = this.fPartialMultiByteChar[var12];
  1438.             case 1:
  1439.                --var12;
  1440.                var1 = this.fPartialMultiByteChar[var12];
  1441.          }
  1442.  
  1443.          switch (var8) {
  1444.             case 1:
  1445.                if ((var9 & 192) != 128) {
  1446.                   this.fErrorHandler.error2(57, this.fStringPool.addString(Integer.toHexString(var1)), this.fStringPool.addString(Integer.toHexString(var9)));
  1447.                }
  1448.             case 2:
  1449.                if ((var1 & 224) == 192) {
  1450.                   int var20 = ((31 & var1) << 6) + (63 & var9);
  1451.                   var5[var6++] = (char)var20;
  1452.                   if (var6 == var7) {
  1453.                      this.fOverflowOffset = var3;
  1454.                      this.fOutputOffset = var6;
  1455.                      this.fPartialMultiByteResult = false;
  1456.                      return false;
  1457.                   }
  1458.  
  1459.                   if (var8 < 2) {
  1460.                      ++var3;
  1461.                      if (var3 == var4) {
  1462.                         this.fOverflowOffset = var3;
  1463.                         this.fOutputOffset = var6;
  1464.                         this.fPartialMultiByteResult = true;
  1465.                         return false;
  1466.                      }
  1467.                   }
  1468.                   break;
  1469.                } else {
  1470.                   if (var8 < 2) {
  1471.                      ++var3;
  1472.                      if (var3 == var4) {
  1473.                         int var18 = 2;
  1474.                         this.fPartialMultiByteIn = var18--;
  1475.                         this.fPartialMultiByteChar[var18] = var9;
  1476.                         this.fOverflowOffset = var3;
  1477.                         this.fOutputOffset = var6;
  1478.                         this.fPartialMultiByteResult = true;
  1479.                         return false;
  1480.                      }
  1481.  
  1482.                      var10 = var2[var3];
  1483.                   }
  1484.  
  1485.                   if ((var10 & 192) != 128) {
  1486.                      this.fErrorHandler.error3(58, this.fStringPool.addString(Integer.toHexString(var1)), this.fStringPool.addString(Integer.toHexString(var9)), this.fStringPool.addString(Integer.toHexString(var10)));
  1487.                   }
  1488.                }
  1489.             case 3:
  1490.                if ((var1 & 240) == 224) {
  1491.                   int var13 = ((15 & var1) << 12) + ((63 & var9) << 6) + (63 & var10);
  1492.                   var5[var6++] = (char)var13;
  1493.                   if (var6 == var7) {
  1494.                      this.fOverflowOffset = var3;
  1495.                      this.fOutputOffset = var6;
  1496.                      this.fPartialMultiByteResult = false;
  1497.                      return false;
  1498.                   }
  1499.  
  1500.                   if (var8 < 3) {
  1501.                      ++var3;
  1502.                      if (var3 == var4) {
  1503.                         this.fOverflowOffset = var3;
  1504.                         this.fOutputOffset = var6;
  1505.                         this.fPartialMultiByteResult = true;
  1506.                         return false;
  1507.                      }
  1508.                   }
  1509.                } else {
  1510.                   if (var8 < 3) {
  1511.                      if ((var1 & 248) != 240) {
  1512.                         this.fErrorHandler.error1(56, this.fStringPool.addString(Integer.toHexString(var1)));
  1513.                      }
  1514.  
  1515.                      ++var3;
  1516.                      if (var3 == var4) {
  1517.                         this.savePartialMultiByte(3, var10, var9);
  1518.                         this.fOverflowOffset = var3;
  1519.                         this.fOutputOffset = var6;
  1520.                         this.fPartialMultiByteResult = true;
  1521.                         return false;
  1522.                      }
  1523.  
  1524.                      var11 = var2[var3];
  1525.                   }
  1526.  
  1527.                   if ((var11 & 192) != 128) {
  1528.                      this.fErrorHandler.error4(59, this.fStringPool.addString(Integer.toHexString(var1)), this.fStringPool.addString(Integer.toHexString(var9)), this.fStringPool.addString(Integer.toHexString(var10)), this.fStringPool.addString(Integer.toHexString(var11)));
  1529.                   }
  1530.  
  1531.                   int var17 = ((15 & var1) << 18) + ((63 & var9) << 12) + ((63 & var10) << 6) + (63 & var11);
  1532.                   if (var17 >= 65536) {
  1533.                      var5[var6++] = (char)((var17 - 65536 >> 10) + '\ud800');
  1534.                      var17 = (var17 - 65536 & 1023) + '\udc00';
  1535.                      if (var6 == var7) {
  1536.                         this.fPartialSurrogatePair = var17;
  1537.                         this.fOverflowOffset = var3;
  1538.                         this.fOutputOffset = var6;
  1539.                         this.fPartialMultiByteResult = false;
  1540.                         return false;
  1541.                      }
  1542.                   }
  1543.  
  1544.                   var5[var6++] = (char)var17;
  1545.                   if (var6 == var7) {
  1546.                      this.fOverflowOffset = var3;
  1547.                      this.fOutputOffset = var6;
  1548.                      this.fPartialMultiByteResult = false;
  1549.                      return false;
  1550.                   }
  1551.  
  1552.                   ++var3;
  1553.                   if (var3 == var4) {
  1554.                      this.fOverflowOffset = var3;
  1555.                      this.fOutputOffset = var6;
  1556.                      this.fPartialMultiByteResult = true;
  1557.                      return false;
  1558.                   }
  1559.                }
  1560.          }
  1561.  
  1562.          this.fOverflowOffset = var3;
  1563.          this.fOutputOffset = var6;
  1564.          return true;
  1565.       }
  1566.    }
  1567. }
  1568.