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