View Javadoc

    1   /* Generated By:JavaCC: Do not edit this line. SimpleCharStream.java Version 3.0 */
    2   /***************************************************************************************
    3    * Copyright (c) Jonas BonŽr, Alexandre Vasseur. All rights reserved.                 *
    4    * http://aspectwerkz.codehaus.org                                                    *
    5    * ---------------------------------------------------------------------------------- *
    6    * The software in this package is published under the terms of the LGPL license      *
    7    * a copy of which has been included with this distribution in the license.txt file.  *
    8    **************************************************************************************/
    9   package org.codehaus.aspectwerkz.expression.ast;
    10
    11  /***
    12   * An implementation of interface CharStream, where the stream is assumed to contain only ASCII characters (without
    13   * unicode processing).
    14   */
    15
    16  public class SimpleCharStream {
    17      public static final boolean staticFlag = true;
    18
    19      static int bufsize;
    20
    21      static int available;
    22
    23      static int tokenBegin;
    24
    25      static public int bufpos = -1;
    26
    27      static protected int bufline[];
    28
    29      static protected int bufcolumn[];
    30
    31      static protected int column = 0;
    32
    33      static protected int line = 1;
    34
    35      static protected boolean prevCharIsCR = false;
    36
    37      static protected boolean prevCharIsLF = false;
    38
    39      static protected java.io.Reader inputStream;
    40
    41      static protected char[] buffer;
    42
    43      static protected int maxNextCharInd = 0;
    44
    45      static protected int inBuf = 0;
    46
    47      static protected void ExpandBuff(boolean wrapAround) {
    48          char[] newbuffer = new char[bufsize + 2048];
    49          int newbufline[] = new int[bufsize + 2048];
    50          int newbufcolumn[] = new int[bufsize + 2048];
    51
    52          try {
    53              if (wrapAround) {
    54                  System.arraycopy(buffer, tokenBegin, newbuffer, 0, bufsize - tokenBegin);
    55                  System.arraycopy(buffer, 0, newbuffer, bufsize - tokenBegin, bufpos);
    56                  buffer = newbuffer;
    57
    58                  System.arraycopy(bufline, tokenBegin, newbufline, 0, bufsize - tokenBegin);
    59                  System.arraycopy(bufline, 0, newbufline, bufsize - tokenBegin, bufpos);
    60                  bufline = newbufline;
    61
    62                  System.arraycopy(bufcolumn, tokenBegin, newbufcolumn, 0, bufsize - tokenBegin);
    63                  System.arraycopy(bufcolumn, 0, newbufcolumn, bufsize - tokenBegin, bufpos);
    64                  bufcolumn = newbufcolumn;
    65
    66                  maxNextCharInd = (bufpos += (bufsize - tokenBegin));
    67              } else {
    68                  System.arraycopy(buffer, tokenBegin, newbuffer, 0, bufsize - tokenBegin);
    69                  buffer = newbuffer;
    70
    71                  System.arraycopy(bufline, tokenBegin, newbufline, 0, bufsize - tokenBegin);
    72                  bufline = newbufline;
    73
    74                  System.arraycopy(bufcolumn, tokenBegin, newbufcolumn, 0, bufsize - tokenBegin);
    75                  bufcolumn = newbufcolumn;
    76
    77                  maxNextCharInd = (bufpos -= tokenBegin);
    78              }
    79          } catch (Throwable t) {
    80              throw new Error(t.getMessage());
    81          }
    82
    83          bufsize += 2048;
    84          available = bufsize;
    85          tokenBegin = 0;
    86      }
    87
    88      static protected void FillBuff() throws java.io.IOException {
    89          if (maxNextCharInd == available) {
    90              if (available == bufsize) {
    91                  if (tokenBegin > 2048) {
    92                      bufpos = maxNextCharInd = 0;
    93                      available = tokenBegin;
    94                  } else if (tokenBegin < 0) {
    95                      bufpos = maxNextCharInd = 0;
    96                  } else {
    97                      ExpandBuff(false);
    98                  }
    99              } else if (available > tokenBegin) {
    100                 available = bufsize;
    101             } else if ((tokenBegin - available) < 2048) {
    102                 ExpandBuff(true);
    103             } else {
    104                 available = tokenBegin;
    105             }
    106         }
    107
    108         int i;
    109         try {
    110             if ((i = inputStream.read(buffer, maxNextCharInd, available - maxNextCharInd)) == -1) {
    111                 inputStream.close();
    112                 throw new java.io.IOException();
    113             } else {
    114                 maxNextCharInd += i;
    115             }
    116             return;
    117         } catch (java.io.IOException e) {
    118             --bufpos;
    119             backup(0);
    120             if (tokenBegin == -1) {
    121                 tokenBegin = bufpos;
    122             }
    123             throw e;
    124         }
    125     }
    126
    127     static public char BeginToken() throws java.io.IOException {
    128         tokenBegin = -1;
    129         char c = readChar();
    130         tokenBegin = bufpos;
    131
    132         return c;
    133     }
    134
    135     static protected void UpdateLineColumn(char c) {
    136         column++;
    137
    138         if (prevCharIsLF) {
    139             prevCharIsLF = false;
    140             line += (column = 1);
    141         } else if (prevCharIsCR) {
    142             prevCharIsCR = false;
    143             if (c == '\n') {
    144                 prevCharIsLF = true;
    145             } else {
    146                 line += (column = 1);
    147             }
    148         }
    149
    150         switch (c) {
    151             case '\r':
    152                 prevCharIsCR = true;
    153                 break;
    154             case '\n':
    155                 prevCharIsLF = true;
    156                 break;
    157             case '\t':
    158                 column--;
    159                 column += (8 - (column & 07));
    160                 break;
    161             default:
    162                 break;
    163         }
    164
    165         bufline[bufpos] = line;
    166         bufcolumn[bufpos] = column;
    167     }
    168
    169     static public char readChar() throws java.io.IOException {
    170         if (inBuf > 0) {
    171             --inBuf;
    172
    173             if (++bufpos == bufsize) {
    174                 bufpos = 0;
    175             }
    176
    177             return buffer[bufpos];
    178         }
    179
    180         if (++bufpos >= maxNextCharInd) {
    181             FillBuff();
    182         }
    183
    184         char c = buffer[bufpos];
    185
    186         UpdateLineColumn(c);
    187         return (c);
    188     }
    189
    190     /***
    191      * @deprecated @see #getEndColumn
    192      */
    193
    194     static public int getColumn() {
    195         return bufcolumn[bufpos];
    196     }
    197
    198     /***
    199      * @deprecated @see #getEndLine
    200      */
    201
    202     static public int getLine() {
    203         return bufline[bufpos];
    204     }
    205
    206     static public int getEndColumn() {
    207         return bufcolumn[bufpos];
    208     }
    209
    210     static public int getEndLine() {
    211         return bufline[bufpos];
    212     }
    213
    214     static public int getBeginColumn() {
    215         return bufcolumn[tokenBegin];
    216     }
    217
    218     static public int getBeginLine() {
    219         return bufline[tokenBegin];
    220     }
    221
    222     static public void backup(int amount) {
    223
    224         inBuf += amount;
    225         if ((bufpos -= amount) < 0) {
    226             bufpos += bufsize;
    227         }
    228     }
    229
    230     public SimpleCharStream(java.io.Reader dstream, int startline, int startcolumn, int buffersize) {
    231         if (inputStream != null) {
    232             throw new Error(
    233                     "\n   ERROR: Second call to the constructor of a static SimpleCharStream.  You must\n"
    234                     + "       either use ReInit() or set the JavaCC option STATIC to false\n"
    235                     + "       during the generation of this class."
    236             );
    237         }
    238         inputStream = dstream;
    239         line = startline;
    240         column = startcolumn - 1;
    241
    242         available = bufsize = buffersize;
    243         buffer = new char[buffersize];
    244         bufline = new int[buffersize];
    245         bufcolumn = new int[buffersize];
    246     }
    247
    248     public SimpleCharStream(java.io.Reader dstream, int startline, int startcolumn) {
    249         this(dstream, startline, startcolumn, 4096);
    250     }
    251
    252     public SimpleCharStream(java.io.Reader dstream) {
    253         this(dstream, 1, 1, 4096);
    254     }
    255
    256     public void ReInit(java.io.Reader dstream, int startline, int startcolumn, int buffersize) {
    257         inputStream = dstream;
    258         line = startline;
    259         column = startcolumn - 1;
    260
    261         if (buffer == null || buffersize != buffer.length) {
    262             available = bufsize = buffersize;
    263             buffer = new char[buffersize];
    264             bufline = new int[buffersize];
    265             bufcolumn = new int[buffersize];
    266         }
    267         prevCharIsLF = prevCharIsCR = false;
    268         tokenBegin = inBuf = maxNextCharInd = 0;
    269         bufpos = -1;
    270     }
    271
    272     public void ReInit(java.io.Reader dstream, int startline, int startcolumn) {
    273         ReInit(dstream, startline, startcolumn, 4096);
    274     }
    275
    276     public void ReInit(java.io.Reader dstream) {
    277         ReInit(dstream, 1, 1, 4096);
    278     }
    279
    280     public SimpleCharStream(java.io.InputStream dstream, int startline, int startcolumn, int buffersize) {
    281         this(new java.io.InputStreamReader(dstream), startline, startcolumn, 4096);
    282     }
    283
    284     public SimpleCharStream(java.io.InputStream dstream, int startline, int startcolumn) {
    285         this(dstream, startline, startcolumn, 4096);
    286     }
    287
    288     public SimpleCharStream(java.io.InputStream dstream) {
    289         this(dstream, 1, 1, 4096);
    290     }
    291
    292     public void ReInit(java.io.InputStream dstream, int startline, int startcolumn, int buffersize) {
    293         ReInit(new java.io.InputStreamReader(dstream), startline, startcolumn, 4096);
    294     }
    295
    296     public void ReInit(java.io.InputStream dstream) {
    297         ReInit(dstream, 1, 1, 4096);
    298     }
    299
    300     public void ReInit(java.io.InputStream dstream, int startline, int startcolumn) {
    301         ReInit(dstream, startline, startcolumn, 4096);
    302     }
    303
    304     static public String GetImage() {
    305         if (bufpos >= tokenBegin) {
    306             return new String(buffer, tokenBegin, bufpos - tokenBegin + 1);
    307         } else {
    308             return new String(buffer, tokenBegin, bufsize - tokenBegin) + new String(buffer, 0, bufpos + 1);
    309         }
    310     }
    311
    312     static public char[] GetSuffix(int len) {
    313         char[] ret = new char[len];
    314
    315         if ((bufpos + 1) >= len) {
    316             System.arraycopy(buffer, bufpos - len + 1, ret, 0, len);
    317         } else {
    318             System.arraycopy(buffer, bufsize - (len - bufpos - 1), ret, 0, len - bufpos - 1);
    319             System.arraycopy(buffer, 0, ret, len - bufpos - 1, bufpos + 1);
    320         }
    321
    322         return ret;
    323     }
    324
    325     static public void Done() {
    326         buffer = null;
    327         bufline = null;
    328         bufcolumn = null;
    329     }
    330
    331     /***
    332      * Method to adjust line and column numbers for the start of a token.
    333      */
    334     static public void adjustBeginLineColumn(int newLine, int newCol) {
    335         int start = tokenBegin;
    336         int len;
    337
    338         if (bufpos >= tokenBegin) {
    339             len = bufpos - tokenBegin + inBuf + 1;
    340         } else {
    341             len = bufsize - tokenBegin + bufpos + 1 + inBuf;
    342         }
    343
    344         int i = 0, j = 0, k = 0;
    345         int nextColDiff = 0, columnDiff = 0;
    346
    347         while (i < len && bufline[j = start % bufsize] == bufline[k = ++start % bufsize]) {
    348             bufline[j] = newLine;
    349             nextColDiff = columnDiff + bufcolumn[k] - bufcolumn[j];
    350             bufcolumn[j] = newCol + columnDiff;
    351             columnDiff = nextColDiff;
    352             i++;
    353         }
    354
    355         if (i < len) {
    356             bufline[j] = newLine++;
    357             bufcolumn[j] = newCol + columnDiff;
    358
    359             while (i++ < len) {
    360                 if (bufline[j = start % bufsize] != bufline[++start % bufsize]) {
    361                     bufline[j] = newLine++;
    362                 } else {
    363                     bufline[j] = newLine;
    364                 }
    365             }
    366         }
    367
    368         line = bufline[j];
    369         column = bufcolumn[j];
    370     }
    371
    372 }