1
2 package com.quiotix.html.parser;
3
4
5 public class HtmlParserTokenManager implements HtmlParserConstants
6 {
7
8
9 public java.io.PrintStream debugStream = System.out;
10
11 public void setDebugStream(java.io.PrintStream ds) { debugStream = ds; }
12 private final int jjStopStringLiteralDfa_7(int pos, long active0)
13 {
14 switch (pos)
15 {
16 case 0:
17 if ((active0 & 0xeL) != 0L)
18 {
19 jjmatchedKind = 19;
20 return 4;
21 }
22 return -1;
23 default :
24 return -1;
25 }
26 }
27 private final int jjStartNfa_7(int pos, long active0)
28 {
29 return jjMoveNfa_7(jjStopStringLiteralDfa_7(pos, active0), pos + 1);
30 }
31 private int jjStopAtPos(int pos, int kind)
32 {
33 jjmatchedKind = kind;
34 jjmatchedPos = pos;
35 return pos + 1;
36 }
37 private int jjMoveStringLiteralDfa0_7()
38 {
39 switch(curChar)
40 {
41 case 60:
42 jjmatchedKind = 15;
43 return jjMoveStringLiteralDfa1_7(0x70000L);
44 case 61:
45 return jjMoveStringLiteralDfa1_7(0xeL);
46 default :
47 return jjMoveNfa_7(5, 0);
48 }
49 }
50 private int jjMoveStringLiteralDfa1_7(long active0)
51 {
52 try { curChar = input_stream.readChar(); }
53 catch(java.io.IOException e) {
54 jjStopStringLiteralDfa_7(0, active0);
55 return 1;
56 }
57 switch(curChar)
58 {
59 case 10:
60 if ((active0 & 0x2L) != 0L)
61 return jjStopAtPos(1, 1);
62 break;
63 case 13:
64 if ((active0 & 0x8L) != 0L)
65 {
66 jjmatchedKind = 3;
67 jjmatchedPos = 1;
68 }
69 return jjMoveStringLiteralDfa2_7(active0, 0x4L);
70 case 33:
71 if ((active0 & 0x40000L) != 0L)
72 {
73 jjmatchedKind = 18;
74 jjmatchedPos = 1;
75 }
76 return jjMoveStringLiteralDfa2_7(active0, 0x20000L);
77 case 47:
78 if ((active0 & 0x10000L) != 0L)
79 return jjStopAtPos(1, 16);
80 break;
81 default :
82 break;
83 }
84 return jjStartNfa_7(0, active0);
85 }
86 private int jjMoveStringLiteralDfa2_7(long old0, long active0)
87 {
88 if (((active0 &= old0)) == 0L)
89 return jjStartNfa_7(0, old0);
90 try { curChar = input_stream.readChar(); }
91 catch(java.io.IOException e) {
92 jjStopStringLiteralDfa_7(1, active0);
93 return 2;
94 }
95 switch(curChar)
96 {
97 case 10:
98 if ((active0 & 0x4L) != 0L)
99 return jjStopAtPos(2, 2);
100 break;
101 case 45:
102 return jjMoveStringLiteralDfa3_7(active0, 0x20000L);
103 default :
104 break;
105 }
106 return jjStartNfa_7(1, active0);
107 }
108 private int jjMoveStringLiteralDfa3_7(long old0, long active0)
109 {
110 if (((active0 &= old0)) == 0L)
111 return jjStartNfa_7(1, old0);
112 try { curChar = input_stream.readChar(); }
113 catch(java.io.IOException e) {
114 jjStopStringLiteralDfa_7(2, active0);
115 return 3;
116 }
117 switch(curChar)
118 {
119 case 45:
120 if ((active0 & 0x20000L) != 0L)
121 return jjStopAtPos(3, 17);
122 break;
123 default :
124 break;
125 }
126 return jjStartNfa_7(2, active0);
127 }
128 static final long[] jjbitVec0 = {
129 0x0L, 0x0L, 0xffffffffffffffffL, 0xffffffffffffffffL
130 };
131 private int jjMoveNfa_7(int startState, int curPos)
132 {
133
134 int startsAt = 0;
135 jjnewStateCnt = 5;
136 int i = 1;
137 jjstateSet[0] = startState;
138
139 int kind = 0x7fffffff;
140 for (;;)
141 {
142 if (++jjround == 0x7fffffff)
143 ReInitRounds();
144 if (curChar < 64)
145 {
146 long l = 1L << curChar;
147 do
148 {
149 switch(jjstateSet[--i])
150 {
151 case 5:
152 if ((0xefffffffffffdbffL & l) != 0L)
153 {
154 if (kind > 19)
155 kind = 19;
156 jjCheckNAdd(4);
157 }
158 else if ((0x2400L & l) != 0L)
159 {
160 if (kind > 14)
161 kind = 14;
162 }
163 if ((0x100000200L & l) != 0L)
164 jjCheckNAddStates(0, 2);
165 else if (curChar == 13)
166 jjstateSet[jjnewStateCnt++] = 1;
167 break;
168 case 0:
169 if ((0x100000200L & l) != 0L)
170 jjCheckNAddStates(0, 2);
171 break;
172 case 1:
173 if (curChar == 10 && kind > 14)
174 kind = 14;
175 break;
176 case 2:
177 if (curChar == 13)
178 jjstateSet[jjnewStateCnt++] = 1;
179 break;
180 case 3:
181 if ((0x2400L & l) != 0L && kind > 14)
182 kind = 14;
183 break;
184 case 4:
185 if ((0xefffffffffffdbffL & l) == 0L)
186 break;
187 if (kind > 19)
188 kind = 19;
189 jjCheckNAdd(4);
190 break;
191 default : break;
192 }
193 } while(i != startsAt);
194 }
195 else if (curChar < 128)
196 {
197 do
198 {
199 switch(jjstateSet[--i])
200 {
201 case 5:
202 case 4:
203 kind = 19;
204 jjCheckNAdd(4);
205 break;
206 default : break;
207 }
208 } while(i != startsAt);
209 }
210 else
211 {
212 int i2 = (curChar & 0xff) >> 6;
213 long l2 = 1L << (curChar & 077);
214 do
215 {
216 switch(jjstateSet[--i])
217 {
218 case 5:
219 case 4:
220 if ((jjbitVec0[i2] & l2) == 0L)
221 break;
222 if (kind > 19)
223 kind = 19;
224 jjCheckNAdd(4);
225 break;
226 default : break;
227 }
228 } while(i != startsAt);
229 }
230 if (kind != 0x7fffffff)
231 {
232 jjmatchedKind = kind;
233 jjmatchedPos = curPos;
234 kind = 0x7fffffff;
235 }
236 ++curPos;
237 if ((i = jjnewStateCnt) == (startsAt = 5 - (jjnewStateCnt = startsAt)))
238 return curPos;
239 try { curChar = input_stream.readChar(); }
240 catch(java.io.IOException e) { return curPos; }
241 }
242 }
243 private final int jjStopStringLiteralDfa_5(int pos, long active0)
244 {
245 switch (pos)
246 {
247 default :
248 return -1;
249 }
250 }
251 private final int jjStartNfa_5(int pos, long active0)
252 {
253 return jjMoveNfa_5(jjStopStringLiteralDfa_5(pos, active0), pos + 1);
254 }
255 private int jjMoveStringLiteralDfa0_5()
256 {
257 switch(curChar)
258 {
259 case 47:
260 return jjMoveStringLiteralDfa1_5(0x8000000L);
261 case 60:
262 return jjStopAtPos(0, 29);
263 case 61:
264 jjmatchedKind = 28;
265 return jjMoveStringLiteralDfa1_5(0xeL);
266 case 62:
267 return jjStopAtPos(0, 26);
268 default :
269 return jjMoveNfa_5(1, 0);
270 }
271 }
272 private int jjMoveStringLiteralDfa1_5(long active0)
273 {
274 try { curChar = input_stream.readChar(); }
275 catch(java.io.IOException e) {
276 jjStopStringLiteralDfa_5(0, active0);
277 return 1;
278 }
279 switch(curChar)
280 {
281 case 10:
282 if ((active0 & 0x2L) != 0L)
283 return jjStopAtPos(1, 1);
284 break;
285 case 13:
286 if ((active0 & 0x8L) != 0L)
287 {
288 jjmatchedKind = 3;
289 jjmatchedPos = 1;
290 }
291 return jjMoveStringLiteralDfa2_5(active0, 0x4L);
292 case 62:
293 if ((active0 & 0x8000000L) != 0L)
294 return jjStopAtPos(1, 27);
295 break;
296 default :
297 break;
298 }
299 return jjStartNfa_5(0, active0);
300 }
301 private int jjMoveStringLiteralDfa2_5(long old0, long active0)
302 {
303 if (((active0 &= old0)) == 0L)
304 return jjStartNfa_5(0, old0);
305 try { curChar = input_stream.readChar(); }
306 catch(java.io.IOException e) {
307 jjStopStringLiteralDfa_5(1, active0);
308 return 2;
309 }
310 switch(curChar)
311 {
312 case 10:
313 if ((active0 & 0x4L) != 0L)
314 return jjStopAtPos(2, 2);
315 break;
316 default :
317 break;
318 }
319 return jjStartNfa_5(1, active0);
320 }
321 private int jjMoveNfa_5(int startState, int curPos)
322 {
323
324 int startsAt = 0;
325 jjnewStateCnt = 3;
326 int i = 1;
327 jjstateSet[0] = startState;
328
329 int kind = 0x7fffffff;
330 for (;;)
331 {
332 if (++jjround == 0x7fffffff)
333 ReInitRounds();
334 if (curChar < 64)
335 {
336 long l = 1L << curChar;
337 do
338 {
339 switch(jjstateSet[--i])
340 {
341 case 1:
342 case 0:
343 if ((0x100002600L & l) == 0L)
344 break;
345 kind = 24;
346 jjCheckNAdd(0);
347 break;
348 case 2:
349 if ((0x7ff600000000000L & l) == 0L)
350 break;
351 kind = 25;
352 jjstateSet[jjnewStateCnt++] = 2;
353 break;
354 default : break;
355 }
356 } while(i != startsAt);
357 }
358 else if (curChar < 128)
359 {
360 long l = 1L << (curChar & 077);
361 do
362 {
363 switch(jjstateSet[--i])
364 {
365 case 1:
366 if ((0x7fffffe07fffffeL & l) == 0L)
367 break;
368 if (kind > 25)
369 kind = 25;
370 jjCheckNAdd(2);
371 break;
372 case 2:
373 if ((0x7fffffe87fffffeL & l) == 0L)
374 break;
375 if (kind > 25)
376 kind = 25;
377 jjCheckNAdd(2);
378 break;
379 default : break;
380 }
381 } while(i != startsAt);
382 }
383 else
384 {
385 do
386 {
387 switch(jjstateSet[--i])
388 {
389 default : break;
390 }
391 } while(i != startsAt);
392 }
393 if (kind != 0x7fffffff)
394 {
395 jjmatchedKind = kind;
396 jjmatchedPos = curPos;
397 kind = 0x7fffffff;
398 }
399 ++curPos;
400 if ((i = jjnewStateCnt) == (startsAt = 3 - (jjnewStateCnt = startsAt)))
401 return curPos;
402 try { curChar = input_stream.readChar(); }
403 catch(java.io.IOException e) { return curPos; }
404 }
405 }
406 private final int jjStopStringLiteralDfa_4(int pos, long active0)
407 {
408 switch (pos)
409 {
410 case 0:
411 if ((active0 & 0xeL) != 0L)
412 {
413 jjmatchedKind = 32;
414 return 1;
415 }
416 return -1;
417 default :
418 return -1;
419 }
420 }
421 private final int jjStartNfa_4(int pos, long active0)
422 {
423 return jjMoveNfa_4(jjStopStringLiteralDfa_4(pos, active0), pos + 1);
424 }
425 private int jjMoveStringLiteralDfa0_4()
426 {
427 switch(curChar)
428 {
429 case 61:
430 return jjMoveStringLiteralDfa1_4(0xeL);
431 default :
432 return jjMoveNfa_4(0, 0);
433 }
434 }
435 private int jjMoveStringLiteralDfa1_4(long active0)
436 {
437 try { curChar = input_stream.readChar(); }
438 catch(java.io.IOException e) {
439 jjStopStringLiteralDfa_4(0, active0);
440 return 1;
441 }
442 switch(curChar)
443 {
444 case 10:
445 if ((active0 & 0x2L) != 0L)
446 return jjStopAtPos(1, 1);
447 break;
448 case 13:
449 if ((active0 & 0x8L) != 0L)
450 {
451 jjmatchedKind = 3;
452 jjmatchedPos = 1;
453 }
454 return jjMoveStringLiteralDfa2_4(active0, 0x4L);
455 default :
456 break;
457 }
458 return jjStartNfa_4(0, active0);
459 }
460 private int jjMoveStringLiteralDfa2_4(long old0, long active0)
461 {
462 if (((active0 &= old0)) == 0L)
463 return jjStartNfa_4(0, old0);
464 try { curChar = input_stream.readChar(); }
465 catch(java.io.IOException e) {
466 jjStopStringLiteralDfa_4(1, active0);
467 return 2;
468 }
469 switch(curChar)
470 {
471 case 10:
472 if ((active0 & 0x4L) != 0L)
473 return jjStopAtPos(2, 2);
474 break;
475 default :
476 break;
477 }
478 return jjStartNfa_4(1, active0);
479 }
480 private int jjMoveNfa_4(int startState, int curPos)
481 {
482
483 int startsAt = 0;
484 jjnewStateCnt = 8;
485 int i = 1;
486 jjstateSet[0] = startState;
487
488 int kind = 0x7fffffff;
489 for (;;)
490 {
491 if (++jjround == 0x7fffffff)
492 ReInitRounds();
493 if (curChar < 64)
494 {
495 long l = 1L << curChar;
496 do
497 {
498 switch(jjstateSet[--i])
499 {
500 case 0:
501 if ((0xbfffff7affffd9ffL & l) != 0L)
502 {
503 if (kind > 32)
504 kind = 32;
505 jjCheckNAdd(1);
506 }
507 else if ((0x100002600L & l) != 0L)
508 {
509 if (kind > 31)
510 kind = 31;
511 }
512 else if (curChar == 39)
513 jjCheckNAddTwoStates(6, 7);
514 else if (curChar == 34)
515 jjCheckNAddTwoStates(3, 4);
516 break;
517 case 1:
518 if ((0xbfffff7affffd9ffL & l) == 0L)
519 break;
520 if (kind > 32)
521 kind = 32;
522 jjCheckNAdd(1);
523 break;
524 case 2:
525 if (curChar == 34)
526 jjCheckNAddTwoStates(3, 4);
527 break;
528 case 3:
529 if ((0xfffffffbffffffffL & l) != 0L)
530 jjCheckNAddTwoStates(3, 4);
531 break;
532 case 4:
533 if (curChar == 34 && kind > 32)
534 kind = 32;
535 break;
536 case 5:
537 if (curChar == 39)
538 jjCheckNAddTwoStates(6, 7);
539 break;
540 case 6:
541 if ((0xffffff7fffffffffL & l) != 0L)
542 jjCheckNAddTwoStates(6, 7);
543 break;
544 case 7:
545 if (curChar == 39 && kind > 32)
546 kind = 32;
547 break;
548 default : break;
549 }
550 } while(i != startsAt);
551 }
552 else if (curChar < 128)
553 {
554 do
555 {
556 switch(jjstateSet[--i])
557 {
558 case 0:
559 case 1:
560 if (kind > 32)
561 kind = 32;
562 jjCheckNAdd(1);
563 break;
564 case 3:
565 jjAddStates(3, 4);
566 break;
567 case 6:
568 jjAddStates(5, 6);
569 break;
570 default : break;
571 }
572 } while(i != startsAt);
573 }
574 else
575 {
576 int i2 = (curChar & 0xff) >> 6;
577 long l2 = 1L << (curChar & 077);
578 do
579 {
580 switch(jjstateSet[--i])
581 {
582 case 0:
583 case 1:
584 if ((jjbitVec0[i2] & l2) == 0L)
585 break;
586 if (kind > 32)
587 kind = 32;
588 jjCheckNAdd(1);
589 break;
590 case 3:
591 if ((jjbitVec0[i2] & l2) != 0L)
592 jjAddStates(3, 4);
593 break;
594 case 6:
595 if ((jjbitVec0[i2] & l2) != 0L)
596 jjAddStates(5, 6);
597 break;
598 default : break;
599 }
600 } while(i != startsAt);
601 }
602 if (kind != 0x7fffffff)
603 {
604 jjmatchedKind = kind;
605 jjmatchedPos = curPos;
606 kind = 0x7fffffff;
607 }
608 ++curPos;
609 if ((i = jjnewStateCnt) == (startsAt = 8 - (jjnewStateCnt = startsAt)))
610 return curPos;
611 try { curChar = input_stream.readChar(); }
612 catch(java.io.IOException e) { return curPos; }
613 }
614 }
615 private final int jjStopStringLiteralDfa_6(int pos, long active0)
616 {
617 switch (pos)
618 {
619 case 0:
620 if ((active0 & 0x300000L) != 0L)
621 {
622 jjmatchedKind = 22;
623 return 1;
624 }
625 return -1;
626 case 1:
627 if ((active0 & 0x300000L) != 0L)
628 {
629 if (jjmatchedPos != 1)
630 {
631 jjmatchedKind = 22;
632 jjmatchedPos = 1;
633 }
634 return 1;
635 }
636 return -1;
637 case 2:
638 if ((active0 & 0x300000L) != 0L)
639 {
640 jjmatchedKind = 22;
641 jjmatchedPos = 2;
642 return 1;
643 }
644 return -1;
645 case 3:
646 if ((active0 & 0x300000L) != 0L)
647 {
648 jjmatchedKind = 22;
649 jjmatchedPos = 3;
650 return 1;
651 }
652 return -1;
653 case 4:
654 if ((active0 & 0x200000L) != 0L)
655 return 1;
656 if ((active0 & 0x100000L) != 0L)
657 {
658 jjmatchedKind = 22;
659 jjmatchedPos = 4;
660 return 1;
661 }
662 return -1;
663 default :
664 return -1;
665 }
666 }
667 private final int jjStartNfa_6(int pos, long active0)
668 {
669 return jjMoveNfa_6(jjStopStringLiteralDfa_6(pos, active0), pos + 1);
670 }
671 private int jjStartNfaWithStates_6(int pos, int kind, int state)
672 {
673 jjmatchedKind = kind;
674 jjmatchedPos = pos;
675 try { curChar = input_stream.readChar(); }
676 catch(java.io.IOException e) { return pos + 1; }
677 return jjMoveNfa_6(state, pos + 1);
678 }
679 private int jjMoveStringLiteralDfa0_6()
680 {
681 switch(curChar)
682 {
683 case 61:
684 return jjMoveStringLiteralDfa1_6(0xeL);
685 case 83:
686 case 115:
687 return jjMoveStringLiteralDfa1_6(0x300000L);
688 default :
689 return jjMoveNfa_6(0, 0);
690 }
691 }
692 private int jjMoveStringLiteralDfa1_6(long active0)
693 {
694 try { curChar = input_stream.readChar(); }
695 catch(java.io.IOException e) {
696 jjStopStringLiteralDfa_6(0, active0);
697 return 1;
698 }
699 switch(curChar)
700 {
701 case 10:
702 if ((active0 & 0x2L) != 0L)
703 return jjStopAtPos(1, 1);
704 break;
705 case 13:
706 if ((active0 & 0x8L) != 0L)
707 {
708 jjmatchedKind = 3;
709 jjmatchedPos = 1;
710 }
711 return jjMoveStringLiteralDfa2_6(active0, 0x4L);
712 case 67:
713 case 99:
714 return jjMoveStringLiteralDfa2_6(active0, 0x100000L);
715 case 84:
716 case 116:
717 return jjMoveStringLiteralDfa2_6(active0, 0x200000L);
718 default :
719 break;
720 }
721 return jjStartNfa_6(0, active0);
722 }
723 private int jjMoveStringLiteralDfa2_6(long old0, long active0)
724 {
725 if (((active0 &= old0)) == 0L)
726 return jjStartNfa_6(0, old0);
727 try { curChar = input_stream.readChar(); }
728 catch(java.io.IOException e) {
729 jjStopStringLiteralDfa_6(1, active0);
730 return 2;
731 }
732 switch(curChar)
733 {
734 case 10:
735 if ((active0 & 0x4L) != 0L)
736 return jjStopAtPos(2, 2);
737 break;
738 case 82:
739 case 114:
740 return jjMoveStringLiteralDfa3_6(active0, 0x100000L);
741 case 89:
742 case 121:
743 return jjMoveStringLiteralDfa3_6(active0, 0x200000L);
744 default :
745 break;
746 }
747 return jjStartNfa_6(1, active0);
748 }
749 private int jjMoveStringLiteralDfa3_6(long old0, long active0)
750 {
751 if (((active0 &= old0)) == 0L)
752 return jjStartNfa_6(1, old0);
753 try { curChar = input_stream.readChar(); }
754 catch(java.io.IOException e) {
755 jjStopStringLiteralDfa_6(2, active0);
756 return 3;
757 }
758 switch(curChar)
759 {
760 case 73:
761 case 105:
762 return jjMoveStringLiteralDfa4_6(active0, 0x100000L);
763 case 76:
764 case 108:
765 return jjMoveStringLiteralDfa4_6(active0, 0x200000L);
766 default :
767 break;
768 }
769 return jjStartNfa_6(2, active0);
770 }
771 private int jjMoveStringLiteralDfa4_6(long old0, long active0)
772 {
773 if (((active0 &= old0)) == 0L)
774 return jjStartNfa_6(2, old0);
775 try { curChar = input_stream.readChar(); }
776 catch(java.io.IOException e) {
777 jjStopStringLiteralDfa_6(3, active0);
778 return 4;
779 }
780 switch(curChar)
781 {
782 case 69:
783 case 101:
784 if ((active0 & 0x200000L) != 0L)
785 return jjStartNfaWithStates_6(4, 21, 1);
786 break;
787 case 80:
788 case 112:
789 return jjMoveStringLiteralDfa5_6(active0, 0x100000L);
790 default :
791 break;
792 }
793 return jjStartNfa_6(3, active0);
794 }
795 private int jjMoveStringLiteralDfa5_6(long old0, long active0)
796 {
797 if (((active0 &= old0)) == 0L)
798 return jjStartNfa_6(3, old0);
799 try { curChar = input_stream.readChar(); }
800 catch(java.io.IOException e) {
801 jjStopStringLiteralDfa_6(4, active0);
802 return 5;
803 }
804 switch(curChar)
805 {
806 case 84:
807 case 116:
808 if ((active0 & 0x100000L) != 0L)
809 return jjStartNfaWithStates_6(5, 20, 1);
810 break;
811 default :
812 break;
813 }
814 return jjStartNfa_6(4, active0);
815 }
816 private int jjMoveNfa_6(int startState, int curPos)
817 {
818
819 int startsAt = 0;
820 jjnewStateCnt = 2;
821 int i = 1;
822 jjstateSet[0] = startState;
823
824 int kind = 0x7fffffff;
825 for (;;)
826 {
827 if (++jjround == 0x7fffffff)
828 ReInitRounds();
829 if (curChar < 64)
830 {
831 long l = 1L << curChar;
832 do
833 {
834 switch(jjstateSet[--i])
835 {
836 case 1:
837 if ((0x7ff600000000000L & l) == 0L)
838 break;
839 kind = 22;
840 jjstateSet[jjnewStateCnt++] = 1;
841 break;
842 default : break;
843 }
844 } while(i != startsAt);
845 }
846 else if (curChar < 128)
847 {
848 long l = 1L << (curChar & 077);
849 do
850 {
851 switch(jjstateSet[--i])
852 {
853 case 0:
854 if ((0x7fffffe07fffffeL & l) == 0L)
855 break;
856 if (kind > 22)
857 kind = 22;
858 jjCheckNAdd(1);
859 break;
860 case 1:
861 if ((0x7fffffe87fffffeL & l) == 0L)
862 break;
863 if (kind > 22)
864 kind = 22;
865 jjCheckNAdd(1);
866 break;
867 default : break;
868 }
869 } while(i != startsAt);
870 }
871 else
872 {
873 do
874 {
875 switch(jjstateSet[--i])
876 {
877 default : break;
878 }
879 } while(i != startsAt);
880 }
881 if (kind != 0x7fffffff)
882 {
883 jjmatchedKind = kind;
884 jjmatchedPos = curPos;
885 kind = 0x7fffffff;
886 }
887 ++curPos;
888 if ((i = jjnewStateCnt) == (startsAt = 2 - (jjnewStateCnt = startsAt)))
889 return curPos;
890 try { curChar = input_stream.readChar(); }
891 catch(java.io.IOException e) { return curPos; }
892 }
893 }
894 private final int jjStopStringLiteralDfa_1(int pos, long active0)
895 {
896 switch (pos)
897 {
898 case 0:
899 if ((active0 & 0xeL) != 0L)
900 {
901 jjmatchedKind = 44;
902 return 3;
903 }
904 return -1;
905 default :
906 return -1;
907 }
908 }
909 private final int jjStartNfa_1(int pos, long active0)
910 {
911 return jjMoveNfa_1(jjStopStringLiteralDfa_1(pos, active0), pos + 1);
912 }
913 private int jjMoveStringLiteralDfa0_1()
914 {
915 switch(curChar)
916 {
917 case 60:
918 jjmatchedKind = 43;
919 return jjMoveStringLiteralDfa1_1(0x10000000000L);
920 case 61:
921 return jjMoveStringLiteralDfa1_1(0xeL);
922 default :
923 return jjMoveNfa_1(1, 0);
924 }
925 }
926 private int jjMoveStringLiteralDfa1_1(long active0)
927 {
928 try { curChar = input_stream.readChar(); }
929 catch(java.io.IOException e) {
930 jjStopStringLiteralDfa_1(0, active0);
931 return 1;
932 }
933 switch(curChar)
934 {
935 case 10:
936 if ((active0 & 0x2L) != 0L)
937 return jjStopAtPos(1, 1);
938 break;
939 case 13:
940 if ((active0 & 0x8L) != 0L)
941 {
942 jjmatchedKind = 3;
943 jjmatchedPos = 1;
944 }
945 return jjMoveStringLiteralDfa2_1(active0, 0x4L);
946 case 47:
947 return jjMoveStringLiteralDfa2_1(active0, 0x10000000000L);
948 default :
949 break;
950 }
951 return jjStartNfa_1(0, active0);
952 }
953 private int jjMoveStringLiteralDfa2_1(long old0, long active0)
954 {
955 if (((active0 &= old0)) == 0L)
956 return jjStartNfa_1(0, old0);
957 try { curChar = input_stream.readChar(); }
958 catch(java.io.IOException e) {
959 jjStopStringLiteralDfa_1(1, active0);
960 return 2;
961 }
962 switch(curChar)
963 {
964 case 10:
965 if ((active0 & 0x4L) != 0L)
966 return jjStopAtPos(2, 2);
967 break;
968 case 83:
969 case 115:
970 return jjMoveStringLiteralDfa3_1(active0, 0x10000000000L);
971 default :
972 break;
973 }
974 return jjStartNfa_1(1, active0);
975 }
976 private int jjMoveStringLiteralDfa3_1(long old0, long active0)
977 {
978 if (((active0 &= old0)) == 0L)
979 return jjStartNfa_1(1, old0);
980 try { curChar = input_stream.readChar(); }
981 catch(java.io.IOException e) {
982 jjStopStringLiteralDfa_1(2, active0);
983 return 3;
984 }
985 switch(curChar)
986 {
987 case 67:
988 case 99:
989 return jjMoveStringLiteralDfa4_1(active0, 0x10000000000L);
990 default :
991 break;
992 }
993 return jjStartNfa_1(2, active0);
994 }
995 private int jjMoveStringLiteralDfa4_1(long old0, long active0)
996 {
997 if (((active0 &= old0)) == 0L)
998 return jjStartNfa_1(2, old0);
999 try { curChar = input_stream.readChar(); }
1000 catch(java.io.IOException e) {
1001 jjStopStringLiteralDfa_1(3, active0);
1002 return 4;
1003 }
1004 switch(curChar)
1005 {
1006 case 82:
1007 case 114:
1008 return jjMoveStringLiteralDfa5_1(active0, 0x10000000000L);
1009 default :
1010 break;
1011 }
1012 return jjStartNfa_1(3, active0);
1013 }
1014 private int jjMoveStringLiteralDfa5_1(long old0, long active0)
1015 {
1016 if (((active0 &= old0)) == 0L)
1017 return jjStartNfa_1(3, old0);
1018 try { curChar = input_stream.readChar(); }
1019 catch(java.io.IOException e) {
1020 jjStopStringLiteralDfa_1(4, active0);
1021 return 5;
1022 }
1023 switch(curChar)
1024 {
1025 case 73:
1026 case 105:
1027 return jjMoveStringLiteralDfa6_1(active0, 0x10000000000L);
1028 default :
1029 break;
1030 }
1031 return jjStartNfa_1(4, active0);
1032 }
1033 private int jjMoveStringLiteralDfa6_1(long old0, long active0)
1034 {
1035 if (((active0 &= old0)) == 0L)
1036 return jjStartNfa_1(4, old0);
1037 try { curChar = input_stream.readChar(); }
1038 catch(java.io.IOException e) {
1039 jjStopStringLiteralDfa_1(5, active0);
1040 return 6;
1041 }
1042 switch(curChar)
1043 {
1044 case 80:
1045 case 112:
1046 return jjMoveStringLiteralDfa7_1(active0, 0x10000000000L);
1047 default :
1048 break;
1049 }
1050 return jjStartNfa_1(5, active0);
1051 }
1052 private int jjMoveStringLiteralDfa7_1(long old0, long active0)
1053 {
1054 if (((active0 &= old0)) == 0L)
1055 return jjStartNfa_1(5, old0);
1056 try { curChar = input_stream.readChar(); }
1057 catch(java.io.IOException e) {
1058 jjStopStringLiteralDfa_1(6, active0);
1059 return 7;
1060 }
1061 switch(curChar)
1062 {
1063 case 84:
1064 case 116:
1065 return jjMoveStringLiteralDfa8_1(active0, 0x10000000000L);
1066 default :
1067 break;
1068 }
1069 return jjStartNfa_1(6, active0);
1070 }
1071 private int jjMoveStringLiteralDfa8_1(long old0, long active0)
1072 {
1073 if (((active0 &= old0)) == 0L)
1074 return jjStartNfa_1(6, old0);
1075 try { curChar = input_stream.readChar(); }
1076 catch(java.io.IOException e) {
1077 jjStopStringLiteralDfa_1(7, active0);
1078 return 8;
1079 }
1080 switch(curChar)
1081 {
1082 case 62:
1083 if ((active0 & 0x10000000000L) != 0L)
1084 return jjStopAtPos(8, 40);
1085 break;
1086 default :
1087 break;
1088 }
1089 return jjStartNfa_1(7, active0);
1090 }
1091 private int jjMoveNfa_1(int startState, int curPos)
1092 {
1093
1094 int startsAt = 0;
1095 jjnewStateCnt = 11;
1096 int i = 1;
1097 jjstateSet[0] = startState;
1098
1099 int kind = 0x7fffffff;
1100 for (;;)
1101 {
1102 if (++jjround == 0x7fffffff)
1103 ReInitRounds();
1104 if (curChar < 64)
1105 {
1106 long l = 1L << curChar;
1107 do
1108 {
1109 switch(jjstateSet[--i])
1110 {
1111 case 1:
1112 if ((0xefffff7bffffdbffL & l) != 0L)
1113 {
1114 if (kind > 44)
1115 kind = 44;
1116 jjCheckNAdd(3);
1117 }
1118 else if ((0x8400000000L & l) != 0L)
1119 {
1120 if (kind > 44)
1121 kind = 44;
1122 }
1123 else if ((0x2400L & l) != 0L)
1124 {
1125 if (kind > 42)
1126 kind = 42;
1127 }
1128 if (curChar == 39)
1129 jjCheckNAddTwoStates(8, 9);
1130 else if (curChar == 34)
1131 jjCheckNAddTwoStates(5, 6);
1132 else if (curChar == 13)
1133 jjstateSet[jjnewStateCnt++] = 0;
1134 break;
1135 case 0:
1136 if (curChar == 10 && kind > 42)
1137 kind = 42;
1138 break;
1139 case 2:
1140 if ((0x2400L & l) != 0L && kind > 42)
1141 kind = 42;
1142 break;
1143 case 3:
1144 if ((0xefffff7bffffdbffL & l) == 0L)
1145 break;
1146 if (kind > 44)
1147 kind = 44;
1148 jjCheckNAdd(3);
1149 break;
1150 case 4:
1151 if (curChar == 34)
1152 jjCheckNAddTwoStates(5, 6);
1153 break;
1154 case 5:
1155 if ((0xfffffffbffffdbffL & l) != 0L)
1156 jjCheckNAddTwoStates(5, 6);
1157 break;
1158 case 6:
1159 if (curChar == 34 && kind > 44)
1160 kind = 44;
1161 break;
1162 case 7:
1163 if (curChar == 39)
1164 jjCheckNAddTwoStates(8, 9);
1165 break;
1166 case 8:
1167 if ((0xffffff7fffffdbffL & l) != 0L)
1168 jjCheckNAddTwoStates(8, 9);
1169 break;
1170 case 9:
1171 if (curChar == 39 && kind > 44)
1172 kind = 44;
1173 break;
1174 case 10:
1175 if ((0x8400000000L & l) != 0L && kind > 44)
1176 kind = 44;
1177 break;
1178 default : break;
1179 }
1180 } while(i != startsAt);
1181 }
1182 else if (curChar < 128)
1183 {
1184 do
1185 {
1186 switch(jjstateSet[--i])
1187 {
1188 case 1:
1189 case 3:
1190 if (kind > 44)
1191 kind = 44;
1192 jjCheckNAdd(3);
1193 break;
1194 case 5:
1195 jjAddStates(7, 8);
1196 break;
1197 case 8:
1198 jjAddStates(9, 10);
1199 break;
1200 default : break;
1201 }
1202 } while(i != startsAt);
1203 }
1204 else
1205 {
1206 int i2 = (curChar & 0xff) >> 6;
1207 long l2 = 1L << (curChar & 077);
1208 do
1209 {
1210 switch(jjstateSet[--i])
1211 {
1212 case 1:
1213 case 3:
1214 if ((jjbitVec0[i2] & l2) == 0L)
1215 break;
1216 if (kind > 44)
1217 kind = 44;
1218 jjCheckNAdd(3);
1219 break;
1220 case 5:
1221 if ((jjbitVec0[i2] & l2) != 0L)
1222 jjAddStates(7, 8);
1223 break;
1224 case 8:
1225 if ((jjbitVec0[i2] & l2) != 0L)
1226 jjAddStates(9, 10);
1227 break;
1228 default : break;
1229 }
1230 } while(i != startsAt);
1231 }
1232 if (kind != 0x7fffffff)
1233 {
1234 jjmatchedKind = kind;
1235 jjmatchedPos = curPos;
1236 kind = 0x7fffffff;
1237 }
1238 ++curPos;
1239 if ((i = jjnewStateCnt) == (startsAt = 11 - (jjnewStateCnt = startsAt)))
1240 return curPos;
1241 try { curChar = input_stream.readChar(); }
1242 catch(java.io.IOException e) { return curPos; }
1243 }
1244 }
1245 private final int jjStopStringLiteralDfa_2(int pos, long active0)
1246 {
1247 switch (pos)
1248 {
1249 case 0:
1250 if ((active0 & 0xeL) != 0L)
1251 {
1252 jjmatchedKind = 38;
1253 return 7;
1254 }
1255 return -1;
1256 case 1:
1257 if ((active0 & 0xeL) != 0L)
1258 return 7;
1259 return -1;
1260 default :
1261 return -1;
1262 }
1263 }
1264 private final int jjStartNfa_2(int pos, long active0)
1265 {
1266 return jjMoveNfa_2(jjStopStringLiteralDfa_2(pos, active0), pos + 1);
1267 }
1268 private int jjStartNfaWithStates_2(int pos, int kind, int state)
1269 {
1270 jjmatchedKind = kind;
1271 jjmatchedPos = pos;
1272 try { curChar = input_stream.readChar(); }
1273 catch(java.io.IOException e) { return pos + 1; }
1274 return jjMoveNfa_2(state, pos + 1);
1275 }
1276 private int jjMoveStringLiteralDfa0_2()
1277 {
1278 switch(curChar)
1279 {
1280 case 61:
1281 return jjMoveStringLiteralDfa1_2(0xeL);
1282 case 62:
1283 return jjStopAtPos(0, 39);
1284 default :
1285 return jjMoveNfa_2(7, 0);
1286 }
1287 }
1288 private int jjMoveStringLiteralDfa1_2(long active0)
1289 {
1290 try { curChar = input_stream.readChar(); }
1291 catch(java.io.IOException e) {
1292 jjStopStringLiteralDfa_2(0, active0);
1293 return 1;
1294 }
1295 switch(curChar)
1296 {
1297 case 10:
1298 if ((active0 & 0x2L) != 0L)
1299 return jjStartNfaWithStates_2(1, 1, 7);
1300 break;
1301 case 13:
1302 if ((active0 & 0x8L) != 0L)
1303 {
1304 jjmatchedKind = 3;
1305 jjmatchedPos = 1;
1306 }
1307 return jjMoveStringLiteralDfa2_2(active0, 0x4L);
1308 default :
1309 break;
1310 }
1311 return jjStartNfa_2(0, active0);
1312 }
1313 private int jjMoveStringLiteralDfa2_2(long old0, long active0)
1314 {
1315 if (((active0 &= old0)) == 0L)
1316 return jjStartNfa_2(0, old0);
1317 try { curChar = input_stream.readChar(); }
1318 catch(java.io.IOException e) {
1319 jjStopStringLiteralDfa_2(1, active0);
1320 return 2;
1321 }
1322 switch(curChar)
1323 {
1324 case 10:
1325 if ((active0 & 0x4L) != 0L)
1326 return jjStartNfaWithStates_2(2, 2, 7);
1327 break;
1328 default :
1329 break;
1330 }
1331 return jjStartNfa_2(1, active0);
1332 }
1333 private int jjMoveNfa_2(int startState, int curPos)
1334 {
1335
1336 int startsAt = 0;
1337 jjnewStateCnt = 7;
1338 int i = 1;
1339 jjstateSet[0] = startState;
1340
1341 int kind = 0x7fffffff;
1342 for (;;)
1343 {
1344 if (++jjround == 0x7fffffff)
1345 ReInitRounds();
1346 if (curChar < 64)
1347 {
1348 long l = 1L << curChar;
1349 do
1350 {
1351 switch(jjstateSet[--i])
1352 {
1353 case 7:
1354 if ((0xbfffffffffffffffL & l) != 0L)
1355 {
1356 if (kind > 38)
1357 kind = 38;
1358 jjCheckNAddStates(11, 13);
1359 }
1360 if (curChar == 39)
1361 jjCheckNAddTwoStates(5, 6);
1362 else if (curChar == 34)
1363 jjCheckNAddTwoStates(2, 3);
1364 break;
1365 case 0:
1366 if ((0xbfffffffffffffffL & l) == 0L)
1367 break;
1368 if (kind > 38)
1369 kind = 38;
1370 jjCheckNAddStates(11, 13);
1371 break;
1372 case 1:
1373 if (curChar == 34)
1374 jjCheckNAddTwoStates(2, 3);
1375 break;
1376 case 2:
1377 if ((0xfffffffbffffdbffL & l) != 0L)
1378 jjCheckNAddTwoStates(2, 3);
1379 break;
1380 case 3:
1381 if (curChar != 34)
1382 break;
1383 if (kind > 38)
1384 kind = 38;
1385 jjCheckNAddStates(11, 13);
1386 break;
1387 case 4:
1388 if (curChar == 39)
1389 jjCheckNAddTwoStates(5, 6);
1390 break;
1391 case 5:
1392 if ((0xffffff7fffffdbffL & l) != 0L)
1393 jjCheckNAddTwoStates(5, 6);
1394 break;
1395 case 6:
1396 if (curChar != 39)
1397 break;
1398 if (kind > 38)
1399 kind = 38;
1400 jjCheckNAddStates(11, 13);
1401 break;
1402 default : break;
1403 }
1404 } while(i != startsAt);
1405 }
1406 else if (curChar < 128)
1407 {
1408 do
1409 {
1410 switch(jjstateSet[--i])
1411 {
1412 case 7:
1413 case 0:
1414 if (kind > 38)
1415 kind = 38;
1416 jjCheckNAddStates(11, 13);
1417 break;
1418 case 2:
1419 jjAddStates(14, 15);
1420 break;
1421 case 5:
1422 jjAddStates(7, 8);
1423 break;
1424 default : break;
1425 }
1426 } while(i != startsAt);
1427 }
1428 else
1429 {
1430 int i2 = (curChar & 0xff) >> 6;
1431 long l2 = 1L << (curChar & 077);
1432 do
1433 {
1434 switch(jjstateSet[--i])
1435 {
1436 case 7:
1437 case 0:
1438 if ((jjbitVec0[i2] & l2) == 0L)
1439 break;
1440 if (kind > 38)
1441 kind = 38;
1442 jjCheckNAddStates(11, 13);
1443 break;
1444 case 2:
1445 if ((jjbitVec0[i2] & l2) != 0L)
1446 jjAddStates(14, 15);
1447 break;
1448 case 5:
1449 if ((jjbitVec0[i2] & l2) != 0L)
1450 jjAddStates(7, 8);
1451 break;
1452 default : break;
1453 }
1454 } while(i != startsAt);
1455 }
1456 if (kind != 0x7fffffff)