001/* Generated By:JavaCC: Do not edit this line. JavaCharStream.java Version 4.1 */
002/* JavaCCOptions:STATIC=false */
003package com.randomnoun.common.jexl.parser;
004
005/**
006 * An implementation of interface CharStream, where the stream is assumed to
007 * contain only ASCII characters (with java-like unicode escape processing).
008 */
009
010public class JavaCharStream
011{
012/** Whether parser is static. */
013  public static final boolean staticFlag = false;
014  static final int hexval(char c) throws java.io.IOException {
015    switch(c)
016    {
017       case '0' :
018          return 0;
019       case '1' :
020          return 1;
021       case '2' :
022          return 2;
023       case '3' :
024          return 3;
025       case '4' :
026          return 4;
027       case '5' :
028          return 5;
029       case '6' :
030          return 6;
031       case '7' :
032          return 7;
033       case '8' :
034          return 8;
035       case '9' :
036          return 9;
037
038       case 'a' :
039       case 'A' :
040          return 10;
041       case 'b' :
042       case 'B' :
043          return 11;
044       case 'c' :
045       case 'C' :
046          return 12;
047       case 'd' :
048       case 'D' :
049          return 13;
050       case 'e' :
051       case 'E' :
052          return 14;
053       case 'f' :
054       case 'F' :
055          return 15;
056    }
057
058    throw new java.io.IOException(); // Should never come here
059  }
060
061/** Position in buffer. */
062  public int bufpos = -1;
063  int bufsize;
064  int available;
065  int tokenBegin;
066  protected int bufline[];
067  protected int bufcolumn[];
068
069  protected int column = 0;
070  protected int line = 1;
071
072  protected boolean prevCharIsCR = false;
073  protected boolean prevCharIsLF = false;
074
075  protected java.io.Reader inputStream;
076
077  protected char[] nextCharBuf;
078  protected char[] buffer;
079  protected int maxNextCharInd = 0;
080  protected int nextCharInd = -1;
081  protected int inBuf = 0;
082  protected int tabSize = 8;
083
084  protected void setTabSize(int i) { tabSize = i; }
085  protected int getTabSize(int i) { return tabSize; }
086
087  protected void ExpandBuff(boolean wrapAround)
088  {
089     char[] newbuffer = new char[bufsize + 2048];
090     int newbufline[] = new int[bufsize + 2048];
091     int newbufcolumn[] = new int[bufsize + 2048];
092
093     try
094     {
095        if (wrapAround)
096        {
097           System.arraycopy(buffer, tokenBegin, newbuffer, 0, bufsize - tokenBegin);
098           System.arraycopy(buffer, 0, newbuffer,
099                                             bufsize - tokenBegin, bufpos);
100           buffer = newbuffer;
101
102           System.arraycopy(bufline, tokenBegin, newbufline, 0, bufsize - tokenBegin);
103           System.arraycopy(bufline, 0, newbufline, bufsize - tokenBegin, bufpos);
104           bufline = newbufline;
105
106           System.arraycopy(bufcolumn, tokenBegin, newbufcolumn, 0, bufsize - tokenBegin);
107           System.arraycopy(bufcolumn, 0, newbufcolumn, bufsize - tokenBegin, bufpos);
108           bufcolumn = newbufcolumn;
109
110           bufpos += (bufsize - tokenBegin);
111        }
112        else
113        {
114           System.arraycopy(buffer, tokenBegin, newbuffer, 0, bufsize - tokenBegin);
115           buffer = newbuffer;
116
117           System.arraycopy(bufline, tokenBegin, newbufline, 0, bufsize - tokenBegin);
118           bufline = newbufline;
119
120           System.arraycopy(bufcolumn, tokenBegin, newbufcolumn, 0, bufsize - tokenBegin);
121           bufcolumn = newbufcolumn;
122
123           bufpos -= tokenBegin;
124        }
125     }
126     catch (Throwable t)
127     {
128        throw new Error(t.getMessage());
129     }
130
131     available = (bufsize += 2048);
132     tokenBegin = 0;
133  }
134
135  protected void FillBuff() throws java.io.IOException
136  {
137     int i;
138     if (maxNextCharInd == 4096)
139        maxNextCharInd = nextCharInd = 0;
140
141     try {
142        if ((i = inputStream.read(nextCharBuf, maxNextCharInd,
143                                            4096 - maxNextCharInd)) == -1)
144        {
145           inputStream.close();
146           throw new java.io.IOException();
147        }
148        else
149           maxNextCharInd += i;
150        return;
151     }
152     catch(java.io.IOException e) {
153        if (bufpos != 0)
154        {
155           --bufpos;
156           backup(0);
157        }
158        else
159        {
160           bufline[bufpos] = line;
161           bufcolumn[bufpos] = column;
162        }
163        throw e;
164     }
165  }
166
167  protected char ReadByte() throws java.io.IOException
168  {
169     if (++nextCharInd >= maxNextCharInd)
170        FillBuff();
171
172     return nextCharBuf[nextCharInd];
173  }
174
175/** @return starting character for token. */
176  public char BeginToken() throws java.io.IOException
177  {
178     if (inBuf > 0)
179     {
180        --inBuf;
181
182        if (++bufpos == bufsize)
183           bufpos = 0;
184
185        tokenBegin = bufpos;
186        return buffer[bufpos];
187     }
188
189     tokenBegin = 0;
190     bufpos = -1;
191
192     return readChar();
193  }
194
195  protected void AdjustBuffSize()
196  {
197     if (available == bufsize)
198     {
199        if (tokenBegin > 2048)
200        {
201           bufpos = 0;
202           available = tokenBegin;
203        }
204        else
205           ExpandBuff(false);
206     }
207     else if (available > tokenBegin)
208        available = bufsize;
209     else if ((tokenBegin - available) < 2048)
210        ExpandBuff(true);
211     else
212        available = tokenBegin;
213  }
214
215  protected void UpdateLineColumn(char c)
216  {
217     column++;
218
219     if (prevCharIsLF)
220     {
221        prevCharIsLF = false;
222        line += (column = 1);
223     }
224     else if (prevCharIsCR)
225     {
226        prevCharIsCR = false;
227        if (c == '\n')
228        {
229           prevCharIsLF = true;
230        }
231        else
232           line += (column = 1);
233     }
234
235     switch (c)
236     {
237        case '\r' :
238           prevCharIsCR = true;
239           break;
240        case '\n' :
241           prevCharIsLF = true;
242           break;
243        case '\t' :
244           column--;
245           column += (tabSize - (column % tabSize));
246           break;
247        default :
248           break;
249     }
250
251     bufline[bufpos] = line;
252     bufcolumn[bufpos] = column;
253  }
254
255/** Read a character. */
256  public char readChar() throws java.io.IOException
257  {
258     if (inBuf > 0)
259     {
260        --inBuf;
261
262        if (++bufpos == bufsize)
263           bufpos = 0;
264
265        return buffer[bufpos];
266     }
267
268     char c;
269
270     if (++bufpos == available)
271        AdjustBuffSize();
272
273     if ((buffer[bufpos] = c = ReadByte()) == '\\')
274     {
275        UpdateLineColumn(c);
276
277        int backSlashCnt = 1;
278
279        for (;;) // Read all the backslashes
280        {
281           if (++bufpos == available)
282              AdjustBuffSize();
283
284           try
285           {
286              if ((buffer[bufpos] = c = ReadByte()) != '\\')
287              {
288                 UpdateLineColumn(c);
289                 // found a non-backslash char.
290                 if ((c == 'u') && ((backSlashCnt & 1) == 1))
291                 {
292                    if (--bufpos < 0)
293                       bufpos = bufsize - 1;
294
295                    break;
296                 }
297
298                 backup(backSlashCnt);
299                 return '\\';
300              }
301           }
302           catch(java.io.IOException e)
303           {
304              if (backSlashCnt > 1)
305                 backup(backSlashCnt-1);
306
307              return '\\';
308           }
309
310           UpdateLineColumn(c);
311           backSlashCnt++;
312        }
313
314        // Here, we have seen an odd number of backslash's followed by a 'u'
315        try
316        {
317           while ((c = ReadByte()) == 'u')
318              ++column;
319
320           buffer[bufpos] = c = (char)(hexval(c) << 12 |
321                                       hexval(ReadByte()) << 8 |
322                                       hexval(ReadByte()) << 4 |
323                                       hexval(ReadByte()));
324
325           column += 4;
326        }
327        catch(java.io.IOException e)
328        {
329           throw new Error("Invalid escape character at line " + line +
330                                         " column " + column + ".");
331        }
332
333        if (backSlashCnt == 1)
334           return c;
335        else
336        {
337           backup(backSlashCnt - 1);
338           return '\\';
339        }
340     }
341     else
342     {
343        UpdateLineColumn(c);
344        return c;
345     }
346  }
347
348  /**
349   * @deprecated
350   * @see #getEndColumn
351   */
352  public int getColumn() {
353     return bufcolumn[bufpos];
354  }
355
356  /**
357   * @deprecated
358   * @see #getEndLine
359   */
360  public int getLine() {
361     return bufline[bufpos];
362  }
363
364/** Get end column. */
365  public int getEndColumn() {
366     return bufcolumn[bufpos];
367  }
368
369/** Get end line. */
370  public int getEndLine() {
371     return bufline[bufpos];
372  }
373
374/** @return column of token start */
375  public int getBeginColumn() {
376     return bufcolumn[tokenBegin];
377  }
378
379/** @return line number of token start */
380  public int getBeginLine() {
381     return bufline[tokenBegin];
382  }
383
384/** Retreat. */
385  public void backup(int amount) {
386
387    inBuf += amount;
388    if ((bufpos -= amount) < 0)
389       bufpos += bufsize;
390  }
391
392/** Constructor. */
393  public JavaCharStream(java.io.Reader dstream,
394                 int startline, int startcolumn, int buffersize)
395  {
396    inputStream = dstream;
397    line = startline;
398    column = startcolumn - 1;
399
400    available = bufsize = buffersize;
401    buffer = new char[buffersize];
402    bufline = new int[buffersize];
403    bufcolumn = new int[buffersize];
404    nextCharBuf = new char[4096];
405  }
406
407/** Constructor. */
408  public JavaCharStream(java.io.Reader dstream,
409                                        int startline, int startcolumn)
410  {
411     this(dstream, startline, startcolumn, 4096);
412  }
413
414/** Constructor. */
415  public JavaCharStream(java.io.Reader dstream)
416  {
417     this(dstream, 1, 1, 4096);
418  }
419/** Reinitialise. */
420  public void ReInit(java.io.Reader dstream,
421                 int startline, int startcolumn, int buffersize)
422  {
423    inputStream = dstream;
424    line = startline;
425    column = startcolumn - 1;
426
427    if (buffer == null || buffersize != buffer.length)
428    {
429      available = bufsize = buffersize;
430      buffer = new char[buffersize];
431      bufline = new int[buffersize];
432      bufcolumn = new int[buffersize];
433      nextCharBuf = new char[4096];
434    }
435    prevCharIsLF = prevCharIsCR = false;
436    tokenBegin = inBuf = maxNextCharInd = 0;
437    nextCharInd = bufpos = -1;
438  }
439
440/** Reinitialise. */
441  public void ReInit(java.io.Reader dstream,
442                                        int startline, int startcolumn)
443  {
444     ReInit(dstream, startline, startcolumn, 4096);
445  }
446
447/** Reinitialise. */
448  public void ReInit(java.io.Reader dstream)
449  {
450     ReInit(dstream, 1, 1, 4096);
451  }
452/** Constructor. */
453  public JavaCharStream(java.io.InputStream dstream, String encoding, int startline,
454  int startcolumn, int buffersize) throws java.io.UnsupportedEncodingException
455  {
456     this(encoding == null ? new java.io.InputStreamReader(dstream) : new java.io.InputStreamReader(dstream, encoding), startline, startcolumn, buffersize);
457  }
458
459/** Constructor. */
460  public JavaCharStream(java.io.InputStream dstream, int startline,
461  int startcolumn, int buffersize)
462  {
463     this(new java.io.InputStreamReader(dstream), startline, startcolumn, 4096);
464  }
465
466/** Constructor. */
467  public JavaCharStream(java.io.InputStream dstream, String encoding, int startline,
468                        int startcolumn) throws java.io.UnsupportedEncodingException
469  {
470     this(dstream, encoding, startline, startcolumn, 4096);
471  }
472
473/** Constructor. */
474  public JavaCharStream(java.io.InputStream dstream, int startline,
475                        int startcolumn)
476  {
477     this(dstream, startline, startcolumn, 4096);
478  }
479
480/** Constructor. */
481  public JavaCharStream(java.io.InputStream dstream, String encoding) throws java.io.UnsupportedEncodingException
482  {
483     this(dstream, encoding, 1, 1, 4096);
484  }
485
486/** Constructor. */
487  public JavaCharStream(java.io.InputStream dstream)
488  {
489     this(dstream, 1, 1, 4096);
490  }
491
492/** Reinitialise. */
493  public void ReInit(java.io.InputStream dstream, String encoding, int startline,
494  int startcolumn, int buffersize) throws java.io.UnsupportedEncodingException
495  {
496     ReInit(encoding == null ? new java.io.InputStreamReader(dstream) : new java.io.InputStreamReader(dstream, encoding), startline, startcolumn, buffersize);
497  }
498
499/** Reinitialise. */
500  public void ReInit(java.io.InputStream dstream, int startline,
501  int startcolumn, int buffersize)
502  {
503     ReInit(new java.io.InputStreamReader(dstream), startline, startcolumn, buffersize);
504  }
505/** Reinitialise. */
506  public void ReInit(java.io.InputStream dstream, String encoding, int startline,
507                     int startcolumn) throws java.io.UnsupportedEncodingException
508  {
509     ReInit(dstream, encoding, startline, startcolumn, 4096);
510  }
511/** Reinitialise. */
512  public void ReInit(java.io.InputStream dstream, int startline,
513                     int startcolumn)
514  {
515     ReInit(dstream, startline, startcolumn, 4096);
516  }
517/** Reinitialise. */
518  public void ReInit(java.io.InputStream dstream, String encoding) throws java.io.UnsupportedEncodingException
519  {
520     ReInit(dstream, encoding, 1, 1, 4096);
521  }
522
523/** Reinitialise. */
524  public void ReInit(java.io.InputStream dstream)
525  {
526     ReInit(dstream, 1, 1, 4096);
527  }
528
529  /** @return token image as String */
530  public String GetImage()
531  {
532     if (bufpos >= tokenBegin)
533        return new String(buffer, tokenBegin, bufpos - tokenBegin + 1);
534     else
535        return new String(buffer, tokenBegin, bufsize - tokenBegin) +
536                              new String(buffer, 0, bufpos + 1);
537  }
538
539  /** @return suffix */
540  public char[] GetSuffix(int len)
541  {
542     char[] ret = new char[len];
543
544     if ((bufpos + 1) >= len)
545        System.arraycopy(buffer, bufpos - len + 1, ret, 0, len);
546     else
547     {
548        System.arraycopy(buffer, bufsize - (len - bufpos - 1), ret, 0,
549                                                          len - bufpos - 1);
550        System.arraycopy(buffer, 0, ret, len - bufpos - 1, bufpos + 1);
551     }
552
553     return ret;
554  }
555
556  /** Set buffers back to null when finished. */
557  public void Done()
558  {
559     nextCharBuf = null;
560     buffer = null;
561     bufline = null;
562     bufcolumn = null;
563  }
564
565  /**
566   * Method to adjust line and column numbers for the start of a token.
567   */
568  public void adjustBeginLineColumn(int newLine, int newCol)
569  {
570     int start = tokenBegin;
571     int len;
572
573     if (bufpos >= tokenBegin)
574     {
575        len = bufpos - tokenBegin + inBuf + 1;
576     }
577     else
578     {
579        len = bufsize - tokenBegin + bufpos + 1 + inBuf;
580     }
581
582     int i = 0, j = 0, k = 0;
583     int nextColDiff = 0, columnDiff = 0;
584
585     while (i < len &&
586            bufline[j = start % bufsize] == bufline[k = ++start % bufsize])
587     {
588        bufline[j] = newLine;
589        nextColDiff = columnDiff + bufcolumn[k] - bufcolumn[j];
590        bufcolumn[j] = newCol + columnDiff;
591        columnDiff = nextColDiff;
592        i++;
593     }
594
595     if (i < len)
596     {
597        bufline[j] = newLine++;
598        bufcolumn[j] = newCol + columnDiff;
599
600        while (i++ < len)
601        {
602           if (bufline[j = start % bufsize] != bufline[++start % bufsize])
603              bufline[j] = newLine++;
604           else
605              bufline[j] = newLine;
606        }
607     }
608
609     line = bufline[j];
610     column = bufcolumn[j];
611  }
612
613}
614/* JavaCC - OriginalChecksum=17d8eb7c7d816e55d149131ba10b95a1 (do not edit this line) */