Debian Codegraph @

templates/SimpleCharStream.template

raw
1 /**
2 * An implementation of interface CharStream, where the stream is assumed to
3 * contain only ASCII characters (without unicode processing).
4 */
5
6 ${SUPPORT_CLASS_VISIBILITY_PUBLIC?public :}class SimpleCharStream
7 {
8 /** Whether parser is static. */
9 public static final boolean staticFlag = ${STATIC};
10 ${PREFIX}int bufsize;
11 ${PREFIX}int available;
12 ${PREFIX}int tokenBegin;
13 /** Position in buffer. */
14 ${PREFIX}public int bufpos = -1;
15 #if KEEP_LINE_COLUMN
16 ${PREFIX}protected int bufline[];
17 ${PREFIX}protected int bufcolumn[];
18
19 ${PREFIX}protected int column = 0;
20 ${PREFIX}protected int line = 1;
21
22 ${PREFIX}protected boolean prevCharIsCR = false;
23 ${PREFIX}protected boolean prevCharIsLF = false;
24 #fi
25
26 ${PREFIX}protected java.io.Reader inputStream;
27
28 ${PREFIX}protected char[] buffer;
29 ${PREFIX}protected int maxNextCharInd = 0;
30 ${PREFIX}protected int inBuf = 0;
31 ${PREFIX}protected int tabSize = 8;
32
33 ${PREFIX}protected void setTabSize(int i) { tabSize = i; }
34 ${PREFIX}protected int getTabSize(int i) { return tabSize; }
35
36
37 ${PREFIX}protected void ExpandBuff(boolean wrapAround)
38 {
39 char[] newbuffer = new char[bufsize + 2048];
40 #if KEEP_LINE_COLUMN
41 int newbufline[] = new int[bufsize + 2048];
42 int newbufcolumn[] = new int[bufsize + 2048];
43 #fi
44
45 try
46 {
47 if (wrapAround)
48 {
49 System.arraycopy(buffer, tokenBegin, newbuffer, 0, bufsize - tokenBegin);
50 System.arraycopy(buffer, 0, newbuffer, bufsize - tokenBegin, bufpos);
51 buffer = newbuffer;
52 #if KEEP_LINE_COLUMN
53
54 System.arraycopy(bufline, tokenBegin, newbufline, 0, bufsize - tokenBegin);
55 System.arraycopy(bufline, 0, newbufline, bufsize - tokenBegin, bufpos);
56 bufline = newbufline;
57
58 System.arraycopy(bufcolumn, tokenBegin, newbufcolumn, 0, bufsize - tokenBegin);
59 System.arraycopy(bufcolumn, 0, newbufcolumn, bufsize - tokenBegin, bufpos);
60 bufcolumn = newbufcolumn;
61 #fi
62
63 maxNextCharInd = (bufpos += (bufsize - tokenBegin));
64 }
65 else
66 {
67 System.arraycopy(buffer, tokenBegin, newbuffer, 0, bufsize - tokenBegin);
68 buffer = newbuffer;
69 #if KEEP_LINE_COLUMN
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 #fi
77
78 maxNextCharInd = (bufpos -= tokenBegin);
79 }
80 }
81 catch (Throwable t)
82 {
83 throw new Error(t.getMessage());
84 }
85
86
87 bufsize += 2048;
88 available = bufsize;
89 tokenBegin = 0;
90 }
91
92 ${PREFIX}protected void FillBuff() throws java.io.IOException
93 {
94 if (maxNextCharInd == available)
95 {
96 if (available == bufsize)
97 {
98 if (tokenBegin > 2048)
99 {
100 bufpos = maxNextCharInd = 0;
101 available = tokenBegin;
102 }
103 else if (tokenBegin < 0)
104 bufpos = maxNextCharInd = 0;
105 else
106 ExpandBuff(false);
107 }
108 else if (available > tokenBegin)
109 available = bufsize;
110 else if ((tokenBegin - available) < 2048)
111 ExpandBuff(true);
112 else
113 available = tokenBegin;
114 }
115
116 int i;
117 try {
118 if ((i = inputStream.read(buffer, maxNextCharInd, available - maxNextCharInd)) == -1)
119 {
120 inputStream.close();
121 throw new java.io.IOException();
122 }
123 else
124 maxNextCharInd += i;
125 return;
126 }
127 catch(java.io.IOException e) {
128 --bufpos;
129 backup(0);
130 if (tokenBegin == -1)
131 tokenBegin = bufpos;
132 throw e;
133 }
134 }
135
136 /** Start. */
137 ${PREFIX}public char BeginToken() throws java.io.IOException
138 {
139 tokenBegin = -1;
140 char c = readChar();
141 tokenBegin = bufpos;
142
143 return c;
144 }
145 #if KEEP_LINE_COLUMN
146
147 ${PREFIX}protected void UpdateLineColumn(char c)
148 {
149 column++;
150
151 if (prevCharIsLF)
152 {
153 prevCharIsLF = false;
154 line += (column = 1);
155 }
156 else if (prevCharIsCR)
157 {
158 prevCharIsCR = false;
159 if (c == '\n')
160 {
161 prevCharIsLF = true;
162 }
163 else
164 line += (column = 1);
165 }
166
167 switch (c)
168 {
169 case '\r' :
170 prevCharIsCR = true;
171 break;
172 case '\n' :
173 prevCharIsLF = true;
174 break;
175 case '\t' :
176 column--;
177 column += (tabSize - (column % tabSize));
178 break;
179 default :
180 break;
181 }
182
183 bufline[bufpos] = line;
184 bufcolumn[bufpos] = column;
185 }
186 #fi
187
188 /** Read a character. */
189 ${PREFIX}public char readChar() throws java.io.IOException
190 {
191 if (inBuf > 0)
192 {
193 --inBuf;
194
195 if (++bufpos == bufsize)
196 bufpos = 0;
197
198 return buffer[bufpos];
199 }
200
201 if (++bufpos >= maxNextCharInd)
202 FillBuff();
203
204 char c = buffer[bufpos];
205
206 #if KEEP_LINE_COLUMN
207 UpdateLineColumn(c);
208 #fi
209 return c;
210 }
211
212 #if GENERATE_ANNOTATIONS
213 @Deprecated
214 #fi
215 /**
216 * @deprecated
217 * @see #getEndColumn
218 */
219
220 ${PREFIX}public int getColumn() {
221 #if KEEP_LINE_COLUMN
222 return bufcolumn[bufpos];
223 #else
224 return -1;
225 #fi
226 }
227
228 #if GENERATE_ANNOTATIONS
229 @Deprecated
230 #fi
231 /**
232 * @deprecated
233 * @see #getEndLine
234 */
235
236 ${PREFIX}public int getLine() {
237 #if KEEP_LINE_COLUMN
238 return bufline[bufpos];
239 #else
240 return -1;
241 #fi
242 }
243
244 /** Get token end column number. */
245 ${PREFIX}public int getEndColumn() {
246 #if KEEP_LINE_COLUMN
247 return bufcolumn[bufpos];
248 #else
249 return -1;
250 #fi
251 }
252
253 /** Get token end line number. */
254 ${PREFIX}public int getEndLine() {
255 #if KEEP_LINE_COLUMN
256 return bufline[bufpos];
257 #else
258 return -1;
259 #fi
260 }
261
262 /** Get token beginning column number. */
263 ${PREFIX}public int getBeginColumn() {
264 #if KEEP_LINE_COLUMN
265 return bufcolumn[tokenBegin];
266 #else
267 return -1;
268 #fi
269 }
270
271 /** Get token beginning line number. */
272 ${PREFIX}public int getBeginLine() {
273 #if KEEP_LINE_COLUMN
274 return bufline[tokenBegin];
275 #else
276 return -1;
277 #fi
278 }
279
280 /** Backup a number of characters. */
281 ${PREFIX}public void backup(int amount) {
282
283 inBuf += amount;
284 if ((bufpos -= amount) < 0)
285 bufpos += bufsize;
286 }
287
288 /** Constructor. */
289 public SimpleCharStream(java.io.Reader dstream, int startline,
290 int startcolumn, int buffersize)
291 {
292 #if STATIC
293 if (inputStream != null)
294 throw new Error("\n ERROR: Second call to the constructor of a static SimpleCharStream.\n" +
295 " You must either use ReInit() or set the JavaCC option STATIC to false\n" +
296 " during the generation of this class.");
297 #fi
298 inputStream = dstream;
299 #if KEEP_LINE_COLUMN
300 line = startline;
301 column = startcolumn - 1;
302 #fi
303
304 available = bufsize = buffersize;
305 buffer = new char[buffersize];
306 #if KEEP_LINE_COLUMN
307 bufline = new int[buffersize];
308 bufcolumn = new int[buffersize];
309 #fi
310 }
311
312 /** Constructor. */
313 public SimpleCharStream(java.io.Reader dstream, int startline,
314 int startcolumn)
315 {
316 this(dstream, startline, startcolumn, 4096);
317 }
318
319 /** Constructor. */
320 public SimpleCharStream(java.io.Reader dstream)
321 {
322 this(dstream, 1, 1, 4096);
323 }
324
325 /** Reinitialise. */
326 public void ReInit(java.io.Reader dstream, int startline,
327 int startcolumn, int buffersize)
328 {
329 inputStream = dstream;
330 #if KEEP_LINE_COLUMN
331 line = startline;
332 column = startcolumn - 1;
333 #fi
334
335 if (buffer == null || buffersize != buffer.length)
336 {
337 available = bufsize = buffersize;
338 buffer = new char[buffersize];
339 #if KEEP_LINE_COLUMN
340 bufline = new int[buffersize];
341 bufcolumn = new int[buffersize];
342 #fi
343 }
344 #if KEEP_LINE_COLUMN
345 prevCharIsLF = prevCharIsCR = false;
346 #fi
347 tokenBegin = inBuf = maxNextCharInd = 0;
348 bufpos = -1;
349 }
350
351 /** Reinitialise. */
352 public void ReInit(java.io.Reader dstream, int startline,
353 int startcolumn)
354 {
355 ReInit(dstream, startline, startcolumn, 4096);
356 }
357
358 /** Reinitialise. */
359 public void ReInit(java.io.Reader dstream)
360 {
361 ReInit(dstream, 1, 1, 4096);
362 }
363 /** Constructor. */
364 public SimpleCharStream(java.io.InputStream dstream, String encoding, int startline,
365 int startcolumn, int buffersize) throws java.io.UnsupportedEncodingException
366 {
367 this(encoding == null ? new java.io.InputStreamReader(dstream) : new java.io.InputStreamReader(dstream, encoding), startline, startcolumn, buffersize);
368 }
369
370 /** Constructor. */
371 public SimpleCharStream(java.io.InputStream dstream, int startline,
372 int startcolumn, int buffersize)
373 {
374 this(new java.io.InputStreamReader(dstream), startline, startcolumn, buffersize);
375 }
376
377 /** Constructor. */
378 public SimpleCharStream(java.io.InputStream dstream, String encoding, int startline,
379 int startcolumn) throws java.io.UnsupportedEncodingException
380 {
381 this(dstream, encoding, startline, startcolumn, 4096);
382 }
383
384 /** Constructor. */
385 public SimpleCharStream(java.io.InputStream dstream, int startline,
386 int startcolumn)
387 {
388 this(dstream, startline, startcolumn, 4096);
389 }
390
391 /** Constructor. */
392 public SimpleCharStream(java.io.InputStream dstream, String encoding) throws java.io.UnsupportedEncodingException
393 {
394 this(dstream, encoding, 1, 1, 4096);
395 }
396
397 /** Constructor. */
398 public SimpleCharStream(java.io.InputStream dstream)
399 {
400 this(dstream, 1, 1, 4096);
401 }
402
403 /** Reinitialise. */
404 public void ReInit(java.io.InputStream dstream, String encoding, int startline,
405 int startcolumn, int buffersize) throws java.io.UnsupportedEncodingException
406 {
407 ReInit(encoding == null ? new java.io.InputStreamReader(dstream) : new java.io.InputStreamReader(dstream, encoding), startline, startcolumn, buffersize);
408 }
409
410 /** Reinitialise. */
411 public void ReInit(java.io.InputStream dstream, int startline,
412 int startcolumn, int buffersize)
413 {
414 ReInit(new java.io.InputStreamReader(dstream), startline, startcolumn, buffersize);
415 }
416
417 /** Reinitialise. */
418 public void ReInit(java.io.InputStream dstream, String encoding) throws java.io.UnsupportedEncodingException
419 {
420 ReInit(dstream, encoding, 1, 1, 4096);
421 }
422
423 /** Reinitialise. */
424 public void ReInit(java.io.InputStream dstream)
425 {
426 ReInit(dstream, 1, 1, 4096);
427 }
428 /** Reinitialise. */
429 public void ReInit(java.io.InputStream dstream, String encoding, int startline,
430 int startcolumn) throws java.io.UnsupportedEncodingException
431 {
432 ReInit(dstream, encoding, startline, startcolumn, 4096);
433 }
434 /** Reinitialise. */
435 public void ReInit(java.io.InputStream dstream, int startline,
436 int startcolumn)
437 {
438 ReInit(dstream, startline, startcolumn, 4096);
439 }
440 /** Get token literal value. */
441 ${PREFIX}public String GetImage()
442 {
443 if (bufpos >= tokenBegin)
444 return new String(buffer, tokenBegin, bufpos - tokenBegin + 1);
445 else
446 return new String(buffer, tokenBegin, bufsize - tokenBegin) +
447 new String(buffer, 0, bufpos + 1);
448 }
449
450 /** Get the suffix. */
451 ${PREFIX}public char[] GetSuffix(int len)
452 {
453 char[] ret = new char[len];
454
455 if ((bufpos + 1) >= len)
456 System.arraycopy(buffer, bufpos - len + 1, ret, 0, len);
457 else
458 {
459 System.arraycopy(buffer, bufsize - (len - bufpos - 1), ret, 0,
460 len - bufpos - 1);
461 System.arraycopy(buffer, 0, ret, len - bufpos - 1, bufpos + 1);
462 }
463
464 return ret;
465 }
466
467 /** Reset buffer when finished. */
468 ${PREFIX}public void Done()
469 {
470 buffer = null;
471 #if KEEP_LINE_COLUMN
472 bufline = null;
473 bufcolumn = null;
474 #fi
475 }
476 #if KEEP_LINE_COLUMN
477
478 /**
479 * Method to adjust line and column numbers for the start of a token.
480 */
481 ${PREFIX}public void adjustBeginLineColumn(int newLine, int newCol)
482 {
483 int start = tokenBegin;
484 int len;
485
486 if (bufpos >= tokenBegin)
487 {
488 len = bufpos - tokenBegin + inBuf + 1;
489 }
490 else
491 {
492 len = bufsize - tokenBegin + bufpos + 1 + inBuf;
493 }
494
495 int i = 0, j = 0, k = 0;
496 int nextColDiff = 0, columnDiff = 0;
497
498 while (i < len && bufline[j = start % bufsize] == bufline[k = ++start % bufsize])
499 {
500 bufline[j] = newLine;
501 nextColDiff = columnDiff + bufcolumn[k] - bufcolumn[j];
502 bufcolumn[j] = newCol + columnDiff;
503 columnDiff = nextColDiff;
504 i++;
505 }
506
507 if (i < len)
508 {
509 bufline[j] = newLine++;
510 bufcolumn[j] = newCol + columnDiff;
511
512 while (i++ < len)
513 {
514 if (bufline[j = start % bufsize] != bufline[++start % bufsize])
515 bufline[j] = newLine++;
516 else
517 bufline[j] = newLine;
518 }
519 }
520
521 line = bufline[j];
522 column = bufcolumn[j];
523 }
524
525 #fi
526 }