|
1
2 package org.apache.taglibs.standard.extra.spath;
3
4 public class SPathParserTokenManager implements SPathParserConstants
5 {
6 private final int jjStopStringLiteralDfa_0(int pos, long active0)
7 {
8 switch (pos)
9 {
10 default :
11 return -1;
12 }
13 }
14 private final int jjStartNfa_0(int pos, long active0)
15 {
16 return jjMoveNfa_0(jjStopStringLiteralDfa_0(pos, active0), pos + 1);
17 }
18 private final int jjStopAtPos(int pos, int kind)
19 {
20 jjmatchedKind = kind;
21 jjmatchedPos = pos;
22 return pos + 1;
23 }
24 private final int jjStartNfaWithStates_0(int pos, int kind, int state)
25 {
26 jjmatchedKind = kind;
27 jjmatchedPos = pos;
28 try { curChar = input_stream.readChar(); }
29 catch(java.io.IOException  e) { return pos + 1; }
30 return jjMoveNfa_0(state, pos + 1);
31 }
32 private final int jjMoveStringLiteralDfa0_0()
33 {
34 switch(curChar)
35 {
36 case 42:
37 return jjStopAtPos(0, 14);
38 case 47:
39 return jjStopAtPos(0, 13);
40 case 58:
41 return jjStopAtPos(0, 15);
42 case 61:
43 return jjStopAtPos(0, 19);
44 case 64:
45 return jjStopAtPos(0, 18);
46 case 91:
47 return jjStopAtPos(0, 16);
48 case 93:
49 return jjStopAtPos(0, 17);
50 default :
51 return jjMoveNfa_0(0, 0);
52 }
53 }
54 private final void jjCheckNAdd(int state)
55 {
56 if (jjrounds[state] != jjround)
57 {
58 jjstateSet[jjnewStateCnt++] = state;
59 jjrounds[state] = jjround;
60 }
61 }
62 private final void jjAddStates(int start, int end)
63 {
64 do {
65 jjstateSet[jjnewStateCnt++] = jjnextStates[start];
66 } while (start++ != end);
67 }
68 private final void jjCheckNAddTwoStates(int state1, int state2)
69 {
70 jjCheckNAdd(state1);
71 jjCheckNAdd(state2);
72 }
73 private final void jjCheckNAddStates(int start, int end)
74 {
75 do {
76 jjCheckNAdd(jjnextStates[start]);
77 } while (start++ != end);
78 }
79 private final void jjCheckNAddStates(int start)
80 {
81 jjCheckNAdd(jjnextStates[start]);
82 jjCheckNAdd(jjnextStates[start + 1]);
83 }
84 static final long[] jjbitVec0 = {
85 0xfffffffffffffffeL, 0xffffffffffffffffL, 0xffffffffffffffffL, 0xffffffffffffffffL
86 };
87 static final long[] jjbitVec2 = {
88 0x0L, 0x0L, 0xffffffffffffffffL, 0xffffffffffffffffL
89 };
90 static final long[] jjbitVec3 = {
91 0x0L, 0xffffffffffffc000L, 0xfffff0007fffffffL, 0x7fffffL
92 };
93 static final long[] jjbitVec4 = {
94 0x0L, 0x0L, 0x0L, 0xff7fffffff7fffffL
95 };
96 static final long[] jjbitVec5 = {
97 0x7ff3ffffffffffffL, 0x7ffffffffffffdfeL, 0xffffffffffffffffL, 0xfc31ffffffffe00fL
98 };
99 static final long[] jjbitVec6 = {
100 0xffffffL, 0xffffffffffff0000L, 0xf80001ffffffffffL, 0x3L
101 };
102 static final long[] jjbitVec7 = {
103 0x0L, 0x0L, 0xfffffffbffffd740L, 0xffffd547f7fffL
104 };
105 static final long[] jjbitVec8 = {
106 0xffffffffffffdffeL, 0xffffffffdffeffffL, 0xffffffffffff0003L, 0x33fcfffffff199fL
107 };
108 static final long[] jjbitVec9 = {
109 0xfffe000000000000L, 0xfffffffe027fffffL, 0x7fL, 0x707ffffff0000L
110 };
111 static final long[] jjbitVec10 = {
112 0x7fffffe00000000L, 0xfffe0000000007feL, 0x7cffffffffffffffL, 0x60002f7fffL
113 };
114 static final long[] jjbitVec11 = {
115 0x23ffffffffffffe0L, 0x3ff000000L, 0x3c5fdfffff99fe0L, 0x30003b0000000L
116 };
117 static final long[] jjbitVec12 = {
118 0x36dfdfffff987e0L, 0x1c00005e000000L, 0x23edfdfffffbafe0L, 0x100000000L
119 };
120 static final long[] jjbitVec13 = {
121 0x23cdfdfffff99fe0L, 0x3b0000000L, 0x3bfc718d63dc7e0L, 0x0L
122 };
123 static final long[] jjbitVec14 = {
124 0x3effdfffffddfe0L, 0x300000000L, 0x3effdfffffddfe0L, 0x340000000L
125 };
126 static final long[] jjbitVec15 = {
127 0x3fffdfffffddfe0L, 0x300000000L, 0x0L, 0x0L
128 };
129 static final long[] jjbitVec16 = {
130 0xd7ffffffffffeL, 0x3fL, 0x200d6caefef02596L, 0x1fL
131 };
132 static final long[] jjbitVec17 = {
133 0x0L, 0x3fffffffeffL, 0x0L, 0x0L
134 };
135 static final long[] jjbitVec18 = {
136 0x0L, 0x0L, 0xffffffff00000000L, 0x7fffffffff003fL
137 };
138 static final long[] jjbitVec19 = {
139 0x500000000007daedL, 0x2c62ab82315001L, 0xf580c90040000000L, 0x201080000000007L
140 };
141 static final long[] jjbitVec20 = {
142 0xffffffffffffffffL, 0xffffffffffffffffL, 0xffffffff0fffffffL, 0x3ffffffffffffffL
143 };
144 static final long[] jjbitVec21 = {
145 0xffffffff3f3fffffL, 0x3fffffffaaff3f3fL, 0x5fdfffffffffffffL, 0x1fdc1fff0fcf1fdcL
146 };
147 static final long[] jjbitVec22 = {
148 0x4c4000000000L, 0x0L, 0x7L, 0x0L
149 };
150 static final long[] jjbitVec23 = {
151 0x3fe00000080L, 0xfffffffffffffffeL, 0xfffffffe001fffffL, 0x7ffffffffffffffL
152 };
153 static final long[] jjbitVec24 = {
154 0x1fffffffffe0L, 0x0L, 0x0L, 0x0L
155 };
156 static final long[] jjbitVec25 = {
157 0xffffffffffffffffL, 0xffffffffffffffffL, 0x3fffffffffL, 0x0L
158 };
159 static final long[] jjbitVec26 = {
160 0xffffffffffffffffL, 0xffffffffffffffffL, 0xfffffffffL, 0x0L
161 };
162 static final long[] jjbitVec27 = {
163 0x0L, 0x0L, 0x80000000000000L, 0xff7fffffff7fffffL
164 };
165 static final long[] jjbitVec28 = {
166 0xffffffL, 0xffffffffffff0000L, 0xf80001ffffffffffL, 0x30003L
167 };
168 static final long[] jjbitVec29 = {
169 0xffffffffffffffffL, 0x30000003fL, 0xfffffffbffffd7c0L, 0xffffd547f7fffL
170 };
171 static final long[] jjbitVec30 = {
172 0xffffffffffffdffeL, 0xffffffffdffeffffL, 0xffffffffffff007bL, 0x33fcfffffff199fL
173 };
174 static final long[] jjbitVec31 = {
175 0xfffe000000000000L, 0xfffffffe027fffffL, 0xbbfffffbfffe007fL, 0x707ffffff0016L
176 };
177 static final long[] jjbitVec32 = {
178 0x7fffffe00000000L, 0xffff03ff0007ffffL, 0x7cffffffffffffffL, 0x3ff3dffffef7fffL
179 };
180 static final long[] jjbitVec33 = {
181 0xf3ffffffffffffeeL, 0xffcfff1e3fffL, 0xd3c5fdfffff99feeL, 0x3ffcfb080399fL
182 };
183 static final long[] jjbitVec34 = {
184 0xd36dfdfffff987e4L, 0x1fffc05e003987L, 0xf3edfdfffffbafeeL, 0xffc100003bbfL
185 };
186 static final long[] jjbitVec35 = {
187 0xf3cdfdfffff99feeL, 0xffc3b0c0398fL, 0xc3bfc718d63dc7ecL, 0xff8000803dc7L
188 };
189 static final long[] jjbitVec36 = {
190 0xc3effdfffffddfeeL, 0xffc300603ddfL, 0xc3effdfffffddfecL, 0xffc340603ddfL
191 };
192 static final long[] jjbitVec37 = {
193 0xc3fffdfffffddfecL, 0xffc300803dcfL, 0x0L, 0x0L
194 };
195 static final long[] jjbitVec38 = {
196 0x7ff7ffffffffffeL, 0x3ff7fffL, 0x3bff6caefef02596L, 0x3ff3f5fL
197 };
198 static final long[] jjbitVec39 = {
199 0xc2a003ff03000000L, 0xfffe03fffffffeffL, 0x2fe3ffffebf0fdfL, 0x0L
200 };
201 static final long[] jjbitVec40 = {
202 0x0L, 0x0L, 0x0L, 0x21fff0000L
203 };
204 static final long[] jjbitVec41 = {
205 0x3efffe000000a0L, 0xfffffffffffffffeL, 0xfffffffe661fffffL, 0x77ffffffffffffffL
206 };
207 private final int jjMoveNfa_0(int startState, int curPos)
208 {
209 int[] nextStates;
210 int startsAt = 0;
211 jjnewStateCnt = 19;
212 int i = 1;
213 jjstateSet[0] = startState;
214 int j, kind = 0x7fffffff;
215 for (;;)
216 {
217 if (++jjround == 0x7fffffff)
218 ReInitRounds();
219 if (curChar < 64)
220 {
221 long l = 1L << curChar;
222 MatchLoop: do
223 {
224 switch(jjstateSet[--i])
225 {
226 case 0:
227 if (curChar == 39)
228 jjCheckNAddStates(0, 2);
229 else if (curChar == 34)
230 jjCheckNAddStates(3, 5);
231 break;
232 case 1:
233 if ((0xfffffffbffffffffL & l) != 0L)
234 jjCheckNAddStates(3, 5);
235 break;
236 case 3:
237 if (curChar == 34)
238 jjCheckNAddStates(3, 5);
239 break;
240 case 4:
241 if (curChar == 34 && kind > 1)
242 kind = 1;
243 break;
244 case 5:
245 case 8:
246 if (curChar == 39)
247 jjCheckNAddStates(0, 2);
248 break;
249 case 6:
250 if ((0xffffff7fffffffffL & l) != 0L)
251 jjCheckNAddStates(0, 2);
252 break;
253 case 9:
254 if (curChar == 39 && kind > 1)
255 kind = 1;
256 break;
257 case 11:
258 if ((0x3ff600000000000L & l) != 0L)
259 jjAddStates(6, 7);
260 break;
261 case 12:
262 if (curChar == 58)
263 jjstateSet[jjnewStateCnt++] = 13;
264 break;
265 case 14:
266 if ((0x3ff600000000000L & l) == 0L)
267 break;
268 if (kind > 2)
269 kind = 2;
270 jjstateSet[jjnewStateCnt++] = 14;
271 break;
272 case 15:
273 if ((0x3ff600000000000L & l) == 0L)
274 break;
275 if (kind > 3)
276 kind = 3;
277 jjstateSet[jjnewStateCnt++] = 15;
278 break;
279 case 16:
280 if ((0x3ff600000000000L & l) != 0L)
281 jjAddStates(8, 9);
282 break;
283 case 17:
284 if (curChar == 58)
285 jjstateSet[jjnewStateCnt++] = 18;
286 break;
287 case 18:
288 if (curChar == 42 && kind > 4)
289 kind = 4;
290 break;
291 default : break;
292 }
293 } while(i != startsAt);
294 }
295 else if (curChar < 128)
296 {
297 long l = 1L << (curChar & 077);
298 MatchLoop: do
299 {
300 switch(jjstateSet[--i])
301 {
302 case 0:
303 if ((0x7fffffe87fffffeL & l) == 0L)
304 break;
305 if (kind > 2)
306 kind = 2;
307 jjCheckNAddStates(10, 15);
308 break;
309 case 1:
310 if ((0xffffffffefffffffL & l) != 0L)
311 jjCheckNAddStates(3, 5);
312 break;
313 case 2:
314 if (curChar == 92)
315 jjstateSet[jjnewStateCnt++] = 3;
316 break;
317 case 3:
318 if (curChar == 92)
319 jjCheckNAddStates(3, 5);
320 break;
321 case 6:
322 if ((0xffffffffefffffffL & l) != 0L)
323 jjCheckNAddStates(0, 2);
324 break;
325 case 7:
326 if (curChar == 92)
327 jjstateSet[jjnewStateCnt++] = 8;
328 break;
329 case 8:
330 if (curChar == 92)
331 jjCheckNAddStates(0, 2);
332 break;
333 case 11:
334 if ((0x7fffffe87fffffeL & l) != 0L)
335 jjCheckNAddTwoStates(11, 12);
336 break;
337 case 13:
338 case 14:
339 if ((0x7fffffe87fffffeL & l) == 0L)
340 break;
341 if (kind > 2)
342 kind = 2;
343 jjCheckNAdd(14);
344 break;
345 case 15:
346 if ((0x7fffffe87fffffeL & l) == 0L)
347 break;
348 if (kind > 3)
349 kind = 3;
350 jjCheckNAdd(15);
351 break;
352 case 16:
353 if ((0x7fffffe87fffffeL & l) != 0L)
354 jjCheckNAddTwoStates(16, 17);
355 break;
356 default : break;
357 }
358 } while(i != startsAt);
359 }
360 else
361 {
362 int hiByte = (int)(curChar >> 8);
363 int i1 = hiByte >> 6;
364 long l1 = 1L << (hiByte & 077);
365 int i2 = (curChar & 0xff) >> 6;
366 long l2 = 1L << (curChar & 077);
367 MatchLoop: do
368 {
369 switch(jjstateSet[--i])
370 {
371 case 0:
372 if (!jjCanMove_1(hiByte, i1, i2, l1, l2))
373 break;
374 if (kind > 2)
375 kind = 2;
376 jjCheckNAddStates(10, 15);
377 break;
378 case 1:
379 if (jjCanMove_0(hiByte, i1, i2, l1, l2))
380 jjAddStates(3, 5);
381 break;
382 case 6:
383 if (jjCanMove_0(hiByte, i1, i2, l1, l2))
384 jjAddStates(0, 2);
385 break;
386 case 11:
387 if (jjCanMove_2(hiByte, i1, i2, l1, l2))
388 jjCheckNAddTwoStates(11, 12);
389 break;
390 case 13:
391 if (!jjCanMove_1(hiByte, i1, i2, l1, l2))
392 break;
393 if (kind > 2)
394 kind = 2;
395 jjCheckNAdd(14);
396 break;
397 case 14:
398 if (!jjCanMove_2(hiByte, i1, i2, l1, l2))
399 break;
400 if (kind > 2)
401 kind = 2;
402 jjCheckNAdd(14);
403 break;
404 case 15:
405 if (!jjCanMove_2(hiByte, i1, i2, l1, l2))
406 break;
407 if (kind > 3)
408 kind = 3;
409 jjCheckNAdd(15);
410 break;
411 case 16:
412 if (jjCanMove_2(hiByte, i1, i2, l1, l2))
413 jjCheckNAddTwoStates(16, 17);
414 break;
415 default : break;
416 }
417 } while(i != startsAt);
418 }
419 if (kind != 0x7fffffff)
420 {
421 jjmatchedKind = kind;
422 jjmatchedPos = curPos;
423 kind = 0x7fffffff;
424 }
425 ++curPos;
426 if ((i = jjnewStateCnt) == (startsAt = 19 - (jjnewStateCnt = startsAt)))
427 return curPos;
428 try { curChar = input_stream.readChar(); }
429 catch(java.io.IOException e) { return curPos; }
430 }
431 }
432 static final int[] jjnextStates = {
433 6, 7, 9, 1, 2, 4, 11, 12, 16, 17, 11, 12, 14, 15, 16, 17,
434 };
435 private static final boolean jjCanMove_0(int hiByte, int i1, int i2, long l1, long l2)
436 {
437 switch(hiByte)
438 {
439 case 0:
440 return ((jjbitVec2[i2] & l2) != 0L);
441 default :
442 if ((jjbitVec0[i1] & l1) != 0L)
443 return true;
444 return false;
445 }
446 }
447 private static final boolean jjCanMove_1(int hiByte, int i1, int i2, long l1, long l2)
448 {
449 switch(hiByte)
450 {
451 case 0:
452 return ((jjbitVec4[i2] & l2) != 0L);
453 case 1:
454 return ((jjbitVec5[i2] & l2) != 0L);
455 case 2:
456 return ((jjbitVec6[i2] & l2) != 0L);
457 case 3:
458 return ((jjbitVec7[i2] & l2) != 0L);
459 case 4:
460 return ((jjbitVec8[i2] & l2) != 0L);
461 case 5:
462 return ((jjbitVec9[i2] & l2) != 0L);
463 case 6:
464 return ((jjbitVec10[i2] & l2) != 0L);
465 case 9:
466 return ((jjbitVec11[i2] & l2) != 0L);
467 case 10:
468 return ((jjbitVec12[i2] & l2) != 0L);
469 case 11:
470 return ((jjbitVec13[i2] & l2) != 0L);
471 case 12:
472 return ((jjbitVec14[i2] & l2) != 0L);
473 case 13:
474 return ((jjbitVec15[i2] & l2) != 0L);
475 case 14:
476 return ((jjbitVec16[i2] & l2) != 0L);
477 case 15:
478 return ((jjbitVec17[i2] & l2) != 0L);
479 case 16:
480 return ((jjbitVec18[i2] & l2) != 0L);
481 case 17:
482 return ((jjbitVec19[i2] & l2) != 0L);
483 case 30:
484 return ((jjbitVec20[i2] & l2) != 0L);
485 case 31:
486 return ((jjbitVec21[i2] & l2) != 0L);
487 case 33:
488 return ((jjbitVec22[i2] & l2) != 0L);
489 case 48:
490 return ((jjbitVec23[i2] & l2) != 0L);
491 case 49:
492 return ((jjbitVec24[i2] & l2) != 0L);
493 case 159:
494 return ((jjbitVec25[i2] & l2) != 0L);
495 case 215:
496 return ((jjbitVec26[i2] & l2) != 0L);
497 default :
498 if ((jjbitVec3[i1] & l1) != 0L)
499 return true;
500 return false;
501 }
502 }
503 private static final boolean jjCanMove_2(int hiByte, int i1, int i2, long l1, long l2)
504 {
505 switch(hiByte)
506 {
507 case 0:
508 return ((jjbitVec27[i2] & l2) != 0L);
509 case 1:
510 return ((jjbitVec5[i2] & l2) != 0L);
511 case 2:
512 return ((jjbitVec28[i2] & l2) != 0L);
513 case 3:
514 return ((jjbitVec29[i2] & l2) != 0L);
515 case 4:
516 return ((jjbitVec30[i2] & l2) != 0L);
517 case 5:
518 return ((jjbitVec31[i2] & l2) != 0L);
519 case 6:
520 return ((jjbitVec32[i2] & l2) != 0L);
521 case 9:
522 return ((jjbitVec33[i2] & l2) != 0L);
523 case 10:
524 return ((jjbitVec34[i2] & l2) != 0L);
525 case 11:
526 return ((jjbitVec35[i2] & l2) != 0L);
527 case 12:
528 return ((jjbitVec36[i2] & l2) != 0L);
529 case 13:
530 return ((jjbitVec37[i2] & l2) != 0L);
531 case 14:
532 return ((jjbitVec38[i2] & l2) != 0L);
533 case 15:
534 return ((jjbitVec39[i2] & l2) != 0L);
535 case 16:
536 return ((jjbitVec18[i2] & l2) != 0L);
537 case 17:
538 return ((jjbitVec19[i2] & l2) != 0L);
539 case 30:
540 return ((jjbitVec20[i2] & l2) != 0L);
541 case 31:
542 return ((jjbitVec21[i2] & l2) != 0L);
543 case 32:
544 return ((jjbitVec40[i2] & l2) != 0L);
545 case 33:
546 return ((jjbitVec22[i2] & l2) != 0L);
547 case 48:
548 return ((jjbitVec41[i2] & l2) != 0L);
549 case 49:
550 return ((jjbitVec24[i2] & l2) != 0L);
551 case 159:
552 return ((jjbitVec25[i2] & l2) != 0L);
553 case 215:
554 return ((jjbitVec26[i2] & l2) != 0L);
555 default :
556 if ((jjbitVec3[i1] & l1) != 0L)
557 return true;
558 return false;
559 }
560 }
561 public static final String [] jjstrLiteralImages = {
562 "", null, null, null, null, null, null, null, null, null, null, null, null,
563 "\57", "\52", "\72", "\133", "\135", "\100", "\75", };
564 public static final String [] lexStateNames = {
565 "DEFAULT",
566 };
567 private ASCII_UCodeESC_CharStream input_stream;
568 private final int[] jjrounds = new int[19];
569 private final int[] jjstateSet = new int[38];
570 protected char curChar;
571 public SPathParserTokenManager(ASCII_UCodeESC_CharStream stream)
572 {
573 if (ASCII_UCodeESC_CharStream.staticFlag)
574 throw new Error ("ERROR: Cannot use a static CharStream class with a non-static lexical analyzer.");
575 input_stream = stream;
576 }
577 public SPathParserTokenManager(ASCII_UCodeESC_CharStream stream, int lexState)
578 {
579 this(stream);
580 SwitchTo(lexState);
581 }
582 public void ReInit(ASCII_UCodeESC_CharStream stream)
583 {
584 jjmatchedPos = jjnewStateCnt = 0;
585 curLexState = defaultLexState;
586 input_stream = stream;
587 ReInitRounds();
588 }
589 private final void ReInitRounds()
590 {
591 int i;
592 jjround = 0x80000001;
593 for (i = 19; i-- > 0;)
594 jjrounds[i] = 0x80000000;
595 }
596 public void ReInit(ASCII_UCodeESC_CharStream stream, int lexState)
597 {
598 ReInit(stream);
599 SwitchTo(lexState);
600 }
601 public void SwitchTo(int lexState)
602 {
603 if (lexState >= 1 || lexState < 0)
604 throw new TokenMgrError("Error: Ignoring invalid lexical state : " + lexState + ". State unchanged.", TokenMgrError.INVALID_LEXICAL_STATE);
605 else
606 curLexState = lexState;
607 }
608
609 private final Token jjFillToken()
610 {
611 Token t = Token.newToken(jjmatchedKind);
612 t.kind = jjmatchedKind;
613 String im = jjstrLiteralImages[jjmatchedKind];
614 t.image = (im == null) ? input_stream.GetImage() : im;
615 t.beginLine = input_stream.getBeginLine();
616 t.beginColumn = input_stream.getBeginColumn();
617 t.endLine = input_stream.getEndLine();
618 t.endColumn = input_stream.getEndColumn();
619 return t;
620 }
621
622 int curLexState = 0;
623 int defaultLexState = 0;
624 int jjnewStateCnt;
625 int jjround;
626 int jjmatchedPos;
627 int jjmatchedKind;
628
629 public final Token getNextToken()
630 {
631 int kind;
632 Token specialToken = null;
633 Token matchedToken;
634 int curPos = 0;
635
636 EOFLoop :
637 for (;;)
638 {
639 try
640 {
641 curChar = input_stream.BeginToken();
642 }
643 catch(java.io.IOException e)
644 {
645 jjmatchedKind = 0;
646 matchedToken = jjFillToken();
647 return matchedToken;
648 }
649
650 jjmatchedKind = 0x7fffffff;
651 jjmatchedPos = 0;
652 curPos = jjMoveStringLiteralDfa0_0();
653 if (jjmatchedKind != 0x7fffffff)
654 {
655 if (jjmatchedPos + 1 < curPos)
656 input_stream.backup(curPos - jjmatchedPos - 1);
657 matchedToken = jjFillToken();
658 return matchedToken;
659 }
660 int error_line = input_stream.getEndLine();
661 int error_column = input_stream.getEndColumn();
662 String error_after = null;
663 boolean EOFSeen = false;
664 try { input_stream.readChar(); input_stream.backup(1); }
665 catch (java.io.IOException e1) {
666 EOFSeen = true;
667 error_after = curPos <= 1 ? "" : input_stream.GetImage();
668 if (curChar == '\n' || curChar == '\r') {
669 error_line++;
670 error_column = 0;
671 }
672 else
673 error_column++;
674 }
675 if (!EOFSeen) {
676 input_stream.backup(1);
677 error_after = curPos <= 1 ? "" : input_stream.GetImage();
678 }
679 throw new TokenMgrError(EOFSeen, curLexState, error_line, error_column, error_after, curChar, TokenMgrError.LEXICAL_ERROR);
680 }
681 }
682
683 }
684 |
Popular Tags |
Java API By Example, From Geeks To Geeks.