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