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