View Javadoc

1   /* Generated By:JavaCC: Do not edit this line. SimpleCharStream.java Version 3.0 */
2   /***************************************************************************************
3    * Copyright (c) Jonas BonŽr, Alexandre Vasseur. All rights reserved.                 *
4    * http://aspectwerkz.codehaus.org                                                    *
5    * ---------------------------------------------------------------------------------- *
6    * The software in this package is published under the terms of the LGPL license      *
7    * a copy of which has been included with this distribution in the license.txt file.  *
8    **************************************************************************************/
9   package org.codehaus.aspectwerkz.expression.ast;
10  
11  /***
12   * An implementation of interface CharStream, where the stream is assumed to contain only ASCII characters (without
13   * unicode processing).
14   */
15  
16  public class SimpleCharStream {
17      public static final boolean staticFlag = true;
18  
19      static int bufsize;
20  
21      static int available;
22  
23      static int tokenBegin;
24  
25      static public int bufpos = -1;
26  
27      static protected int bufline[];
28  
29      static protected int bufcolumn[];
30  
31      static protected int column = 0;
32  
33      static protected int line = 1;
34  
35      static protected boolean prevCharIsCR = false;
36  
37      static protected boolean prevCharIsLF = false;
38  
39      static protected java.io.Reader inputStream;
40  
41      static protected char[] buffer;
42  
43      static protected int maxNextCharInd = 0;
44  
45      static protected int inBuf = 0;
46  
47      static protected void ExpandBuff(boolean wrapAround) {
48          char[] newbuffer = new char[bufsize + 2048];
49          int newbufline[] = new int[bufsize + 2048];
50          int newbufcolumn[] = new int[bufsize + 2048];
51  
52          try {
53              if (wrapAround) {
54                  System.arraycopy(buffer, tokenBegin, newbuffer, 0, bufsize - tokenBegin);
55                  System.arraycopy(buffer, 0, newbuffer, bufsize - tokenBegin, bufpos);
56                  buffer = newbuffer;
57  
58                  System.arraycopy(bufline, tokenBegin, newbufline, 0, bufsize - tokenBegin);
59                  System.arraycopy(bufline, 0, newbufline, bufsize - tokenBegin, bufpos);
60                  bufline = newbufline;
61  
62                  System.arraycopy(bufcolumn, tokenBegin, newbufcolumn, 0, bufsize - tokenBegin);
63                  System.arraycopy(bufcolumn, 0, newbufcolumn, bufsize - tokenBegin, bufpos);
64                  bufcolumn = newbufcolumn;
65  
66                  maxNextCharInd = (bufpos += (bufsize - tokenBegin));
67              } else {
68                  System.arraycopy(buffer, tokenBegin, newbuffer, 0, bufsize - tokenBegin);
69                  buffer = newbuffer;
70  
71                  System.arraycopy(bufline, tokenBegin, newbufline, 0, bufsize - tokenBegin);
72                  bufline = newbufline;
73  
74                  System.arraycopy(bufcolumn, tokenBegin, newbufcolumn, 0, bufsize - tokenBegin);
75                  bufcolumn = newbufcolumn;
76  
77                  maxNextCharInd = (bufpos -= tokenBegin);
78              }
79          } catch (Throwable t) {
80              throw new Error(t.getMessage());
81          }
82  
83          bufsize += 2048;
84          available = bufsize;
85          tokenBegin = 0;
86      }
87  
88      static protected void FillBuff() throws java.io.IOException {
89          if (maxNextCharInd == available) {
90              if (available == bufsize) {
91                  if (tokenBegin > 2048) {
92                      bufpos = maxNextCharInd = 0;
93                      available = tokenBegin;
94                  } else if (tokenBegin < 0) {
95                      bufpos = maxNextCharInd = 0;
96                  } else {
97                      ExpandBuff(false);
98                  }
99              } else if (available > tokenBegin) {
100                 available = bufsize;
101             } else if ((tokenBegin - available) < 2048) {
102                 ExpandBuff(true);
103             } else {
104                 available = tokenBegin;
105             }
106         }
107 
108         int i;
109         try {
110             if ((i = inputStream.read(buffer, maxNextCharInd, available - maxNextCharInd)) == -1) {
111                 inputStream.close();
112                 throw new java.io.IOException();
113             } else {
114                 maxNextCharInd += i;
115             }
116             return;
117         } catch (java.io.IOException e) {
118             --bufpos;
119             backup(0);
120             if (tokenBegin == -1) {
121                 tokenBegin = bufpos;
122             }
123             throw e;
124         }
125     }
126 
127     static public char BeginToken() throws java.io.IOException {
128         tokenBegin = -1;
129         char c = readChar();
130         tokenBegin = bufpos;
131 
132         return c;
133     }
134 
135     static protected void UpdateLineColumn(char c) {
136         column++;
137 
138         if (prevCharIsLF) {
139             prevCharIsLF = false;
140             line += (column = 1);
141         } else if (prevCharIsCR) {
142             prevCharIsCR = false;
143             if (c == '\n') {
144                 prevCharIsLF = true;
145             } else {
146                 line += (column = 1);
147             }
148         }
149 
150         switch (c) {
151             case '\r':
152                 prevCharIsCR = true;
153                 break;
154             case '\n':
155                 prevCharIsLF = true;
156                 break;
157             case '\t':
158                 column--;
159                 column += (8 - (column & 07));
160                 break;
161             default:
162                 break;
163         }
164 
165         bufline[bufpos] = line;
166         bufcolumn[bufpos] = column;
167     }
168 
169     static public char readChar() throws java.io.IOException {
170         if (inBuf > 0) {
171             --inBuf;
172 
173             if (++bufpos == bufsize) {
174                 bufpos = 0;
175             }
176 
177             return buffer[bufpos];
178         }
179 
180         if (++bufpos >= maxNextCharInd) {
181             FillBuff();
182         }
183 
184         char c = buffer[bufpos];
185 
186         UpdateLineColumn(c);
187         return (c);
188     }
189 
190     /***
191      * @deprecated @see #getEndColumn
192      */
193 
194     static public int getColumn() {
195         return bufcolumn[bufpos];
196     }
197 
198     /***
199      * @deprecated @see #getEndLine
200      */
201 
202     static public int getLine() {
203         return bufline[bufpos];
204     }
205 
206     static public int getEndColumn() {
207         return bufcolumn[bufpos];
208     }
209 
210     static public int getEndLine() {
211         return bufline[bufpos];
212     }
213 
214     static public int getBeginColumn() {
215         return bufcolumn[tokenBegin];
216     }
217 
218     static public int getBeginLine() {
219         return bufline[tokenBegin];
220     }
221 
222     static public void backup(int amount) {
223 
224         inBuf += amount;
225         if ((bufpos -= amount) < 0) {
226             bufpos += bufsize;
227         }
228     }
229 
230     public SimpleCharStream(java.io.Reader dstream, int startline, int startcolumn, int buffersize) {
231         if (inputStream != null) {
232             throw new Error(
233                     "\n   ERROR: Second call to the constructor of a static SimpleCharStream.  You must\n"
234                     + "       either use ReInit() or set the JavaCC option STATIC to false\n"
235                     + "       during the generation of this class."
236             );
237         }
238         inputStream = dstream;
239         line = startline;
240         column = startcolumn - 1;
241 
242         available = bufsize = buffersize;
243         buffer = new char[buffersize];
244         bufline = new int[buffersize];
245         bufcolumn = new int[buffersize];
246     }
247 
248     public SimpleCharStream(java.io.Reader dstream, int startline, int startcolumn) {
249         this(dstream, startline, startcolumn, 4096);
250     }
251 
252     public SimpleCharStream(java.io.Reader dstream) {
253         this(dstream, 1, 1, 4096);
254     }
255 
256     public void ReInit(java.io.Reader dstream, int startline, int startcolumn, int buffersize) {
257         inputStream = dstream;
258         line = startline;
259         column = startcolumn - 1;
260 
261         if (buffer == null || buffersize != buffer.length) {
262             available = bufsize = buffersize;
263             buffer = new char[buffersize];
264             bufline = new int[buffersize];
265             bufcolumn = new int[buffersize];
266         }
267         prevCharIsLF = prevCharIsCR = false;
268         tokenBegin = inBuf = maxNextCharInd = 0;
269         bufpos = -1;
270     }
271 
272     public void ReInit(java.io.Reader dstream, int startline, int startcolumn) {
273         ReInit(dstream, startline, startcolumn, 4096);
274     }
275 
276     public void ReInit(java.io.Reader dstream) {
277         ReInit(dstream, 1, 1, 4096);
278     }
279 
280     public SimpleCharStream(java.io.InputStream dstream, int startline, int startcolumn, int buffersize) {
281         this(new java.io.InputStreamReader(dstream), startline, startcolumn, 4096);
282     }
283 
284     public SimpleCharStream(java.io.InputStream dstream, int startline, int startcolumn) {
285         this(dstream, startline, startcolumn, 4096);
286     }
287 
288     public SimpleCharStream(java.io.InputStream dstream) {
289         this(dstream, 1, 1, 4096);
290     }
291 
292     public void ReInit(java.io.InputStream dstream, int startline, int startcolumn, int buffersize) {
293         ReInit(new java.io.InputStreamReader(dstream), startline, startcolumn, 4096);
294     }
295 
296     public void ReInit(java.io.InputStream dstream) {
297         ReInit(dstream, 1, 1, 4096);
298     }
299 
300     public void ReInit(java.io.InputStream dstream, int startline, int startcolumn) {
301         ReInit(dstream, startline, startcolumn, 4096);
302     }
303 
304     static public String GetImage() {
305         if (bufpos >= tokenBegin) {
306             return new String(buffer, tokenBegin, bufpos - tokenBegin + 1);
307         } else {
308             return new String(buffer, tokenBegin, bufsize - tokenBegin) + new String(buffer, 0, bufpos + 1);
309         }
310     }
311 
312     static public char[] GetSuffix(int len) {
313         char[] ret = new char[len];
314 
315         if ((bufpos + 1) >= len) {
316             System.arraycopy(buffer, bufpos - len + 1, ret, 0, len);
317         } else {
318             System.arraycopy(buffer, bufsize - (len - bufpos - 1), ret, 0, len - bufpos - 1);
319             System.arraycopy(buffer, 0, ret, len - bufpos - 1, bufpos + 1);
320         }
321 
322         return ret;
323     }
324 
325     static public void Done() {
326         buffer = null;
327         bufline = null;
328         bufcolumn = null;
329     }
330 
331     /***
332      * Method to adjust line and column numbers for the start of a token.
333      */
334     static public void adjustBeginLineColumn(int newLine, int newCol) {
335         int start = tokenBegin;
336         int len;
337 
338         if (bufpos >= tokenBegin) {
339             len = bufpos - tokenBegin + inBuf + 1;
340         } else {
341             len = bufsize - tokenBegin + bufpos + 1 + inBuf;
342         }
343 
344         int i = 0, j = 0, k = 0;
345         int nextColDiff = 0, columnDiff = 0;
346 
347         while (i < len && bufline[j = start % bufsize] == bufline[k = ++start % bufsize]) {
348             bufline[j] = newLine;
349             nextColDiff = columnDiff + bufcolumn[k] - bufcolumn[j];
350             bufcolumn[j] = newCol + columnDiff;
351             columnDiff = nextColDiff;
352             i++;
353         }
354 
355         if (i < len) {
356             bufline[j] = newLine++;
357             bufcolumn[j] = newCol + columnDiff;
358 
359             while (i++ < len) {
360                 if (bufline[j = start % bufsize] != bufline[++start % bufsize]) {
361                     bufline[j] = newLine++;
362                 } else {
363                     bufline[j] = newLine;
364                 }
365             }
366         }
367 
368         line = bufline[j];
369         column = bufcolumn[j];
370     }
371 
372 }