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