View Javadoc

    1   /* Generated By:JavaCC: Do not edit this line. JavaCharStream.java Version 2.1 */
    2   package xjavadoc;
    3
    4   /***
    5    * An implementation of interface CharStream, where the stream is assumed to
    6    * contain only ASCII characters (with java-like unicode escape processing).
    7    */
    8
    9   public final class JavaCharStream
    10  {
    11    public static final boolean staticFlag = false;
    12    static final int hexval(char c) throws java.io.IOException {
    13      switch(c)
    14      {
    15         case '0' :
    16            return 0;
    17         case '1' :
    18            return 1;
    19         case '2' :
    20            return 2;
    21         case '3' :
    22            return 3;
    23         case '4' :
    24            return 4;
    25         case '5' :
    26            return 5;
    27         case '6' :
    28            return 6;
    29         case '7' :
    30            return 7;
    31         case '8' :
    32            return 8;
    33         case '9' :
    34            return 9;
    35
    36         case 'a' :
    37         case 'A' :
    38            return 10;
    39         case 'b' :
    40         case 'B' :
    41            return 11;
    42         case 'c' :
    43         case 'C' :
    44            return 12;
    45         case 'd' :
    46         case 'D' :
    47            return 13;
    48         case 'e' :
    49         case 'E' :
    50            return 14;
    51         case 'f' :
    52         case 'F' :
    53            return 15;
    54      }
    55
    56      throw new java.io.IOException(); // Should never come here
    57    }
    58
    59    public int bufpos = -1;
    60    int bufsize;
    61    int available;
    62    int tokenBegin;
    63    private int bufline[];
    64    private int bufcolumn[];
    65
    66    private int column = 0;
    67    private int line = 1;
    68
    69    private boolean prevCharIsCR = false;
    70    private boolean prevCharIsLF = false;
    71
    72    private java.io.Reader inputStream;
    73
    74    private char[] nextCharBuf;
    75    private char[] buffer;
    76    private int maxNextCharInd = 0;
    77    private int nextCharInd = -1;
    78    private int inBuf = 0;
    79
    80    private final void ExpandBuff(boolean wrapAround)
    81    {
    82       char[] newbuffer = new char[bufsize + 2048];
    83       int newbufline[] = new int[bufsize + 2048];
    84       int newbufcolumn[] = new int[bufsize + 2048];
    85
    86       try
    87       {
    88          if (wrapAround)
    89          {
    90             System.arraycopy(buffer, tokenBegin, newbuffer, 0, bufsize - tokenBegin);
    91             System.arraycopy(buffer, 0, newbuffer,
    92                                               bufsize - tokenBegin, bufpos);
    93             buffer = newbuffer;
    94
    95             System.arraycopy(bufline, tokenBegin, newbufline, 0, bufsize - tokenBegin);
    96             System.arraycopy(bufline, 0, newbufline, bufsize - tokenBegin, bufpos);
    97             bufline = newbufline;
    98
    99             System.arraycopy(bufcolumn, tokenBegin, newbufcolumn, 0, bufsize - tokenBegin);
    100            System.arraycopy(bufcolumn, 0, newbufcolumn, bufsize - tokenBegin, bufpos);
    101            bufcolumn = newbufcolumn;
    102
    103            bufpos += (bufsize - tokenBegin);
    104         }
    105         else
    106         {
    107            System.arraycopy(buffer, tokenBegin, newbuffer, 0, bufsize - tokenBegin);
    108            buffer = newbuffer;
    109
    110            System.arraycopy(bufline, tokenBegin, newbufline, 0, bufsize - tokenBegin);
    111            bufline = newbufline;
    112
    113            System.arraycopy(bufcolumn, tokenBegin, newbufcolumn, 0, bufsize - tokenBegin);
    114            bufcolumn = newbufcolumn;
    115
    116            bufpos -= tokenBegin;
    117         }
    118      }
    119      catch (Throwable t)
    120      {
    121         throw new Error(t.getMessage());
    122      }
    123
    124      available = (bufsize += 2048);
    125      tokenBegin = 0;
    126   }
    127
    128   private final void FillBuff() throws java.io.IOException
    129   {
    130      int i;
    131      if (maxNextCharInd == 4096)
    132         maxNextCharInd = nextCharInd = 0;
    133
    134      try {
    135         if ((i = inputStream.read(nextCharBuf, maxNextCharInd,
    136                                             4096 - maxNextCharInd)) == -1)
    137         {
    138            inputStream.close();
    139            throw new java.io.IOException();
    140         }
    141         else
    142            maxNextCharInd += i;
    143         return;
    144      }
    145      catch(java.io.IOException e) {
    146         if (bufpos != 0)
    147         {
    148            --bufpos;
    149            backup(0);
    150         }
    151         else
    152         {
    153            bufline[bufpos] = line;
    154            bufcolumn[bufpos] = column;
    155         }
    156         throw e;
    157      }
    158   }
    159
    160   private final char ReadByte() throws java.io.IOException
    161   {
    162      if (++nextCharInd >= maxNextCharInd)
    163         FillBuff();
    164
    165      return nextCharBuf[nextCharInd];
    166   }
    167
    168   public final char BeginToken() throws java.io.IOException
    169   {
    170      if (inBuf > 0)
    171      {
    172         --inBuf;
    173
    174         if (++bufpos == bufsize)
    175            bufpos = 0;
    176
    177         tokenBegin = bufpos;
    178         return buffer[bufpos];
    179      }
    180
    181      tokenBegin = 0;
    182      bufpos = -1;
    183
    184      return readChar();
    185   }
    186
    187   private final void AdjustBuffSize()
    188   {
    189      if (available == bufsize)
    190      {
    191         if (tokenBegin > 2048)
    192         {
    193            bufpos = 0;
    194            available = tokenBegin;
    195         }
    196         else
    197            ExpandBuff(false);
    198      }
    199      else if (available > tokenBegin)
    200         available = bufsize;
    201      else if ((tokenBegin - available) < 2048)
    202         ExpandBuff(true);
    203      else
    204         available = tokenBegin;
    205   }
    206
    207   private final void UpdateLineColumn(char c)
    208   {
    209      column++;
    210
    211      if (prevCharIsLF)
    212      {
    213         prevCharIsLF = false;
    214         line += (column = 1);
    215      }
    216      else if (prevCharIsCR)
    217      {
    218         prevCharIsCR = false;
    219         if (c == '\n')
    220         {
    221            prevCharIsLF = true;
    222         }
    223         else
    224            line += (column = 1);
    225      }
    226
    227      switch (c)
    228      {
    229         case '\r' :
    230            prevCharIsCR = true;
    231            break;
    232         case '\n' :
    233            prevCharIsLF = true;
    234            break;
    235         case '\t' :
    236            column--;
    237            column += (8 - (column & 07));
    238            break;
    239         default :
    240            break;
    241      }
    242
    243      bufline[bufpos] = line;
    244      bufcolumn[bufpos] = column;
    245   }
    246
    247   public final char readChar() throws java.io.IOException
    248   {
    249      if (inBuf > 0)
    250      {
    251         --inBuf;
    252
    253         if (++bufpos == bufsize)
    254            bufpos = 0;
    255
    256         return buffer[bufpos];
    257      }
    258
    259      char c;
    260
    261      if (++bufpos == available)
    262         AdjustBuffSize();
    263
    264      if ((buffer[bufpos] = c = ReadByte()) == '//')
    265      {
    266         UpdateLineColumn(c);
    267
    268         int backSlashCnt = 1;
    269
    270         for (;;) // Read all the backslashes
    271         {
    272            if (++bufpos == available)
    273               AdjustBuffSize();
    274
    275            try
    276            {
    277               if ((buffer[bufpos] = c = ReadByte()) != '//')
    278               {
    279                  UpdateLineColumn(c);
    280                  // found a non-backslash char.
    281                  if ((c == 'u') && ((backSlashCnt & 1) == 1))
    282                  {
    283                     if (--bufpos < 0)
    284                        bufpos = bufsize - 1;
    285
    286                     break;
    287                  }
    288
    289                  backup(backSlashCnt);
    290                  return '//';
    291               }
    292            }
    293            catch(java.io.IOException e)
    294            {
    295               if (backSlashCnt > 1)
    296                  backup(backSlashCnt);
    297
    298               return '//';
    299            }
    300
    301            UpdateLineColumn(c);
    302            backSlashCnt++;
    303         }
    304
    305         // Here, we have seen an odd number of backslash's followed by a 'u'
    306         try
    307         {
    308            while ((c = ReadByte()) == 'u')
    309               ++column;
    310
    311            buffer[bufpos] = c = (char)(hexval(c) << 12 |
    312                                        hexval(ReadByte()) << 8 |
    313                                        hexval(ReadByte()) << 4 |
    314                                        hexval(ReadByte()));
    315
    316            column += 4;
    317         }
    318         catch(java.io.IOException e)
    319         {
    320            throw new Error("Invalid escape character at line " + line +
    321                                          " column " + column + ".");
    322         }
    323
    324         if (backSlashCnt == 1)
    325            return c;
    326         else
    327         {
    328            backup(backSlashCnt - 1);
    329            return '//';
    330         }
    331      }
    332      else
    333      {
    334         UpdateLineColumn(c);
    335         return (c);
    336      }
    337   }
    338
    339   /***
    340    * @deprecated
    341    * @see #getEndColumn
    342    */
    343
    344   public final int getColumn() {
    345      return bufcolumn[bufpos];
    346   }
    347
    348   /***
    349    * @deprecated
    350    * @see #getEndLine
    351    */
    352
    353   public final int getLine() {
    354      return bufline[bufpos];
    355   }
    356
    357   public final int getEndColumn() {
    358      return bufcolumn[bufpos];
    359   }
    360
    361   public final int getEndLine() {
    362      return bufline[bufpos];
    363   }
    364
    365   public final int getBeginColumn() {
    366      return bufcolumn[tokenBegin];
    367   }
    368
    369   public final int getBeginLine() {
    370      return bufline[tokenBegin];
    371   }
    372
    373   public final void backup(int amount) {
    374
    375     inBuf += amount;
    376     if ((bufpos -= amount) < 0)
    377        bufpos += bufsize;
    378   }
    379
    380   public JavaCharStream(java.io.Reader dstream,
    381                  int startline, int startcolumn, int buffersize)
    382   {
    383     inputStream = dstream;
    384     line = startline;
    385     column = startcolumn - 1;
    386
    387     available = bufsize = buffersize;
    388     buffer = new char[buffersize];
    389     bufline = new int[buffersize];
    390     bufcolumn = new int[buffersize];
    391     nextCharBuf = new char[4096];
    392   }
    393
    394   public JavaCharStream(java.io.Reader dstream,
    395                                         int startline, int startcolumn)
    396   {
    397      this(dstream, startline, startcolumn, 4096);
    398   }
    399
    400   public JavaCharStream(java.io.Reader dstream)
    401   {
    402      this(dstream, 1, 1, 4096);
    403   }
    404   public void ReInit(java.io.Reader dstream,
    405                  int startline, int startcolumn, int buffersize)
    406   {
    407     inputStream = dstream;
    408     line = startline;
    409     column = startcolumn - 1;
    410
    411     if (buffer == null || buffersize != buffer.length)
    412     {
    413       available = bufsize = buffersize;
    414       buffer = new char[buffersize];
    415       bufline = new int[buffersize];
    416       bufcolumn = new int[buffersize];
    417       nextCharBuf = new char[4096];
    418     }
    419     prevCharIsLF = prevCharIsCR = false;
    420     tokenBegin = inBuf = maxNextCharInd = 0;
    421     nextCharInd = bufpos = -1;
    422   }
    423
    424   public void ReInit(java.io.Reader dstream,
    425                                         int startline, int startcolumn)
    426   {
    427      ReInit(dstream, startline, startcolumn, 4096);
    428   }
    429
    430   public void ReInit(java.io.Reader dstream)
    431   {
    432      ReInit(dstream, 1, 1, 4096);
    433   }
    434   public JavaCharStream(java.io.InputStream dstream, int startline,
    435   int startcolumn, int buffersize)
    436   {
    437      this(new java.io.InputStreamReader(dstream), startline, startcolumn, 4096);
    438   }
    439
    440   public JavaCharStream(java.io.InputStream dstream, int startline,
    441                                                            int startcolumn)
    442   {
    443      this(dstream, startline, startcolumn, 4096);
    444   }
    445
    446   public JavaCharStream(java.io.InputStream dstream)
    447   {
    448      this(dstream, 1, 1, 4096);
    449   }
    450
    451   public void ReInit(java.io.InputStream dstream, int startline,
    452   int startcolumn, int buffersize)
    453   {
    454      ReInit(new java.io.InputStreamReader(dstream), startline, startcolumn, 4096);
    455   }
    456   public void ReInit(java.io.InputStream dstream, int startline,
    457                                                            int startcolumn)
    458   {
    459      ReInit(dstream, startline, startcolumn, 4096);
    460   }
    461   public void ReInit(java.io.InputStream dstream)
    462   {
    463      ReInit(dstream, 1, 1, 4096);
    464   }
    465
    466   public final String GetImage()
    467   {
    468      if (bufpos >= tokenBegin)
    469         return new String(buffer, tokenBegin, bufpos - tokenBegin + 1);
    470      else
    471         return new String(buffer, tokenBegin, bufsize - tokenBegin) +
    472                               new String(buffer, 0, bufpos + 1);
    473   }
    474
    475   public final char[] GetSuffix(int len)
    476   {
    477      char[] ret = new char[len];
    478
    479      if ((bufpos + 1) >= len)
    480         System.arraycopy(buffer, bufpos - len + 1, ret, 0, len);
    481      else
    482      {
    483         System.arraycopy(buffer, bufsize - (len - bufpos - 1), ret, 0,
    484                                                           len - bufpos - 1);
    485         System.arraycopy(buffer, 0, ret, len - bufpos - 1, bufpos + 1);
    486      }
    487
    488      return ret;
    489   }
    490
    491   public void Done()
    492   {
    493      nextCharBuf = null;
    494      buffer = null;
    495      bufline = null;
    496      bufcolumn = null;
    497   }
    498
    499   /***
    500    * Method to adjust line and column numbers for the start of a token.<BR>
    501    */
    502   public void adjustBeginLineColumn(int newLine, int newCol)
    503   {
    504      int start = tokenBegin;
    505      int len;
    506
    507      if (bufpos >= tokenBegin)
    508      {
    509         len = bufpos - tokenBegin + inBuf + 1;
    510      }
    511      else
    512      {
    513         len = bufsize - tokenBegin + bufpos + 1 + inBuf;
    514      }
    515
    516      int i = 0, j = 0, k = 0;
    517      int nextColDiff = 0, columnDiff = 0;
    518
    519      while (i < len &&
    520             bufline[j = start % bufsize] == bufline[k = ++start % bufsize])
    521      {
    522         bufline[j] = newLine;
    523         nextColDiff = columnDiff + bufcolumn[k] - bufcolumn[j];
    524         bufcolumn[j] = newCol + columnDiff;
    525         columnDiff = nextColDiff;
    526         i++;
    527      }
    528
    529      if (i < len)
    530      {
    531         bufline[j] = newLine++;
    532         bufcolumn[j] = newCol + columnDiff;
    533
    534         while (i++ < len)
    535         {
    536            if (bufline[j = start % bufsize] != bufline[++start % bufsize])
    537               bufline[j] = newLine++;
    538            else
    539               bufline[j] = newLine;
    540         }
    541      }
    542
    543      line = bufline[j];
    544      column = bufcolumn[j];
    545   }
    546
    547 }