|
1
2 package prefuse.data.expression.parser;
3
4 public class ExpressionParserTokenManager implements ExpressionParserConstants
5 {
6 public static java.io.PrintStream  debugStream = System.out;
7 public static void setDebugStream(java.io.PrintStream ds) { debugStream = ds; }
8 private static final int jjStopStringLiteralDfa_0(int pos, long active0)
9 {
10 switch (pos)
11 {
12 case 0:
13 if ((active0 & 0x600000000L) != 0L)
14 return 71;
15 return -1;
16 default :
17 return -1;
18 }
19 }
20 private static final int jjStartNfa_0(int pos, long active0)
21 {
22 return jjMoveNfa_0(jjStopStringLiteralDfa_0(pos, active0), pos + 1);
23 }
24 static private final int jjStopAtPos(int pos, int kind)
25 {
26 jjmatchedKind = kind;
27 jjmatchedPos = pos;
28 return pos + 1;
29 }
30 static private final int jjMoveStringLiteralDfa0_0()
31 {
32 switch(curChar)
33 {
34 case 37:
35 return jjStopAtPos(0, 42);
36 case 40:
37 return jjStopAtPos(0, 29);
38 case 41:
39 return jjStopAtPos(0, 30);
40 case 42:
41 return jjStopAtPos(0, 39);
42 case 43:
43 return jjStopAtPos(0, 37);
44 case 44:
45 return jjStopAtPos(0, 43);
46 case 45:
47 return jjStopAtPos(0, 38);
48 case 47:
49 return jjStopAtPos(0, 40);
50 case 60:
51 jjmatchedKind = 33;
52 return jjMoveStringLiteralDfa1_0(0x400000000L);
53 case 62:
54 jjmatchedKind = 32;
55 return jjMoveStringLiteralDfa1_0(0x800000000L);
56 case 94:
57 return jjStopAtPos(0, 41);
58 default :
59 return jjMoveNfa_0(4, 0);
60 }
61 }
62 static private final int jjMoveStringLiteralDfa1_0(long active0)
63 {
64 try { curChar = JavaCharStream.readChar(); }
65 catch(java.io.IOException e) {
66 jjStopStringLiteralDfa_0(0, active0);
67 return 1;
68 }
69 switch(curChar)
70 {
71 case 61:
72 if ((active0 & 0x400000000L) != 0L)
73 return jjStopAtPos(1, 34);
74 else if ((active0 & 0x800000000L) != 0L)
75 return jjStopAtPos(1, 35);
76 break;
77 default :
78 break;
79 }
80 return jjStartNfa_0(0, active0);
81 }
82 static private final void jjCheckNAdd(int state)
83 {
84 if (jjrounds[state] != jjround)
85 {
86 jjstateSet[jjnewStateCnt++] = state;
87 jjrounds[state] = jjround;
88 }
89 }
90 static private final void jjAddStates(int start, int end)
91 {
92 do {
93 jjstateSet[jjnewStateCnt++] = jjnextStates[start];
94 } while (start++ != end);
95 }
96 static private final void jjCheckNAddTwoStates(int state1, int state2)
97 {
98 jjCheckNAdd(state1);
99 jjCheckNAdd(state2);
100 }
101 static private final void jjCheckNAddStates(int start, int end)
102 {
103 do {
104 jjCheckNAdd(jjnextStates[start]);
105 } while (start++ != end);
106 }
107 static final long[] jjbitVec0 = {
108 0xfffffffffffffffeL, 0xffffffffffffffffL, 0xffffffffffffffffL, 0xffffffffffffffffL
109 };
110 static final long[] jjbitVec2 = {
111 0x0L, 0x0L, 0xffffffffffffffffL, 0xffffffffffffffffL
112 };
113 static final long[] jjbitVec3 = {
114 0x1ff00000fffffffeL, 0xffffffffffffc000L, 0xffffffffL, 0x600000000000000L
115 };
116 static final long[] jjbitVec4 = {
117 0x0L, 0x0L, 0x0L, 0xff7fffffff7fffffL
118 };
119 static final long[] jjbitVec5 = {
120 0x0L, 0xffffffffffffffffL, 0xffffffffffffffffL, 0xffffffffffffffffL
121 };
122 static final long[] jjbitVec6 = {
123 0xffffffffffffffffL, 0xffffffffffffffffL, 0xffffL, 0x0L
124 };
125 static final long[] jjbitVec7 = {
126 0xffffffffffffffffL, 0xffffffffffffffffL, 0x0L, 0x0L
127 };
128 static final long[] jjbitVec8 = {
129 0x3fffffffffffL, 0x0L, 0x0L, 0x0L
130 };
131 static private final int jjMoveNfa_0(int startState, int curPos)
132 {
133 int startsAt = 0;
134 jjnewStateCnt = 141;
135 int i = 1;
136 jjstateSet[0] = startState;
137 int kind = 0x7fffffff;
138 for (;;)
139 {
140 if (++jjround == 0x7fffffff)
141 ReInitRounds();
142 if (curChar < 64)
143 {
144 long l = 1L << curChar;
145 MatchLoop: do
146 {
147 switch(jjstateSet[--i])
148 {
149 case 4:
150 if ((0x3ff000000000000L & l) != 0L)
151 jjCheckNAddStates(0, 7);
152 else if (curChar == 46)
153 {
154 if (kind > 21)
155 kind = 21;
156 jjCheckNAddStates(8, 12);
157 }
158 else if (curChar == 60)
159 jjstateSet[jjnewStateCnt++] = 71;
160 else if (curChar == 33)
161 jjstateSet[jjnewStateCnt++] = 69;
162 else if (curChar == 61)
163 jjstateSet[jjnewStateCnt++] = 67;
164 else if (curChar == 36)
165 {
166 if (kind > 26)
167 kind = 26;
168 jjCheckNAdd(65);
169 }
170 else if (curChar == 39)
171 jjCheckNAddStates(13, 15);
172 else if (curChar == 34)
173 jjCheckNAddStates(16, 18);
174 else if (curChar == 38)
175 jjstateSet[jjnewStateCnt++] = 28;
176 if ((0x3fe000000000000L & l) != 0L)
177 {
178 if (kind > 16)
179 kind = 16;
180 jjCheckNAddStates(19, 21);
181 }
182 else if (curChar == 48)
183 {
184 if (kind > 16)
185 kind = 16;
186 jjCheckNAddStates(22, 26);
187 }
188 else if (curChar == 61)
189 {
190 if (kind > 31)
191 kind = 31;
192 }
193 else if (curChar == 33)
194 {
195 if (kind > 14)
196 kind = 14;
197 }
198 break;
199 case 28:
200 if (curChar == 38 && kind > 12)
201 kind = 12;
202 break;
203 case 29:
204 if (curChar == 38)
205 jjstateSet[jjnewStateCnt++] = 28;
206 break;
207 case 36:
208 if (curChar == 33 && kind > 14)
209 kind = 14;
210 break;
211 case 43:
212 if (curChar == 34)
213 jjCheckNAddStates(16, 18);
214 break;
215 case 44:
216 if ((0xfffffffbffffdbffL & l) != 0L)
217 jjCheckNAddStates(16, 18);
218 break;
219 case 46:
220 if ((0x8400000000L & l) != 0L)
221 jjCheckNAddStates(16, 18);
222 break;
223 case 47:
224 if (curChar == 34 && kind > 24)
225 kind = 24;
226 break;
227 case 48:
228 if ((0xff000000000000L & l) != 0L)
229 jjCheckNAddStates(27, 30);
230 break;
231 case 49:
232 if ((0xff000000000000L & l) != 0L)
233 jjCheckNAddStates(16, 18);
234 break;
235 case 50:
236 if ((0xf000000000000L & l) != 0L)
237 jjstateSet[jjnewStateCnt++] = 51;
238 break;
239 case 51:
240 if ((0xff000000000000L & l) != 0L)
241 jjCheckNAdd(49);
242 break;
243 case 52:
244 if (curChar == 39)
245 jjCheckNAddStates(13, 15);
246 break;
247 case 53:
248 if ((0xffffff7fffffdbffL & l) != 0L)
249 jjCheckNAddStates(13, 15);
250 break;
251 case 55:
252 if ((0x8400000000L & l) != 0L)
253 jjCheckNAddStates(13, 15);
254 break;
255 case 56:
256 if (curChar == 39 && kind > 24)
257 kind = 24;
258 break;
259 case 57:
260 if ((0xff000000000000L & l) != 0L)
261 jjCheckNAddStates(31, 34);
262 break;
263 case 58:
264 if ((0xff000000000000L & l) != 0L)
265 jjCheckNAddStates(13, 15);
266 break;
267 case 59:
268 if ((0xf000000000000L & l) != 0L)
269 jjstateSet[jjnewStateCnt++] = 60;
270 break;
271 case 60:
272 if ((0xff000000000000L & l) != 0L)
273 jjCheckNAdd(58);
274 break;
275 case 62:
276 jjAddStates(35, 36);
277 break;
278 case 64:
279 if (curChar != 36)
280 break;
281 if (kind > 26)
282 kind = 26;
283 jjCheckNAdd(65);
284 break;
285 case 65:
286 if ((0x3ff001000000000L & l) == 0L)
287 break;
288 if (kind > 26)
289 kind = 26;
290 jjCheckNAdd(65);
291 break;
292 case 66:
293 case 67:
294 if (curChar == 61 && kind > 31)
295 kind = 31;
296 break;
297 case 68:
298 if (curChar == 61)
299 jjstateSet[jjnewStateCnt++] = 67;
300 break;
301 case 69:
302 if (curChar == 61 && kind > 36)
303 kind = 36;
304 break;
305 case 70:
306 if (curChar == 33)
307 jjstateSet[jjnewStateCnt++] = 69;
308 break;
309 case 71:
310 if (curChar == 62 && kind > 36)
311 kind = 36;
312 break;
313 case 72:
314 if (curChar == 60)
315 jjstateSet[jjnewStateCnt++] = 71;
316 break;
317 case 99:
318 if ((0x3fe000000000000L & l) == 0L)
319 break;
320 if (kind > 16)
321 kind = 16;
322 jjCheckNAddStates(19, 21);
323 break;
324 case 100:
325 if ((0x3ff000000000000L & l) == 0L)
326 break;
327 if (kind > 16)
328 kind = 16;
329 jjCheckNAdd(100);
330 break;
331 case 101:
332 if ((0x3ff000000000000L & l) != 0L)
333 jjCheckNAddTwoStates(101, 102);
334 break;
335 case 103:
336 if (curChar != 46)
337 break;
338 if (kind > 21)
339 kind = 21;
340 jjCheckNAddStates(8, 12);
341 break;
342 case 104:
343 if ((0x3ff000000000000L & l) == 0L)
344 break;
345 if (kind > 21)
346 kind = 21;
347 jjCheckNAddTwoStates(104, 105);
348 break;
349 case 106:
350 if ((0x280000000000L & l) != 0L)
351 jjCheckNAdd(107);
352 break;
353 case 107:
354 if ((0x3ff000000000000L & l) == 0L)
355 break;
356 if (kind > 21)
357 kind = 21;
358 jjCheckNAdd(107);
359 break;
360 case 108:
361 if ((0x3ff000000000000L & l) != 0L)
362 jjCheckNAddStates(37, 39);
363 break;
364 case 110:
365 if ((0x280000000000L & l) != 0L)
366 jjCheckNAdd(111);
367 break;
368 case 111:
369 if ((0x3ff000000000000L & l) != 0L)
370 jjCheckNAddTwoStates(111, 112);
371 break;
372 case 113:
373 if ((0x3ff000000000000L & l) != 0L)
374 jjCheckNAddStates(0, 7);
375 break;
376 case 114:
377 if ((0x3ff000000000000L & l) != 0L)
378 jjCheckNAddTwoStates(114, 115);
379 break;
380 case 115:
381 if (curChar != 46)
382 break;
383 if (kind > 21)
384 kind = 21;
385 jjCheckNAddTwoStates(116, 117);
386 break;
387 case 116:
388 if ((0x3ff000000000000L & l) == 0L)
389 break;
390 if (kind > 21)
391 kind = 21;
392 jjCheckNAddTwoStates(116, 117);
393 break;
394 case 118:
395 if ((0x280000000000L & l) != 0L)
396 jjCheckNAdd(119);
397 break;
398 case 119:
399 if ((0x3ff000000000000L & l) == 0L)
400 break;
401 if (kind > 21)
402 kind = 21;
403 jjCheckNAdd(119);
404 break;
405 case 120:
406 if ((0x3ff000000000000L & l) != 0L)
407 jjCheckNAddTwoStates(120, 121);
408 break;
409 case 122:
410 if ((0x280000000000L & l) != 0L)
411 jjCheckNAdd(123);
412 break;
413 case 123:
414 if ((0x3ff000000000000L & l) == 0L)
415 break;
416 if (kind > 21)
417 kind = 21;
418 jjCheckNAdd(123);
419 break;
420 case 124:
421 if ((0x3ff000000000000L & l) != 0L)
422 jjCheckNAddTwoStates(124, 125);
423 break;
424 case 125:
425 if (curChar == 46)
426 jjCheckNAddStates(40, 42);
427 break;
428 case 126:
429 if ((0x3ff000000000000L & l) != 0L)
430 jjCheckNAddStates(40, 42);
431 break;
432 case 128:
433 if ((0x280000000000L & l) != 0L)
434 jjCheckNAdd(129);
435 break;
436 case 129:
437 if ((0x3ff000000000000L & l) != 0L)
438 jjCheckNAddTwoStates(129, 112);
439 break;
440 case 130:
441 if ((0x3ff000000000000L & l) != 0L)
442 jjCheckNAddTwoStates(130, 131);
443 break;
444 case 132:
445 if ((0x280000000000L & l) != 0L)
446 jjCheckNAdd(133);
447 break;
448 case 133:
449 if ((0x3ff000000000000L & l) != 0L)
450 jjCheckNAddTwoStates(133, 112);
451 break;
452 case 134:
453 if (curChar != 48)
454 break;
455 if (kind > 16)
456 kind = 16;
457 jjCheckNAddStates(22, 26);
458 break;
459 case 136:
460 if ((0x3ff000000000000L & l) == 0L)
461 break;
462 if (kind > 16)
463 kind = 16;
464 jjstateSet[jjnewStateCnt++] = 136;
465 break;
466 case 137:
467 if ((0xff000000000000L & l) == 0L)
468 break;
469 if (kind > 16)
470 kind = 16;
471 jjCheckNAdd(137);
472 break;
473 case 139:
474 if ((0x3ff000000000000L & l) != 0L)
475 jjCheckNAddTwoStates(139, 102);
476 break;
477 case 140:
478 if ((0xff000000000000L & l) != 0L)
479 jjCheckNAddTwoStates(140, 102);
480 break;
481 default : break;
482 }
483 } while(i != startsAt);
484 }
485 else if (curChar < 128)
486 {
487 long l = 1L << (curChar & 077);
488 MatchLoop: do
489 {
490 switch(jjstateSet[--i])
491 {
492 case 4:
493 if ((0x7fffffe87fffffeL & l) != 0L)
494 {
495 if (kind > 26)
496 kind = 26;
497 jjCheckNAdd(65);
498 }
499 else if (curChar == 91)
500 jjCheckNAdd(62);
501 else if (curChar == 124)
502 jjstateSet[jjnewStateCnt++] = 34;
503 if (curChar == 110)
504 jjAddStates(43, 44);
505 else if (curChar == 78)
506 jjAddStates(45, 46);
507 else if (curChar == 116)
508 jjAddStates(47, 48);
509 else if (curChar == 84)
510 jjAddStates(49, 50);
511 else if (curChar == 120)
512 jjstateSet[jjnewStateCnt++] = 41;
513 else if (curChar == 88)
514 jjstateSet[jjnewStateCnt++] = 38;
515 else if (curChar == 111)
516 jjstateSet[jjnewStateCnt++] = 32;
517 else if (curChar == 79)
518 jjstateSet[jjnewStateCnt++] = 30;
519 else if (curChar == 97)
520 jjstateSet[jjnewStateCnt++] = 26;
521 else if (curChar == 65)
522 jjstateSet[jjnewStateCnt++] = 23;
523 else if (curChar == 101)
524 jjstateSet[jjnewStateCnt++] = 20;
525 else if (curChar == 69)
526 jjstateSet[jjnewStateCnt++] = 16;
527 else if (curChar == 105)
528 jjstateSet[jjnewStateCnt++] = 12;
529 else if (curChar == 73)
530 jjstateSet[jjnewStateCnt++] = 10;
531 else if (curChar == 102)
532 jjstateSet[jjnewStateCnt++] = 8;
533 else if (curChar == 70)
534 jjstateSet[jjnewStateCnt++] = 3;
535 break;
536 case 0:
537 if (curChar == 69 && kind > 7)
538 kind = 7;
539 break;
540 case 1:
541 if (curChar == 83)
542 jjstateSet[jjnewStateCnt++] = 0;
543 break;
544 case 2:
545 if (curChar == 76)
546 jjstateSet[jjnewStateCnt++] = 1;
547 break;
548 case 3:
549 if (curChar == 65)
550 jjstateSet[jjnewStateCnt++] = 2;
551 break;
552 case 5:
553 if (curChar == 101 && kind > 7)
554 kind = 7;
555 break;
556 case 6:
557 if (curChar == 115)
558 jjstateSet[jjnewStateCnt++] = 5;
559 break;
560 case 7:
561 if (curChar == 108)
562 jjstateSet[jjnewStateCnt++] = 6;
563 break;
564 case 8:
565 if (curChar == 97)
566 jjstateSet[jjnewStateCnt++] = 7;
567 break;
568 case 9:
569 if (curChar == 102)
570 jjstateSet[jjnewStateCnt++] = 8;
571 break;
572 case 10:
573 if (curChar == 70 && kind > 9)
574 kind = 9;
575 break;
576 case 11:
577 if (curChar == 73)
578 jjstateSet[jjnewStateCnt++] = 10;
579 break;
580 case 12:
581 if (curChar == 102 && kind > 9)
582 kind = 9;
583 break;
584 case 13:
585 if (curChar == 105)
586 jjstateSet[jjnewStateCnt++] = 12;
587 break;
588 case 14:
589 if (curChar == 69 && kind > 11)
590 kind = 11;
591 break;
592 case 15:
593 if (curChar == 83)
594 jjstateSet[jjnewStateCnt++] = 14;
595 break;
596 case 16:
597 if (curChar == 76)
598 jjstateSet[jjnewStateCnt++] = 15;
599 break;
600 case 17:
601 if (curChar == 69)
602 jjstateSet[jjnewStateCnt++] = 16;
603 break;
604 case 18:
605 if (curChar == 101 && kind > 11)
606 kind = 11;
607 break;
608 case 19:
609 if (curChar == 115)
610 jjstateSet[jjnewStateCnt++] = 18;
611 break;
612 case 20:
613 if (curChar == 108)
614 jjstateSet[jjnewStateCnt++] = 19;
615 break;
616 case 21:
617 if (curChar == 101)
618 jjstateSet[jjnewStateCnt++] = 20;
619 break;
620 case 22:
621 if (curChar == 68 && kind > 12)
622 kind = 12;
623 break;
624 case 23:
625 if (curChar == 78)
626 jjstateSet[jjnewStateCnt++] = 22;
627 break;
628 case 24:
629 if (curChar == 65)
630 jjstateSet[jjnewStateCnt++] = 23;
631 break;
632 case 25:
633 if (curChar == 100 && kind > 12)
634 kind = 12;
635 break;
636 case 26:
637 if (curChar == 110)
638 jjstateSet[jjnewStateCnt++] = 25;
639 break;
640 case 27:
641 if (curChar == 97)
642 jjstateSet[jjnewStateCnt++] = 26;
643 break;
644 case 30:
645 if (curChar == 82 && kind > 13)
646 kind = 13;
647 break;
648 case 31:
649 if (curChar == 79)
650 jjstateSet[jjnewStateCnt++] = 30;
651 break;
652 case 32:
653 if (curChar == 114 && kind > 13)
654 kind = 13;
655 break;
656 case 33:
657 if (curChar == 111)
658 jjstateSet[jjnewStateCnt++] = 32;
659 break;
660 case 34:
661 if (curChar == 124 && kind > 13)
662 kind = 13;
663 break;
664 case 35:
665 if (curChar == 124)
666 jjstateSet[jjnewStateCnt++] = 34;
667 break;
668 case 37:
669 if (curChar == 82 && kind > 15)
670 kind = 15;
671 break;
672 case 38:
673 if (curChar == 79)
674 jjstateSet[jjnewStateCnt++] = 37;
675 break;
676 case 39:
677 if (curChar == 88)
678 jjstateSet[jjnewStateCnt++] = 38;
679 break;
680 case 40:
681 if (curChar == 114 && kind > 15)
682 kind = 15;
683 break;
684 case 41:
685 if (curChar == 111)
686 jjstateSet[jjnewStateCnt++] = 40;
687 break;
688 case 42:
689 if (curChar == 120)
690 jjstateSet[jjnewStateCnt++] = 41;
691 break;
692 case 44:
693 if ((0xffffffffefffffffL & l) != 0L)
694 jjCheckNAddStates(16, 18);
695 break;
696 case 45:
697 if (curChar == 92)
698 jjAddStates(51, 53);
699 break;
700 case 46:
701 if ((0x14404410000000L & l) != 0L)
702 jjCheckNAddStates(16, 18);
703 break;
704 case 53:
705 if ((0xffffffffefffffffL & l) != 0L)
706 jjCheckNAddStates(13, 15);
707 break;
708 case 54:
709 if (curChar == 92)
710 jjAddStates(54, 56);
711 break;
712 case 55:
713 if ((0x14404410000000L & l) != 0L)
714 jjCheckNAddStates(13, 15);
715 break;
716 case 61:
717 if (curChar == 91)
718 jjCheckNAdd(62);
719 break;
720 case 62:
721 if ((0xffffffffdfffffffL & l) != 0L)
722 jjCheckNAddTwoStates(62, 63);
723 break;
724 case 63:
725 if (curChar == 93 && kind > 25)
726 kind = 25;
727 break;
728 case 64:
729 case 65:
730 if ((0x7fffffe87fffffeL & l) == 0L)
731 break;
732 if (kind > 26)
733 kind = 26;
734 jjCheckNAdd(65);
735 break;
736 case 73:
737 if (curChar == 84)
738 jjAddStates(49, 50);
739 break;
740 case 74:
741 if (curChar == 69 && kind > 6)
742 kind = 6;
743 break;
744 case 75:
745 if (curChar == 85)
746 jjstateSet[jjnewStateCnt++] = 74;
747 break;
748 case 76:
749 if (curChar == 82)
750 jjstateSet[jjnewStateCnt++] = 75;
751 break;
752 case 77:
753 if (curChar == 78 && kind > 10)
754 kind = 10;
755 break;
756 case 78:
757 if (curChar == 69)
758 jjstateSet[jjnewStateCnt++] = 77;
759 break;
760 case 79:
761 if (curChar == 72)
762 jjstateSet[jjnewStateCnt++] = 78;
763 break;
764 case 80:
765 if (curChar == 116)
766 jjAddStates(47, 48);
767 break;
768 case 81:
769 if (curChar == 101 && kind > 6)
770 kind = 6;
771 break;
772 case 82:
773 if (curChar == 117)
774 jjstateSet[jjnewStateCnt++] = 81;
775 break;
776 case 83:
777 if (curChar == 114)
778 jjstateSet[jjnewStateCnt++] = 82;
779 break;
780 case 84:
781 if (curChar == 110 && kind > 10)
782 kind = 10;
783 break;
784 case 85:
785 if (curChar == 101)
786 jjstateSet[jjnewStateCnt++] = 84;
787 break;
788 case 86:
789 if (curChar == 104)
790 jjstateSet[jjnewStateCnt++] = 85;
791 break;
792 case 87:
793 if (curChar == 78)
794 jjAddStates(45, 46);
795 break;
796 case 88:
797 if (curChar == 76 && kind > 8)
798 kind = 8;
799 break;
800 case 89:
801 if (curChar == 76)
802 jjstateSet[jjnewStateCnt++] = 88;
803 break;
804 case 90:
805 if (curChar == 85)
806 jjstateSet[jjnewStateCnt++] = 89;
807 break;
808 case 91:
809 if (curChar == 84 && kind > 14)
810 kind = 14;
811 break;
812 case 92:
813 if (curChar == 79)
814 jjstateSet[jjnewStateCnt++] = 91;
815 break;
816 case 93:
817 if (curChar == 110)
818 jjAddStates(43, 44);
819 break;
820 case 94:
821 if (curChar == 108 && kind > 8)
822 kind = 8;
823 break;
824 case 95:
825 if (curChar == 108)
826 jjstateSet[jjnewStateCnt++] = 94;
827 break;
828 case 96:
829 if (curChar == 117)
830 jjstateSet[jjnewStateCnt++] = 95;
831 break;
832 case 97:
833 if (curChar == 116 && kind > 14)
834 kind = 14;
835 break;
836 case 98:
837 if (curChar == 111)
838 jjstateSet[jjnewStateCnt++] = 97;
839 break;
840 case 102:
841 if ((0x100000001000L & l) != 0L && kind > 20)
842 kind = 20;
843 break;
844 case 105:
845 if ((0x2000000020L & l) != 0L)
846 jjAddStates(57, 58);
847 break;
848 case 109:
849 if ((0x2000000020L & l) != 0L)
850 jjAddStates(59, 60);
851 break;
852 case 112:
853 if ((0x4000000040L & l) != 0L && kind > 22)
854 kind = 22;
855 break;
856 case 117:
857 if ((0x2000000020L & l) != 0L)
858 jjAddStates(61, 62);
859 break;
860 case 121:
861 if ((0x2000000020L & l) != 0L)
862 jjAddStates(63, 64);
863 break;
864 case 127:
865 if ((0x2000000020L & l) != 0L)
866 jjAddStates(65, 66);
867 break;
868 case 131:
869 if ((0x2000000020L & l) != 0L)
870 jjAddStates(67, 68);
871 break;
872 case 135:
873 if ((0x100000001000000L & l) != 0L)
874 jjCheckNAdd(136);
875 break;
876 case 136:
877 if ((0x7e0000007eL & l) == 0L)
878 break;
879 if (kind > 16)
880 kind = 16;
881 jjCheckNAdd(136);
882 break;
883 case 138:
884 if ((0x100000001000000L & l) != 0L)
885 jjCheckNAdd(139);
886 break;
887 case 139:
888 if ((0x7e0000007eL & l) != 0L)
889 jjCheckNAddTwoStates(139, 102);
890 break;
891 default : break;
892 }
893 } while(i != startsAt);
894 }
895 else
896 {
897 int hiByte = (int)(curChar >> 8);
898 int i1 = hiByte >> 6;
899 long l1 = 1L << (hiByte & 077);
900 int i2 = (curChar & 0xff) >> 6;
901 long l2 = 1L << (curChar & 077);
902 MatchLoop: do
903 {
904 switch(jjstateSet[--i])
905 {
906 case 4:
907 case 65:
908 if (!jjCanMove_1(hiByte, i1, i2, l1, l2))
909 break;
910 if (kind > 26)
911 kind = 26;
912 jjCheckNAdd(65);
913 break;
914 case 44:
915 if (jjCanMove_0(hiByte, i1, i2, l1, l2))
916 jjAddStates(16, 18);
917 break;
918 case 53:
919 if (jjCanMove_0(hiByte, i1, i2, l1, l2))
920 jjAddStates(13, 15);
921 break;
922 case 62:
923 if (jjCanMove_0(hiByte, i1, i2, l1, l2))
924 jjAddStates(35, 36);
925 break;
926 default : break;
927 }
928 } while(i != startsAt);
929 }
930 if (kind != 0x7fffffff)
931 {
932 jjmatchedKind = kind;
933 jjmatchedPos = curPos;
934 kind = 0x7fffffff;
935 }
936 ++curPos;
937 if ((i = jjnewStateCnt) == (startsAt = 141 - (jjnewStateCnt = startsAt)))
938 return curPos;
939 try { curChar = JavaCharStream.readChar(); }
940 catch(java.io.IOException e) { return curPos; }
941 }
942 }
943 static final int[] jjnextStates = {
944 114, 115, 120, 121, 124, 125, 130, 131, 104, 105, 108, 109, 112, 53, 54, 56,
945 44, 45, 47, 100, 101, 102, 135, 137, 138, 140, 102, 44, 45, 49, 47, 53,
946 54, 58, 56, 62, 63, 108, 109, 112, 126, 127, 112, 96, 98, 90, 92, 83,
947 86, 76, 79, 46, 48, 50, 55, 57, 59, 106, 107, 110, 111, 118, 119, 122,
948 123, 128, 129, 132, 133,
949 };
950 private static final boolean jjCanMove_0(int hiByte, int i1, int i2, long l1, long l2)
951 {
952 switch(hiByte)
953 {
954 case 0:
955 return ((jjbitVec2[i2] & l2) != 0L);
956 default :
957 if ((jjbitVec0[i1] & l1) != 0L)
958 return true;
959 return false;
960 }
961 }
962 private static final boolean jjCanMove_1(int hiByte, int i1, int i2, long l1, long l2)
963 {
964 switch(hiByte)
965 {
966 case 0:
967 return ((jjbitVec4[i2] & l2) != 0L);
968 case 48:
969 return ((jjbitVec5[i2] & l2) != 0L);
970 case 49:
971 return ((jjbitVec6[i2] & l2) != 0L);
972 case 51:
973 return ((jjbitVec7[i2] & l2) != 0L);
974 case 61:
975 return ((jjbitVec8[i2] & l2) != 0L);
976 default :
977 if ((jjbitVec3[i1] & l1) != 0L)
978 return true;
979 return false;
980 }
981 }
982 public static final String [] jjstrLiteralImages = {
983 "", null, null, null, null, null, null, null, null, null, null, null, null,
984 null, null, null, null, null, null, null, null, null, null, null, null, null, null,
985 null, null, "\50", "\51", null, "\76", "\74", "\74\75", "\76\75", null, "\53",
986 "\55", "\52", "\57", "\136", "\45", "\54", };
987 public static final String [] lexStateNames = {
988 "DEFAULT",
989 };
990 static final long[] jjtoToken = {
991 0xfffe771ffc1L,
992 };
993 static final long[] jjtoSkip = {
994 0x3eL,
995 };
996 static protected JavaCharStream input_stream;
997 static private final int[] jjrounds = new int[141];
998 static private final int[] jjstateSet = new int[282];
999 static protected char curChar;
1000public ExpressionParserTokenManager(JavaCharStream stream)
1001{
1002 if (input_stream != null)
1003 throw new TokenMgrError("ERROR: Second call to constructor of static lexer. You must use ReInit() to initialize the static variables.", TokenMgrError.STATIC_LEXER_ERROR);
1004 input_stream = stream;
1005}
1006public ExpressionParserTokenManager(JavaCharStream stream, int lexState)
1007{
1008 this(stream);
1009 SwitchTo(lexState);
1010}
1011static public void ReInit(JavaCharStream stream)
1012{
1013 jjmatchedPos = jjnewStateCnt = 0;
1014 curLexState = defaultLexState;
1015 input_stream = stream;
1016 ReInitRounds();
1017}
1018static private final void ReInitRounds()
1019{
1020 int i;
1021 jjround = 0x80000001;
1022 for (i = 141; i-- > 0;)
1023 jjrounds[i] = 0x80000000;
1024}
1025static public void ReInit(JavaCharStream stream, int lexState)
1026{
1027 ReInit(stream);
1028 SwitchTo(lexState);
1029}
1030static public void SwitchTo(int lexState)
1031{
1032 if (lexState >= 1 || lexState < 0)
1033 throw new TokenMgrError("Error: Ignoring invalid lexical state : " + lexState + ". State unchanged.", TokenMgrError.INVALID_LEXICAL_STATE);
1034 else
1035 curLexState = lexState;
1036}
1037
1038static protected Token jjFillToken()
1039{
1040 Token t = Token.newToken(jjmatchedKind);
1041 t.kind = jjmatchedKind;
1042 String im = jjstrLiteralImages[jjmatchedKind];
1043 t.image = (im == null) ? JavaCharStream.GetImage() : im;
1044 t.beginLine = JavaCharStream.getBeginLine();
1045 t.beginColumn = JavaCharStream.getBeginColumn();
1046 t.endLine = JavaCharStream.getEndLine();
1047 t.endColumn = JavaCharStream.getEndColumn();
1048 return t;
1049}
1050
1051static int curLexState = 0;
1052static int defaultLexState = 0;
1053static int jjnewStateCnt;
1054static int jjround;
1055static int jjmatchedPos;
1056static int jjmatchedKind;
1057
1058public static Token getNextToken()
1059{
1060 Token matchedToken;
1061 int curPos = 0;
1062
1063 EOFLoop :
1064 for (;;)
1065 {
1066 try
1067 {
1068 curChar = JavaCharStream.BeginToken();
1069 }
1070 catch(java.io.IOException e)
1071 {
1072 jjmatchedKind = 0;
1073 matchedToken = jjFillToken();
1074 return matchedToken;
1075 }
1076
1077 try { JavaCharStream.backup(0);
1078 while (curChar <= 32 && (0x100003600L & (1L << curChar)) != 0L)
1079 curChar = JavaCharStream.BeginToken();
1080 }
1081 catch (java.io.IOException e1) { continue EOFLoop; }
1082 jjmatchedKind = 0x7fffffff;
1083 jjmatchedPos = 0;
1084 curPos = jjMoveStringLiteralDfa0_0();
1085 if (jjmatchedKind != 0x7fffffff)
1086 {
1087 if (jjmatchedPos + 1 < curPos)
1088 JavaCharStream.backup(curPos - jjmatchedPos - 1);
1089 if ((jjtoToken[jjmatchedKind >> 6] & (1L << (jjmatchedKind & 077))) != 0L)
1090 {
1091 matchedToken = jjFillToken();
1092 return matchedToken;
1093 }
1094 else
1095 {
1096 continue EOFLoop;
1097 }
1098 }
1099 int error_line = JavaCharStream.getEndLine();
1100 int error_column = JavaCharStream.getEndColumn();
1101 String error_after = null;
1102 boolean EOFSeen = false;
1103 try { JavaCharStream.readChar(); JavaCharStream.backup(1); }
1104 catch (java.io.IOException e1) {
1105 EOFSeen = true;
1106 error_after = curPos <= 1 ? "" : JavaCharStream.GetImage();
1107 if (curChar == '\n' || curChar == '\r') {
1108 error_line++;
1109 error_column = 0;
1110 }
1111 else
1112 error_column++;
1113 }
1114 if (!EOFSeen) {
1115 JavaCharStream.backup(1);
1116 error_after = curPos <= 1 ? "" : JavaCharStream.GetImage();
1117 }
1118 throw new TokenMgrError(EOFSeen, curLexState, error_line, error_column, error_after, curChar, TokenMgrError.LEXICAL_ERROR);
1119 }
1120}
1121
1122}
1123 |
Popular Tags |
Java API By Example, From Geeks To Geeks.