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