net.sourceforge.phpeclipse/src/test/SimpleCharStream.java

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