KickJava   Java API By Example, From Geeks To Geeks.

Java > Open Source Codes > org > codehaus > aspectwerkz > annotation > expression > ast > SimpleCharStream


1 /* Generated By:JavaCC: Do not edit this line. SimpleCharStream.java Version 3.0 */
2
3 /**************************************************************************************
4  * Copyright (c) Jonas Bonér, Alexandre Vasseur. All rights reserved. *
5  * http://aspectwerkz.codehaus.org *
6  * ---------------------------------------------------------------------------------- *
7  * The software in this package is published under the terms of the LGPL license *
8  * a copy of which has been included with this distribution in the license.txt file. *
9  **************************************************************************************/

10 package org.codehaus.aspectwerkz.annotation.expression.ast;
11
12 /**
13  * An implementation of interface CharStream, where the stream is assumed to contain only ASCII characters (without
14  * unicode processing).
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 JavaDoc inputStream;
40
41     static protected char[] buffer;
42
43     static protected int maxNextCharInd = 0;
44
45     static protected int inBuf = 0;
46
47     public SimpleCharStream(java.io.Reader JavaDoc dstream, int startline, int startcolumn, int buffersize) {
48         if (inputStream != null) {
49             throw new Error JavaDoc(
50                     "\n ERROR: Second call to the constructor of a static SimpleCharStream. You must\n"
51                     + " either use ReInit() or set the JavaCC option STATIC to false\n"
52                     + " during the generation of this class."
53             );
54         }
55         inputStream = dstream;
56         line = startline;
57         column = startcolumn - 1;
58         available = bufsize = buffersize;
59         buffer = new char[buffersize];
60         bufline = new int[buffersize];
61         bufcolumn = new int[buffersize];
62     }
63
64     public SimpleCharStream(java.io.Reader JavaDoc dstream, int startline, int startcolumn) {
65         this(dstream, startline, startcolumn, 4096);
66     }
67
68     public SimpleCharStream(java.io.Reader JavaDoc dstream) {
69         this(dstream, 1, 1, 4096);
70     }
71
72     public SimpleCharStream(java.io.InputStream JavaDoc dstream, int startline, int startcolumn, int buffersize) {
73         this(new java.io.InputStreamReader JavaDoc(dstream), startline, startcolumn, 4096);
74     }
75
76     public SimpleCharStream(java.io.InputStream JavaDoc dstream, int startline, int startcolumn) {
77         this(dstream, startline, startcolumn, 4096);
78     }
79
80     public SimpleCharStream(java.io.InputStream JavaDoc dstream) {
81         this(dstream, 1, 1, 4096);
82     }
83
84     static protected void ExpandBuff(boolean wrapAround) {
85         char[] newbuffer = new char[bufsize + 2048];
86         int[] newbufline = new int[bufsize + 2048];
87         int[] newbufcolumn = new int[bufsize + 2048];
88         try {
89             if (wrapAround) {
90                 System.arraycopy(buffer, tokenBegin, newbuffer, 0, bufsize - tokenBegin);
91                 System.arraycopy(buffer, 0, newbuffer, bufsize - tokenBegin, bufpos);
92                 buffer = newbuffer;
93                 System.arraycopy(bufline, tokenBegin, newbufline, 0, bufsize - tokenBegin);
94                 System.arraycopy(bufline, 0, newbufline, bufsize - tokenBegin, bufpos);
95                 bufline = newbufline;
96                 System.arraycopy(bufcolumn, tokenBegin, newbufcolumn, 0, bufsize - tokenBegin);
97                 System.arraycopy(bufcolumn, 0, newbufcolumn, bufsize - tokenBegin, bufpos);
98                 bufcolumn = newbufcolumn;
99                 maxNextCharInd = (bufpos += (bufsize - tokenBegin));
100             } else {
101                 System.arraycopy(buffer, tokenBegin, newbuffer, 0, bufsize - tokenBegin);
102                 buffer = newbuffer;
103                 System.arraycopy(bufline, tokenBegin, newbufline, 0, bufsize - tokenBegin);
104                 bufline = newbufline;
105                 System.arraycopy(bufcolumn, tokenBegin, newbufcolumn, 0, bufsize - tokenBegin);
106                 bufcolumn = newbufcolumn;
107                 maxNextCharInd = (bufpos -= tokenBegin);
108             }
109         } catch (Throwable JavaDoc t) {
110             throw new Error JavaDoc(t.getMessage());
111         }
112         bufsize += 2048;
113         available = bufsize;
114         tokenBegin = 0;
115     }
116
117     static protected void FillBuff() throws java.io.IOException JavaDoc {
118         if (maxNextCharInd == available) {
119             if (available == bufsize) {
120                 if (tokenBegin > 2048) {
121                     bufpos = maxNextCharInd = 0;
122                     available = tokenBegin;
123                 } else if (tokenBegin < 0) {
124                     bufpos = maxNextCharInd = 0;
125                 } else {
126                     ExpandBuff(false);
127                 }
128             } else if (available > tokenBegin) {
129                 available = bufsize;
130             } else if ((tokenBegin - available) < 2048) {
131                 ExpandBuff(true);
132             } else {
133                 available = tokenBegin;
134             }
135         }
136         int i;
137         try {
138             if ((i = inputStream.read(buffer, maxNextCharInd, available - maxNextCharInd)) == -1) {
139                 inputStream.close();
140                 throw new java.io.IOException JavaDoc();
141             } else {
142                 maxNextCharInd += i;
143             }
144             return;
145         } catch (java.io.IOException JavaDoc e) {
146             --bufpos;
147             backup(0);
148             if (tokenBegin == -1) {
149                 tokenBegin = bufpos;
150             }
151             throw e;
152         }
153     }
154
155     static public char BeginToken() throws java.io.IOException JavaDoc {
156         tokenBegin = -1;
157         char c = readChar();
158         tokenBegin = bufpos;
159         return c;
160     }
161
162     static protected void UpdateLineColumn(char c) {
163         column++;
164         if (prevCharIsLF) {
165             prevCharIsLF = false;
166             line += (column = 1);
167         } else if (prevCharIsCR) {
168             prevCharIsCR = false;
169             if (c == '\n') {
170                 prevCharIsLF = true;
171             } else {
172                 line += (column = 1);
173             }
174         }
175         switch (c) {
176             case '\r':
177                 prevCharIsCR = true;
178                 break;
179             case '\n':
180                 prevCharIsLF = true;
181                 break;
182             case '\t':
183                 column--;
184                 column += (8 - (column & 07));
185                 break;
186             default:
187                 break;
188         }
189         bufline[bufpos] = line;
190         bufcolumn[bufpos] = column;
191     }
192
193     static public char readChar() throws java.io.IOException JavaDoc {
194         if (inBuf > 0) {
195             --inBuf;
196             if (++bufpos == bufsize) {
197                 bufpos = 0;
198             }
199             return buffer[bufpos];
200         }
201         if (++bufpos >= maxNextCharInd) {
202             FillBuff();
203         }
204         char c = buffer[bufpos];
205         UpdateLineColumn(c);
206         return (c);
207     }
208
209     /**
210      * @see #getEndColumn
211      * @deprecated
212      */

213     static public int getColumn() {
214         return bufcolumn[bufpos];
215     }
216
217     /**
218      * @see #getEndLine
219      * @deprecated
220      */

221     static public int getLine() {
222         return bufline[bufpos];
223     }
224
225     static public int getEndColumn() {
226         return bufcolumn[bufpos];
227     }
228
229     static public int getEndLine() {
230         return bufline[bufpos];
231     }
232
233     static public int getBeginColumn() {
234         return bufcolumn[tokenBegin];
235     }
236
237     static public int getBeginLine() {
238         return bufline[tokenBegin];
239     }
240
241     static public void backup(int amount) {
242         inBuf += amount;
243         if ((bufpos -= amount) < 0) {
244             bufpos += bufsize;
245         }
246     }
247
248     public void ReInit(java.io.Reader JavaDoc dstream, int startline, int startcolumn, int buffersize) {
249         inputStream = dstream;
250         line = startline;
251         column = startcolumn - 1;
252         if ((buffer == null) || (buffersize != buffer.length)) {
253             available = bufsize = buffersize;
254             buffer = new char[buffersize];
255             bufline = new int[buffersize];
256             bufcolumn = new int[buffersize];
257         }
258         prevCharIsLF = prevCharIsCR = false;
259         tokenBegin = inBuf = maxNextCharInd = 0;
260         bufpos = -1;
261     }
262
263     public void ReInit(java.io.Reader JavaDoc dstream, int startline, int startcolumn) {
264         ReInit(dstream, startline, startcolumn, 4096);
265     }
266
267     public void ReInit(java.io.Reader JavaDoc dstream) {
268         ReInit(dstream, 1, 1, 4096);
269     }
270
271     public void ReInit(java.io.InputStream JavaDoc dstream, int startline, int startcolumn, int buffersize) {
272         ReInit(new java.io.InputStreamReader JavaDoc(dstream), startline, startcolumn, 4096);
273     }
274
275     public void ReInit(java.io.InputStream JavaDoc dstream) {
276         ReInit(dstream, 1, 1, 4096);
277     }
278
279     public void ReInit(java.io.InputStream JavaDoc dstream, int startline, int startcolumn) {
280         ReInit(dstream, startline, startcolumn, 4096);
281     }
282
283     static public String JavaDoc GetImage() {
284         if (bufpos >= tokenBegin) {
285             return new String JavaDoc(buffer, tokenBegin, bufpos - tokenBegin + 1);
286         } else {
287             return new String JavaDoc(buffer, tokenBegin, bufsize - tokenBegin) + new String JavaDoc(buffer, 0, bufpos + 1);
288         }
289     }
290
291     static public char[] GetSuffix(int len) {
292         char[] ret = new char[len];
293         if ((bufpos + 1) >= len) {
294             System.arraycopy(buffer, bufpos - len + 1, ret, 0, len);
295         } else {
296             System.arraycopy(buffer, bufsize - (len - bufpos - 1), ret, 0, len - bufpos - 1);
297             System.arraycopy(buffer, 0, ret, len - bufpos - 1, bufpos + 1);
298         }
299         return ret;
300     }
301
302     static public void Done() {
303         buffer = null;
304         bufline = null;
305         bufcolumn = null;
306     }
307
308     /**
309      * Method to adjust line and column numbers for the start of a token.
310      */

311     static public void adjustBeginLineColumn(int newLine, int newCol) {
312         int start = tokenBegin;
313         int len;
314         if (bufpos >= tokenBegin) {
315             len = bufpos - tokenBegin + inBuf + 1;
316         } else {
317             len = bufsize - tokenBegin + bufpos + 1 + inBuf;
318         }
319         int i = 0;
320         int j = 0;
321         int k = 0;
322         int nextColDiff = 0;
323         int columnDiff = 0;
324         while ((i < len) && (bufline[j = start % bufsize] == bufline[k = ++start % bufsize])) {
325             bufline[j] = newLine;
326             nextColDiff = (columnDiff + bufcolumn[k]) - bufcolumn[j];
327             bufcolumn[j] = newCol + columnDiff;
328             columnDiff = nextColDiff;
329             i++;
330         }
331         if (i < len) {
332             bufline[j] = newLine++;
333             bufcolumn[j] = newCol + columnDiff;
334             while (i++ < len) {
335                 if (bufline[j = start % bufsize] != bufline[++start % bufsize]) {
336                     bufline[j] = newLine++;
337                 } else {
338                     bufline[j] = newLine;
339                 }
340             }
341         }
342         line = bufline[j];
343         column = bufcolumn[j];
344     }
345 }
Popular Tags