|
1
7
8
9
10 package com.sun.tools.example.debug.expr;
11
12
16
17 public final class ASCII_UCodeESC_CharStream
18 {
19 public static final boolean staticFlag = false;
20 static final int hexval(char c) throws java.io.IOException  {
21 switch(c)
22 {
23 case '0' :
24 return 0;
25 case '1' :
26 return 1;
27 case '2' :
28 return 2;
29 case '3' :
30 return 3;
31 case '4' :
32 return 4;
33 case '5' :
34 return 5;
35 case '6' :
36 return 6;
37 case '7' :
38 return 7;
39 case '8' :
40 return 8;
41 case '9' :
42 return 9;
43
44 case 'a' :
45 case 'A' :
46 return 10;
47 case 'b' :
48 case 'B' :
49 return 11;
50 case 'c' :
51 case 'C' :
52 return 12;
53 case 'd' :
54 case 'D' :
55 return 13;
56 case 'e' :
57 case 'E' :
58 return 14;
59 case 'f' :
60 case 'F' :
61 return 15;
62 }
63
64 throw new java.io.IOException (); }
66
67 public int bufpos = -1;
68 int bufsize;
69 int available;
70 int tokenBegin;
71 private int bufline[];
72 private int bufcolumn[];
73
74 private int column = 0;
75 private int line = 1;
76
77 private java.io.InputStream inputStream;
78
79 private boolean prevCharIsCR = false;
80 private boolean prevCharIsLF = false;
81
82 private byte[] nextCharBuf;
83 private char[] buffer;
84 private int maxNextCharInd = 0;
85 private int nextCharInd = -1;
86 private int inBuf = 0;
87
88 private final void ExpandBuff(boolean wrapAround)
89 {
90 char[] newbuffer = new char[bufsize + 2048];
91 int newbufline[] = new int[bufsize + 2048];
92 int newbufcolumn[] = new int[bufsize + 2048];
93
94 try
95 {
96 if (wrapAround)
97 {
98 System.arraycopy(buffer, tokenBegin, newbuffer, 0, bufsize - tokenBegin);
99 System.arraycopy(buffer, 0, newbuffer,
100 bufsize - tokenBegin, bufpos);
101 buffer = newbuffer;
102
103 System.arraycopy(bufline, tokenBegin, newbufline, 0, bufsize - tokenBegin);
104 System.arraycopy(bufline, 0, newbufline, bufsize - tokenBegin, bufpos);
105 bufline = newbufline;
106
107 System.arraycopy(bufcolumn, tokenBegin, newbufcolumn, 0, bufsize - tokenBegin);
108 System.arraycopy(bufcolumn, 0, newbufcolumn, bufsize - tokenBegin, bufpos);
109 bufcolumn = newbufcolumn;
110
111 bufpos += (bufsize - tokenBegin);
112 }
113 else
114 {
115 System.arraycopy(buffer, tokenBegin, newbuffer, 0, bufsize - tokenBegin);
116 buffer = newbuffer;
117
118 System.arraycopy(bufline, tokenBegin, newbufline, 0, bufsize - tokenBegin);
119 bufline = newbufline;
120
121 System.arraycopy(bufcolumn, tokenBegin, newbufcolumn, 0, bufsize - tokenBegin);
122 bufcolumn = newbufcolumn;
123
124 bufpos -= tokenBegin;
125 }
126 }
127 catch (Throwable t)
128 {
129 throw new Error (t.getMessage());
130 }
131
132 available = (bufsize += 2048);
133 tokenBegin = 0;
134 }
135
136 private final void FillBuff() throws java.io.IOException
137 {
138 int i;
139 if (maxNextCharInd == 4096)
140 maxNextCharInd = nextCharInd = 0;
141
142 try {
143 if ((i = inputStream.read(nextCharBuf, maxNextCharInd,
144 4096 - maxNextCharInd)) == -1)
145 {
146 inputStream.close();
147 throw new java.io.IOException ();
148 }
149 else
150 maxNextCharInd += i;
151 return;
152 }
153 catch(java.io.IOException e) {
154 if (bufpos != 0)
155 {
156 --bufpos;
157 backup(0);
158 }
159 else
160 {
161 bufline[bufpos] = line;
162 bufcolumn[bufpos] = column;
163 }
164 throw e;
165 }
166 }
167
168 private final byte ReadByte() throws java.io.IOException
169 {
170 if (++nextCharInd >= maxNextCharInd)
171 FillBuff();
172
173 return nextCharBuf[nextCharInd];
174 }
175
176 public final char BeginToken() throws java.io.IOException
177 {
178 if (inBuf > 0)
179 {
180 --inBuf;
181 return buffer[tokenBegin = (bufpos == bufsize - 1) ? (bufpos = 0)
182 : ++bufpos];
183 }
184
185 tokenBegin = 0;
186 bufpos = -1;
187
188 return readChar();
189 }
190
191 private final void AdjustBuffSize()
192 {
193 if (available == bufsize)
194 {
195 if (tokenBegin > 2048)
196 {
197 bufpos = 0;
198 available = tokenBegin;
199 }
200 else
201 ExpandBuff(false);
202 }
203 else if (available > tokenBegin)
204 available = bufsize;
205 else if ((tokenBegin - available) < 2048)
206 ExpandBuff(true);
207 else
208 available = tokenBegin;
209 }
210
211 private final void UpdateLineColumn(char c)
212 {
213 column++;
214
215 if (prevCharIsLF)
216 {
217 prevCharIsLF = false;
218 line += (column = 1);
219 }
220 else if (prevCharIsCR)
221 {
222 prevCharIsCR = false;
223 if (c == '\n')
224 {
225 prevCharIsLF = true;
226 }
227 else
228 line += (column = 1);
229 }
230
231 switch (c)
232 {
233 case '\r' :
234 prevCharIsCR = true;
235 break;
236 case '\n' :
237 prevCharIsLF = true;
238 break;
239 case '\t' :
240 column--;
241 column += (8 - (column & 07));
242 break;
243 default :
244 break;
245 }
246
247 bufline[bufpos] = line;
248 bufcolumn[bufpos] = column;
249 }
250
251 public final char readChar() throws java.io.IOException
252 {
253 if (inBuf > 0)
254 {
255 --inBuf;
256 return buffer[(bufpos == bufsize - 1) ? (bufpos = 0) : ++bufpos];
257 }
258
259 char c;
260
261 if (++bufpos == available)
262 AdjustBuffSize();
263
264 if (((buffer[bufpos] = c = (char)((char)0xff & ReadByte())) == '\\'))
265 {
266 UpdateLineColumn(c);
267
268 int backSlashCnt = 1;
269
270 for (;;) {
272 if (++bufpos == available)
273 AdjustBuffSize();
274
275 try
276 {
277 if ((buffer[bufpos] = c = (char)((char)0xff & ReadByte())) != '\\')
278 {
279 UpdateLineColumn(c);
280 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 try
307 {
308 while ((c = (char)((char)0xff & ReadByte())) == 'u')
309 ++column;
310
311 buffer[bufpos] = c = (char)(hexval(c) << 12 |
312 hexval((char)((char)0xff & ReadByte())) << 8 |
313 hexval((char)((char)0xff & ReadByte())) << 4 |
314 hexval((char)((char)0xff & 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
343 @Deprecated
344 public final int getColumn() {
345 return bufcolumn[bufpos];
346 }
347
348
352 @Deprecated
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 ASCII_UCodeESC_CharStream(java.io.InputStream 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 byte[4096];
392 }
393
394 public ASCII_UCodeESC_CharStream(java.io.InputStream dstream,
395 int startline, int startcolumn)
396 {
397 this(dstream, startline, startcolumn, 4096);
398 }
399 public void ReInit(java.io.InputStream dstream,
400 int startline, int startcolumn, int buffersize)
401 {
402 inputStream = dstream;
403 line = startline;
404 column = startcolumn - 1;
405
406 if (buffer == null || buffersize != buffer.length)
407 {
408 available = bufsize = buffersize;
409 buffer = new char[buffersize];
410 bufline = new int[buffersize];
411 bufcolumn = new int[buffersize];
412 nextCharBuf = new byte[4096];
413 }
414 prevCharIsLF = prevCharIsCR = false;
415 tokenBegin = inBuf = maxNextCharInd = 0;
416 nextCharInd = bufpos = -1;
417 }
418
419 public void ReInit(java.io.InputStream dstream,
420 int startline, int startcolumn)
421 {
422 ReInit(dstream, startline, startcolumn, 4096);
423 }
424
425 public final String GetImage()
426 {
427 if (bufpos >= tokenBegin)
428 return new String (buffer, tokenBegin, bufpos - tokenBegin + 1);
429 else
430 return new String (buffer, tokenBegin, bufsize - tokenBegin) +
431 new String (buffer, 0, bufpos + 1);
432 }
433
434 public final char[] GetSuffix(int len)
435 {
436 char[] ret = new char[len];
437
438 if ((bufpos + 1) >= len)
439 System.arraycopy(buffer, bufpos - len + 1, ret, 0, len);
440 else
441 {
442 System.arraycopy(buffer, bufsize - (len - bufpos - 1), ret, 0,
443 len - bufpos - 1);
444 System.arraycopy(buffer, 0, ret, len - bufpos - 1, bufpos + 1);
445 }
446
447 return ret;
448 }
449
450 public void Done()
451 {
452 nextCharBuf = null;
453 buffer = null;
454 bufline = null;
455 bufcolumn = null;
456 }
457
458
461 public void adjustBeginLineColumn(int newLine, int newCol)
462 {
463 int start = tokenBegin;
464 int len;
465
466 if (bufpos >= tokenBegin)
467 {
468 len = bufpos - tokenBegin + inBuf + 1;
469 }
470 else
471 {
472 len = bufsize - tokenBegin + bufpos + 1 + inBuf;
473 }
474
475 int i = 0, j = 0, k = 0;
476 int nextColDiff = 0, columnDiff = 0;
477
478 while (i < len &&
479 bufline[j = start % bufsize] == bufline[k = ++start % bufsize])
480 {
481 bufline[j] = newLine;
482 nextColDiff = columnDiff + bufcolumn[k] - bufcolumn[j];
483 bufcolumn[j] = newCol + columnDiff;
484 columnDiff = nextColDiff;
485 i++;
486 }
487
488 if (i < len)
489 {
490 bufline[j] = newLine++;
491 bufcolumn[j] = newCol + columnDiff;
492
493 while (i++ < len)
494 {
495 if (bufline[j = start % bufsize] != bufline[++start % bufsize])
496 bufline[j] = newLine++;
497 else
498 bufline[j] = newLine;
499 }
500 }
501
502 line = bufline[j];
503 column = bufcolumn[j];
504 }
505
506 }
507 |
Popular Tags |
Java API By Example, From Geeks To Geeks.