bundles/org.simantics.spreadsheet.graph/src/org/simantics/spreadsheet/graph/parser/SimpleCharStream.java

   1 /* Generated By:JavaCC: Do not edit this line. SimpleCharStream.java Version 5.0 */
   2 /* JavaCCOptions:STATIC=false,SUPPORT_CLASS_VISIBILITY_PUBLIC=true */
   3 package org.simantics.spreadsheet.graph.parser;
   4
   5 /**
   6  * An implementation of interface CharStream, where the stream is assumed to
   7  * contain only ASCII characters (without unicode processing).
   8  */
   9
  10 public class SimpleCharStream
  11 {
  12 /** Whether parser is static. */
  13   public static final boolean staticFlag = false;
  14   int bufsize;
  15   int available;
  16   int tokenBegin;
  17 /** Position in buffer. */
  18   public int bufpos = -1;
  19   protected int bufline[];
  20   protected int bufcolumn[];
  21
  22   protected int column = 0;
  23   protected int line = 1;
  24
  25   protected boolean prevCharIsCR = false;
  26   protected boolean prevCharIsLF = false;
  27
  28   protected java.io.Reader inputStream;
  29
  30   protected char[] buffer;
  31   protected int maxNextCharInd = 0;
  32   protected int inBuf = 0;
  33   protected int tabSize = 8;
  34
  35   protected void setTabSize(int i) { tabSize = i; }
  36   protected int getTabSize(int i) { return tabSize; }
  37
  38
  39   protected void ExpandBuff(boolean wrapAround)
  40   {
  41     char[] newbuffer = new char[bufsize + 2048];
  42     int newbufline[] = new int[bufsize + 2048];
  43     int newbufcolumn[] = new int[bufsize + 2048];
  44
  45     try
  46     {
  47       if (wrapAround)
  48       {
  49         System.arraycopy(buffer, tokenBegin, newbuffer, 0, bufsize - tokenBegin);
  50         System.arraycopy(buffer, 0, newbuffer, 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   protected void FillBuff() throws java.io.IOException
  89   {
  90     if (maxNextCharInd == available)
  91     {
  92       if (available == bufsize)
  93       {
  94         if (tokenBegin > 2048)
  95         {
  96           bufpos = maxNextCharInd = 0;
  97           available = tokenBegin;
  98         }
  99         else if (tokenBegin < 0)
 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, available - maxNextCharInd)) == -1)
 115       {
 116         inputStream.close();
 117         throw new java.io.IOException();
 118       }
 119       else
 120         maxNextCharInd += i;
 121       return;
 122     }
 123     catch(java.io.IOException e) {
 124       --bufpos;
 125       backup(0);
 126       if (tokenBegin == -1)
 127         tokenBegin = bufpos;
 128       throw e;
 129     }
 130   }
 131
 132 /** Start. */
 133   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   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 += (tabSize - (column % tabSize));
 173         break;
 174       default :
 175         break;
 176     }
 177
 178     bufline[bufpos] = line;
 179     bufcolumn[bufpos] = column;
 180   }
 181
 182 /** Read a character. */
 183   public char readChar() throws java.io.IOException
 184   {
 185     if (inBuf > 0)
 186     {
 187       --inBuf;
 188
 189       if (++bufpos == bufsize)
 190         bufpos = 0;
 191
 192       return buffer[bufpos];
 193     }
 194
 195     if (++bufpos >= maxNextCharInd)
 196       FillBuff();
 197
 198     char c = buffer[bufpos];
 199
 200     UpdateLineColumn(c);
 201     return c;
 202   }
 203
 204   @Deprecated
 205   /**
 206    * @deprecated
 207    * @see #getEndColumn
 208    */
 209
 210   public int getColumn() {
 211     return bufcolumn[bufpos];
 212   }
 213
 214   @Deprecated
 215   /**
 216    * @deprecated
 217    * @see #getEndLine
 218    */
 219
 220   public int getLine() {
 221     return bufline[bufpos];
 222   }
 223
 224   /** Get token end column number. */
 225   public int getEndColumn() {
 226     return bufcolumn[bufpos];
 227   }
 228
 229   /** Get token end line number. */
 230   public int getEndLine() {
 231      return bufline[bufpos];
 232   }
 233
 234   /** Get token beginning column number. */
 235   public int getBeginColumn() {
 236     return bufcolumn[tokenBegin];
 237   }
 238
 239   /** Get token beginning line number. */
 240   public int getBeginLine() {
 241     return bufline[tokenBegin];
 242   }
 243
 244 /** Backup a number of characters. */
 245   public void backup(int amount) {
 246
 247     inBuf += amount;
 248     if ((bufpos -= amount) < 0)
 249       bufpos += bufsize;
 250   }
 251
 252   /** Constructor. */
 253   public SimpleCharStream(java.io.Reader dstream, int startline,
 254   int startcolumn, int buffersize)
 255   {
 256     inputStream = dstream;
 257     line = startline;
 258     column = startcolumn - 1;
 259
 260     available = bufsize = buffersize;
 261     buffer = new char[buffersize];
 262     bufline = new int[buffersize];
 263     bufcolumn = new int[buffersize];
 264   }
 265
 266   /** Constructor. */
 267   public SimpleCharStream(java.io.Reader dstream, int startline,
 268                           int startcolumn)
 269   {
 270     this(dstream, startline, startcolumn, 4096);
 271   }
 272
 273   /** Constructor. */
 274   public SimpleCharStream(java.io.Reader dstream)
 275   {
 276     this(dstream, 1, 1, 4096);
 277   }
 278
 279   /** Reinitialise. */
 280   public void ReInit(java.io.Reader dstream, int startline,
 281   int startcolumn, int buffersize)
 282   {
 283     inputStream = dstream;
 284     line = startline;
 285     column = startcolumn - 1;
 286
 287     if (buffer == null || buffersize != buffer.length)
 288     {
 289       available = bufsize = buffersize;
 290       buffer = new char[buffersize];
 291       bufline = new int[buffersize];
 292       bufcolumn = new int[buffersize];
 293     }
 294     prevCharIsLF = prevCharIsCR = false;
 295     tokenBegin = inBuf = maxNextCharInd = 0;
 296     bufpos = -1;
 297   }
 298
 299   /** Reinitialise. */
 300   public void ReInit(java.io.Reader dstream, int startline,
 301                      int startcolumn)
 302   {
 303     ReInit(dstream, startline, startcolumn, 4096);
 304   }
 305
 306   /** Reinitialise. */
 307   public void ReInit(java.io.Reader dstream)
 308   {
 309     ReInit(dstream, 1, 1, 4096);
 310   }
 311   /** Constructor. */
 312   public SimpleCharStream(java.io.InputStream dstream, String encoding, int startline,
 313   int startcolumn, int buffersize) throws java.io.UnsupportedEncodingException
 314   {
 315     this(encoding == null ? new java.io.InputStreamReader(dstream) : new java.io.InputStreamReader(dstream, encoding), startline, startcolumn, buffersize);
 316   }
 317
 318   /** Constructor. */
 319   public SimpleCharStream(java.io.InputStream dstream, int startline,
 320   int startcolumn, int buffersize)
 321   {
 322     this(new java.io.InputStreamReader(dstream), startline, startcolumn, buffersize);
 323   }
 324
 325   /** Constructor. */
 326   public SimpleCharStream(java.io.InputStream dstream, String encoding, int startline,
 327                           int startcolumn) throws java.io.UnsupportedEncodingException
 328   {
 329     this(dstream, encoding, startline, startcolumn, 4096);
 330   }
 331
 332   /** Constructor. */
 333   public SimpleCharStream(java.io.InputStream dstream, int startline,
 334                           int startcolumn)
 335   {
 336     this(dstream, startline, startcolumn, 4096);
 337   }
 338
 339   /** Constructor. */
 340   public SimpleCharStream(java.io.InputStream dstream, String encoding) throws java.io.UnsupportedEncodingException
 341   {
 342     this(dstream, encoding, 1, 1, 4096);
 343   }
 344
 345   /** Constructor. */
 346   public SimpleCharStream(java.io.InputStream dstream)
 347   {
 348     this(dstream, 1, 1, 4096);
 349   }
 350
 351   /** Reinitialise. */
 352   public void ReInit(java.io.InputStream dstream, String encoding, int startline,
 353                           int startcolumn, int buffersize) throws java.io.UnsupportedEncodingException
 354   {
 355     ReInit(encoding == null ? new java.io.InputStreamReader(dstream) : new java.io.InputStreamReader(dstream, encoding), startline, startcolumn, buffersize);
 356   }
 357
 358   /** Reinitialise. */
 359   public void ReInit(java.io.InputStream dstream, int startline,
 360                           int startcolumn, int buffersize)
 361   {
 362     ReInit(new java.io.InputStreamReader(dstream), startline, startcolumn, buffersize);
 363   }
 364
 365   /** Reinitialise. */
 366   public void ReInit(java.io.InputStream dstream, String encoding) throws java.io.UnsupportedEncodingException
 367   {
 368     ReInit(dstream, encoding, 1, 1, 4096);
 369   }
 370
 371   /** Reinitialise. */
 372   public void ReInit(java.io.InputStream dstream)
 373   {
 374     ReInit(dstream, 1, 1, 4096);
 375   }
 376   /** Reinitialise. */
 377   public void ReInit(java.io.InputStream dstream, String encoding, int startline,
 378                      int startcolumn) throws java.io.UnsupportedEncodingException
 379   {
 380     ReInit(dstream, encoding, startline, startcolumn, 4096);
 381   }
 382   /** Reinitialise. */
 383   public void ReInit(java.io.InputStream dstream, int startline,
 384                      int startcolumn)
 385   {
 386     ReInit(dstream, startline, startcolumn, 4096);
 387   }
 388   /** Get token literal value. */
 389   public String GetImage()
 390   {
 391     if (bufpos >= tokenBegin)
 392       return new String(buffer, tokenBegin, bufpos - tokenBegin + 1);
 393     else
 394       return new String(buffer, tokenBegin, bufsize - tokenBegin) +
 395                             new String(buffer, 0, bufpos + 1);
 396   }
 397
 398   /** Get the suffix. */
 399   public char[] GetSuffix(int len)
 400   {
 401     char[] ret = new char[len];
 402
 403     if ((bufpos + 1) >= len)
 404       System.arraycopy(buffer, bufpos - len + 1, ret, 0, len);
 405     else
 406     {
 407       System.arraycopy(buffer, bufsize - (len - bufpos - 1), ret, 0,
 408                                                         len - bufpos - 1);
 409       System.arraycopy(buffer, 0, ret, len - bufpos - 1, bufpos + 1);
 410     }
 411
 412     return ret;
 413   }
 414
 415   /** Reset buffer when finished. */
 416   public void Done()
 417   {
 418     buffer = null;
 419     bufline = null;
 420     bufcolumn = null;
 421   }
 422
 423   /**
 424    * Method to adjust line and column numbers for the start of a token.
 425    */
 426   public void adjustBeginLineColumn(int newLine, int newCol)
 427   {
 428     int start = tokenBegin;
 429     int len;
 430
 431     if (bufpos >= tokenBegin)
 432     {
 433       len = bufpos - tokenBegin + inBuf + 1;
 434     }
 435     else
 436     {
 437       len = bufsize - tokenBegin + bufpos + 1 + inBuf;
 438     }
 439
 440     int i = 0, j = 0, k = 0;
 441     int nextColDiff = 0, columnDiff = 0;
 442
 443     while (i < len && bufline[j = start % bufsize] == bufline[k = ++start % bufsize])
 444     {
 445       bufline[j] = newLine;
 446       nextColDiff = columnDiff + bufcolumn[k] - bufcolumn[j];
 447       bufcolumn[j] = newCol + columnDiff;
 448       columnDiff = nextColDiff;
 449       i++;
 450     }
 451
 452     if (i < len)
 453     {
 454       bufline[j] = newLine++;
 455       bufcolumn[j] = newCol + columnDiff;
 456
 457       while (i++ < len)
 458       {
 459         if (bufline[j = start % bufsize] != bufline[++start % bufsize])
 460           bufline[j] = newLine++;
 461         else
 462           bufline[j] = newLine;
 463       }
 464     }
 465
 466     line = bufline[j];
 467     column = bufcolumn[j];
 468   }
 469
 470 }
 471 /* JavaCC - OriginalChecksum=ba0a2636eda0843482e36cc3e9220588 (do not edit this line) */