1
2 package xjavadoc;
3
4 /***
5 * An implementation of interface CharStream, where the stream is assumed to
6 * contain only ASCII characters (with java-like unicode escape processing).
7 */
8
9 public final class JavaCharStream
10 {
11 public static final boolean staticFlag = false;
12 static final int hexval(char c) throws java.io.IOException {
13 switch(c)
14 {
15 case '0' :
16 return 0;
17 case '1' :
18 return 1;
19 case '2' :
20 return 2;
21 case '3' :
22 return 3;
23 case '4' :
24 return 4;
25 case '5' :
26 return 5;
27 case '6' :
28 return 6;
29 case '7' :
30 return 7;
31 case '8' :
32 return 8;
33 case '9' :
34 return 9;
35
36 case 'a' :
37 case 'A' :
38 return 10;
39 case 'b' :
40 case 'B' :
41 return 11;
42 case 'c' :
43 case 'C' :
44 return 12;
45 case 'd' :
46 case 'D' :
47 return 13;
48 case 'e' :
49 case 'E' :
50 return 14;
51 case 'f' :
52 case 'F' :
53 return 15;
54 }
55
56 throw new java.io.IOException();
57 }
58
59 public int bufpos = -1;
60 int bufsize;
61 int available;
62 int tokenBegin;
63 private int bufline[];
64 private int bufcolumn[];
65
66 private int column = 0;
67 private int line = 1;
68
69 private boolean prevCharIsCR = false;
70 private boolean prevCharIsLF = false;
71
72 private java.io.Reader inputStream;
73
74 private char[] nextCharBuf;
75 private char[] buffer;
76 private int maxNextCharInd = 0;
77 private int nextCharInd = -1;
78 private int inBuf = 0;
79
80 private final void ExpandBuff(boolean wrapAround)
81 {
82 char[] newbuffer = new char[bufsize + 2048];
83 int newbufline[] = new int[bufsize + 2048];
84 int newbufcolumn[] = new int[bufsize + 2048];
85
86 try
87 {
88 if (wrapAround)
89 {
90 System.arraycopy(buffer, tokenBegin, newbuffer, 0, bufsize - tokenBegin);
91 System.arraycopy(buffer, 0, newbuffer,
92 bufsize - tokenBegin, bufpos);
93 buffer = newbuffer;
94
95 System.arraycopy(bufline, tokenBegin, newbufline, 0, bufsize - tokenBegin);
96 System.arraycopy(bufline, 0, newbufline, bufsize - tokenBegin, bufpos);
97 bufline = newbufline;
98
99 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 private final 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 private final char ReadByte() throws java.io.IOException
161 {
162 if (++nextCharInd >= maxNextCharInd)
163 FillBuff();
164
165 return nextCharBuf[nextCharInd];
166 }
167
168 public final 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 private final 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 private final 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 final 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 (;;)
271 {
272 if (++bufpos == available)
273 AdjustBuffSize();
274
275 try
276 {
277 if ((buffer[bufpos] = c = ReadByte()) != '//')
278 {
279 UpdateLineColumn(c);
280
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
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 final int getColumn() {
345 return bufcolumn[bufpos];
346 }
347
348 /***
349 * @deprecated
350 * @see #getEndLine
351 */
352
353 public final int getLine() {
354 return bufline[bufpos];
355 }
356
357 public final int getEndColumn() {
358 return bufcolumn[bufpos];
359 }
360
361 public final int getEndLine() {
362 return bufline[bufpos];
363 }
364
365 public final int getBeginColumn() {
366 return bufcolumn[tokenBegin];
367 }
368
369 public final int getBeginLine() {
370 return bufline[tokenBegin];
371 }
372
373 public final 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 final 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 final 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 }