|
1
2
17 package com.lutris.util;
18 import java.io.*;
19 import java.util.*;
20
21 public class ConfigParserTokenManager implements ConfigParserConstants
22 {
23 public java.io.PrintStream  debugStream = System.out;
24 public void setDebugStream(java.io.PrintStream ds) { debugStream = ds; }
25 private final int jjStopStringLiteralDfa_0(int pos, long active0)
26 {
27 switch (pos)
28 {
29 default :
30 return -1;
31 }
32 }
33 private final int jjStartNfa_0(int pos, long active0)
34 {
35 return jjMoveNfa_0(jjStopStringLiteralDfa_0(pos, active0), pos + 1);
36 }
37 private final int jjStopAtPos(int pos, int kind)
38 {
39 jjmatchedKind = kind;
40 jjmatchedPos = pos;
41 return pos + 1;
42 }
43 private final int jjStartNfaWithStates_0(int pos, int kind, int state)
44 {
45 jjmatchedKind = kind;
46 jjmatchedPos = pos;
47 try { curChar = input_stream.readChar(); }
48 catch(java.io.IOException e) { return pos + 1; }
49 return jjMoveNfa_0(state, pos + 1);
50 }
51 private final int jjMoveStringLiteralDfa0_0()
52 {
53 switch(curChar)
54 {
55 case 91:
56 return jjStopAtPos(0, 1);
57 case 93:
58 return jjStopAtPos(0, 2);
59 default :
60 return jjMoveNfa_0(17, 0);
61 }
62 }
63 private final void jjCheckNAdd(int state)
64 {
65 if (jjrounds[state] != jjround)
66 {
67 jjstateSet[jjnewStateCnt++] = state;
68 jjrounds[state] = jjround;
69 }
70 }
71 private final void jjAddStates(int start, int end)
72 {
73 do {
74 jjstateSet[jjnewStateCnt++] = jjnextStates[start];
75 } while (start++ != end);
76 }
77 private final void jjCheckNAddTwoStates(int state1, int state2)
78 {
79 jjCheckNAdd(state1);
80 jjCheckNAdd(state2);
81 }
82 private final void jjCheckNAddStates(int start, int end)
83 {
84 do {
85 jjCheckNAdd(jjnextStates[start]);
86 } while (start++ != end);
87 }
88 private final void jjCheckNAddStates(int start)
89 {
90 jjCheckNAdd(jjnextStates[start]);
91 jjCheckNAdd(jjnextStates[start + 1]);
92 }
93 static final long[] jjbitVec0 = {
94 0x0L, 0x0L, 0xffffffffffffffffL, 0xffffffffffffffffL
95 };
96 private final int jjMoveNfa_0(int startState, int curPos)
97 {
98 int[] nextStates;
99 int startsAt = 0;
100 jjnewStateCnt = 26;
101 int i = 1;
102 jjstateSet[0] = startState;
103 int j, kind = 0x7fffffff;
104 for (;;)
105 {
106 if (++jjround == 0x7fffffff)
107 ReInitRounds();
108 if (curChar < 64)
109 {
110 long l = 1L << curChar;
111 MatchLoop: do
112 {
113 switch(jjstateSet[--i])
114 {
115 case 17:
116 if ((0x1ffffdbffL & l) != 0L)
117 {
118 if (kind > 5)
119 kind = 5;
120 jjCheckNAdd(16);
121 }
122 else if ((0xdffffff600000000L & l) != 0L)
123 {
124 if (kind > 4)
125 kind = 4;
126 jjCheckNAdd(15);
127 }
128 else if ((0x2400L & l) != 0L)
129 {
130 if (kind > 8)
131 kind = 8;
132 }
133 else if (curChar == 61)
134 {
135 if (kind > 15)
136 kind = 15;
137 }
138 else if (curChar == 35)
139 jjCheckNAddStates(0, 2);
140 if (curChar == 13)
141 jjstateSet[jjnewStateCnt++] = 23;
142 break;
143 case 0:
144 if (curChar == 46)
145 jjCheckNAddStates(3, 7);
146 break;
147 case 2:
148 if (curChar == 52)
149 jjstateSet[jjnewStateCnt++] = 1;
150 break;
151 case 7:
152 if (curChar == 52)
153 jjstateSet[jjnewStateCnt++] = 6;
154 break;
155 case 11:
156 if ((0xffffffffffffdbffL & l) != 0L)
157 jjCheckNAddStates(8, 10);
158 break;
159 case 12:
160 if ((0x2400L & l) != 0L && kind > 3)
161 kind = 3;
162 break;
163 case 13:
164 if (curChar == 10 && kind > 3)
165 kind = 3;
166 break;
167 case 14:
168 if (curChar == 13)
169 jjstateSet[jjnewStateCnt++] = 13;
170 break;
171 case 15:
172 if ((0xdffffff600000000L & l) == 0L)
173 break;
174 if (kind > 4)
175 kind = 4;
176 jjCheckNAdd(15);
177 break;
178 case 16:
179 if ((0x1ffffdbffL & l) == 0L)
180 break;
181 if (kind > 5)
182 kind = 5;
183 jjCheckNAdd(16);
184 break;
185 case 18:
186 if ((0xffffffffffffdbffL & l) != 0L)
187 jjCheckNAddStates(0, 2);
188 break;
189 case 19:
190 if ((0x2400L & l) != 0L && kind > 6)
191 kind = 6;
192 break;
193 case 20:
194 if (curChar == 10 && kind > 6)
195 kind = 6;
196 break;
197 case 21:
198 if (curChar == 13)
199 jjstateSet[jjnewStateCnt++] = 20;
200 break;
201 case 22:
202 if ((0x2400L & l) != 0L && kind > 8)
203 kind = 8;
204 break;
205 case 23:
206 if (curChar == 10 && kind > 8)
207 kind = 8;
208 break;
209 case 24:
210 if (curChar == 13)
211 jjstateSet[jjnewStateCnt++] = 23;
212 break;
213 case 25:
214 if (curChar == 61 && kind > 15)
215 kind = 15;
216 break;
217 default : break;
218 }
219 } while(i != startsAt);
220 }
221 else if (curChar < 128)
222 {
223 long l = 1L << (curChar & 077);
224 MatchLoop: do
225 {
226 switch(jjstateSet[--i])
227 {
228 case 17:
229 if ((0x7fffffffd7ffffffL & l) != 0L)
230 {
231 if (kind > 4)
232 kind = 4;
233 jjCheckNAdd(15);
234 }
235 else if (curChar == 127)
236 {
237 if (kind > 5)
238 kind = 5;
239 jjCheckNAdd(16);
240 }
241 if (curChar == 76)
242 jjstateSet[jjnewStateCnt++] = 9;
243 else if (curChar == 108)
244 jjstateSet[jjnewStateCnt++] = 4;
245 break;
246 case 1:
247 if (curChar == 106)
248 jjCheckNAdd(0);
249 break;
250 case 3:
251 if (curChar == 103)
252 jjstateSet[jjnewStateCnt++] = 2;
253 break;
254 case 4:
255 if (curChar == 111)
256 jjstateSet[jjnewStateCnt++] = 3;
257 break;
258 case 5:
259 if (curChar == 108)
260 jjstateSet[jjnewStateCnt++] = 4;
261 break;
262 case 6:
263 if (curChar == 74)
264 jjCheckNAdd(0);
265 break;
266 case 8:
267 if (curChar == 71)
268 jjstateSet[jjnewStateCnt++] = 7;
269 break;
270 case 9:
271 if (curChar == 79)
272 jjstateSet[jjnewStateCnt++] = 8;
273 break;
274 case 10:
275 if (curChar == 76)
276 jjstateSet[jjnewStateCnt++] = 9;
277 break;
278 case 11:
279 jjAddStates(8, 10);
280 break;
281 case 15:
282 if ((0x7fffffffd7ffffffL & l) == 0L)
283 break;
284 if (kind > 4)
285 kind = 4;
286 jjCheckNAdd(15);
287 break;
288 case 16:
289 if (curChar != 127)
290 break;
291 if (kind > 5)
292 kind = 5;
293 jjCheckNAdd(16);
294 break;
295 case 18:
296 jjAddStates(0, 2);
297 break;
298 default : break;
299 }
300 } while(i != startsAt);
301 }
302 else
303 {
304 int i2 = (curChar & 0xff) >> 6;
305 long l2 = 1L << (curChar & 077);
306 MatchLoop: do
307 {
308 switch(jjstateSet[--i])
309 {
310 case 17:
311 case 15:
312 if ((jjbitVec0[i2] & l2) == 0L)
313 break;
314 if (kind > 4)
315 kind = 4;
316 jjCheckNAdd(15);
317 break;
318 case 11:
319 if ((jjbitVec0[i2] & l2) != 0L)
320 jjAddStates(8, 10);
321 break;
322 case 18:
323 if ((jjbitVec0[i2] & l2) != 0L)
324 jjAddStates(0, 2);
325 break;
326 default : break;
327 }
328 } while(i != startsAt);
329 }
330 if (kind != 0x7fffffff)
331 {
332 jjmatchedKind = kind;
333 jjmatchedPos = curPos;
334 kind = 0x7fffffff;
335 }
336 ++curPos;
337 if ((i = jjnewStateCnt) == (startsAt = 26 - (jjnewStateCnt = startsAt)))
338 return curPos;
339 try { curChar = input_stream.readChar(); }
340 catch(java.io.IOException e) { return curPos; }
341 }
342 }
343 private final int jjMoveStringLiteralDfa0_1()
344 {
345 return jjMoveNfa_1(1, 0);
346 }
347 private final int jjMoveNfa_1(int startState, int curPos)
348 {
349 int[] nextStates;
350 int startsAt = 0;
351 jjnewStateCnt = 46;
352 int i = 1;
353 jjstateSet[0] = startState;
354 int j, kind = 0x7fffffff;
355 for (;;)
356 {
357 if (++jjround == 0x7fffffff)
358 ReInitRounds();
359 if (curChar < 64)
360 {
361 long l = 1L << curChar;
362 MatchLoop: do
363 {
364 switch(jjstateSet[--i])
365 {
366 case 1:
367 if ((0x1ffffdbffL & l) != 0L)
368 {
369 if (kind > 5)
370 kind = 5;
371 jjCheckNAdd(0);
372 }
373 else if ((0xffffe7fa00000000L & l) != 0L)
374 {
375 if (kind > 10)
376 kind = 10;
377 jjCheckNAdd(35);
378 }
379 else if ((0x2400L & l) != 0L)
380 {
381 if (kind > 8)
382 kind = 8;
383 }
384 else if (curChar == 44)
385 {
386 if (kind > 13)
387 kind = 13;
388 jjCheckNAddStates(11, 13);
389 }
390 else if (curChar == 43)
391 {
392 if (kind > 12)
393 kind = 12;
394 jjCheckNAddStates(14, 16);
395 }
396 else if (curChar == 34)
397 jjCheckNAddStates(17, 22);
398 if (curChar == 13)
399 jjstateSet[jjnewStateCnt++] = 7;
400 else if (curChar == 35)
401 jjCheckNAddStates(23, 25);
402 break;
403 case 0:
404 if ((0x1ffffdbffL & l) == 0L)
405 break;
406 if (kind > 5)
407 kind = 5;
408 jjCheckNAdd(0);
409 break;
410 case 2:
411 if ((0xffffffffffffdbffL & l) != 0L)
412 jjCheckNAddStates(23, 25);
413 break;
414 case 3:
415 if ((0x2400L & l) != 0L && kind > 6)
416 kind = 6;
417 break;
418 case 4:
419 if (curChar == 10 && kind > 6)
420 kind = 6;
421 break;
422 case 5:
423 if (curChar == 13)
424 jjstateSet[jjnewStateCnt++] = 4;
425 break;
426 case 6:
427 if ((0x2400L & l) != 0L && kind > 8)
428 kind = 8;
429 break;
430 case 7:
431 if (curChar == 10 && kind > 8)
432 kind = 8;
433 break;
434 case 8:
435 if (curChar == 13)
436 jjstateSet[jjnewStateCnt++] = 7;
437 break;
438 case 9:
439 if (curChar == 34)
440 jjCheckNAddStates(17, 22);
441 break;
442 case 10:
443 if (curChar == 43)
444 jjCheckNAddStates(26, 34);
445 break;
446 case 11:
447 if ((0x1ffffdbffL & l) != 0L)
448 jjCheckNAddStates(26, 34);
449 break;
450 case 12:
451 if ((0x2400L & l) != 0L)
452 jjCheckNAddStates(17, 22);
453 break;
454 case 13:
455 if (curChar == 44)
456 jjCheckNAddStates(35, 43);
457 break;
458 case 14:
459 if ((0x1ffffdbffL & l) != 0L)
460 jjCheckNAddStates(35, 43);
461 break;
462 case 15:
463 if (curChar == 10)
464 jjCheckNAddStates(17, 22);
465 break;
466 case 16:
467 if ((0xffffe7fbffffdbffL & l) != 0L)
468 jjCheckNAddStates(17, 22);
469 break;
470 case 17:
471 if (curChar == 34 && kind > 9)
472 kind = 9;
473 break;
474 case 19:
475 jjCheckNAddStates(17, 22);
476 break;
477 case 22:
478 if ((0x3ff000000000000L & l) != 0L)
479 jjstateSet[jjnewStateCnt++] = 23;
480 break;
481 case 23:
482 if ((0x3ff000000000000L & l) != 0L)
483 jjstateSet[jjnewStateCnt++] = 24;
484 break;
485 case 24:
486 case 27:
487 if ((0x3ff000000000000L & l) != 0L)
488 jjCheckNAdd(25);
489 break;
490 case 25:
491 if ((0x3ff000000000000L & l) != 0L)
492 jjCheckNAddStates(17, 22);
493 break;
494 case 28:
495 case 33:
496 case 34:
497 if (curChar == 13)
498 jjCheckNAdd(15);
499 break;
500 case 29:
501 if (curChar == 13)
502 jjCheckNAddStates(17, 22);
503 break;
504 case 30:
505 if ((0xf000000000000L & l) != 0L)
506 jjstateSet[jjnewStateCnt++] = 31;
507 break;
508 case 31:
509 if ((0xff000000000000L & l) != 0L)
510 jjstateSet[jjnewStateCnt++] = 32;
511 break;
512 case 32:
513 if ((0xff000000000000L & l) != 0L)
514 jjCheckNAddStates(17, 22);
515 break;
516 case 35:
517 if ((0xffffe7fa00000000L & l) == 0L)
518 break;
519 if (kind > 10)
520 kind = 10;
521 jjCheckNAdd(35);
522 break;
523 case 36:
524 if (curChar != 43)
525 break;
526 if (kind > 12)
527 kind = 12;
528 jjCheckNAddStates(14, 16);
529 break;
530 case 37:
531 if ((0x1ffffdbffL & l) == 0L)
532 break;
533 if (kind > 12)
534 kind = 12;
535 jjCheckNAddStates(14, 16);
536 break;
537 case 38:
538 if ((0x2400L & l) != 0L && kind > 12)
539 kind = 12;
540 break;
541 case 39:
542 if (curChar == 10 && kind > 12)
543 kind = 12;
544 break;
545 case 40:
546 if (curChar == 13)
547 jjstateSet[jjnewStateCnt++] = 39;
548 break;
549 case 41:
550 if (curChar != 44)
551 break;
552 if (kind > 13)
553 kind = 13;
554 jjCheckNAddStates(11, 13);
555 break;
556 case 42:
557 if ((0x1ffffdbffL & l) == 0L)
558 break;
559 if (kind > 13)
560 kind = 13;
561 jjCheckNAddStates(11, 13);
562 break;
563 case 43:
564 if ((0x2400L & l) != 0L && kind > 13)
565 kind = 13;
566 break;
567 case 44:
568 if (curChar == 10 && kind > 13)
569 kind = 13;
570 break;
571 case 45:
572 if (curChar == 13)
573 jjstateSet[jjnewStateCnt++] = 44;
574 break;
575 default : break;
576 }
577 } while(i != startsAt);
578 }
579 else if (curChar < 128)
580 {
581 long l = 1L << (curChar & 077);
582 MatchLoop: do
583 {
584 switch(jjstateSet[--i])
585 {
586 case 1:
587 if ((0x7fffffffffffffffL & l) != 0L)
588 {
589 if (kind > 10)
590 kind = 10;
591 jjCheckNAdd(35);
592 }
593 else if (curChar == 127)
594 {
595 if (kind > 5)
596 kind = 5;
597 jjCheckNAdd(0);
598 }
599 break;
600 case 0:
601 if (curChar != 127)
602 break;
603 if (kind > 5)
604 kind = 5;
605 jjCheckNAdd(0);
606 break;
607 case 2:
608 jjAddStates(23, 25);
609 break;
610 case 11:
611 if (curChar == 127)
612 jjCheckNAddStates(26, 34);
613 break;
614 case 14:
615 if (curChar == 127)
616 jjCheckNAddStates(35, 43);
617 break;
618 case 16:
619 if ((0xffffffffefffffffL & l) != 0L)
620 jjCheckNAddStates(17, 22);
621 break;
622 case 18:
623 if (curChar == 92)
624 jjAddStates(44, 45);
625 break;
626 case 19:
627 jjCheckNAddStates(17, 22);
628 break;
629 case 20:
630 if (curChar == 92)
631 jjAddStates(46, 50);
632 break;
633 case 21:
634 if (curChar == 117)
635 jjstateSet[jjnewStateCnt++] = 22;
636 break;
637 case 22:
638 if ((0x7e0000007eL & l) != 0L)
639 jjstateSet[jjnewStateCnt++] = 23;
640 break;
641 case 23:
642 if ((0x7e0000007eL & l) != 0L)
643 jjstateSet[jjnewStateCnt++] = 24;
644 break;
645 case 24:
646 case 27:
647 if ((0x7e0000007eL & l) != 0L)
648 jjCheckNAdd(25);
649 break;
650 case 25:
651 if ((0x7e0000007eL & l) != 0L)
652 jjCheckNAddStates(17, 22);
653 break;
654 case 26:
655 if (curChar == 120)
656 jjstateSet[jjnewStateCnt++] = 27;
657 break;
658 case 35:
659 if ((0x7fffffffffffffffL & l) == 0L)
660 break;
661 if (kind > 10)
662 kind = 10;
663 jjCheckNAdd(35);
664 break;
665 case 37:
666 if (curChar != 127)
667 break;
668 if (kind > 12)
669 kind = 12;
670 jjAddStates(14, 16);
671 break;
672 case 42:
673 if (curChar != 127)
674 break;
675 if (kind > 13)
676 kind = 13;
677 jjAddStates(11, 13);
678 break;
679 default : break;
680 }
681 } while(i != startsAt);
682 }
683 else
684 {
685 int i2 = (curChar & 0xff) >> 6;
686 long l2 = 1L << (curChar & 077);
687 MatchLoop: do
688 {
689 switch(jjstateSet[--i])
690 {
691 case 2:
692 if ((jjbitVec0[i2] & l2) != 0L)
693 jjAddStates(23, 25);
694 break;
695 case 16:
696 case 19:
697 if ((jjbitVec0[i2] & l2) != 0L)
698 jjCheckNAddStates(17, 22);
699 break;
700 default : break;
701 }
702 } while(i != startsAt);
703 }
704 if (kind != 0x7fffffff)
705 {
706 jjmatchedKind = kind;
707 jjmatchedPos = curPos;
708 kind = 0x7fffffff;
709 }
710 ++curPos;
711 if ((i = jjnewStateCnt) == (startsAt = 46 - (jjnewStateCnt = startsAt)))
712 return curPos;
713 try { curChar = input_stream.readChar(); }
714 catch(java.io.IOException e) { return curPos; }
715 }
716 }
717 static final int[] jjnextStates = {
718 18, 19, 21, 5, 10, 11, 12, 14, 11, 12, 14, 42, 43, 45, 37, 38,
719 40, 10, 13, 16, 17, 18, 20, 2, 3, 5, 10, 11, 12, 34, 13, 16,
720 17, 18, 20, 10, 13, 14, 12, 33, 16, 17, 18, 20, 19, 30, 21, 26,
721 28, 29, 15,
722 };
723 public static final String [] jjstrLiteralImages = {
724 "", "\133", "\135", null, null, null, null, null, null, null, null, null, null,
725 null, null, null, };
726 public static final String [] lexStateNames = {
727 "DEFAULT",
728 "RHS",
729 };
730 public static final int[] jjnewLexState = {
731 -1, -1, -1, -1, -1, -1, -1, -1, 0, -1, -1, -1, -1, -1, -1, 1,
732 };
733 static final long[] jjtoToken = {
734 0xb777L,
735 };
736 static final long[] jjtoSkip = {
737 0x8L,
738 };
739 protected SimpleCharStream input_stream;
740 private final int[] jjrounds = new int[46];
741 private final int[] jjstateSet = new int[92];
742 protected char curChar;
743 public ConfigParserTokenManager(SimpleCharStream stream)
744 {
745 if (SimpleCharStream.staticFlag)
746 throw new Error ("ERROR: Cannot use a static CharStream class with a non-static lexical analyzer.");
747 input_stream = stream;
748 }
749 public ConfigParserTokenManager(SimpleCharStream stream, int lexState)
750 {
751 this(stream);
752 SwitchTo(lexState);
753 }
754 public void ReInit(SimpleCharStream stream)
755 {
756 jjmatchedPos = jjnewStateCnt = 0;
757 curLexState = defaultLexState;
758 input_stream = stream;
759 ReInitRounds();
760 }
761 private final void ReInitRounds()
762 {
763 int i;
764 jjround = 0x80000001;
765 for (i = 46; i-- > 0;)
766 jjrounds[i] = 0x80000000;
767 }
768 public void ReInit(SimpleCharStream stream, int lexState)
769 {
770 ReInit(stream);
771 SwitchTo(lexState);
772 }
773 public void SwitchTo(int lexState)
774 {
775 if (lexState >= 2 || lexState < 0)
776 throw new TokenMgrError("Error: Ignoring invalid lexical state : " + lexState + ". State unchanged.", TokenMgrError.INVALID_LEXICAL_STATE);
777 else
778 curLexState = lexState;
779 }
780
781 protected Token jjFillToken()
782 {
783 Token t = Token.newToken(jjmatchedKind);
784 t.kind = jjmatchedKind;
785 String im = jjstrLiteralImages[jjmatchedKind];
786 t.image = (im == null) ? input_stream.GetImage() : im;
787 t.beginLine = input_stream.getBeginLine();
788 t.beginColumn = input_stream.getBeginColumn();
789 t.endLine = input_stream.getEndLine();
790 t.endColumn = input_stream.getEndColumn();
791 return t;
792 }
793
794 int curLexState = 0;
795 int defaultLexState = 0;
796 int jjnewStateCnt;
797 int jjround;
798 int jjmatchedPos;
799 int jjmatchedKind;
800
801 public Token getNextToken()
802 {
803 int kind;
804 Token specialToken = null;
805 Token matchedToken;
806 int curPos = 0;
807
808 EOFLoop :
809 for (;;)
810 {
811 try
812 {
813 curChar = input_stream.BeginToken();
814 }
815 catch(java.io.IOException e)
816 {
817 jjmatchedKind = 0;
818 matchedToken = jjFillToken();
819 return matchedToken;
820 }
821
822 switch(curLexState)
823 {
824 case 0:
825 jjmatchedKind = 0x7fffffff;
826 jjmatchedPos = 0;
827 curPos = jjMoveStringLiteralDfa0_0();
828 break;
829 case 1:
830 jjmatchedKind = 0x7fffffff;
831 jjmatchedPos = 0;
832 curPos = jjMoveStringLiteralDfa0_1();
833 break;
834 }
835 if (jjmatchedKind != 0x7fffffff)
836 {
837 if (jjmatchedPos + 1 < curPos)
838 input_stream.backup(curPos - jjmatchedPos - 1);
839 if ((jjtoToken[jjmatchedKind >> 6] & (1L << (jjmatchedKind & 077))) != 0L)
840 {
841 matchedToken = jjFillToken();
842 if (jjnewLexState[jjmatchedKind] != -1)
843 curLexState = jjnewLexState[jjmatchedKind];
844 return matchedToken;
845 }
846 else
847 {
848 if (jjnewLexState[jjmatchedKind] != -1)
849 curLexState = jjnewLexState[jjmatchedKind];
850 continue EOFLoop;
851 }
852 }
853 int error_line = input_stream.getEndLine();
854 int error_column = input_stream.getEndColumn();
855 String error_after = null;
856 boolean EOFSeen = false;
857 try { input_stream.readChar(); input_stream.backup(1); }
858 catch (java.io.IOException e1) {
859 EOFSeen = true;
860 error_after = curPos <= 1 ? "" : input_stream.GetImage();
861 if (curChar == '\n' || curChar == '\r') {
862 error_line++;
863 error_column = 0;
864 }
865 else
866 error_column++;
867 }
868 if (!EOFSeen) {
869 input_stream.backup(1);
870 error_after = curPos <= 1 ? "" : input_stream.GetImage();
871 }
872 throw new TokenMgrError(EOFSeen, curLexState, error_line, error_column, error_after, curChar, TokenMgrError.LEXICAL_ERROR);
873 }
874 }
875
876 }
877 |
Popular Tags |
Java API By Example, From Geeks To Geeks.