001    /* Generated By:JavaCC: Do not edit this line. JavaCharStream.java Version 4.1 */
002    /* JavaCCOptions:STATIC=false */
003    package org.jfree.formula.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    
010    public 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=cc3cca1b398f69f0cf0ab4b5fc4fa7f3 (do not edit this line) */