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