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)
1457 {
1458 jjmatchedKind = kind;
1459 jjmatchedPos = curPos;
1460 kind = 0x7fffffff;
1461 }
1462 ++curPos;
1463 if ((i = jjnewStateCnt) == (startsAt = 7 - (jjnewStateCnt = startsAt)))
1464 return curPos;
1465 try { curChar = input_stream.readChar(); }
1466 catch(java.io.IOException e) { return curPos; }
1467 }
1468 }
1469 private final int jjStopStringLiteralDfa_0(int pos, long active0)
1470 {
1471 switch (pos)
1472 {
1473 case 0:
1474 if ((active0 & 0xeL) != 0L)
1475 {
1476 jjmatchedKind = 44;
1477 return 3;
1478 }
1479 return -1;
1480 default :
1481 return -1;
1482 }
1483 }
1484 private final int jjStartNfa_0(int pos, long active0)
1485 {
1486 return jjMoveNfa_0(jjStopStringLiteralDfa_0(pos, active0), pos + 1);
1487 }
1488 private int jjMoveStringLiteralDfa0_0()
1489 {
1490 switch(curChar)
1491 {
1492 case 60:
1493 jjmatchedKind = 43;
1494 return jjMoveStringLiteralDfa1_0(0x20000000000L);
1495 case 61:
1496 return jjMoveStringLiteralDfa1_0(0xeL);
1497 default :
1498 return jjMoveNfa_0(1, 0);
1499 }
1500 }
1501 private int jjMoveStringLiteralDfa1_0(long active0)
1502 {
1503 try { curChar = input_stream.readChar(); }
1504 catch(java.io.IOException e) {
1505 jjStopStringLiteralDfa_0(0, active0);
1506 return 1;
1507 }
1508 switch(curChar)
1509 {
1510 case 10:
1511 if ((active0 & 0x2L) != 0L)
1512 return jjStopAtPos(1, 1);
1513 break;
1514 case 13:
1515 if ((active0 & 0x8L) != 0L)
1516 {
1517 jjmatchedKind = 3;
1518 jjmatchedPos = 1;
1519 }
1520 return jjMoveStringLiteralDfa2_0(active0, 0x4L);
1521 case 47:
1522 return jjMoveStringLiteralDfa2_0(active0, 0x20000000000L);
1523 default :
1524 break;
1525 }
1526 return jjStartNfa_0(0, active0);
1527 }
1528 private int jjMoveStringLiteralDfa2_0(long old0, long active0)
1529 {
1530 if (((active0 &= old0)) == 0L)
1531 return jjStartNfa_0(0, old0);
1532 try { curChar = input_stream.readChar(); }
1533 catch(java.io.IOException e) {
1534 jjStopStringLiteralDfa_0(1, active0);
1535 return 2;
1536 }
1537 switch(curChar)
1538 {
1539 case 10:
1540 if ((active0 & 0x4L) != 0L)
1541 return jjStopAtPos(2, 2);
1542 break;
1543 case 83:
1544 case 115:
1545 return jjMoveStringLiteralDfa3_0(active0, 0x20000000000L);
1546 default :
1547 break;
1548 }
1549 return jjStartNfa_0(1, active0);
1550 }
1551 private int jjMoveStringLiteralDfa3_0(long old0, long active0)
1552 {
1553 if (((active0 &= old0)) == 0L)
1554 return jjStartNfa_0(1, old0);
1555 try { curChar = input_stream.readChar(); }
1556 catch(java.io.IOException e) {
1557 jjStopStringLiteralDfa_0(2, active0);
1558 return 3;
1559 }
1560 switch(curChar)
1561 {
1562 case 84:
1563 case 116:
1564 return jjMoveStringLiteralDfa4_0(active0, 0x20000000000L);
1565 default :
1566 break;
1567 }
1568 return jjStartNfa_0(2, active0);
1569 }
1570 private int jjMoveStringLiteralDfa4_0(long old0, long active0)
1571 {
1572 if (((active0 &= old0)) == 0L)
1573 return jjStartNfa_0(2, old0);
1574 try { curChar = input_stream.readChar(); }
1575 catch(java.io.IOException e) {
1576 jjStopStringLiteralDfa_0(3, active0);
1577 return 4;
1578 }
1579 switch(curChar)
1580 {
1581 case 89:
1582 case 121:
1583 return jjMoveStringLiteralDfa5_0(active0, 0x20000000000L);
1584 default :
1585 break;
1586 }
1587 return jjStartNfa_0(3, active0);
1588 }
1589 private int jjMoveStringLiteralDfa5_0(long old0, long active0)
1590 {
1591 if (((active0 &= old0)) == 0L)
1592 return jjStartNfa_0(3, old0);
1593 try { curChar = input_stream.readChar(); }
1594 catch(java.io.IOException e) {
1595 jjStopStringLiteralDfa_0(4, active0);
1596 return 5;
1597 }
1598 switch(curChar)
1599 {
1600 case 76:
1601 case 108:
1602 return jjMoveStringLiteralDfa6_0(active0, 0x20000000000L);
1603 default :
1604 break;
1605 }
1606 return jjStartNfa_0(4, active0);
1607 }
1608 private int jjMoveStringLiteralDfa6_0(long old0, long active0)
1609 {
1610 if (((active0 &= old0)) == 0L)
1611 return jjStartNfa_0(4, old0);
1612 try { curChar = input_stream.readChar(); }
1613 catch(java.io.IOException e) {
1614 jjStopStringLiteralDfa_0(5, active0);
1615 return 6;
1616 }
1617 switch(curChar)
1618 {
1619 case 69:
1620 case 101:
1621 return jjMoveStringLiteralDfa7_0(active0, 0x20000000000L);
1622 default :
1623 break;
1624 }
1625 return jjStartNfa_0(5, active0);
1626 }
1627 private int jjMoveStringLiteralDfa7_0(long old0, long active0)
1628 {
1629 if (((active0 &= old0)) == 0L)
1630 return jjStartNfa_0(5, old0);
1631 try { curChar = input_stream.readChar(); }
1632 catch(java.io.IOException e) {
1633 jjStopStringLiteralDfa_0(6, active0);
1634 return 7;
1635 }
1636 switch(curChar)
1637 {
1638 case 62:
1639 if ((active0 & 0x20000000000L) != 0L)
1640 return jjStopAtPos(7, 41);
1641 break;
1642 default :
1643 break;
1644 }
1645 return jjStartNfa_0(6, active0);
1646 }
1647 private int jjMoveNfa_0(int startState, int curPos)
1648 {
1649
1650 int startsAt = 0;
1651 jjnewStateCnt = 11;
1652 int i = 1;
1653 jjstateSet[0] = startState;
1654
1655 int kind = 0x7fffffff;
1656 for (;;)
1657 {
1658 if (++jjround == 0x7fffffff)
1659 ReInitRounds();
1660 if (curChar < 64)
1661 {
1662 long l = 1L << curChar;
1663 do
1664 {
1665 switch(jjstateSet[--i])
1666 {
1667 case 1:
1668 if ((0xefffff7bffffdbffL & l) != 0L)
1669 {
1670 if (kind > 44)
1671 kind = 44;
1672 jjCheckNAdd(3);
1673 }
1674 else if ((0x8400000000L & l) != 0L)
1675 {
1676 if (kind > 44)
1677 kind = 44;
1678 }
1679 else if ((0x2400L & l) != 0L)
1680 {
1681 if (kind > 42)
1682 kind = 42;
1683 }
1684 if (curChar == 39)
1685 jjCheckNAddTwoStates(8, 9);
1686 else if (curChar == 34)
1687 jjCheckNAddTwoStates(5, 6);
1688 else if (curChar == 13)
1689 jjstateSet[jjnewStateCnt++] = 0;
1690 break;
1691 case 0:
1692 if (curChar == 10 && kind > 42)
1693 kind = 42;
1694 break;
1695 case 2:
1696 if ((0x2400L & l) != 0L && kind > 42)
1697 kind = 42;
1698 break;
1699 case 3:
1700 if ((0xefffff7bffffdbffL & l) == 0L)
1701 break;
1702 if (kind > 44)
1703 kind = 44;
1704 jjCheckNAdd(3);
1705 break;
1706 case 4:
1707 if (curChar == 34)
1708 jjCheckNAddTwoStates(5, 6);
1709 break;
1710 case 5:
1711 if ((0xfffffffbffffdbffL & l) != 0L)
1712 jjCheckNAddTwoStates(5, 6);
1713 break;
1714 case 6:
1715 if (curChar == 34 && kind > 44)
1716 kind = 44;
1717 break;
1718 case 7:
1719 if (curChar == 39)
1720 jjCheckNAddTwoStates(8, 9);
1721 break;
1722 case 8:
1723 if ((0xffffff7fffffdbffL & l) != 0L)
1724 jjCheckNAddTwoStates(8, 9);
1725 break;
1726 case 9:
1727 if (curChar == 39 && kind > 44)
1728 kind = 44;
1729 break;
1730 case 10:
1731 if ((0x8400000000L & l) != 0L && kind > 44)
1732 kind = 44;
1733 break;
1734 default : break;
1735 }
1736 } while(i != startsAt);
1737 }
1738 else if (curChar < 128)
1739 {
1740 do
1741 {
1742 switch(jjstateSet[--i])
1743 {
1744 case 1:
1745 case 3:
1746 if (kind > 44)
1747 kind = 44;
1748 jjCheckNAdd(3);
1749 break;
1750 case 5:
1751 jjAddStates(7, 8);
1752 break;
1753 case 8:
1754 jjAddStates(9, 10);
1755 break;
1756 default : break;
1757 }
1758 } while(i != startsAt);
1759 }
1760 else
1761 {
1762 int i2 = (curChar & 0xff) >> 6;
1763 long l2 = 1L << (curChar & 077);
1764 do
1765 {
1766 switch(jjstateSet[--i])
1767 {
1768 case 1:
1769 case 3:
1770 if ((jjbitVec0[i2] & l2) == 0L)
1771 break;
1772 if (kind > 44)
1773 kind = 44;
1774 jjCheckNAdd(3);
1775 break;
1776 case 5:
1777 if ((jjbitVec0[i2] & l2) != 0L)
1778 jjAddStates(7, 8);
1779 break;
1780 case 8:
1781 if ((jjbitVec0[i2] & l2) != 0L)
1782 jjAddStates(9, 10);
1783 break;
1784 default : break;
1785 }
1786 } while(i != startsAt);
1787 }
1788 if (kind != 0x7fffffff)
1789 {
1790 jjmatchedKind = kind;
1791 jjmatchedPos = curPos;
1792 kind = 0x7fffffff;
1793 }
1794 ++curPos;
1795 if ((i = jjnewStateCnt) == (startsAt = 11 - (jjnewStateCnt = startsAt)))
1796 return curPos;
1797 try { curChar = input_stream.readChar(); }
1798 catch(java.io.IOException e) { return curPos; }
1799 }
1800 }
1801 private final int jjStopStringLiteralDfa_3(int pos, long active0)
1802 {
1803 switch (pos)
1804 {
1805 case 0:
1806 if ((active0 & 0x800000000L) != 0L)
1807 return 12;
1808 if ((active0 & 0xeL) != 0L)
1809 {
1810 jjmatchedKind = 37;
1811 return 3;
1812 }
1813 return -1;
1814 default :
1815 return -1;
1816 }
1817 }
1818 private final int jjStartNfa_3(int pos, long active0)
1819 {
1820 return jjMoveNfa_3(jjStopStringLiteralDfa_3(pos, active0), pos + 1);
1821 }
1822 private int jjStartNfaWithStates_3(int pos, int kind, int state)
1823 {
1824 jjmatchedKind = kind;
1825 jjmatchedPos = pos;
1826 try { curChar = input_stream.readChar(); }
1827 catch(java.io.IOException e) { return pos + 1; }
1828 return jjMoveNfa_3(state, pos + 1);
1829 }
1830 private int jjMoveStringLiteralDfa0_3()
1831 {
1832 switch(curChar)
1833 {
1834 case 45:
1835 return jjStartNfaWithStates_3(0, 35, 12);
1836 case 61:
1837 return jjMoveStringLiteralDfa1_3(0xeL);
1838 default :
1839 return jjMoveNfa_3(1, 0);
1840 }
1841 }
1842 private int jjMoveStringLiteralDfa1_3(long active0)
1843 {
1844 try { curChar = input_stream.readChar(); }
1845 catch(java.io.IOException e) {
1846 jjStopStringLiteralDfa_3(0, active0);
1847 return 1;
1848 }
1849 switch(curChar)
1850 {
1851 case 10:
1852 if ((active0 & 0x2L) != 0L)
1853 return jjStopAtPos(1, 1);
1854 break;
1855 case 13:
1856 if ((active0 & 0x8L) != 0L)
1857 {
1858 jjmatchedKind = 3;
1859 jjmatchedPos = 1;
1860 }
1861 return jjMoveStringLiteralDfa2_3(active0, 0x4L);
1862 default :
1863 break;
1864 }
1865 return jjStartNfa_3(0, active0);
1866 }
1867 private int jjMoveStringLiteralDfa2_3(long old0, long active0)
1868 {
1869 if (((active0 &= old0)) == 0L)
1870 return jjStartNfa_3(0, old0);
1871 try { curChar = input_stream.readChar(); }
1872 catch(java.io.IOException e) {
1873 jjStopStringLiteralDfa_3(1, active0);
1874 return 2;
1875 }
1876 switch(curChar)
1877 {
1878 case 10:
1879 if ((active0 & 0x4L) != 0L)
1880 return jjStopAtPos(2, 2);
1881 break;
1882 default :
1883 break;
1884 }
1885 return jjStartNfa_3(1, active0);
1886 }
1887 private int jjMoveNfa_3(int startState, int curPos)
1888 {
1889
1890 int startsAt = 0;
1891 jjnewStateCnt = 16;
1892 int i = 1;
1893 jjstateSet[0] = startState;
1894
1895 int kind = 0x7fffffff;
1896 for (;;)
1897 {
1898 if (++jjround == 0x7fffffff)
1899 ReInitRounds();
1900 if (curChar < 64)
1901 {
1902 long l = 1L << curChar;
1903 do
1904 {
1905 switch(jjstateSet[--i])
1906 {
1907 case 12:
1908 if (curChar == 62)
1909 {
1910 if (kind > 34)
1911 kind = 34;
1912 }
1913 else if (curChar == 45)
1914 jjCheckNAddTwoStates(13, 14);
1915 break;
1916 case 1:
1917 if ((0xffffdf7bffffdbffL & l) != 0L)
1918 {
1919 if (kind > 37)
1920 kind = 37;
1921 jjCheckNAdd(3);
1922 }
1923 else if ((0x8400000000L & l) != 0L)
1924 {
1925 if (kind > 37)
1926 kind = 37;
1927 }
1928 else if ((0x2400L & l) != 0L)
1929 {
1930 if (kind > 36)
1931 kind = 36;
1932 }
1933 else if (curChar == 45)
1934 jjAddStates(16, 17);
1935 if (curChar == 39)
1936 jjCheckNAddTwoStates(8, 9);
1937 else if (curChar == 34)
1938 jjCheckNAddTwoStates(5, 6);
1939 else if (curChar == 13)
1940 jjstateSet[jjnewStateCnt++] = 0;
1941 break;
1942 case 0:
1943 if (curChar == 10 && kind > 36)
1944 kind = 36;
1945 break;
1946 case 2:
1947 if ((0x2400L & l) != 0L && kind > 36)
1948 kind = 36;
1949 break;
1950 case 3:
1951 if ((0xffffdf7bffffdbffL & l) == 0L)
1952 break;
1953 if (kind > 37)
1954 kind = 37;
1955 jjCheckNAdd(3);
1956 break;
1957 case 4:
1958 if (curChar == 34)
1959 jjCheckNAddTwoStates(5, 6);
1960 break;
1961 case 5:
1962 if ((0xfffffffbffffdbffL & l) != 0L)
1963 jjCheckNAddTwoStates(5, 6);
1964 break;
1965 case 6:
1966 if (curChar == 34 && kind > 37)
1967 kind = 37;
1968 break;
1969 case 7:
1970 if (curChar == 39)
1971 jjCheckNAddTwoStates(8, 9);
1972 break;
1973 case 8:
1974 if ((0xffffff7fffffdbffL & l) != 0L)
1975 jjCheckNAddTwoStates(8, 9);
1976 break;
1977 case 9:
1978 if (curChar == 39 && kind > 37)
1979 kind = 37;
1980 break;
1981 case 10:
1982 if ((0x8400000000L & l) != 0L && kind > 37)
1983 kind = 37;
1984 break;
1985 case 11:
1986 if (curChar == 45)
1987 jjAddStates(16, 17);
1988 break;
1989 case 13:
1990 if (curChar == 32)
1991 jjCheckNAddTwoStates(13, 14);
1992 break;
1993 case 14:
1994 if (curChar == 62 && kind > 34)
1995 kind = 34;
1996 break;
1997 case 15:
1998 if (curChar == 62 && kind > 34)
1999 kind = 34;
2000 break;
2001 default : break;
2002 }
2003 } while(i != startsAt);
2004 }
2005 else if (curChar < 128)
2006 {
2007 do
2008 {
2009 switch(jjstateSet[--i])
2010 {
2011 case 1:
2012 case 3:
2013 if (kind > 37)
2014 kind = 37;
2015 jjCheckNAdd(3);
2016 break;
2017 case 5:
2018 jjAddStates(7, 8);
2019 break;
2020 case 8:
2021 jjAddStates(9, 10);
2022 break;
2023 default : break;
2024 }
2025 } while(i != startsAt);
2026 }
2027 else
2028 {
2029 int i2 = (curChar & 0xff) >> 6;
2030 long l2 = 1L << (curChar & 077);
2031 do
2032 {
2033 switch(jjstateSet[--i])
2034 {
2035 case 1:
2036 case 3:
2037 if ((jjbitVec0[i2] & l2) == 0L)
2038 break;
2039 if (kind > 37)
2040 kind = 37;
2041 jjCheckNAdd(3);
2042 break;
2043 case 5:
2044 if ((jjbitVec0[i2] & l2) != 0L)
2045 jjAddStates(7, 8);
2046 break;
2047 case 8:
2048 if ((jjbitVec0[i2] & l2) != 0L)
2049 jjAddStates(9, 10);
2050 break;
2051 default : break;
2052 }
2053 } while(i != startsAt);
2054 }
2055 if (kind != 0x7fffffff)
2056 {
2057 jjmatchedKind = kind;
2058 jjmatchedPos = curPos;
2059 kind = 0x7fffffff;
2060 }
2061 ++curPos;
2062 if ((i = jjnewStateCnt) == (startsAt = 16 - (jjnewStateCnt = startsAt)))
2063 return curPos;
2064 try { curChar = input_stream.readChar(); }
2065 catch(java.io.IOException e) { return curPos; }
2066 }
2067 }
2068 static final int[] jjnextStates = {
2069 0, 2, 3, 3, 4, 6, 7, 5, 6, 8, 9, 0, 1, 4, 2, 3,
2070 12, 15,
2071 };
2072
2073
2074 public static final String[] jjstrLiteralImages = {
2075 "", null, null, null, null, null, null, null, null, null, null, null, null,
2076 null, null, "\74", "\74\57", "\74\41\55\55", "\74\41", null, null, null, null, null,
2077 null, null, "\76", "\57\76", "\75", "\74", null, null, null, null, null, "\55", null,
2078 null, null, "\76", null, null, null, "\74", null, };
2079
2080
2081 public static final String[] lexStateNames = {
2082 "LexStyle",
2083 "LexScript",
2084 "LexDecl",
2085 "LexComment",
2086 "LexAttrVal",
2087 "LexInTag",
2088 "LexStartTag",
2089 "DEFAULT",
2090 };
2091
2092
2093 public static final int[] jjnewLexState = {
2094 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 6, 6, 3, 2, -1, 5, 5, 5, 7, -1,
2095 -1, 7, 7, 4, 6, -1, -1, 5, -1, 7, -1, -1, -1, -1, 7, 7, 7, -1, -1, -1,
2096 };
2097 static final long[] jjtoToken = {
2098 0x1fff7effc001L,
2099 };
2100 static final long[] jjtoSkip = {
2101 0x8100000eL,
2102 };
2103 static final long[] jjtoSpecial = {
2104 0x81000000L,
2105 };
2106 protected SimpleCharStream input_stream;
2107 private final int[] jjrounds = new int[16];
2108 private final int[] jjstateSet = new int[32];
2109 StringBuffer image;
2110 int jjimageLen;
2111 int lengthOfMatch;
2112 protected char curChar;
2113
2114 public HtmlParserTokenManager(SimpleCharStream stream){
2115 if (SimpleCharStream.staticFlag)
2116 throw new Error("ERROR: Cannot use a static CharStream class with a non-static lexical analyzer.");
2117 input_stream = stream;
2118 }
2119
2120
2121 public HtmlParserTokenManager(SimpleCharStream stream, int lexState){
2122 this(stream);
2123 SwitchTo(lexState);
2124 }
2125
2126
2127 public void ReInit(SimpleCharStream stream)
2128 {
2129 jjmatchedPos = jjnewStateCnt = 0;
2130 curLexState = defaultLexState;
2131 input_stream = stream;
2132 ReInitRounds();
2133 }
2134 private void ReInitRounds()
2135 {
2136 int i;
2137 jjround = 0x80000001;
2138 for (i = 16; i-- > 0;)
2139 jjrounds[i] = 0x80000000;
2140 }
2141
2142
2143 public void ReInit(SimpleCharStream stream, int lexState)
2144 {
2145 ReInit(stream);
2146 SwitchTo(lexState);
2147 }
2148
2149
2150 public void SwitchTo(int lexState)
2151 {
2152 if (lexState >= 8 || lexState < 0)
2153 throw new TokenMgrError("Error: Ignoring invalid lexical state : " + lexState + ". State unchanged.", TokenMgrError.INVALID_LEXICAL_STATE);
2154 else
2155 curLexState = lexState;
2156 }
2157
2158 protected Token jjFillToken()
2159 {
2160 final Token t;
2161 final String tokenImage;
2162 final int beginLine;
2163 final int endLine;
2164 final int beginColumn;
2165 final int endColumn;
2166 String im = jjstrLiteralImages[jjmatchedKind];
2167 tokenImage = (im == null) ? input_stream.GetImage() : im;
2168 beginLine = input_stream.getBeginLine();
2169 beginColumn = input_stream.getBeginColumn();
2170 endLine = input_stream.getEndLine();
2171 endColumn = input_stream.getEndColumn();
2172 t = Token.newToken(jjmatchedKind, tokenImage);
2173
2174 t.beginLine = beginLine;
2175 t.endLine = endLine;
2176 t.beginColumn = beginColumn;
2177 t.endColumn = endColumn;
2178
2179 return t;
2180 }
2181
2182 int curLexState = 7;
2183 int defaultLexState = 7;
2184 int jjnewStateCnt;
2185 int jjround;
2186 int jjmatchedPos;
2187 int jjmatchedKind;
2188
2189
2190 public Token getNextToken()
2191 {
2192
2193 Token specialToken = null;
2194 Token matchedToken;
2195 int curPos = 0;
2196
2197 EOFLoop :
2198 for (;;)
2199 {
2200 try
2201 {
2202 curChar = input_stream.BeginToken();
2203 }
2204 catch(java.io.IOException e)
2205 {
2206 jjmatchedKind = 0;
2207 matchedToken = jjFillToken();
2208 matchedToken.specialToken = specialToken;
2209 return matchedToken;
2210 }
2211 image = null;
2212 jjimageLen = 0;
2213
2214 switch(curLexState)
2215 {
2216 case 0:
2217 jjmatchedKind = 0x7fffffff;
2218 jjmatchedPos = 0;
2219 curPos = jjMoveStringLiteralDfa0_0();
2220 break;
2221 case 1:
2222 jjmatchedKind = 0x7fffffff;
2223 jjmatchedPos = 0;
2224 curPos = jjMoveStringLiteralDfa0_1();
2225 break;
2226 case 2:
2227 jjmatchedKind = 0x7fffffff;
2228 jjmatchedPos = 0;
2229 curPos = jjMoveStringLiteralDfa0_2();
2230 break;
2231 case 3:
2232 jjmatchedKind = 0x7fffffff;
2233 jjmatchedPos = 0;
2234 curPos = jjMoveStringLiteralDfa0_3();
2235 break;
2236 case 4:
2237 jjmatchedKind = 0x7fffffff;
2238 jjmatchedPos = 0;
2239 curPos = jjMoveStringLiteralDfa0_4();
2240 if (jjmatchedPos == 0 && jjmatchedKind > 33)
2241 {
2242 jjmatchedKind = 33;
2243 }
2244 break;
2245 case 5:
2246 jjmatchedKind = 0x7fffffff;
2247 jjmatchedPos = 0;
2248 curPos = jjMoveStringLiteralDfa0_5();
2249 if (jjmatchedPos == 0 && jjmatchedKind > 30)
2250 {
2251 jjmatchedKind = 30;
2252 }
2253 break;
2254 case 6:
2255 jjmatchedKind = 0x7fffffff;
2256 jjmatchedPos = 0;
2257 curPos = jjMoveStringLiteralDfa0_6();
2258 if (jjmatchedPos == 0 && jjmatchedKind > 23)
2259 {
2260 jjmatchedKind = 23;
2261 }
2262 break;
2263 case 7:
2264 jjmatchedKind = 0x7fffffff;
2265 jjmatchedPos = 0;
2266 curPos = jjMoveStringLiteralDfa0_7();
2267 break;
2268 }
2269 if (jjmatchedKind != 0x7fffffff)
2270 {
2271 if (jjmatchedPos + 1 < curPos)
2272 input_stream.backup(curPos - jjmatchedPos - 1);
2273 if ((jjtoToken[jjmatchedKind >> 6] & (1L << (jjmatchedKind & 077))) != 0L)
2274 {
2275 matchedToken = jjFillToken();
2276 matchedToken.specialToken = specialToken;
2277 TokenLexicalActions(matchedToken);
2278 if (jjnewLexState[jjmatchedKind] != -1)
2279 curLexState = jjnewLexState[jjmatchedKind];
2280 return matchedToken;
2281 }
2282 else
2283 {
2284 if ((jjtoSpecial[jjmatchedKind >> 6] & (1L << (jjmatchedKind & 077))) != 0L)
2285 {
2286 matchedToken = jjFillToken();
2287 if (specialToken == null)
2288 specialToken = matchedToken;
2289 else
2290 {
2291 matchedToken.specialToken = specialToken;
2292 specialToken = (specialToken.next = matchedToken);
2293 }
2294 SkipLexicalActions(matchedToken);
2295 }
2296 else
2297 SkipLexicalActions(null);
2298 if (jjnewLexState[jjmatchedKind] != -1)
2299 curLexState = jjnewLexState[jjmatchedKind];
2300 continue EOFLoop;
2301 }
2302 }
2303 int error_line = input_stream.getEndLine();
2304 int error_column = input_stream.getEndColumn();
2305 String error_after = null;
2306 boolean EOFSeen = false;
2307 try { input_stream.readChar(); input_stream.backup(1); }
2308 catch (java.io.IOException e1) {
2309 EOFSeen = true;
2310 error_after = curPos <= 1 ? "" : input_stream.GetImage();
2311 if (curChar == '\n' || curChar == '\r') {
2312 error_line++;
2313 error_column = 0;
2314 }
2315 else
2316 error_column++;
2317 }
2318 if (!EOFSeen) {
2319 input_stream.backup(1);
2320 error_after = curPos <= 1 ? "" : input_stream.GetImage();
2321 }
2322 throw new TokenMgrError(EOFSeen, curLexState, error_line, error_column, error_after, curChar, TokenMgrError.LEXICAL_ERROR);
2323 }
2324 }
2325
2326 void SkipLexicalActions(Token matchedToken)
2327 {
2328 switch(jjmatchedKind)
2329 {
2330 case 3 :
2331 if (image == null)
2332 image = new StringBuffer();
2333 image.append(input_stream.GetSuffix(jjimageLen + (lengthOfMatch = jjmatchedPos + 1)));
2334 System.err.println("Skipping");
2335 break;
2336 default :
2337 break;
2338 }
2339 }
2340 void TokenLexicalActions(Token matchedToken)
2341 {
2342 switch(jjmatchedKind)
2343 {
2344 case 29 :
2345 if (image == null)
2346 image = new StringBuffer();
2347 image.append(jjstrLiteralImages[29]);
2348 Token t = new Token();
2349 t.image = "<";
2350 t.kind = TAG_START;
2351 t.next = matchedToken.next;
2352 t.beginLine = matchedToken.beginLine;
2353 t.beginColumn = matchedToken.beginColumn;
2354 t.endLine = matchedToken.endLine;
2355 t.endColumn = matchedToken.endColumn;
2356 matchedToken.next = t;
2357 matchedToken.kind = TAG_END;
2358 matchedToken.image = ">";
2359 break;
2360 default :
2361 break;
2362 }
2363 }
2364 private void jjCheckNAdd(int state)
2365 {
2366 if (jjrounds[state] != jjround)
2367 {
2368 jjstateSet[jjnewStateCnt++] = state;
2369 jjrounds[state] = jjround;
2370 }
2371 }
2372 private void jjAddStates(int start, int end)
2373 {
2374 do {
2375 jjstateSet[jjnewStateCnt++] = jjnextStates[start];
2376 } while (start++ != end);
2377 }
2378 private void jjCheckNAddTwoStates(int state1, int state2)
2379 {
2380 jjCheckNAdd(state1);
2381 jjCheckNAdd(state2);
2382 }
2383
2384 private void jjCheckNAddStates(int start, int end)
2385 {
2386 do {
2387 jjCheckNAdd(jjnextStates[start]);
2388 } while (start++ != end);
2389 }
2390
2391 }