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