1
2 /**
3 * JSP Parser for PMD.
4 * @author Pieter ? Application Engineers NV/SA ? http://www.ae.be
5 */
6
7 package net.sourceforge.pmd.jsp.ast;
8
9 /** Token Manager. */
10 public class JspParserTokenManager implements JspParserConstants
11 {
12
13 /** Debug output. */
14 public java.io.PrintStream debugStream = System.out;
15 /** Set debug output. */
16 public void setDebugStream(java.io.PrintStream ds) { debugStream = ds; }
17 private final int jjStopStringLiteralDfa_9(int pos, long active0)
18 {
19 switch (pos)
20 {
21 case 0:
22 if ((active0 & 0x40000000000L) != 0L)
23 return 2;
24 return -1;
25 default :
26 return -1;
27 }
28 }
29 private final int jjStartNfa_9(int pos, long active0)
30 {
31 return jjMoveNfa_9(jjStopStringLiteralDfa_9(pos, active0), pos + 1);
32 }
33 private int jjStopAtPos(int pos, int kind)
34 {
35 jjmatchedKind = kind;
36 jjmatchedPos = pos;
37 return pos + 1;
38 }
39 private int jjMoveStringLiteralDfa0_9()
40 {
41 switch(curChar)
42 {
43 case 37:
44 return jjMoveStringLiteralDfa1_9(0x40000000000L);
45 default :
46 return jjMoveNfa_9(3, 0);
47 }
48 }
49 private int jjMoveStringLiteralDfa1_9(long active0)
50 {
51 try { curChar = input_stream.readChar(); }
52 catch(java.io.IOException e) {
53 jjStopStringLiteralDfa_9(0, active0);
54 return 1;
55 }
56 switch(curChar)
57 {
58 case 62:
59 if ((active0 & 0x40000000000L) != 0L)
60 return jjStopAtPos(1, 42);
61 break;
62 default :
63 break;
64 }
65 return jjStartNfa_9(0, active0);
66 }
67 static final long[] jjbitVec0 = {
68 0x0L, 0x0L, 0xffffffffffffffffL, 0xffffffffffffffffL
69 };
70 private int jjMoveNfa_9(int startState, int curPos)
71 {
72 int startsAt = 0;
73 jjnewStateCnt = 3;
74 int i = 1;
75 jjstateSet[0] = startState;
76 int kind = 0x7fffffff;
77 for (;;)
78 {
79 if (++jjround == 0x7fffffff)
80 ReInitRounds();
81 if (curChar < 64)
82 {
83 long l = 1L << curChar;
84 do
85 {
86 switch(jjstateSet[--i])
87 {
88 case 3:
89 if ((0xffffffdfffffffffL & l) != 0L)
90 {
91 if (kind > 43)
92 kind = 43;
93 jjCheckNAddTwoStates(0, 1);
94 }
95 else if (curChar == 37)
96 jjstateSet[jjnewStateCnt++] = 2;
97 break;
98 case 0:
99 if ((0xffffffdfffffffffL & l) == 0L)
100 break;
101 if (kind > 43)
102 kind = 43;
103 jjCheckNAddTwoStates(0, 1);
104 break;
105 case 1:
106 if (curChar == 37)
107 jjstateSet[jjnewStateCnt++] = 2;
108 break;
109 case 2:
110 if ((0xbfffffffffffffffL & l) == 0L)
111 break;
112 if (kind > 43)
113 kind = 43;
114 jjCheckNAddTwoStates(0, 1);
115 break;
116 default : break;
117 }
118 } while(i != startsAt);
119 }
120 else if (curChar < 128)
121 {
122 long l = 1L << (curChar & 077);
123 do
124 {
125 switch(jjstateSet[--i])
126 {
127 case 3:
128 case 0:
129 case 2:
130 if (kind > 43)
131 kind = 43;
132 jjCheckNAddTwoStates(0, 1);
133 break;
134 default : break;
135 }
136 } while(i != startsAt);
137 }
138 else
139 {
140 int i2 = (curChar & 0xff) >> 6;
141 long l2 = 1L << (curChar & 077);
142 do
143 {
144 switch(jjstateSet[--i])
145 {
146 case 3:
147 case 0:
148 case 2:
149 if ((jjbitVec0[i2] & l2) == 0L)
150 break;
151 if (kind > 43)
152 kind = 43;
153 jjCheckNAddTwoStates(0, 1);
154 break;
155 default : break;
156 }
157 } while(i != startsAt);
158 }
159 if (kind != 0x7fffffff)
160 {
161 jjmatchedKind = kind;
162 jjmatchedPos = curPos;
163 kind = 0x7fffffff;
164 }
165 ++curPos;
166 if ((i = jjnewStateCnt) == (startsAt = 3 - (jjnewStateCnt = startsAt)))
167 return curPos;
168 try { curChar = input_stream.readChar(); }
169 catch(java.io.IOException e) { return curPos; }
170 }
171 }
172 private int jjMoveStringLiteralDfa0_4()
173 {
174 switch(curChar)
175 {
176 case 93:
177 return jjMoveStringLiteralDfa1_4(0x80000000000000L);
178 default :
179 return 1;
180 }
181 }
182 private int jjMoveStringLiteralDfa1_4(long active0)
183 {
184 try { curChar = input_stream.readChar(); }
185 catch(java.io.IOException e) {
186 return 1;
187 }
188 switch(curChar)
189 {
190 case 93:
191 return jjMoveStringLiteralDfa2_4(active0, 0x80000000000000L);
192 default :
193 return 2;
194 }
195 }
196 private int jjMoveStringLiteralDfa2_4(long old0, long active0)
197 {
198 if (((active0 &= old0)) == 0L)
199 return 2;
200 try { curChar = input_stream.readChar(); }
201 catch(java.io.IOException e) {
202 return 2;
203 }
204 switch(curChar)
205 {
206 case 62:
207 if ((active0 & 0x80000000000000L) != 0L)
208 return jjStopAtPos(2, 55);
209 break;
210 default :
211 return 3;
212 }
213 return 3;
214 }
215 private int jjMoveStringLiteralDfa0_6()
216 {
217 return jjMoveNfa_6(1, 0);
218 }
219 static final long[] jjbitVec1 = {
220 0x0L, 0x0L, 0x0L, 0xff7fffffff7fffffL
221 };
222 private int jjMoveNfa_6(int startState, int curPos)
223 {
224 int startsAt = 0;
225 jjnewStateCnt = 3;
226 int i = 1;
227 jjstateSet[0] = startState;
228 int kind = 0x7fffffff;
229 for (;;)
230 {
231 if (++jjround == 0x7fffffff)
232 ReInitRounds();
233 if (curChar < 64)
234 {
235 long l = 1L << curChar;
236 do
237 {
238 switch(jjstateSet[--i])
239 {
240 case 1:
241 if ((0x100002600L & l) != 0L)
242 {
243 if (kind > 48)
244 kind = 48;
245 jjCheckNAdd(0);
246 }
247 else if ((0x400001000000000L & l) != 0L)
248 {
249 if (kind > 49)
250 kind = 49;
251 jjCheckNAdd(2);
252 }
253 break;
254 case 0:
255 if ((0x100002600L & l) == 0L)
256 break;
257 kind = 48;
258 jjCheckNAdd(0);
259 break;
260 case 2:
261 if ((0x7ff601000000000L & l) == 0L)
262 break;
263 if (kind > 49)
264 kind = 49;
265 jjCheckNAdd(2);
266 break;
267 default : break;
268 }
269 } while(i != startsAt);
270 }
271 else if (curChar < 128)
272 {
273 long l = 1L << (curChar & 077);
274 do
275 {
276 switch(jjstateSet[--i])
277 {
278 case 1:
279 case 2:
280 if ((0x7fffffe87fffffeL & l) == 0L)
281 break;
282 if (kind > 49)
283 kind = 49;
284 jjCheckNAdd(2);
285 break;
286 default : break;
287 }
288 } while(i != startsAt);
289 }
290 else
291 {
292 int i2 = (curChar & 0xff) >> 6;
293 long l2 = 1L << (curChar & 077);
294 do
295 {
296 switch(jjstateSet[--i])
297 {
298 case 1:
299 case 2:
300 if ((jjbitVec1[i2] & l2) == 0L)
301 break;
302 if (kind > 49)
303 kind = 49;
304 jjCheckNAdd(2);
305 break;
306 default : break;
307 }
308 } while(i != startsAt);
309 }
310 if (kind != 0x7fffffff)
311 {
312 jjmatchedKind = kind;
313 jjmatchedPos = curPos;
314 kind = 0x7fffffff;
315 }
316 ++curPos;
317 if ((i = jjnewStateCnt) == (startsAt = 3 - (jjnewStateCnt = startsAt)))
318 return curPos;
319 try { curChar = input_stream.readChar(); }
320 catch(java.io.IOException e) { return curPos; }
321 }
322 }
323 private int jjMoveStringLiteralDfa0_3()
324 {
325 return jjMoveNfa_3(0, 0);
326 }
327 private int jjMoveNfa_3(int startState, int curPos)
328 {
329 int startsAt = 0;
330 jjnewStateCnt = 2;
331 int i = 1;
332 jjstateSet[0] = startState;
333 int kind = 0x7fffffff;
334 for (;;)
335 {
336 if (++jjround == 0x7fffffff)
337 ReInitRounds();
338 if (curChar < 64)
339 {
340 long l = 1L << curChar;
341 do
342 {
343 switch(jjstateSet[--i])
344 {
345 case 0:
346 if (curChar != 36)
347 break;
348 if (kind > 56)
349 kind = 56;
350 jjCheckNAdd(1);
351 break;
352 case 1:
353 if ((0x7ff601000000000L & l) == 0L)
354 break;
355 if (kind > 56)
356 kind = 56;
357 jjCheckNAdd(1);
358 break;
359 default : break;
360 }
361 } while(i != startsAt);
362 }
363 else if (curChar < 128)
364 {
365 long l = 1L << (curChar & 077);
366 do
367 {
368 switch(jjstateSet[--i])
369 {
370 case 0:
371 case 1:
372 if ((0x7fffffe87fffffeL & l) == 0L)
373 break;
374 if (kind > 56)
375 kind = 56;
376 jjCheckNAdd(1);
377 break;
378 default : break;
379 }
380 } while(i != startsAt);
381 }
382 else
383 {
384 int i2 = (curChar & 0xff) >> 6;
385 long l2 = 1L << (curChar & 077);
386 do
387 {
388 switch(jjstateSet[--i])
389 {
390 case 0:
391 case 1:
392 if ((jjbitVec1[i2] & l2) == 0L)
393 break;
394 if (kind > 56)
395 kind = 56;
396 jjCheckNAdd(1);
397 break;
398 default : break;
399 }
400 } while(i != startsAt);
401 }
402 if (kind != 0x7fffffff)
403 {
404 jjmatchedKind = kind;
405 jjmatchedPos = curPos;
406 kind = 0x7fffffff;
407 }
408 ++curPos;
409 if ((i = jjnewStateCnt) == (startsAt = 2 - (jjnewStateCnt = startsAt)))
410 return curPos;
411 try { curChar = input_stream.readChar(); }
412 catch(java.io.IOException e) { return curPos; }
413 }
414 }
415 private int jjMoveStringLiteralDfa0_0()
416 {
417 return jjMoveNfa_0(0, 0);
418 }
419 private int jjMoveNfa_0(int startState, int curPos)
420 {
421 int startsAt = 0;
422 jjnewStateCnt = 5;
423 int i = 1;
424 jjstateSet[0] = startState;
425 int kind = 0x7fffffff;
426 for (;;)
427 {
428 if (++jjround == 0x7fffffff)
429 ReInitRounds();
430 if (curChar < 64)
431 {
432 long l = 1L << curChar;
433 do
434 {
435 switch(jjstateSet[--i])
436 {
437 case 0:
438 if (curChar == 45)
439 jjAddStates(0, 1);
440 break;
441 case 1:
442 if (curChar == 45)
443 jjCheckNAddTwoStates(2, 3);
444 break;
445 case 2:
446 if (curChar == 32)
447 jjCheckNAddTwoStates(2, 3);
448 break;
449 case 3:
450 case 4:
451 if (curChar == 62 && kind > 75)
452 kind = 75;
453 break;
454 default : break;
455 }
456 } while(i != startsAt);
457 }
458 else if (curChar < 128)
459 {
460 long l = 1L << (curChar & 077);
461 do
462 {
463 switch(jjstateSet[--i])
464 {
465 default : break;
466 }
467 } while(i != startsAt);
468 }
469 else
470 {
471 int i2 = (curChar & 0xff) >> 6;
472 long l2 = 1L << (curChar & 077);
473 do
474 {
475 switch(jjstateSet[--i])
476 {
477 default : break;
478 }
479 } while(i != startsAt);
480 }
481 if (kind != 0x7fffffff)
482 {
483 jjmatchedKind = kind;
484 jjmatchedPos = curPos;
485 kind = 0x7fffffff;
486 }
487 ++curPos;
488 if ((i = jjnewStateCnt) == (startsAt = 5 - (jjnewStateCnt = startsAt)))
489 return curPos;
490 try { curChar = input_stream.readChar(); }
491 catch(java.io.IOException e) { return curPos; }
492 }
493 }
494 private final int jjStopStringLiteralDfa_2(int pos, long active0, long active1)
495 {
496 switch (pos)
497 {
498 default :
499 return -1;
500 }
501 }
502 private final int jjStartNfa_2(int pos, long active0, long active1)
503 {
504 return jjMoveNfa_2(jjStopStringLiteralDfa_2(pos, active0, active1), pos + 1);
505 }
506 private int jjMoveStringLiteralDfa0_2()
507 {
508 switch(curChar)
509 {
510 case 39:
511 return jjStopAtPos(0, 69);
512 default :
513 return jjMoveNfa_2(9, 0);
514 }
515 }
516 private int jjMoveNfa_2(int startState, int curPos)
517 {
518 int startsAt = 0;
519 jjnewStateCnt = 37;
520 int i = 1;
521 jjstateSet[0] = startState;
522 int kind = 0x7fffffff;
523 for (;;)
524 {
525 if (++jjround == 0x7fffffff)
526 ReInitRounds();
527 if (curChar < 64)
528 {
529 long l = 1L << curChar;
530 do
531 {
532 switch(jjstateSet[--i])
533 {
534 case 9:
535 if ((0xffffff67ffffffffL & l) != 0L)
536 {
537 if (kind > 70)
538 kind = 70;
539 jjCheckNAddStates(2, 4);
540 }
541 else if ((0x1800000000L & l) != 0L)
542 jjCheckNAddTwoStates(30, 36);
543 if (curChar == 60)
544 jjstateSet[jjnewStateCnt++] = 26;
545 else if (curChar == 35)
546 jjstateSet[jjnewStateCnt++] = 10;
547 else if (curChar == 36)
548 jjstateSet[jjnewStateCnt++] = 0;
549 break;
550 case 1:
551 if ((0xffffff7bffffffffL & l) != 0L)
552 jjCheckNAddStates(5, 8);
553 break;
554 case 2:
555 if (curChar == 34)
556 jjCheckNAddTwoStates(3, 4);
557 break;
558 case 3:
559 if ((0xfffffffbffffffffL & l) != 0L)
560 jjCheckNAddTwoStates(3, 4);
561 break;
562 case 4:
563 if (curChar == 34)
564 jjCheckNAddStates(5, 8);
565 break;
566 case 5:
567 if (curChar == 39)
568 jjCheckNAddTwoStates(6, 7);
569 break;
570 case 6:
571 if ((0xffffff7fffffffffL & l) != 0L)
572 jjCheckNAddTwoStates(6, 7);
573 break;
574 case 7:
575 if (curChar == 39)
576 jjCheckNAddStates(5, 8);
577 break;
578 case 11:
579 if ((0xffffff7bffffffffL & l) != 0L)
580 jjCheckNAddStates(9, 12);
581 break;
582 case 12:
583 if (curChar == 34)
584 jjCheckNAddTwoStates(13, 14);
585 break;
586 case 13:
587 if ((0xfffffffbffffffffL & l) != 0L)
588 jjCheckNAddTwoStates(13, 14);
589 break;
590 case 14:
591 if (curChar == 34)
592 jjCheckNAddStates(9, 12);
593 break;
594 case 15:
595 if (curChar == 39)
596 jjCheckNAddTwoStates(16, 17);
597 break;
598 case 16:
599 if ((0xffffff7fffffffffL & l) != 0L)
600 jjCheckNAddTwoStates(16, 17);
601 break;
602 case 17:
603 if (curChar == 39)
604 jjCheckNAddStates(9, 12);
605 break;
606 case 19:
607 if (curChar == 35)
608 jjstateSet[jjnewStateCnt++] = 10;
609 break;
610 case 20:
611 if (curChar == 61)
612 jjCheckNAddTwoStates(21, 22);
613 break;
614 case 21:
615 if ((0xffffffdfffffffffL & l) != 0L)
616 jjCheckNAddStates(13, 15);
617 break;
618 case 22:
619 if (curChar == 37)
620 jjstateSet[jjnewStateCnt++] = 23;
621 break;
622 case 23:
623 if ((0xbfffffffffffffffL & l) != 0L)
624 jjCheckNAddStates(13, 15);
625 break;
626 case 24:
627 if (curChar == 62 && kind > 68)
628 kind = 68;
629 break;
630 case 25:
631 if (curChar == 37)
632 jjstateSet[jjnewStateCnt++] = 24;
633 break;
634 case 26:
635 if (curChar == 37)
636 jjstateSet[jjnewStateCnt++] = 20;
637 break;
638 case 27:
639 if (curChar == 60)
640 jjstateSet[jjnewStateCnt++] = 26;
641 break;
642 case 28:
643 if ((0xffffff67ffffffffL & l) == 0L)
644 break;
645 if (kind > 70)
646 kind = 70;
647 jjCheckNAddStates(2, 4);
648 break;
649 case 29:
650 if ((0x1800000000L & l) != 0L)
651 jjCheckNAdd(30);
652 break;
653 case 30:
654 if ((0xffffff7fffffffffL & l) == 0L)
655 break;
656 if (kind > 70)
657 kind = 70;
658 jjCheckNAddStates(2, 4);
659 break;
660 case 33:
661 if (curChar == 35)
662 jjCheckNAdd(32);
663 break;
664 case 34:
665 if (curChar == 36)
666 jjCheckNAdd(32);
667 break;
668 case 35:
669 if ((0x1800000000L & l) != 0L)
670 jjCheckNAddTwoStates(30, 36);
671 break;
672 case 36:
673 if (curChar == 39 && kind > 71)
674 kind = 71;
675 break;
676 default : break;
677 }
678 } while(i != startsAt);
679 }
680 else if (curChar < 128)
681 {
682 long l = 1L << (curChar & 077);
683 do
684 {
685 switch(jjstateSet[--i])
686 {
687 case 9:
688 if (kind > 70)
689 kind = 70;
690 jjCheckNAddStates(2, 4);
691 if (curChar == 92)
692 jjAddStates(16, 17);
693 break;
694 case 0:
695 if (curChar == 123)
696 jjCheckNAddStates(5, 8);
697 break;
698 case 1:
699 if ((0xdfffffffffffffffL & l) != 0L)
700 jjCheckNAddStates(5, 8);
701 break;
702 case 3:
703 jjAddStates(18, 19);
704 break;
705 case 6:
706 jjAddStates(20, 21);
707 break;
708 case 8:
709 if (curChar == 125 && kind > 66)
710 kind = 66;
711 break;
712 case 10:
713 if (curChar == 123)
714 jjCheckNAddStates(9, 12);
715 break;
716 case 11:
717 if ((0xdfffffffffffffffL & l) != 0L)
718 jjCheckNAddStates(9, 12);
719 break;
720 case 13:
721 jjAddStates(22, 23);
722 break;
723 case 16:
724 jjAddStates(24, 25);
725 break;
726 case 18:
727 if (curChar == 125 && kind > 67)
728 kind = 67;
729 break;
730 case 21:
731 case 23:
732 jjCheckNAddStates(13, 15);
733 break;
734 case 28:
735 if (kind > 70)
736 kind = 70;
737 jjCheckNAddStates(2, 4);
738 break;
739 case 30:
740 if ((0xf7ffffffffffffffL & l) == 0L)
741 break;
742 if (kind > 70)
743 kind = 70;
744 jjCheckNAddStates(2, 4);
745 break;
746 case 31:
747 if (curChar == 92)
748 jjAddStates(16, 17);
749 break;
750 case 32:
751 if (curChar != 123)
752 break;
753 if (kind > 70)
754 kind = 70;
755 jjCheckNAddStates(2, 4);
756 break;
757 default : break;
758 }
759 } while(i != startsAt);
760 }
761 else
762 {
763 int i2 = (curChar & 0xff) >> 6;
764 long l2 = 1L << (curChar & 077);
765 do
766 {
767 switch(jjstateSet[--i])
768 {
769 case 9:
770 case 28:
771 case 30:
772 if ((jjbitVec0[i2] & l2) == 0L)
773 break;
774 if (kind > 70)
775 kind = 70;
776 jjCheckNAddStates(2, 4);
777 break;
778 case 1:
779 if ((jjbitVec0[i2] & l2) != 0L)
780 jjAddStates(5, 8);
781 break;
782 case 3:
783 if ((jjbitVec0[i2] & l2) != 0L)
784 jjAddStates(18, 19);
785 break;
786 case 6:
787 if ((jjbitVec0[i2] & l2) != 0L)
788 jjAddStates(20, 21);
789 break;
790 case 11:
791 if ((jjbitVec0[i2] & l2) != 0L)
792 jjAddStates(9, 12);
793 break;
794 case 13:
795 if ((jjbitVec0[i2] & l2) != 0L)
796 jjAddStates(22, 23);
797 break;
798 case 16:
799 if ((jjbitVec0[i2] & l2) != 0L)
800 jjAddStates(24, 25);
801 break;
802 case 21:
803 case 23:
804 if ((jjbitVec0[i2] & l2) != 0L)
805 jjCheckNAddStates(13, 15);
806 break;
807 default : break;
808 }
809 } while(i != startsAt);
810 }
811 if (kind != 0x7fffffff)
812 {
813 jjmatchedKind = kind;
814 jjmatchedPos = curPos;
815 kind = 0x7fffffff;
816 }
817 ++curPos;
818 if ((i = jjnewStateCnt) == (startsAt = 37 - (jjnewStateCnt = startsAt)))
819 return curPos;
820 try { curChar = input_stream.readChar(); }
821 catch(java.io.IOException e) { return curPos; }
822 }
823 }
824 private final int jjStopStringLiteralDfa_7(int pos, long active0)
825 {
826 switch (pos)
827 {
828 case 0:
829 if ((active0 & 0x400000000000L) != 0L)
830 return 3;
831 return -1;
832 case 1:
833 if ((active0 & 0x400000000000L) != 0L)
834 return 4;
835 return -1;
836 case 2:
837 if ((active0 & 0x400000000000L) != 0L)
838 return 6;
839 return -1;
840 default :
841 return -1;
842 }
843 }
844 private final int jjStartNfa_7(int pos, long active0)
845 {
846 return jjMoveNfa_7(jjStopStringLiteralDfa_7(pos, active0), pos + 1);
847 }
848 private int jjMoveStringLiteralDfa0_7()
849 {
850 switch(curChar)
851 {
852 case 45:
853 return jjMoveStringLiteralDfa1_7(0x400000000000L);
854 default :
855 return jjMoveNfa_7(8, 0);
856 }
857 }
858 private int jjMoveStringLiteralDfa1_7(long active0)
859 {
860 try { curChar = input_stream.readChar(); }
861 catch(java.io.IOException e) {
862 jjStopStringLiteralDfa_7(0, active0);
863 return 1;
864 }
865 switch(curChar)
866 {
867 case 45:
868 return jjMoveStringLiteralDfa2_7(active0, 0x400000000000L);
869 default :
870 break;
871 }
872 return jjStartNfa_7(0, active0);
873 }
874 private int jjMoveStringLiteralDfa2_7(long old0, long active0)
875 {
876 if (((active0 &= old0)) == 0L)
877 return jjStartNfa_7(0, old0);
878 try { curChar = input_stream.readChar(); }
879 catch(java.io.IOException e) {
880 jjStopStringLiteralDfa_7(1, active0);
881 return 2;
882 }
883 switch(curChar)
884 {
885 case 37:
886 return jjMoveStringLiteralDfa3_7(active0, 0x400000000000L);
887 default :
888 break;
889 }
890 return jjStartNfa_7(1, active0);
891 }
892 private int jjMoveStringLiteralDfa3_7(long old0, long active0)
893 {
894 if (((active0 &= old0)) == 0L)
895 return jjStartNfa_7(1, old0);
896 try { curChar = input_stream.readChar(); }
897 catch(java.io.IOException e) {
898 jjStopStringLiteralDfa_7(2, active0);
899 return 3;
900 }
901 switch(curChar)
902 {
903 case 62:
904 if ((active0 & 0x400000000000L) != 0L)
905 return jjStopAtPos(3, 46);
906 break;
907 default :
908 break;
909 }
910 return jjStartNfa_7(2, active0);
911 }
912 private int jjMoveNfa_7(int startState, int curPos)
913 {
914 int startsAt = 0;
915 jjnewStateCnt = 8;
916 int i = 1;
917 jjstateSet[0] = startState;
918 int kind = 0x7fffffff;
919 for (;;)
920 {
921 if (++jjround == 0x7fffffff)
922 ReInitRounds();
923 if (curChar < 64)
924 {
925 long l = 1L << curChar;
926 do
927 {
928 switch(jjstateSet[--i])
929 {
930 case 4:
931 if ((0xffffffdfffffffffL & l) != 0L)
932 {
933 if (kind > 47)
934 kind = 47;
935 jjCheckNAddStates(26, 28);
936 }
937 else if (curChar == 37)
938 jjstateSet[jjnewStateCnt++] = 6;
939 break;
940 case 3:
941 if ((0xffffdfffffffffffL & l) != 0L)
942 {
943 if (kind > 47)
944 kind = 47;
945 jjCheckNAddStates(26, 28);
946 }
947 else if (curChar == 45)
948 jjstateSet[jjnewStateCnt++] = 5;
949 if (curChar == 45)
950 jjstateSet[jjnewStateCnt++] = 4;
951 break;
952 case 8:
953 if ((0xffffdfffffffffffL & l) != 0L)
954 {
955 if (kind > 47)
956 kind = 47;
957 jjCheckNAddStates(26, 28);
958 }
959 else if (curChar == 45)
960 jjAddStates(29, 30);
961 if (curChar == 45)
962 jjCheckNAdd(0);
963 break;
964 case 0:
965 if ((0xffffdfffffffffffL & l) == 0L)
966 break;
967 if (kind > 47)
968 kind = 47;
969 jjCheckNAddStates(26, 28);
970 break;
971 case 1:
972 if (curChar == 45)
973 jjCheckNAdd(0);
974 break;
975 case 2:
976 if (curChar == 45)
977 jjAddStates(29, 30);
978 break;
979 case 5:
980 if (curChar == 37)
981 jjstateSet[jjnewStateCnt++] = 6;
982 break;
983 case 6:
984 if ((0xbfffffffffffffffL & l) == 0L)
985 break;
986 if (kind > 47)
987 kind = 47;
988 jjCheckNAddStates(26, 28);
989 break;
990 case 7:
991 if (curChar == 45)
992 jjstateSet[jjnewStateCnt++] = 5;
993 break;
994 default : break;
995 }
996 } while(i != startsAt);
997 }
998 else if (curChar < 128)
999 {
1000 long l = 1L << (curChar & 077);
1001 do
1002 {
1003 switch(jjstateSet[--i])
1004 {
1005 case 4:
1006 case 6:
1007 if (kind > 47)
1008 kind = 47;
1009 jjCheckNAddStates(26, 28);
1010 break;
1011 case 3:
1012 case 0:
1013 if (kind > 47)
1014 kind = 47;
1015 jjCheckNAddStates(26, 28);
1016 break;
1017 case 8:
1018 if (kind > 47)
1019 kind = 47;
1020 jjCheckNAddStates(26, 28);
1021 break;
1022 default : break;
1023 }
1024 } while(i != startsAt);
1025 }
1026 else
1027 {
1028 int i2 = (curChar & 0xff) >> 6;
1029 long l2 = 1L << (curChar & 077);
1030 do
1031 {
1032 switch(jjstateSet[--i])
1033 {
1034 case 4:
1035 case 6:
1036 if ((jjbitVec0[i2] & l2) == 0L)
1037 break;
1038 if (kind > 47)
1039 kind = 47;
1040 jjCheckNAddStates(26, 28);
1041 break;
1042 case 3:
1043 case 0:
1044 if ((jjbitVec0[i2] & l2) == 0L)
1045 break;
1046 if (kind > 47)
1047 kind = 47;
1048 jjCheckNAddStates(26, 28);
1049 break;
1050 case 8:
1051 if ((jjbitVec0[i2] & l2) == 0L)
1052 break;
1053 if (kind > 47)
1054 kind = 47;
1055 jjCheckNAddStates(26, 28);
1056 break;
1057 default : break;
1058 }
1059 } while(i != startsAt);
1060 }
1061 if (kind != 0x7fffffff)
1062 {
1063 jjmatchedKind = kind;
1064 jjmatchedPos = curPos;
1065 kind = 0x7fffffff;
1066 }
1067 ++curPos;
1068 if ((i = jjnewStateCnt) == (startsAt = 8 - (jjnewStateCnt = startsAt)))
1069 return curPos;
1070 try { curChar = input_stream.readChar(); }
1071 catch(java.io.IOException e) { return curPos; }
1072 }
1073 }
1074 private final int jjStopStringLiteralDfa_13(int pos, long active0, long active1)
1075 {
1076 switch (pos)
1077 {
1078 default :
1079 return -1;
1080 }
1081 }
1082 private final int jjStartNfa_13(int pos, long active0, long active1)
1083 {
1084 return jjMoveNfa_13(jjStopStringLiteralDfa_13(pos, active0, active1), pos + 1);
1085 }
1086 private int jjMoveStringLiteralDfa0_13()
1087 {
1088 switch(curChar)
1089 {
1090 case 34:
1091 return jjStopAtPos(0, 65);
1092 case 39:
1093 return jjStopAtPos(0, 64);
1094 default :
1095 return jjMoveNfa_13(0, 0);
1096 }
1097 }
1098 private int jjMoveNfa_13(int startState, int curPos)
1099 {
1100 int startsAt = 0;
1101 jjnewStateCnt = 1;
1102 int i = 1;
1103 jjstateSet[0] = startState;
1104 int kind = 0x7fffffff;
1105 for (;;)
1106 {
1107 if (++jjround == 0x7fffffff)
1108 ReInitRounds();
1109 if (curChar < 64)
1110 {
1111 long l = 1L << curChar;
1112 do
1113 {
1114 switch(jjstateSet[--i])
1115 {
1116 case 0:
1117 if ((0x100002600L & l) == 0L)
1118 break;
1119 kind = 21;
1120 jjstateSet[jjnewStateCnt++] = 0;
1121 break;
1122 default : break;
1123 }
1124 } while(i != startsAt);
1125 }
1126 else if (curChar < 128)
1127 {
1128 long l = 1L << (curChar & 077);
1129 do
1130 {
1131 switch(jjstateSet[--i])
1132 {
1133 default : break;
1134 }
1135 } while(i != startsAt);
1136 }
1137 else
1138 {
1139 int i2 = (curChar & 0xff) >> 6;
1140 long l2 = 1L << (curChar & 077);
1141 do
1142 {
1143 switch(jjstateSet[--i])
1144 {
1145 default : break;
1146 }
1147 } while(i != startsAt);
1148 }
1149 if (kind != 0x7fffffff)
1150 {
1151 jjmatchedKind = kind;
1152 jjmatchedPos = curPos;
1153 kind = 0x7fffffff;
1154 }
1155 ++curPos;
1156 if ((i = jjnewStateCnt) == (startsAt = 1 - (jjnewStateCnt = startsAt)))
1157 return curPos;
1158 try { curChar = input_stream.readChar(); }
1159 catch(java.io.IOException e) { return curPos; }
1160 }
1161 }
1162 private final int jjStopStringLiteralDfa_16(int pos, long active0)
1163 {
1164 switch (pos)
1165 {
1166 default :
1167 return -1;
1168 }
1169 }
1170 private final int jjStartNfa_16(int pos, long active0)
1171 {
1172 return jjMoveNfa_16(jjStopStringLiteralDfa_16(pos, active0), pos + 1);
1173 }
1174 private int jjMoveStringLiteralDfa0_16()
1175 {
1176 switch(curChar)
1177 {
1178 case 60:
1179 jjmatchedKind = 22;
1180 return jjMoveStringLiteralDfa1_16(0x1ff800000L);
1181 default :
1182 return jjMoveNfa_16(0, 0);
1183 }
1184 }
1185 private int jjMoveStringLiteralDfa1_16(long active0)
1186 {
1187 try { curChar = input_stream.readChar(); }
1188 catch(java.io.IOException e) {
1189 jjStopStringLiteralDfa_16(0, active0);
1190 return 1;
1191 }
1192 switch(curChar)
1193 {
1194 case 33:
1195 return jjMoveStringLiteralDfa2_16(active0, 0xd000000L);
1196 case 37:
1197 if ((active0 & 0x80000000L) != 0L)
1198 {
1199 jjmatchedKind = 31;
1200 jjmatchedPos = 1;
1201 }
1202 return jjMoveStringLiteralDfa2_16(active0, 0x170000000L);
1203 case 47:
1204 if ((active0 & 0x800000L) != 0L)
1205 return jjStopAtPos(1, 23);
1206 break;
1207 case 63:
1208 if ((active0 & 0x2000000L) != 0L)
1209 return jjStopAtPos(1, 25);
1210 break;
1211 default :
1212 break;
1213 }
1214 return jjStartNfa_16(0, active0);
1215 }
1216 private int jjMoveStringLiteralDfa2_16(long old0, long active0)
1217 {
1218 if (((active0 &= old0)) == 0L)
1219 return jjStartNfa_16(0, old0);
1220 try { curChar = input_stream.readChar(); }
1221 catch(java.io.IOException e) {
1222 jjStopStringLiteralDfa_16(1, active0);
1223 return 2;
1224 }
1225 switch(curChar)
1226 {
1227 case 33:
1228 if ((active0 & 0x20000000L) != 0L)
1229 return jjStopAtPos(2, 29);
1230 break;
1231 case 45:
1232 return jjMoveStringLiteralDfa3_16(active0, 0x11000000L);
1233 case 61:
1234 if ((active0 & 0x40000000L) != 0L)
1235 return jjStopAtPos(2, 30);
1236 break;
1237 case 64:
1238 if ((active0 & 0x100000000L) != 0L)
1239 return jjStopAtPos(2, 32);
1240 break;
1241 case 91:
1242 return jjMoveStringLiteralDfa3_16(active0, 0x8000000L);
1243 case 68:
1244 case 100:
1245 return jjMoveStringLiteralDfa3_16(active0, 0x4000000L);
1246 default :
1247 break;
1248 }
1249 return jjStartNfa_16(1, active0);
1250 }
1251 private int jjMoveStringLiteralDfa3_16(long old0, long active0)
1252 {
1253 if (((active0 &= old0)) == 0L)
1254 return jjStartNfa_16(1, old0);
1255 try { curChar = input_stream.readChar(); }
1256 catch(java.io.IOException e) {
1257 jjStopStringLiteralDfa_16(2, active0);
1258 return 3;
1259 }
1260 switch(curChar)
1261 {
1262 case 45:
1263 if ((active0 & 0x1000000L) != 0L)
1264 return jjStopAtPos(3, 24);
1265 else if ((active0 & 0x10000000L) != 0L)
1266 return jjStopAtPos(3, 28);
1267 break;
1268 case 67:
1269 case 99:
1270 return jjMoveStringLiteralDfa4_16(active0, 0x8000000L);
1271 case 79:
1272 case 111:
1273 return jjMoveStringLiteralDfa4_16(active0, 0x4000000L);
1274 default :
1275 break;
1276 }
1277 return jjStartNfa_16(2, active0);
1278 }
1279 private int jjMoveStringLiteralDfa4_16(long old0, long active0)
1280 {
1281 if (((active0 &= old0)) == 0L)
1282 return jjStartNfa_16(2, old0);
1283 try { curChar = input_stream.readChar(); }
1284 catch(java.io.IOException e) {
1285 jjStopStringLiteralDfa_16(3, active0);
1286 return 4;
1287 }
1288 switch(curChar)
1289 {
1290 case 67:
1291 case 99:
1292 return jjMoveStringLiteralDfa5_16(active0, 0x4000000L);
1293 case 68:
1294 case 100:
1295 return jjMoveStringLiteralDfa5_16(active0, 0x8000000L);
1296 default :
1297 break;
1298 }
1299 return jjStartNfa_16(3, active0);
1300 }
1301 private int jjMoveStringLiteralDfa5_16(long old0, long active0)
1302 {
1303 if (((active0 &= old0)) == 0L)
1304 return jjStartNfa_16(3, old0);
1305 try { curChar = input_stream.readChar(); }
1306 catch(java.io.IOException e) {
1307 jjStopStringLiteralDfa_16(4, active0);
1308 return 5;
1309 }
1310 switch(curChar)
1311 {
1312 case 65:
1313 case 97:
1314 return jjMoveStringLiteralDfa6_16(active0, 0x8000000L);
1315 case 84:
1316 case 116:
1317 return jjMoveStringLiteralDfa6_16(active0, 0x4000000L);
1318 default :
1319 break;
1320 }
1321 return jjStartNfa_16(4, active0);
1322 }
1323 private int jjMoveStringLiteralDfa6_16(long old0, long active0)
1324 {
1325 if (((active0 &= old0)) == 0L)
1326 return jjStartNfa_16(4, old0);
1327 try { curChar = input_stream.readChar(); }
1328 catch(java.io.IOException e) {
1329 jjStopStringLiteralDfa_16(5, active0);
1330 return 6;
1331 }
1332 switch(curChar)
1333 {
1334 case 84:
1335 case 116:
1336 return jjMoveStringLiteralDfa7_16(active0, 0x8000000L);
1337 case 89:
1338 case 121:
1339 return jjMoveStringLiteralDfa7_16(active0, 0x4000000L);
1340 default :
1341 break;
1342 }
1343 return jjStartNfa_16(5, active0);
1344 }
1345 private int jjMoveStringLiteralDfa7_16(long old0, long active0)
1346 {
1347 if (((active0 &= old0)) == 0L)
1348 return jjStartNfa_16(5, old0);
1349 try { curChar = input_stream.readChar(); }
1350 catch(java.io.IOException e) {
1351 jjStopStringLiteralDfa_16(6, active0);
1352 return 7;
1353 }
1354 switch(curChar)
1355 {
1356 case 65:
1357 case 97:
1358 return jjMoveStringLiteralDfa8_16(active0, 0x8000000L);
1359 case 80:
1360 case 112:
1361 return jjMoveStringLiteralDfa8_16(active0, 0x4000000L);
1362 default :
1363 break;
1364 }
1365 return jjStartNfa_16(6, active0);
1366 }
1367 private int jjMoveStringLiteralDfa8_16(long old0, long active0)
1368 {
1369 if (((active0 &= old0)) == 0L)
1370 return jjStartNfa_16(6, old0);
1371 try { curChar = input_stream.readChar(); }
1372 catch(java.io.IOException e) {
1373 jjStopStringLiteralDfa_16(7, active0);
1374 return 8;
1375 }
1376 switch(curChar)
1377 {
1378 case 91:
1379 if ((active0 & 0x8000000L) != 0L)
1380 return jjStopAtPos(8, 27);
1381 break;
1382 case 69:
1383 case 101:
1384 if ((active0 & 0x4000000L) != 0L)
1385 return jjStopAtPos(8, 26);
1386 break;
1387 default :
1388 break;
1389 }
1390 return jjStartNfa_16(7, active0);
1391 }
1392 private int jjMoveNfa_16(int startState, int curPos)
1393 {
1394 int startsAt = 0;
1395 jjnewStateCnt = 1;
1396 int i = 1;
1397 jjstateSet[0] = startState;
1398 int kind = 0x7fffffff;
1399 for (;;)
1400 {
1401 if (++jjround == 0x7fffffff)
1402 ReInitRounds();
1403 if (curChar < 64)
1404 {
1405 long l = 1L << curChar;
1406 do
1407 {
1408 switch(jjstateSet[--i])
1409 {
1410 case 0:
1411 if ((0x100002600L & l) == 0L)
1412 break;
1413 kind = 20;
1414 jjstateSet[jjnewStateCnt++] = 0;
1415 break;
1416 default : break;
1417 }
1418 } while(i != startsAt);
1419 }
1420 else if (curChar < 128)
1421 {
1422 long l = 1L << (curChar & 077);
1423 do
1424 {
1425 switch(jjstateSet[--i])
1426 {
1427 default : break;
1428 }
1429 } while(i != startsAt);
1430 }
1431 else
1432 {
1433 int i2 = (curChar & 0xff) >> 6;
1434 long l2 = 1L << (curChar & 077);
1435 do
1436 {
1437 switch(jjstateSet[--i])
1438 {
1439 default : break;
1440 }
1441 } while(i != startsAt);
1442 }
1443 if (kind != 0x7fffffff)
1444 {
1445 jjmatchedKind = kind;
1446 jjmatchedPos = curPos;
1447 kind = 0x7fffffff;
1448 }
1449 ++curPos;
1450 if ((i = jjnewStateCnt) == (startsAt = 1 - (jjnewStateCnt = startsAt)))
1451 return curPos;
1452 try { curChar = input_stream.readChar(); }
1453 catch(java.io.IOException e) { return curPos; }
1454 }
1455 }
1456 private final int jjStopStringLiteralDfa_12(int pos, long active0)
1457 {
1458 switch (pos)
1459 {
1460 default :
1461 return -1;
1462 }
1463 }
1464 private final int jjStartNfa_12(int pos, long active0)
1465 {
1466 return jjMoveNfa_12(jjStopStringLiteralDfa_12(pos, active0), pos + 1);
1467 }
1468 private int jjMoveStringLiteralDfa0_12()
1469 {
1470 switch(curChar)
1471 {
1472 case 60:
1473 jjmatchedKind = 22;
1474 return jjMoveStringLiteralDfa1_12(0x1ff800000L);
1475 default :
1476 return jjMoveNfa_12(10, 0);
1477 }
1478 }
1479 private int jjMoveStringLiteralDfa1_12(long active0)
1480 {
1481 try { curChar = input_stream.readChar(); }
1482 catch(java.io.IOException e) {
1483 jjStopStringLiteralDfa_12(0, active0);
1484 return 1;
1485 }
1486 switch(curChar)
1487 {
1488 case 33:
1489 return jjMoveStringLiteralDfa2_12(active0, 0xd000000L);
1490 case 37:
1491 if ((active0 & 0x80000000L) != 0L)
1492 {
1493 jjmatchedKind = 31;
1494 jjmatchedPos = 1;
1495 }
1496 return jjMoveStringLiteralDfa2_12(active0, 0x170000000L);
1497 case 47:
1498 if ((active0 & 0x800000L) != 0L)
1499 return jjStopAtPos(1, 23);
1500 break;
1501 case 63:
1502 if ((active0 & 0x2000000L) != 0L)
1503 return jjStopAtPos(1, 25);
1504 break;
1505 default :
1506 break;
1507 }
1508 return jjStartNfa_12(0, active0);
1509 }
1510 private int jjMoveStringLiteralDfa2_12(long old0, long active0)
1511 {
1512 if (((active0 &= old0)) == 0L)
1513 return jjStartNfa_12(0, old0);
1514 try { curChar = input_stream.readChar(); }
1515 catch(java.io.IOException e) {
1516 jjStopStringLiteralDfa_12(1, active0);
1517 return 2;
1518 }
1519 switch(curChar)
1520 {
1521 case 33:
1522 if ((active0 & 0x20000000L) != 0L)
1523 return jjStopAtPos(2, 29);
1524 break;
1525 case 45:
1526 return jjMoveStringLiteralDfa3_12(active0, 0x11000000L);
1527 case 61:
1528 if ((active0 & 0x40000000L) != 0L)
1529 return jjStopAtPos(2, 30);
1530 break;
1531 case 64:
1532 if ((active0 & 0x100000000L) != 0L)
1533 return jjStopAtPos(2, 32);
1534 break;
1535 case 91:
1536 return jjMoveStringLiteralDfa3_12(active0, 0x8000000L);
1537 case 68:
1538 case 100:
1539 return jjMoveStringLiteralDfa3_12(active0, 0x4000000L);
1540 default :
1541 break;
1542 }
1543 return jjStartNfa_12(1, active0);
1544 }
1545 private int jjMoveStringLiteralDfa3_12(long old0, long active0)
1546 {
1547 if (((active0 &= old0)) == 0L)
1548 return jjStartNfa_12(1, old0);
1549 try { curChar = input_stream.readChar(); }
1550 catch(java.io.IOException e) {
1551 jjStopStringLiteralDfa_12(2, active0);
1552 return 3;
1553 }
1554 switch(curChar)
1555 {
1556 case 45:
1557 if ((active0 & 0x1000000L) != 0L)
1558 return jjStopAtPos(3, 24);
1559 else if ((active0 & 0x10000000L) != 0L)
1560 return jjStopAtPos(3, 28);
1561 break;
1562 case 67:
1563 case 99:
1564 return jjMoveStringLiteralDfa4_12(active0, 0x8000000L);
1565 case 79:
1566 case 111:
1567 return jjMoveStringLiteralDfa4_12(active0, 0x4000000L);
1568 default :
1569 break;
1570 }
1571 return jjStartNfa_12(2, active0);
1572 }
1573 private int jjMoveStringLiteralDfa4_12(long old0, long active0)
1574 {
1575 if (((active0 &= old0)) == 0L)
1576 return jjStartNfa_12(2, old0);
1577 try { curChar = input_stream.readChar(); }
1578 catch(java.io.IOException e) {
1579 jjStopStringLiteralDfa_12(3, active0);
1580 return 4;
1581 }
1582 switch(curChar)
1583 {
1584 case 67:
1585 case 99:
1586 return jjMoveStringLiteralDfa5_12(active0, 0x4000000L);
1587 case 68:
1588 case 100:
1589 return jjMoveStringLiteralDfa5_12(active0, 0x8000000L);
1590 default :
1591 break;
1592 }
1593 return jjStartNfa_12(3, active0);
1594 }
1595 private int jjMoveStringLiteralDfa5_12(long old0, long active0)
1596 {
1597 if (((active0 &= old0)) == 0L)
1598 return jjStartNfa_12(3, old0);
1599 try { curChar = input_stream.readChar(); }
1600 catch(java.io.IOException e) {
1601 jjStopStringLiteralDfa_12(4, active0);
1602 return 5;
1603 }
1604 switch(curChar)
1605 {
1606 case 65:
1607 case 97:
1608 return jjMoveStringLiteralDfa6_12(active0, 0x8000000L);
1609 case 84:
1610 case 116:
1611 return jjMoveStringLiteralDfa6_12(active0, 0x4000000L);
1612 default :
1613 break;
1614 }
1615 return jjStartNfa_12(4, active0);
1616 }
1617 private int jjMoveStringLiteralDfa6_12(long old0, long active0)
1618 {
1619 if (((active0 &= old0)) == 0L)
1620 return jjStartNfa_12(4, old0);
1621 try { curChar = input_stream.readChar(); }
1622 catch(java.io.IOException e) {
1623 jjStopStringLiteralDfa_12(5, active0);
1624 return 6;
1625 }
1626 switch(curChar)
1627 {
1628 case 84:
1629 case 116:
1630 return jjMoveStringLiteralDfa7_12(active0, 0x8000000L);
1631 case 89:
1632 case 121:
1633 return jjMoveStringLiteralDfa7_12(active0, 0x4000000L);
1634 default :
1635 break;
1636 }
1637 return jjStartNfa_12(5, active0);
1638 }
1639 private int jjMoveStringLiteralDfa7_12(long old0, long active0)
1640 {
1641 if (((active0 &= old0)) == 0L)
1642 return jjStartNfa_12(5, old0);
1643 try { curChar = input_stream.readChar(); }
1644 catch(java.io.IOException e) {
1645 jjStopStringLiteralDfa_12(6, active0);
1646 return 7;
1647 }
1648 switch(curChar)
1649 {
1650 case 65:
1651 case 97:
1652 return jjMoveStringLiteralDfa8_12(active0, 0x8000000L);
1653 case 80:
1654 case 112:
1655 return jjMoveStringLiteralDfa8_12(active0, 0x4000000L);
1656 default :
1657 break;
1658 }
1659 return jjStartNfa_12(6, active0);
1660 }
1661 private int jjMoveStringLiteralDfa8_12(long old0, long active0)
1662 {
1663 if (((active0 &= old0)) == 0L)
1664 return jjStartNfa_12(6, old0);
1665 try { curChar = input_stream.readChar(); }
1666 catch(java.io.IOException e) {
1667 jjStopStringLiteralDfa_12(7, active0);
1668 return 8;
1669 }
1670 switch(curChar)
1671 {
1672 case 91:
1673 if ((active0 & 0x8000000L) != 0L)
1674 return jjStopAtPos(8, 27);
1675 break;
1676 case 69:
1677 case 101:
1678 if ((active0 & 0x4000000L) != 0L)
1679 return jjStopAtPos(8, 26);
1680 break;
1681 default :
1682 break;
1683 }
1684 return jjStartNfa_12(7, active0);
1685 }
1686 private int jjMoveNfa_12(int startState, int curPos)
1687 {
1688 int startsAt = 0;
1689 jjnewStateCnt = 18;
1690 int i = 1;
1691 jjstateSet[0] = startState;
1692 int kind = 0x7fffffff;
1693 for (;;)
1694 {
1695 if (++jjround == 0x7fffffff)
1696 ReInitRounds();
1697 if (curChar < 64)
1698 {
1699 long l = 1L << curChar;
1700 do
1701 {
1702 switch(jjstateSet[--i])
1703 {
1704 case 10:
1705 if ((0xefffffefffffffffL & l) != 0L)
1706 {
1707 if (kind > 34)
1708 kind = 34;
1709 jjCheckNAddStates(31, 33);
1710 }
1711 else if (curChar == 36)
1712 jjstateSet[jjnewStateCnt++] = 13;
1713 if ((0x100002600L & l) != 0L)
1714 {
1715 if (kind > 21)
1716 kind = 21;
1717 jjCheckNAdd(0);
1718 }
1719 else if (curChar == 36)
1720 jjstateSet[jjnewStateCnt++] = 1;
1721 break;
1722 case 0:
1723 if ((0x100002600L & l) == 0L)
1724 break;
1725 if (kind > 21)
1726 kind = 21;
1727 jjCheckNAdd(0);
1728 break;
1729 case 2:
1730 if ((0xffffff7bffffffffL & l) != 0L)
1731 jjCheckNAddStates(34, 37);
1732 break;
1733 case 3:
1734 if (curChar == 34)
1735 jjCheckNAddTwoStates(4, 5);
1736 break;
1737 case 4:
1738 if ((0xfffffffbffffffffL & l) != 0L)
1739 jjCheckNAddTwoStates(4, 5);
1740 break;
1741 case 5:
1742 if (curChar == 34)
1743 jjCheckNAddStates(34, 37);
1744 break;
1745 case 6:
1746 if (curChar == 39)
1747 jjCheckNAddTwoStates(7, 8);
1748 break;
1749 case 7:
1750 if ((0xffffff7fffffffffL & l) != 0L)
1751 jjCheckNAddTwoStates(7, 8);
1752 break;
1753 case 8:
1754 if (curChar == 39)
1755 jjCheckNAddStates(34, 37);
1756 break;
1757 case 11:
1758 if ((0xefffffefffffffffL & l) == 0L)
1759 break;
1760 if (kind > 34)
1761 kind = 34;
1762 jjCheckNAddStates(31, 33);
1763 break;
1764 case 12:
1765 if (curChar == 36)
1766 jjstateSet[jjnewStateCnt++] = 13;
1767 break;
1768 case 13:
1769 if ((0xefffffffffffffffL & l) == 0L)
1770 break;
1771 if (kind > 34)
1772 kind = 34;
1773 jjCheckNAddStates(31, 33);
1774 break;
1775 case 16:
1776 if (curChar == 35)
1777 jjCheckNAdd(15);
1778 break;
1779 case 17:
1780 if (curChar == 36)
1781 jjCheckNAdd(15);
1782 break;
1783 default : break;
1784 }
1785 } while(i != startsAt);
1786 }
1787 else if (curChar < 128)
1788 {
1789 long l = 1L << (curChar & 077);
1790 do
1791 {
1792 switch(jjstateSet[--i])
1793 {
1794 case 10:
1795 if (kind > 34)
1796 kind = 34;
1797 jjCheckNAddStates(31, 33);
1798 if (curChar == 92)
1799 jjAddStates(24, 25);
1800 break;
1801 case 1:
1802 if (curChar == 123)
1803 jjCheckNAddStates(34, 37);
1804 break;
1805 case 2:
1806 if ((0xdfffffffffffffffL & l) != 0L)
1807 jjCheckNAddStates(34, 37);
1808 break;
1809 case 4:
1810 jjAddStates(38, 39);
1811 break;
1812 case 7:
1813 jjAddStates(40, 41);
1814 break;
1815 case 9:
1816 if (curChar == 125 && kind > 33)
1817 kind = 33;
1818 break;
1819 case 11:
1820 if (kind > 34)
1821 kind = 34;
1822 jjCheckNAddStates(31, 33);
1823 break;
1824 case 13:
1825 if ((0xf7ffffffffffffffL & l) == 0L)
1826 break;
1827 if (kind > 34)
1828 kind = 34;
1829 jjCheckNAddStates(31, 33);
1830 break;
1831 case 14:
1832 if (curChar == 92)
1833 jjAddStates(24, 25);
1834 break;
1835 case 15:
1836 if (curChar != 123)
1837 break;
1838 if (kind > 34)
1839 kind = 34;
1840 jjCheckNAddStates(31, 33);
1841 break;
1842 default : break;
1843 }
1844 } while(i != startsAt);
1845 }
1846 else
1847 {
1848 int i2 = (curChar & 0xff) >> 6;
1849 long l2 = 1L << (curChar & 077);
1850 do
1851 {
1852 switch(jjstateSet[--i])
1853 {
1854 case 10:
1855 case 11:
1856 case 13:
1857 if ((jjbitVec0[i2] & l2) == 0L)
1858 break;
1859 if (kind > 34)
1860 kind = 34;
1861 jjCheckNAddStates(31, 33);
1862 break;
1863 case 2:
1864 if ((jjbitVec0[i2] & l2) != 0L)
1865 jjAddStates(34, 37);
1866 break;
1867 case 4:
1868 if ((jjbitVec0[i2] & l2) != 0L)
1869 jjAddStates(38, 39);
1870 break;
1871 case 7:
1872 if ((jjbitVec0[i2] & l2) != 0L)
1873 jjAddStates(40, 41);
1874 break;
1875 default : break;
1876 }
1877 } while(i != startsAt);
1878 }
1879 if (kind != 0x7fffffff)
1880 {
1881 jjmatchedKind = kind;
1882 jjmatchedPos = curPos;
1883 kind = 0x7fffffff;
1884 }
1885 ++curPos;
1886 if ((i = jjnewStateCnt) == (startsAt = 18 - (jjnewStateCnt = startsAt)))
1887 return curPos;
1888 try { curChar = input_stream.readChar(); }
1889 catch(java.io.IOException e) { return curPos; }
1890 }
1891 }
1892 private final int jjStopStringLiteralDfa_8(int pos, long active0)
1893 {
1894 switch (pos)
1895 {
1896 case 0:
1897 if ((active0 & 0x100000000000L) != 0L)
1898 return 2;
1899 return -1;
1900 default :
1901 return -1;
1902 }
1903 }
1904 private final int jjStartNfa_8(int pos, long active0)
1905 {
1906 return jjMoveNfa_8(jjStopStringLiteralDfa_8(pos, active0), pos + 1);
1907 }
1908 private int jjMoveStringLiteralDfa0_8()
1909 {
1910 switch(curChar)
1911 {
1912 case 37:
1913 return jjMoveStringLiteralDfa1_8(0x100000000000L);
1914 default :
1915 return jjMoveNfa_8(3, 0);
1916 }
1917 }
1918 private int jjMoveStringLiteralDfa1_8(long active0)
1919 {
1920 try { curChar = input_stream.readChar(); }
1921 catch(java.io.IOException e) {
1922 jjStopStringLiteralDfa_8(0, active0);
1923 return 1;
1924 }
1925 switch(curChar)
1926 {
1927 case 62:
1928 if ((active0 & 0x100000000000L) != 0L)
1929 return jjStopAtPos(1, 44);
1930 break;
1931 default :
1932 break;
1933 }
1934 return jjStartNfa_8(0, active0);
1935 }
1936 private int jjMoveNfa_8(int startState, int curPos)
1937 {
1938 int startsAt = 0;
1939 jjnewStateCnt = 3;
1940 int i = 1;
1941 jjstateSet[0] = startState;
1942 int kind = 0x7fffffff;
1943 for (;;)
1944 {
1945 if (++jjround == 0x7fffffff)
1946 ReInitRounds();
1947 if (curChar < 64)
1948 {
1949 long l = 1L << curChar;
1950 do
1951 {
1952 switch(jjstateSet[--i])
1953 {
1954 case 3:
1955 if ((0xffffffdfffffffffL & l) != 0L)
1956 {
1957 if (kind > 45)
1958 kind = 45;
1959 jjCheckNAddTwoStates(0, 1);
1960 }
1961 else if (curChar == 37)
1962 jjstateSet[jjnewStateCnt++] = 2;
1963 break;
1964 case 0:
1965 if ((0xffffffdfffffffffL & l) == 0L)
1966 break;
1967 if (kind > 45)
1968 kind = 45;
1969 jjCheckNAddTwoStates(0, 1);
1970 break;
1971 case 1:
1972 if (curChar == 37)
1973 jjstateSet[jjnewStateCnt++] = 2;
1974 break;
1975 case 2:
1976 if ((0xbfffffffffffffffL & l) == 0L)
1977 break;
1978 if (kind > 45)
1979 kind = 45;
1980 jjCheckNAddTwoStates(0, 1);
1981 break;
1982 default : break;
1983 }
1984 } while(i != startsAt);
1985 }
1986 else if (curChar < 128)
1987 {
1988 long l = 1L << (curChar & 077);
1989 do
1990 {
1991 switch(jjstateSet[--i])
1992 {
1993 case 3:
1994 case 0:
1995 case 2:
1996 if (kind > 45)
1997 kind = 45;
1998 jjCheckNAddTwoStates(0, 1);
1999 break;
2000 default : break;
2001 }
2002 } while(i != startsAt);
2003 }
2004 else
2005 {
2006 int i2 = (curChar & 0xff) >> 6;
2007 long l2 = 1L << (curChar & 077);
2008 do
2009 {
2010 switch(jjstateSet[--i])
2011 {
2012 case 3:
2013 case 0:
2014 case 2:
2015 if ((jjbitVec0[i2] & l2) == 0L)
2016 break;
2017 if (kind > 45)
2018 kind = 45;
2019 jjCheckNAddTwoStates(0, 1);
2020 break;
2021 default : break;
2022 }
2023 } while(i != startsAt);
2024 }
2025 if (kind != 0x7fffffff)
2026 {
2027 jjmatchedKind = kind;
2028 jjmatchedPos = curPos;
2029 kind = 0x7fffffff;
2030 }
2031 ++curPos;
2032 if ((i = jjnewStateCnt) == (startsAt = 3 - (jjnewStateCnt = startsAt)))
2033 return curPos;
2034 try { curChar = input_stream.readChar(); }
2035 catch(java.io.IOException e) { return curPos; }
2036 }
2037 }
2038 private final int jjStopStringLiteralDfa_11(int pos, long active0)
2039 {
2040 switch (pos)
2041 {
2042 default :
2043 return -1;
2044 }
2045 }
2046 private final int jjStartNfa_11(int pos, long active0)
2047 {
2048 return jjMoveNfa_11(jjStopStringLiteralDfa_11(pos, active0), pos + 1);
2049 }
2050 private int jjMoveStringLiteralDfa0_11()
2051 {
2052 switch(curChar)
2053 {
2054 case 47:
2055 return jjMoveStringLiteralDfa1_11(0x2000000000000000L);
2056 case 61:
2057 return jjStopAtPos(0, 62);
2058 case 62:
2059 return jjStopAtPos(0, 59);
2060 default :
2061 return jjMoveNfa_11(1, 0);
2062 }
2063 }
2064 private int jjMoveStringLiteralDfa1_11(long active0)
2065 {
2066 try { curChar = input_stream.readChar(); }
2067 catch(java.io.IOException e) {
2068 jjStopStringLiteralDfa_11(0, active0);
2069 return 1;
2070 }
2071 switch(curChar)
2072 {
2073 case 62:
2074 if ((active0 & 0x2000000000000000L) != 0L)
2075 return jjStopAtPos(1, 61);
2076 break;
2077 default :
2078 break;
2079 }
2080 return jjStartNfa_11(0, active0);
2081 }
2082 private int jjMoveNfa_11(int startState, int curPos)
2083 {
2084 int startsAt = 0;
2085 jjnewStateCnt = 6;
2086 int i = 1;
2087 jjstateSet[0] = startState;
2088 int kind = 0x7fffffff;
2089 for (;;)
2090 {
2091 if (++jjround == 0x7fffffff)
2092 ReInitRounds();
2093 if (curChar < 64)
2094 {
2095 long l = 1L << curChar;
2096 do
2097 {
2098 switch(jjstateSet[--i])
2099 {
2100 case 1:
2101 if ((0x100002600L & l) != 0L)
2102 {
2103 if (kind > 21)
2104 kind = 21;
2105 jjCheckNAdd(0);
2106 }
2107 else if (curChar == 33)
2108 jjCheckNAdd(3);
2109 else if (curChar == 36)
2110 {
2111 if (kind > 58)
2112 kind = 58;
2113 jjCheckNAdd(2);
2114 }
2115 else if (curChar == 63)
2116 jjCheckNAdd(3);
2117 break;
2118 case 0:
2119 if ((0x100002600L & l) == 0L)
2120 break;
2121 kind = 21;
2122 jjCheckNAdd(0);
2123 break;
2124 case 2:
2125 if ((0x7ff601000000000L & l) == 0L)
2126 break;
2127 if (kind > 58)
2128 kind = 58;
2129 jjCheckNAdd(2);
2130 break;
2131 case 3:
2132 if (curChar == 62)
2133 kind = 60;
2134 break;
2135 case 4:
2136 if (curChar == 63)
2137 jjCheckNAdd(3);
2138 break;
2139 case 5:
2140 if (curChar == 33)
2141 jjCheckNAdd(3);
2142 break;
2143 default : break;
2144 }
2145 } while(i != startsAt);
2146 }
2147 else if (curChar < 128)
2148 {
2149 long l = 1L << (curChar & 077);
2150 do
2151 {
2152 switch(jjstateSet[--i])
2153 {
2154 case 1:
2155 case 2:
2156 if ((0x7fffffe87fffffeL & l) == 0L)
2157 break;
2158 if (kind > 58)
2159 kind = 58;
2160 jjCheckNAdd(2);
2161 break;
2162 default : break;
2163 }
2164 } while(i != startsAt);
2165 }
2166 else
2167 {
2168 int i2 = (curChar & 0xff) >> 6;
2169 long l2 = 1L << (curChar & 077);
2170 do
2171 {
2172 switch(jjstateSet[--i])
2173 {
2174 case 1:
2175 case 2:
2176 if ((jjbitVec1[i2] & l2) == 0L)
2177 break;
2178 if (kind > 58)
2179 kind = 58;
2180 jjCheckNAdd(2);
2181 break;
2182 default : break;
2183 }
2184 } while(i != startsAt);
2185 }
2186 if (kind != 0x7fffffff)
2187 {
2188 jjmatchedKind = kind;
2189 jjmatchedPos = curPos;
2190 kind = 0x7fffffff;
2191 }
2192 ++curPos;
2193 if ((i = jjnewStateCnt) == (startsAt = 6 - (jjnewStateCnt = startsAt)))
2194 return curPos;
2195 try { curChar = input_stream.readChar(); }
2196 catch(java.io.IOException e) { return curPos; }
2197 }
2198 }
2199 private int jjMoveStringLiteralDfa0_15()
2200 {
2201 return jjMoveNfa_15(1, 0);
2202 }
2203 private int jjMoveNfa_15(int startState, int curPos)
2204 {
2205 int startsAt = 0;
2206 jjnewStateCnt = 3;
2207 int i = 1;
2208 jjstateSet[0] = startState;
2209 int kind = 0x7fffffff;
2210 for (;;)
2211 {
2212 if (++jjround == 0x7fffffff)
2213 ReInitRounds();
2214 if (curChar < 64)
2215 {
2216 long l = 1L << curChar;
2217 do
2218 {
2219 switch(jjstateSet[--i])
2220 {
2221 case 1:
2222 if ((0x100002600L & l) != 0L)
2223 {
2224 if (kind > 20)
2225 kind = 20;
2226 jjCheckNAdd(0);
2227 }
2228 else if (curChar == 36)
2229 {
2230 if (kind > 35)
2231 kind = 35;
2232 jjCheckNAdd(2);
2233 }
2234 break;
2235 case 0:
2236 if ((0x100002600L & l) == 0L)
2237 break;
2238 kind = 20;
2239 jjCheckNAdd(0);
2240 break;
2241 case 2:
2242 if ((0x7ff601000000000L & l) == 0L)
2243 break;
2244 if (kind > 35)
2245 kind = 35;
2246 jjCheckNAdd(2);
2247 break;
2248 default : break;
2249 }
2250 } while(i != startsAt);
2251 }
2252 else if (curChar < 128)
2253 {
2254 long l = 1L << (curChar & 077);
2255 do
2256 {
2257 switch(jjstateSet[--i])
2258 {
2259 case 1:
2260 case 2:
2261 if ((0x7fffffe87fffffeL & l) == 0L)
2262 break;
2263 if (kind > 35)
2264 kind = 35;
2265 jjCheckNAdd(2);
2266 break;
2267 default : break;
2268 }
2269 } while(i != startsAt);
2270 }
2271 else
2272 {
2273 int i2 = (curChar & 0xff) >> 6;
2274 long l2 = 1L << (curChar & 077);
2275 do
2276 {
2277 switch(jjstateSet[--i])
2278 {
2279 case 1:
2280 case 2:
2281 if ((jjbitVec1[i2] & l2) == 0L)
2282 break;
2283 if (kind > 35)
2284 kind = 35;
2285 jjCheckNAdd(2);
2286 break;
2287 default : break;
2288 }
2289 } while(i != startsAt);
2290 }
2291 if (kind != 0x7fffffff)
2292 {
2293 jjmatchedKind = kind;
2294 jjmatchedPos = curPos;
2295 kind = 0x7fffffff;
2296 }
2297 ++curPos;
2298 if ((i = jjnewStateCnt) == (startsAt = 3 - (jjnewStateCnt = startsAt)))
2299 return curPos;
2300 try { curChar = input_stream.readChar(); }
2301 catch(java.io.IOException e) { return curPos; }
2302 }
2303 }
2304 private final int jjStopStringLiteralDfa_1(int pos, long active0, long active1)
2305 {
2306 switch (pos)
2307 {
2308 default :
2309 return -1;
2310 }
2311 }
2312 private final int jjStartNfa_1(int pos, long active0, long active1)
2313 {
2314 return jjMoveNfa_1(jjStopStringLiteralDfa_1(pos, active0, active1), pos + 1);
2315 }
2316 private int jjMoveStringLiteralDfa0_1()
2317 {
2318 switch(curChar)
2319 {
2320 case 34:
2321 return jjStopAtPos(0, 72);
2322 default :
2323 return jjMoveNfa_1(9, 0);
2324 }
2325 }
2326 private int jjMoveNfa_1(int startState, int curPos)
2327 {
2328 int startsAt = 0;
2329 jjnewStateCnt = 37;
2330 int i = 1;
2331 jjstateSet[0] = startState;
2332 int kind = 0x7fffffff;
2333 for (;;)
2334 {
2335 if (++jjround == 0x7fffffff)
2336 ReInitRounds();
2337 if (curChar < 64)
2338 {
2339 long l = 1L << curChar;
2340 do
2341 {
2342 switch(jjstateSet[--i])
2343 {
2344 case 9:
2345 if ((0xffffffe3ffffffffL & l) != 0L)
2346 {
2347 if (kind > 73)
2348 kind = 73;
2349 jjCheckNAddStates(2, 4);
2350 }
2351 else if ((0x1800000000L & l) != 0L)
2352 jjCheckNAddTwoStates(30, 36);
2353 if (curChar == 60)
2354 jjstateSet[jjnewStateCnt++] = 26;
2355 else if (curChar == 35)
2356 jjstateSet[jjnewStateCnt++] = 10;
2357 else if (curChar == 36)
2358 jjstateSet[jjnewStateCnt++] = 0;
2359 break;
2360 case 1:
2361 if ((0xffffff7bffffffffL & l) != 0L)
2362 jjCheckNAddStates(5, 8);
2363 break;
2364 case 2:
2365 if (curChar == 34)
2366 jjCheckNAddTwoStates(3, 4);
2367 break;
2368 case 3:
2369 if ((0xfffffffbffffffffL & l) != 0L)
2370 jjCheckNAddTwoStates(3, 4);
2371 break;
2372 case 4:
2373 if (curChar == 34)
2374 jjCheckNAddStates(5, 8);
2375 break;
2376 case 5:
2377 if (curChar == 39)
2378 jjCheckNAddTwoStates(6, 7);
2379 break;
2380 case 6:
2381 if ((0xffffff7fffffffffL & l) != 0L)
2382 jjCheckNAddTwoStates(6, 7);
2383 break;
2384 case 7:
2385 if (curChar == 39)
2386 jjCheckNAddStates(5, 8);
2387 break;
2388 case 11:
2389 if ((0xffffff7bffffffffL & l) != 0L)
2390 jjCheckNAddStates(9, 12);
2391 break;
2392 case 12:
2393 if (curChar == 34)
2394 jjCheckNAddTwoStates(13, 14);
2395 break;
2396 case 13:
2397 if ((0xfffffffbffffffffL & l) != 0L)
2398 jjCheckNAddTwoStates(13, 14);
2399 break;
2400 case 14:
2401 if (curChar == 34)
2402 jjCheckNAddStates(9, 12);
2403 break;
2404 case 15:
2405 if (curChar == 39)
2406 jjCheckNAddTwoStates(16, 17);
2407 break;
2408 case 16:
2409 if ((0xffffff7fffffffffL & l) != 0L)
2410 jjCheckNAddTwoStates(16, 17);
2411 break;
2412 case 17:
2413 if (curChar == 39)
2414 jjCheckNAddStates(9, 12);
2415 break;
2416 case 19:
2417 if (curChar == 35)
2418 jjstateSet[jjnewStateCnt++] = 10;
2419 break;
2420 case 20:
2421 if (curChar == 61)
2422 jjCheckNAddTwoStates(21, 22);
2423 break;
2424 case 21:
2425 if ((0xffffffdfffffffffL & l) != 0L)
2426 jjCheckNAddStates(13, 15);
2427 break;
2428 case 22:
2429 if (curChar == 37)
2430 jjstateSet[jjnewStateCnt++] = 23;
2431 break;
2432 case 23:
2433 if ((0xbfffffffffffffffL & l) != 0L)
2434 jjCheckNAddStates(13, 15);
2435 break;
2436 case 24:
2437 if (curChar == 62 && kind > 68)
2438 kind = 68;
2439 break;
2440 case 25:
2441 if (curChar == 37)
2442 jjstateSet[jjnewStateCnt++] = 24;
2443 break;
2444 case 26:
2445 if (curChar == 37)
2446 jjstateSet[jjnewStateCnt++] = 20;
2447 break;
2448 case 27:
2449 if (curChar == 60)
2450 jjstateSet[jjnewStateCnt++] = 26;
2451 break;
2452 case 28:
2453 if ((0xffffffe3ffffffffL & l) == 0L)
2454 break;
2455 if (kind > 73)
2456 kind = 73;
2457 jjCheckNAddStates(2, 4);
2458 break;
2459 case 29:
2460 if ((0x1800000000L & l) != 0L)
2461 jjCheckNAdd(30);
2462 break;
2463 case 30:
2464 if ((0xfffffffbffffffffL & l) == 0L)
2465 break;
2466 if (kind > 73)
2467 kind = 73;
2468 jjCheckNAddStates(2, 4);
2469 break;
2470 case 33:
2471 if (curChar == 35)
2472 jjCheckNAdd(32);
2473 break;
2474 case 34:
2475 if (curChar == 36)
2476 jjCheckNAdd(32);
2477 break;
2478 case 35:
2479 if ((0x1800000000L & l) != 0L)
2480 jjCheckNAddTwoStates(30, 36);
2481 break;
2482 case 36:
2483 if (curChar == 34 && kind > 74)
2484 kind = 74;
2485 break;
2486 default : break;
2487 }
2488 } while(i != startsAt);
2489 }
2490 else if (curChar < 128)
2491 {
2492 long l = 1L << (curChar & 077);
2493 do
2494 {
2495 switch(jjstateSet[--i])
2496 {
2497 case 9:
2498 if (kind > 73)
2499 kind = 73;
2500 jjCheckNAddStates(2, 4);
2501 if (curChar == 92)
2502 jjAddStates(16, 17);
2503 break;
2504 case 0:
2505 if (curChar == 123)
2506 jjCheckNAddStates(5, 8);
2507 break;
2508 case 1:
2509 if ((0xdfffffffffffffffL & l) != 0L)
2510 jjCheckNAddStates(5, 8);
2511 break;
2512 case 3:
2513 jjAddStates(18, 19);
2514 break;
2515 case 6:
2516 jjAddStates(20, 21);
2517 break;
2518 case 8:
2519 if (curChar == 125 && kind > 66)
2520 kind = 66;
2521 break;
2522 case 10:
2523 if (curChar == 123)
2524 jjCheckNAddStates(9, 12);
2525 break;
2526 case 11:
2527 if ((0xdfffffffffffffffL & l) != 0L)
2528 jjCheckNAddStates(9, 12);
2529 break;
2530 case 13:
2531 jjAddStates(22, 23);
2532 break;
2533 case 16:
2534 jjAddStates(24, 25);
2535 break;
2536 case 18:
2537 if (curChar == 125 && kind > 67)
2538 kind = 67;
2539 break;
2540 case 21:
2541 case 23:
2542 jjCheckNAddStates(13, 15);
2543 break;
2544 case 28:
2545 if (kind > 73)
2546 kind = 73;
2547 jjCheckNAddStates(2, 4);
2548 break;
2549 case 30:
2550 if ((0xf7ffffffffffffffL & l) == 0L)
2551 break;
2552 if (kind > 73)
2553 kind = 73;
2554 jjCheckNAddStates(2, 4);
2555 break;
2556 case 31:
2557 if (curChar == 92)
2558 jjAddStates(16, 17);
2559 break;
2560 case 32:
2561 if (curChar != 123)
2562 break;
2563 if (kind > 73)
2564 kind = 73;
2565 jjCheckNAddStates(2, 4);
2566 break;
2567 default : break;
2568 }
2569 } while(i != startsAt);
2570 }
2571 else
2572 {
2573 int i2 = (curChar & 0xff) >> 6;
2574 long l2 = 1L << (curChar & 077);
2575 do
2576 {
2577 switch(jjstateSet[--i])
2578 {
2579 case 9:
2580 case 28:
2581 case 30:
2582 if ((jjbitVec0[i2] & l2) == 0L)
2583 break;
2584 if (kind > 73)
2585 kind = 73;
2586 jjCheckNAddStates(2, 4);
2587 break;
2588 case 1:
2589 if ((jjbitVec0[i2] & l2) != 0L)
2590 jjAddStates(5, 8);
2591 break;
2592 case 3:
2593 if ((jjbitVec0[i2] & l2) != 0L)
2594 jjAddStates(18, 19);
2595 break;
2596 case 6:
2597 if ((jjbitVec0[i2] & l2) != 0L)
2598 jjAddStates(20, 21);
2599 break;
2600 case 11:
2601 if ((jjbitVec0[i2] & l2) != 0L)
2602 jjAddStates(9, 12);
2603 break;
2604 case 13:
2605 if ((jjbitVec0[i2] & l2) != 0L)
2606 jjAddStates(22, 23);
2607 break;
2608 case 16:
2609 if ((jjbitVec0[i2] & l2) != 0L)
2610 jjAddStates(24, 25);
2611 break;
2612 case 21:
2613 case 23:
2614 if ((jjbitVec0[i2] & l2) != 0L)
2615 jjCheckNAddStates(13, 15);
2616 break;
2617 default : break;
2618 }
2619 } while(i != startsAt);
2620 }
2621 if (kind != 0x7fffffff)
2622 {
2623 jjmatchedKind = kind;
2624 jjmatchedPos = curPos;
2625 kind = 0x7fffffff;
2626 }
2627 ++curPos;
2628 if ((i = jjnewStateCnt) == (startsAt = 37 - (jjnewStateCnt = startsAt)))
2629 return curPos;
2630 try { curChar = input_stream.readChar(); }
2631 catch(java.io.IOException e) { return curPos; }
2632 }
2633 }
2634 private final int jjStopStringLiteralDfa_5(int pos, long active0)
2635 {
2636 switch (pos)
2637 {
2638 default :
2639 return -1;
2640 }
2641 }
2642 private final int jjStartNfa_5(int pos, long active0)
2643 {
2644 return jjMoveNfa_5(jjStopStringLiteralDfa_5(pos, active0), pos + 1);
2645 }
2646 private int jjMoveStringLiteralDfa0_5()
2647 {
2648 switch(curChar)
2649 {
2650 case 62:
2651 return jjStopAtPos(0, 52);
2652 case 80:
2653 case 112:
2654 return jjMoveStringLiteralDfa1_5(0x4000000000000L);
2655 case 83:
2656 case 115:
2657 return jjMoveStringLiteralDfa1_5(0x8000000000000L);
2658 default :
2659 return jjMoveNfa_5(1, 0);
2660 }
2661 }
2662 private int jjMoveStringLiteralDfa1_5(long active0)
2663 {
2664 try { curChar = input_stream.readChar(); }
2665 catch(java.io.IOException e) {
2666 jjStopStringLiteralDfa_5(0, active0);
2667 return 1;
2668 }
2669 switch(curChar)
2670 {
2671 case 85:
2672 case 117:
2673 return jjMoveStringLiteralDfa2_5(active0, 0x4000000000000L);
2674 case 89:
2675 case 121:
2676 return jjMoveStringLiteralDfa2_5(active0, 0x8000000000000L);
2677 default :
2678 break;
2679 }
2680 return jjStartNfa_5(0, active0);
2681 }
2682 private int jjMoveStringLiteralDfa2_5(long old0, long active0)
2683 {
2684 if (((active0 &= old0)) == 0L)
2685 return jjStartNfa_5(0, old0);
2686 try { curChar = input_stream.readChar(); }
2687 catch(java.io.IOException e) {
2688 jjStopStringLiteralDfa_5(1, active0);
2689 return 2;
2690 }
2691 switch(curChar)
2692 {
2693 case 66:
2694 case 98:
2695 return jjMoveStringLiteralDfa3_5(active0, 0x4000000000000L);
2696 case 83:
2697 case 115:
2698 return jjMoveStringLiteralDfa3_5(active0, 0x8000000000000L);
2699 default :
2700 break;
2701 }
2702 return jjStartNfa_5(1, active0);
2703 }
2704 private int jjMoveStringLiteralDfa3_5(long old0, long active0)
2705 {
2706 if (((active0 &= old0)) == 0L)
2707 return jjStartNfa_5(1, old0);
2708 try { curChar = input_stream.readChar(); }
2709 catch(java.io.IOException e) {
2710 jjStopStringLiteralDfa_5(2, active0);
2711 return 3;
2712 }
2713 switch(curChar)
2714 {
2715 case 76:
2716 case 108:
2717 return jjMoveStringLiteralDfa4_5(active0, 0x4000000000000L);
2718 case 84:
2719 case 116:
2720 return jjMoveStringLiteralDfa4_5(active0, 0x8000000000000L);
2721 default :
2722 break;
2723 }
2724 return jjStartNfa_5(2, active0);
2725 }
2726 private int jjMoveStringLiteralDfa4_5(long old0, long active0)
2727 {
2728 if (((active0 &= old0)) == 0L)
2729 return jjStartNfa_5(2, old0);
2730 try { curChar = input_stream.readChar(); }
2731 catch(java.io.IOException e) {
2732 jjStopStringLiteralDfa_5(3, active0);
2733 return 4;
2734 }
2735 switch(curChar)
2736 {
2737 case 69:
2738 case 101:
2739 return jjMoveStringLiteralDfa5_5(active0, 0x8000000000000L);
2740 case 73:
2741 case 105:
2742 return jjMoveStringLiteralDfa5_5(active0, 0x4000000000000L);
2743 default :
2744 break;
2745 }
2746 return jjStartNfa_5(3, active0);
2747 }
2748 private int jjMoveStringLiteralDfa5_5(long old0, long active0)
2749 {
2750 if (((active0 &= old0)) == 0L)
2751 return jjStartNfa_5(3, old0);
2752 try { curChar = input_stream.readChar(); }
2753 catch(java.io.IOException e) {
2754 jjStopStringLiteralDfa_5(4, active0);
2755 return 5;
2756 }
2757 switch(curChar)
2758 {
2759 case 67:
2760 case 99:
2761 if ((active0 & 0x4000000000000L) != 0L)
2762 return jjStopAtPos(5, 50);
2763 break;
2764 case 77:
2765 case 109:
2766 if ((active0 & 0x8000000000000L) != 0L)
2767 return jjStopAtPos(5, 51);
2768 break;
2769 default :
2770 break;
2771 }
2772 return jjStartNfa_5(4, active0);
2773 }
2774 private int jjMoveNfa_5(int startState, int curPos)
2775 {
2776 int startsAt = 0;
2777 jjnewStateCnt = 7;
2778 int i = 1;
2779 jjstateSet[0] = startState;
2780 int kind = 0x7fffffff;
2781 for (;;)
2782 {
2783 if (++jjround == 0x7fffffff)
2784 ReInitRounds();
2785 if (curChar < 64)
2786 {
2787 long l = 1L << curChar;
2788 do
2789 {
2790 switch(jjstateSet[--i])
2791 {
2792 case 1:
2793 if ((0x100002600L & l) != 0L)
2794 {
2795 if (kind > 48)
2796 kind = 48;
2797 jjCheckNAdd(0);
2798 }
2799 else if (curChar == 34)
2800 jjCheckNAddTwoStates(5, 6);
2801 else if (curChar == 39)
2802 jjCheckNAddTwoStates(2, 3);
2803 break;
2804 case 0:
2805 if ((0x100002600L & l) == 0L)
2806 break;
2807 if (kind > 48)
2808 kind = 48;
2809 jjCheckNAdd(0);
2810 break;
2811 case 2:
2812 if ((0xffffff7fffffffffL & l) != 0L)
2813 jjCheckNAddTwoStates(2, 3);
2814 break;
2815 case 3:
2816 if (curChar == 39 && kind > 53)
2817 kind = 53;
2818 break;
2819 case 4:
2820 if (curChar == 34)
2821 jjCheckNAddTwoStates(5, 6);
2822 break;
2823 case 5:
2824 if ((0xfffffffbffffffffL & l) != 0L)
2825 jjCheckNAddTwoStates(5, 6);
2826 break;
2827 case 6:
2828 if (curChar == 34 && kind > 53)
2829 kind = 53;
2830 break;
2831 default : break;
2832 }
2833 } while(i != startsAt);
2834 }
2835 else if (curChar < 128)
2836 {
2837 long l = 1L << (curChar & 077);
2838 do
2839 {
2840 switch(jjstateSet[--i])
2841 {
2842 case 2:
2843 jjAddStates(42, 43);
2844 break;
2845 case 5:
2846 jjAddStates(44, 45);
2847 break;
2848 default : break;
2849 }
2850 } while(i != startsAt);
2851 }
2852 else
2853 {
2854 int i2 = (curChar & 0xff) >> 6;
2855 long l2 = 1L << (curChar & 077);
2856 do
2857 {
2858 switch(jjstateSet[--i])
2859 {
2860 case 2:
2861 if ((jjbitVec0[i2] & l2) != 0L)
2862 jjAddStates(42, 43);
2863 break;
2864 case 5:
2865 if ((jjbitVec0[i2] & l2) != 0L)
2866 jjAddStates(44, 45);
2867 break;
2868 default : break;
2869 }
2870 } while(i != startsAt);
2871 }
2872 if (kind != 0x7fffffff)
2873 {
2874 jjmatchedKind = kind;
2875 jjmatchedPos = curPos;
2876 kind = 0x7fffffff;
2877 }
2878 ++curPos;
2879 if ((i = jjnewStateCnt) == (startsAt = 7 - (jjnewStateCnt = startsAt)))
2880 return curPos;
2881 try { curChar = input_stream.readChar(); }
2882 catch(java.io.IOException e) { return curPos; }
2883 }
2884 }
2885 private final int jjStopStringLiteralDfa_10(int pos, long active0)
2886 {
2887 switch (pos)
2888 {
2889 case 0:
2890 if ((active0 & 0x10000000000L) != 0L)
2891 return 2;
2892 return -1;
2893 default :
2894 return -1;
2895 }
2896 }
2897 private final int jjStartNfa_10(int pos, long active0)
2898 {
2899 return jjMoveNfa_10(jjStopStringLiteralDfa_10(pos, active0), pos + 1);
2900 }
2901 private int jjMoveStringLiteralDfa0_10()
2902 {
2903 switch(curChar)
2904 {
2905 case 37:
2906 return jjMoveStringLiteralDfa1_10(0x10000000000L);
2907 default :
2908 return jjMoveNfa_10(3, 0);
2909 }
2910 }
2911 private int jjMoveStringLiteralDfa1_10(long active0)
2912 {
2913 try { curChar = input_stream.readChar(); }
2914 catch(java.io.IOException e) {
2915 jjStopStringLiteralDfa_10(0, active0);
2916 return 1;
2917 }
2918 switch(curChar)
2919 {
2920 case 62:
2921 if ((active0 & 0x10000000000L) != 0L)
2922 return jjStopAtPos(1, 40);
2923 break;
2924 default :
2925 break;
2926 }
2927 return jjStartNfa_10(0, active0);
2928 }
2929 private int jjMoveNfa_10(int startState, int curPos)
2930 {
2931 int startsAt = 0;
2932 jjnewStateCnt = 3;
2933 int i = 1;
2934 jjstateSet[0] = startState;
2935 int kind = 0x7fffffff;
2936 for (;;)
2937 {
2938 if (++jjround == 0x7fffffff)
2939 ReInitRounds();
2940 if (curChar < 64)
2941 {
2942 long l = 1L << curChar;
2943 do
2944 {
2945 switch(jjstateSet[--i])
2946 {
2947 case 3:
2948 if ((0xffffffdfffffffffL & l) != 0L)
2949 {
2950 if (kind > 41)
2951 kind = 41;
2952 jjCheckNAddTwoStates(0, 1);
2953 }
2954 else if (curChar == 37)
2955 jjstateSet[jjnewStateCnt++] = 2;
2956 break;
2957 case 0:
2958 if ((0xffffffdfffffffffL & l) == 0L)
2959 break;
2960 if (kind > 41)
2961 kind = 41;
2962 jjCheckNAddTwoStates(0, 1);
2963 break;
2964 case 1:
2965 if (curChar == 37)
2966 jjstateSet[jjnewStateCnt++] = 2;
2967 break;
2968 case 2:
2969 if ((0xbfffffffffffffffL & l) == 0L)
2970 break;
2971 if (kind > 41)
2972 kind = 41;
2973 jjCheckNAddTwoStates(0, 1);
2974 break;
2975 default : break;
2976 }
2977 } while(i != startsAt);
2978 }
2979 else if (curChar < 128)
2980 {
2981 long l = 1L << (curChar & 077);
2982 do
2983 {
2984 switch(jjstateSet[--i])
2985 {
2986 case 3:
2987 case 0:
2988 case 2:
2989 if (kind > 41)
2990 kind = 41;
2991 jjCheckNAddTwoStates(0, 1);
2992 break;
2993 default : break;
2994 }
2995 } while(i != startsAt);
2996 }
2997 else
2998 {
2999 int i2 = (curChar & 0xff) >> 6;
3000 long l2 = 1L << (curChar & 077);
3001 do
3002 {
3003 switch(jjstateSet[--i])
3004 {
3005 case 3:
3006 case 0:
3007 case 2:
3008 if ((jjbitVec0[i2] & l2) == 0L)
3009 break;
3010 if (kind > 41)
3011 kind = 41;
3012 jjCheckNAddTwoStates(0, 1);
3013 break;
3014 default : break;
3015 }
3016 } while(i != startsAt);
3017 }
3018 if (kind != 0x7fffffff)
3019 {
3020 jjmatchedKind = kind;
3021 jjmatchedPos = curPos;
3022 kind = 0x7fffffff;
3023 }
3024 ++curPos;
3025 if ((i = jjnewStateCnt) == (startsAt = 3 - (jjnewStateCnt = startsAt)))
3026 return curPos;
3027 try { curChar = input_stream.readChar(); }
3028 catch(java.io.IOException e) { return curPos; }
3029 }
3030 }
3031 private final int jjStopStringLiteralDfa_14(int pos, long active0)
3032 {
3033 switch (pos)
3034 {
3035 default :
3036 return -1;
3037 }
3038 }
3039 private final int jjStartNfa_14(int pos, long active0)
3040 {
3041 return jjMoveNfa_14(jjStopStringLiteralDfa_14(pos, active0), pos + 1);
3042 }
3043 private int jjMoveStringLiteralDfa0_14()
3044 {
3045 switch(curChar)
3046 {
3047 case 37:
3048 return jjMoveStringLiteralDfa1_14(0x8000000000L);
3049 case 61:
3050 return jjStopAtPos(0, 37);
3051 default :
3052 return jjMoveNfa_14(1, 0);
3053 }
3054 }
3055 private int jjMoveStringLiteralDfa1_14(long active0)
3056 {
3057 try { curChar = input_stream.readChar(); }
3058 catch(java.io.IOException e) {
3059 jjStopStringLiteralDfa_14(0, active0);
3060 return 1;
3061 }
3062 switch(curChar)
3063 {
3064 case 62:
3065 if ((active0 & 0x8000000000L) != 0L)
3066 return jjStopAtPos(1, 39);
3067 break;
3068 default :
3069 break;
3070 }
3071 return jjStartNfa_14(0, active0);
3072 }
3073 private int jjMoveNfa_14(int startState, int curPos)
3074 {
3075 int startsAt = 0;
3076 jjnewStateCnt = 9;
3077 int i = 1;
3078 jjstateSet[0] = startState;
3079 int kind = 0x7fffffff;
3080 for (;;)
3081 {
3082 if (++jjround == 0x7fffffff)
3083 ReInitRounds();
3084 if (curChar < 64)
3085 {
3086 long l = 1L << curChar;
3087 do
3088 {
3089 switch(jjstateSet[--i])
3090 {
3091 case 1:
3092 if ((0x100002600L & l) != 0L)
3093 {
3094 if (kind > 20)
3095 kind = 20;
3096 jjCheckNAdd(0);
3097 }
3098 else if (curChar == 34)
3099 jjCheckNAddTwoStates(7, 8);
3100 else if (curChar == 39)
3101 jjCheckNAddTwoStates(4, 5);
3102 else if (curChar == 36)
3103 {
3104 if (kind > 36)
3105 kind = 36;
3106 jjCheckNAdd(2);
3107 }
3108 break;
3109 case 0:
3110 if ((0x100002600L & l) == 0L)
3111 break;
3112 if (kind > 20)
3113 kind = 20;
3114 jjCheckNAdd(0);
3115 break;
3116 case 2:
3117 if ((0x7ff601000000000L & l) == 0L)
3118 break;
3119 if (kind > 36)
3120 kind = 36;
3121 jjCheckNAdd(2);
3122 break;
3123 case 3:
3124 if (curChar == 39)
3125 jjCheckNAddTwoStates(4, 5);
3126 break;
3127 case 4:
3128 if ((0xffffff7fffffffffL & l) != 0L)
3129 jjCheckNAddTwoStates(4, 5);
3130 break;
3131 case 5:
3132 if (curChar == 39 && kind > 38)
3133 kind = 38;
3134 break;
3135 case 6:
3136 if (curChar == 34)
3137 jjCheckNAddTwoStates(7, 8);
3138 break;
3139 case 7:
3140 if ((0xfffffffbffffffffL & l) != 0L)
3141 jjCheckNAddTwoStates(7, 8);
3142 break;
3143 case 8:
3144 if (curChar == 34 && kind > 38)
3145 kind = 38;
3146 break;
3147 default : break;
3148 }
3149 } while(i != startsAt);
3150 }
3151 else if (curChar < 128)
3152 {
3153 long l = 1L << (curChar & 077);
3154 do
3155 {
3156 switch(jjstateSet[--i])
3157 {
3158 case 1:
3159 case 2:
3160 if ((0x7fffffe87fffffeL & l) == 0L)
3161 break;
3162 if (kind > 36)
3163 kind = 36;
3164 jjCheckNAdd(2);
3165 break;
3166 case 4:
3167 jjAddStates(38, 39);
3168 break;
3169 case 7:
3170 jjAddStates(40, 41);
3171 break;
3172 default : break;
3173 }
3174 } while(i != startsAt);
3175 }
3176 else
3177 {
3178 int i2 = (curChar & 0xff) >> 6;
3179 long l2 = 1L << (curChar & 077);
3180 do
3181 {
3182 switch(jjstateSet[--i])
3183 {
3184 case 1:
3185 case 2:
3186 if ((jjbitVec1[i2] & l2) == 0L)
3187 break;
3188 if (kind > 36)
3189 kind = 36;
3190 jjCheckNAdd(2);
3191 break;
3192 case 4:
3193 if ((jjbitVec0[i2] & l2) != 0L)
3194 jjAddStates(38, 39);
3195 break;
3196 case 7:
3197 if ((jjbitVec0[i2] & l2) != 0L)
3198 jjAddStates(40, 41);
3199 break;
3200 default : break;
3201 }
3202 } while(i != startsAt);
3203 }
3204 if (kind != 0x7fffffff)
3205 {
3206 jjmatchedKind = kind;
3207 jjmatchedPos = curPos;
3208 kind = 0x7fffffff;
3209 }
3210 ++curPos;
3211 if ((i = jjnewStateCnt) == (startsAt = 9 - (jjnewStateCnt = startsAt)))
3212 return curPos;
3213 try { curChar = input_stream.readChar(); }
3214 catch(java.io.IOException e) { return curPos; }
3215 }
3216 }
3217 static final int[] jjnextStates = {
3218 1, 4, 28, 29, 31, 1, 2, 5, 8, 11, 12, 15, 18, 21, 22, 25,
3219 33, 34, 3, 4, 6, 7, 13, 14, 16, 17, 0, 1, 2, 3, 7, 11,
3220 12, 14, 2, 3, 6, 9, 4, 5, 7, 8, 2, 3, 5, 6,
3221 };
3222
3223 /** Token literal values. */
3224 public static final String[] jjstrLiteralImages = {
3225 "", null, null, null, null, null, null, null, null, null, null, null, null,
3226 null, null, null, null, null, null, null, null, null, "\74", "\74\57",
3227 "\74\41\55\55", "\74\77", null, null, "\74\45\55\55", "\74\45\41", "\74\45\75", "\74\45",
3228 "\74\45\100", null, null, null, null, "\75", null, "\45\76", "\45\76", null, "\45\76", null,
3229 "\45\76", null, "\55\55\45\76", null, null, null, null, null, "\76", null, null,
3230 "\135\135\76", null, null, null, "\76", null, "\57\76", "\75", null, "\47", "\42", null, null,
3231 null, "\47", null, null, "\42", null, null, null, null, };
3232
3233 /** Lexer state names. */
3234 public static final String[] lexStateNames = {
3235 "CommentState",
3236 "AttrValueBetweenDoubleQuotesState",
3237 "AttrValueBetweenSingleQuotesState",
3238 "StartTagState",
3239 "CDataState",
3240 "DocTypeExternalIdState",
3241 "DocTypeState",
3242 "JspCommentState",
3243 "JspDeclarationState",
3244 "JspExpressionState",
3245 "JspScriptletState",
3246 "InTagState",
3247 "AfterTagState",
3248 "AttrValueState",
3249 "JspDirectiveAttributesState",
3250 "JspDirectiveState",
3251 "DEFAULT",
3252 };
3253
3254 /** Lex State array. */
3255 public static final int[] jjnewLexState = {
3256 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 3, 3, 0,
3257 3, 6, 4, 7, 8, 9, 10, 15, -1, -1, 14, -1, -1, -1, 12, 12, -1, 12, -1, 12, -1, 12, -1, -1, 5,
3258 -1, -1, 12, -1, -1, 12, 11, 16, -1, 12, 12, 12, 13, -1, 2, 1, -1, -1, -1, 11, -1, 11, 11, -1, 11,
3259 12, -1,
3260 };
3261 static final long[] jjtoToken = {
3262 0xffffffffffc00001L, 0x1fffL,
3263 };
3264 static final long[] jjtoSkip = {
3265 0x300000L, 0x0L,
3266 };
3267 static final long[] jjtoSpecial = {
3268 0x200000L, 0x0L,
3269 };
3270 protected CharStream input_stream;
3271 private final int[] jjrounds = new int[37];
3272 private final int[] jjstateSet = new int[74];
3273 protected char curChar;
3274 /** Constructor. */
3275 public JspParserTokenManager(CharStream stream){
3276 input_stream = stream;
3277 }
3278
3279 /** Constructor. */
3280 public JspParserTokenManager(CharStream stream, int lexState){
3281 this(stream);
3282 SwitchTo(lexState);
3283 }
3284
3285 /** Reinitialise parser. */
3286 public void ReInit(CharStream stream)
3287 {
3288 jjmatchedPos = jjnewStateCnt = 0;
3289 curLexState = defaultLexState;
3290 input_stream = stream;
3291 ReInitRounds();
3292 }
3293 private void ReInitRounds()
3294 {
3295 int i;
3296 jjround = 0x80000001;
3297 for (i = 37; i-- > 0;)
3298 jjrounds[i] = 0x80000000;
3299 }
3300
3301 /** Reinitialise parser. */
3302 public void ReInit(CharStream stream, int lexState)
3303 {
3304 ReInit(stream);
3305 SwitchTo(lexState);
3306 }
3307
3308 /** Switch to specified lex state. */
3309 public void SwitchTo(int lexState)
3310 {
3311 if (lexState >= 17 || lexState < 0)
3312 throw new TokenMgrError("Error: Ignoring invalid lexical state : " + lexState + ". State unchanged.", TokenMgrError.INVALID_LEXICAL_STATE);
3313 else
3314 curLexState = lexState;
3315 }
3316
3317 protected Token jjFillToken()
3318 {
3319 final Token t;
3320 final String curTokenImage;
3321 final int beginLine;
3322 final int endLine;
3323 final int beginColumn;
3324 final int endColumn;
3325 String im = jjstrLiteralImages[jjmatchedKind];
3326 curTokenImage = (im == null) ? input_stream.GetImage() : im;
3327 beginLine = input_stream.getBeginLine();
3328 beginColumn = input_stream.getBeginColumn();
3329 endLine = input_stream.getEndLine();
3330 endColumn = input_stream.getEndColumn();
3331 t = Token.newToken(jjmatchedKind, curTokenImage);
3332
3333 t.beginLine = beginLine;
3334 t.endLine = endLine;
3335 t.beginColumn = beginColumn;
3336 t.endColumn = endColumn;
3337
3338 return t;
3339 }
3340
3341 int curLexState = 16;
3342 int defaultLexState = 16;
3343 int jjnewStateCnt;
3344 int jjround;
3345 int jjmatchedPos;
3346 int jjmatchedKind;
3347
3348 /** Get the next Token. */
3349 public Token getNextToken()
3350 {
3351 Token specialToken = null;
3352 Token matchedToken;
3353 int curPos = 0;
3354
3355 EOFLoop :
3356 for (;;)
3357 {
3358 try
3359 {
3360 curChar = input_stream.BeginToken();
3361 }
3362 catch(java.io.IOException e)
3363 {
3364 jjmatchedKind = 0;
3365 matchedToken = jjFillToken();
3366 matchedToken.specialToken = specialToken;
3367 return matchedToken;
3368 }
3369
3370 switch(curLexState)
3371 {
3372 case 0:
3373 jjmatchedKind = 0x7fffffff;
3374 jjmatchedPos = 0;
3375 curPos = jjMoveStringLiteralDfa0_0();
3376 if (jjmatchedPos == 0 && jjmatchedKind > 76)
3377 {
3378 jjmatchedKind = 76;
3379 }
3380 break;
3381 case 1:
3382 jjmatchedKind = 0x7fffffff;
3383 jjmatchedPos = 0;
3384 curPos = jjMoveStringLiteralDfa0_1();
3385 break;
3386 case 2:
3387 jjmatchedKind = 0x7fffffff;
3388 jjmatchedPos = 0;
3389 curPos = jjMoveStringLiteralDfa0_2();
3390 break;
3391 case 3:
3392 jjmatchedKind = 0x7fffffff;
3393 jjmatchedPos = 0;
3394 curPos = jjMoveStringLiteralDfa0_3();
3395 if (jjmatchedPos == 0 && jjmatchedKind > 57)
3396 {
3397 jjmatchedKind = 57;
3398 }
3399 break;
3400 case 4:
3401 jjmatchedKind = 0x7fffffff;
3402 jjmatchedPos = 0;
3403 curPos = jjMoveStringLiteralDfa0_4();
3404 if (jjmatchedPos == 0 && jjmatchedKind > 54)
3405 {
3406 jjmatchedKind = 54;
3407 }
3408 break;
3409 case 5:
3410 jjmatchedKind = 0x7fffffff;
3411 jjmatchedPos = 0;
3412 curPos = jjMoveStringLiteralDfa0_5();
3413 break;
3414 case 6:
3415 jjmatchedKind = 0x7fffffff;
3416 jjmatchedPos = 0;
3417 curPos = jjMoveStringLiteralDfa0_6();
3418 break;
3419 case 7:
3420 jjmatchedKind = 0x7fffffff;
3421 jjmatchedPos = 0;
3422 curPos = jjMoveStringLiteralDfa0_7();
3423 break;
3424 case 8:
3425 jjmatchedKind = 0x7fffffff;
3426 jjmatchedPos = 0;
3427 curPos = jjMoveStringLiteralDfa0_8();
3428 break;
3429 case 9:
3430 jjmatchedKind = 0x7fffffff;
3431 jjmatchedPos = 0;
3432 curPos = jjMoveStringLiteralDfa0_9();
3433 break;
3434 case 10:
3435 jjmatchedKind = 0x7fffffff;
3436 jjmatchedPos = 0;
3437 curPos = jjMoveStringLiteralDfa0_10();
3438 break;
3439 case 11:
3440 jjmatchedKind = 0x7fffffff;
3441 jjmatchedPos = 0;
3442 curPos = jjMoveStringLiteralDfa0_11();
3443 if (jjmatchedPos == 0 && jjmatchedKind > 63)
3444 {
3445 jjmatchedKind = 63;
3446 }
3447 break;
3448 case 12:
3449 jjmatchedKind = 0x7fffffff;
3450 jjmatchedPos = 0;
3451 curPos = jjMoveStringLiteralDfa0_12();
3452 break;
3453 case 13:
3454 jjmatchedKind = 0x7fffffff;
3455 jjmatchedPos = 0;
3456 curPos = jjMoveStringLiteralDfa0_13();
3457 break;
3458 case 14:
3459 jjmatchedKind = 0x7fffffff;
3460 jjmatchedPos = 0;
3461 curPos = jjMoveStringLiteralDfa0_14();
3462 break;
3463 case 15:
3464 jjmatchedKind = 0x7fffffff;
3465 jjmatchedPos = 0;
3466 curPos = jjMoveStringLiteralDfa0_15();
3467 break;
3468 case 16:
3469 jjmatchedKind = 0x7fffffff;
3470 jjmatchedPos = 0;
3471 curPos = jjMoveStringLiteralDfa0_16();
3472 break;
3473 }
3474 if (jjmatchedKind != 0x7fffffff)
3475 {
3476 if (jjmatchedPos + 1 < curPos)
3477 input_stream.backup(curPos - jjmatchedPos - 1);
3478 if ((jjtoToken[jjmatchedKind >> 6] & (1L << (jjmatchedKind & 077))) != 0L)
3479 {
3480 matchedToken = jjFillToken();
3481 matchedToken.specialToken = specialToken;
3482 if (jjnewLexState[jjmatchedKind] != -1)
3483 curLexState = jjnewLexState[jjmatchedKind];
3484 return matchedToken;
3485 }
3486 else
3487 {
3488 if ((jjtoSpecial[jjmatchedKind >> 6] & (1L << (jjmatchedKind & 077))) != 0L)
3489 {
3490 matchedToken = jjFillToken();
3491 if (specialToken == null)
3492 specialToken = matchedToken;
3493 else
3494 {
3495 matchedToken.specialToken = specialToken;
3496 specialToken = (specialToken.next = matchedToken);
3497 }
3498 }
3499 if (jjnewLexState[jjmatchedKind] != -1)
3500 curLexState = jjnewLexState[jjmatchedKind];
3501 continue EOFLoop;
3502 }
3503 }
3504 int error_line = input_stream.getEndLine();
3505 int error_column = input_stream.getEndColumn();
3506 String error_after = null;
3507 boolean EOFSeen = false;
3508 try { input_stream.readChar(); input_stream.backup(1); }
3509 catch (java.io.IOException e1) {
3510 EOFSeen = true;
3511 error_after = curPos <= 1 ? "" : input_stream.GetImage();
3512 if (curChar == '\n' || curChar == '\r') {
3513 error_line++;
3514 error_column = 0;
3515 }
3516 else
3517 error_column++;
3518 }
3519 if (!EOFSeen) {
3520 input_stream.backup(1);
3521 error_after = curPos <= 1 ? "" : input_stream.GetImage();
3522 }
3523 throw new TokenMgrError(EOFSeen, curLexState, error_line, error_column, error_after, curChar, TokenMgrError.LEXICAL_ERROR);
3524 }
3525 }
3526
3527 private void jjCheckNAdd(int state)
3528 {
3529 if (jjrounds[state] != jjround)
3530 {
3531 jjstateSet[jjnewStateCnt++] = state;
3532 jjrounds[state] = jjround;
3533 }
3534 }
3535 private void jjAddStates(int start, int end)
3536 {
3537 do {
3538 jjstateSet[jjnewStateCnt++] = jjnextStates[start];
3539 } while (start++ != end);
3540 }
3541 private void jjCheckNAddTwoStates(int state1, int state2)
3542 {
3543 jjCheckNAdd(state1);
3544 jjCheckNAdd(state2);
3545 }
3546
3547 private void jjCheckNAddStates(int start, int end)
3548 {
3549 do {
3550 jjCheckNAdd(jjnextStates[start]);
3551 } while (start++ != end);
3552 }
3553
3554 }