|
1
2 package org.apache.lucene.demo.html;
3
4 public class HTMLParserTokenManager implements HTMLParserConstants
5 {
6 public java.io.PrintStream  debugStream = System.out;
7 public void setDebugStream(java.io.PrintStream ds) { debugStream = ds; }
8 private final int jjStopStringLiteralDfa_0(int pos, long active0)
9 {
10 switch (pos)
11 {
12 case 0:
13 if ((active0 & 0x32L) != 0L)
14 return 26;
15 return -1;
16 case 1:
17 if ((active0 & 0x30L) != 0L)
18 return 31;
19 if ((active0 & 0x2L) != 0L)
20 {
21 if (jjmatchedPos != 1)
22 {
23 jjmatchedKind = 2;
24 jjmatchedPos = 1;
25 }
26 return 28;
27 }
28 return -1;
29 case 2:
30 if ((active0 & 0x2L) != 0L)
31 {
32 jjmatchedKind = 2;
33 jjmatchedPos = 2;
34 return 29;
35 }
36 return -1;
37 case 3:
38 if ((active0 & 0x2L) != 0L)
39 {
40 jjmatchedKind = 2;
41 jjmatchedPos = 3;
42 return 29;
43 }
44 return -1;
45 case 4:
46 if ((active0 & 0x2L) != 0L)
47 {
48 jjmatchedKind = 2;
49 jjmatchedPos = 4;
50 return 29;
51 }
52 return -1;
53 case 5:
54 if ((active0 & 0x2L) != 0L)
55 {
56 jjmatchedKind = 2;
57 jjmatchedPos = 5;
58 return 29;
59 }
60 return -1;
61 default :
62 return -1;
63 }
64 }
65 private final int jjStartNfa_0(int pos, long active0)
66 {
67 return jjMoveNfa_0(jjStopStringLiteralDfa_0(pos, active0), pos + 1);
68 }
69 private final int jjStopAtPos(int pos, int kind)
70 {
71 jjmatchedKind = kind;
72 jjmatchedPos = pos;
73 return pos + 1;
74 }
75 private final int jjStartNfaWithStates_0(int pos, int kind, int state)
76 {
77 jjmatchedKind = kind;
78 jjmatchedPos = pos;
79 try { curChar = input_stream.readChar(); }
80 catch(java.io.IOException e) { return pos + 1; }
81 return jjMoveNfa_0(state, pos + 1);
82 }
83 private final int jjMoveStringLiteralDfa0_0()
84 {
85 switch(curChar)
86 {
87 case 60:
88 return jjMoveStringLiteralDfa1_0(0x32L);
89 default :
90 return jjMoveNfa_0(17, 0);
91 }
92 }
93 private final int jjMoveStringLiteralDfa1_0(long active0)
94 {
95 try { curChar = input_stream.readChar(); }
96 catch(java.io.IOException e) {
97 jjStopStringLiteralDfa_0(0, active0);
98 return 1;
99 }
100 switch(curChar)
101 {
102 case 33:
103 if ((active0 & 0x20L) != 0L)
104 {
105 jjmatchedKind = 5;
106 jjmatchedPos = 1;
107 }
108 return jjMoveStringLiteralDfa2_0(active0, 0x10L);
109 case 115:
110 return jjMoveStringLiteralDfa2_0(active0, 0x2L);
111 default :
112 break;
113 }
114 return jjStartNfa_0(0, active0);
115 }
116 private final int jjMoveStringLiteralDfa2_0(long old0, long active0)
117 {
118 if (((active0 &= old0)) == 0L)
119 return jjStartNfa_0(0, old0);
120 try { curChar = input_stream.readChar(); }
121 catch(java.io.IOException e) {
122 jjStopStringLiteralDfa_0(1, active0);
123 return 2;
124 }
125 switch(curChar)
126 {
127 case 45:
128 return jjMoveStringLiteralDfa3_0(active0, 0x10L);
129 case 99:
130 return jjMoveStringLiteralDfa3_0(active0, 0x2L);
131 default :
132 break;
133 }
134 return jjStartNfa_0(1, active0);
135 }
136 private final int jjMoveStringLiteralDfa3_0(long old0, long active0)
137 {
138 if (((active0 &= old0)) == 0L)
139 return jjStartNfa_0(1, old0);
140 try { curChar = input_stream.readChar(); }
141 catch(java.io.IOException e) {
142 jjStopStringLiteralDfa_0(2, active0);
143 return 3;
144 }
145 switch(curChar)
146 {
147 case 45:
148 if ((active0 & 0x10L) != 0L)
149 return jjStopAtPos(3, 4);
150 break;
151 case 114:
152 return jjMoveStringLiteralDfa4_0(active0, 0x2L);
153 default :
154 break;
155 }
156 return jjStartNfa_0(2, active0);
157 }
158 private final int jjMoveStringLiteralDfa4_0(long old0, long active0)
159 {
160 if (((active0 &= old0)) == 0L)
161 return jjStartNfa_0(2, old0);
162 try { curChar = input_stream.readChar(); }
163 catch(java.io.IOException e) {
164 jjStopStringLiteralDfa_0(3, active0);
165 return 4;
166 }
167 switch(curChar)
168 {
169 case 105:
170 return jjMoveStringLiteralDfa5_0(active0, 0x2L);
171 default :
172 break;
173 }
174 return jjStartNfa_0(3, active0);
175 }
176 private final int jjMoveStringLiteralDfa5_0(long old0, long active0)
177 {
178 if (((active0 &= old0)) == 0L)
179 return jjStartNfa_0(3, old0);
180 try { curChar = input_stream.readChar(); }
181 catch(java.io.IOException e) {
182 jjStopStringLiteralDfa_0(4, active0);
183 return 5;
184 }
185 switch(curChar)
186 {
187 case 112:
188 return jjMoveStringLiteralDfa6_0(active0, 0x2L);
189 default :
190 break;
191 }
192 return jjStartNfa_0(4, active0);
193 }
194 private final int jjMoveStringLiteralDfa6_0(long old0, long active0)
195 {
196 if (((active0 &= old0)) == 0L)
197 return jjStartNfa_0(4, old0);
198 try { curChar = input_stream.readChar(); }
199 catch(java.io.IOException e) {
200 jjStopStringLiteralDfa_0(5, active0);
201 return 6;
202 }
203 switch(curChar)
204 {
205 case 116:
206 if ((active0 & 0x2L) != 0L)
207 return jjStartNfaWithStates_0(6, 1, 29);
208 break;
209 default :
210 break;
211 }
212 return jjStartNfa_0(5, active0);
213 }
214 private final void jjCheckNAdd(int state)
215 {
216 if (jjrounds[state] != jjround)
217 {
218 jjstateSet[jjnewStateCnt++] = state;
219 jjrounds[state] = jjround;
220 }
221 }
222 private final void jjAddStates(int start, int end)
223 {
224 do {
225 jjstateSet[jjnewStateCnt++] = jjnextStates[start];
226 } while (start++ != end);
227 }
228 private final void jjCheckNAddTwoStates(int state1, int state2)
229 {
230 jjCheckNAdd(state1);
231 jjCheckNAdd(state2);
232 }
233 private final void jjCheckNAddStates(int start, int end)
234 {
235 do {
236 jjCheckNAdd(jjnextStates[start]);
237 } while (start++ != end);
238 }
239 static final long[] jjbitVec0 = {
240 0xfffffffffffffffeL, 0xffffffffffffffffL, 0xffffffffffffffffL, 0xffffffffffffffffL
241 };
242 static final long[] jjbitVec2 = {
243 0x0L, 0x0L, 0xffffffffffffffffL, 0xffffffffffffffffL
244 };
245 private final int jjMoveNfa_0(int startState, int curPos)
246 {
247 int startsAt = 0;
248 jjnewStateCnt = 34;
249 int i = 1;
250 jjstateSet[0] = startState;
251 int kind = 0x7fffffff;
252 for (;;)
253 {
254 if (++jjround == 0x7fffffff)
255 ReInitRounds();
256 if (curChar < 64)
257 {
258 long l = 1L << curChar;
259 do
260 {
261 switch(jjstateSet[--i])
262 {
263 case 26:
264 if (curChar == 33)
265 jjstateSet[jjnewStateCnt++] = 31;
266 else if (curChar == 47)
267 jjCheckNAdd(27);
268 break;
269 case 17:
270 if ((0x3ff000000000000L & l) != 0L)
271 jjCheckNAddTwoStates(7, 2);
272 else if ((0x100002600L & l) != 0L)
273 {
274 if (kind > 10)
275 kind = 10;
276 jjCheckNAddTwoStates(10, 16);
277 }
278 else if (curChar == 60)
279 jjCheckNAddStates(0, 2);
280 else if (curChar == 38)
281 jjAddStates(3, 5);
282 else if (curChar == 36)
283 jjstateSet[jjnewStateCnt++] = 1;
284 if ((0x3ff000000000000L & l) != 0L)
285 {
286 if (kind > 6)
287 kind = 6;
288 jjCheckNAddStates(6, 10);
289 }
290 else if (curChar == 38)
291 jjstateSet[jjnewStateCnt++] = 15;
292 break;
293 case 0:
294 if (curChar == 36)
295 jjstateSet[jjnewStateCnt++] = 1;
296 break;
297 case 1:
298 if ((0x3ff000000000000L & l) != 0L)
299 jjCheckNAdd(2);
300 break;
301 case 2:
302 if ((0x500000000000L & l) != 0L)
303 jjstateSet[jjnewStateCnt++] = 3;
304 break;
305 case 3:
306 case 9:
307 if ((0x3ff000000000000L & l) == 0L)
308 break;
309 if (kind > 6)
310 kind = 6;
311 jjCheckNAddStates(11, 13);
312 break;
313 case 4:
314 if ((0x3ff000000000000L & l) == 0L)
315 break;
316 if (kind > 6)
317 kind = 6;
318 jjCheckNAddStates(6, 10);
319 break;
320 case 5:
321 if ((0x880000000000L & l) == 0L)
322 break;
323 if (kind > 6)
324 kind = 6;
325 jjCheckNAddStates(14, 17);
326 break;
327 case 6:
328 if ((0x3ff000000000000L & l) != 0L)
329 jjCheckNAddTwoStates(7, 2);
330 break;
331 case 7:
332 if (curChar != 34)
333 break;
334 if (kind > 6)
335 kind = 6;
336 jjCheckNAddStates(11, 13);
337 break;
338 case 8:
339 if ((0x208000000000L & l) != 0L)
340 jjstateSet[jjnewStateCnt++] = 9;
341 break;
342 case 10:
343 if ((0x100002600L & l) == 0L)
344 break;
345 kind = 10;
346 jjCheckNAddTwoStates(10, 16);
347 break;
348 case 11:
349 if (curChar != 59)
350 break;
351 if (kind > 10)
352 kind = 10;
353 jjCheckNAddTwoStates(10, 16);
354 break;
355 case 16:
356 if (curChar == 38)
357 jjstateSet[jjnewStateCnt++] = 15;
358 break;
359 case 19:
360 if (curChar == 59 && kind > 12)
361 kind = 12;
362 break;
363 case 20:
364 if (curChar == 35)
365 jjCheckNAdd(21);
366 break;
367 case 21:
368 if ((0x3ff000000000000L & l) == 0L)
369 break;
370 if (kind > 12)
371 kind = 12;
372 jjCheckNAddTwoStates(21, 19);
373 break;
374 case 22:
375 if (curChar == 35)
376 jjstateSet[jjnewStateCnt++] = 23;
377 break;
378 case 24:
379 if ((0x3ff000000000000L & l) == 0L)
380 break;
381 if (kind > 12)
382 kind = 12;
383 jjCheckNAddTwoStates(24, 19);
384 break;
385 case 25:
386 if (curChar == 60)
387 jjCheckNAddStates(0, 2);
388 break;
389 case 28:
390 if ((0x9fffff7affffd9ffL & l) == 0L)
391 break;
392 if (kind > 2)
393 kind = 2;
394 jjCheckNAdd(29);
395 break;
396 case 29:
397 if ((0x9ffffffeffffd9ffL & l) == 0L)
398 break;
399 if (kind > 2)
400 kind = 2;
401 jjCheckNAdd(29);
402 break;
403 case 30:
404 if (curChar == 33)
405 jjstateSet[jjnewStateCnt++] = 31;
406 break;
407 case 32:
408 if ((0x9fffff7affffd9ffL & l) == 0L)
409 break;
410 if (kind > 3)
411 kind = 3;
412 jjCheckNAdd(33);
413 break;
414 case 33:
415 if ((0x9ffffffeffffd9ffL & l) == 0L)
416 break;
417 if (kind > 3)
418 kind = 3;
419 jjCheckNAdd(33);
420 break;
421 default : break;
422 }
423 } while(i != startsAt);
424 }
425 else if (curChar < 128)
426 {
427 long l = 1L << (curChar & 077);
428 do
429 {
430 switch(jjstateSet[--i])
431 {
432 case 26:
433 case 27:
434 if ((0x7fffffe07fffffeL & l) == 0L)
435 break;
436 if (kind > 2)
437 kind = 2;
438 jjstateSet[jjnewStateCnt++] = 28;
439 break;
440 case 17:
441 case 4:
442 if ((0x7fffffe07fffffeL & l) == 0L)
443 break;
444 if (kind > 6)
445 kind = 6;
446 jjCheckNAddStates(6, 10);
447 break;
448 case 9:
449 if ((0x7fffffe07fffffeL & l) == 0L)
450 break;
451 if (kind > 6)
452 kind = 6;
453 jjCheckNAddStates(11, 13);
454 break;
455 case 12:
456 if (curChar == 112)
457 jjstateSet[jjnewStateCnt++] = 11;
458 break;
459 case 13:
460 if (curChar == 115)
461 jjstateSet[jjnewStateCnt++] = 12;
462 break;
463 case 14:
464 if (curChar == 98)
465 jjstateSet[jjnewStateCnt++] = 13;
466 break;
467 case 15:
468 if (curChar == 110)
469 jjstateSet[jjnewStateCnt++] = 14;
470 break;
471 case 18:
472 if ((0x7fffffe07fffffeL & l) == 0L)
473 break;
474 if (kind > 12)
475 kind = 12;
476 jjCheckNAddTwoStates(18, 19);
477 break;
478 case 23:
479 if ((0x100000001000000L & l) != 0L)
480 jjCheckNAdd(24);
481 break;
482 case 24:
483 if ((0x7e0000007eL & l) == 0L)
484 break;
485 if (kind > 12)
486 kind = 12;
487 jjCheckNAddTwoStates(24, 19);
488 break;
489 case 28:
490 case 29:
491 if (kind > 2)
492 kind = 2;
493 jjCheckNAdd(29);
494 break;
495 case 31:
496 if ((0x7fffffe07fffffeL & l) == 0L)
497 break;
498 if (kind > 3)
499 kind = 3;
500 jjstateSet[jjnewStateCnt++] = 32;
501 break;
502 case 32:
503 case 33:
504 if (kind > 3)
505 kind = 3;
506 jjCheckNAdd(33);
507 break;
508 default : break;
509 }
510 } while(i != startsAt);
511 }
512 else
513 {
514 int hiByte = (int)(curChar >> 8);
515 int i1 = hiByte >> 6;
516 long l1 = 1L << (hiByte & 077);
517 int i2 = (curChar & 0xff) >> 6;
518 long l2 = 1L << (curChar & 077);
519 do
520 {
521 switch(jjstateSet[--i])
522 {
523 case 28:
524 case 29:
525 if (!jjCanMove_0(hiByte, i1, i2, l1, l2))
526 break;
527 if (kind > 2)
528 kind = 2;
529 jjCheckNAdd(29);
530 break;
531 case 32:
532 case 33:
533 if (!jjCanMove_0(hiByte, i1, i2, l1, l2))
534 break;
535 if (kind > 3)
536 kind = 3;
537 jjCheckNAdd(33);
538 break;
539 default : break;
540 }
541 } while(i != startsAt);
542 }
543 if (kind != 0x7fffffff)
544 {
545 jjmatchedKind = kind;
546 jjmatchedPos = curPos;
547 kind = 0x7fffffff;
548 }
549 ++curPos;
550 if ((i = jjnewStateCnt) == (startsAt = 34 - (jjnewStateCnt = startsAt)))
551 return curPos;
552 try { curChar = input_stream.readChar(); }
553 catch(java.io.IOException e) { return curPos; }
554 }
555 }
556 private final int jjMoveStringLiteralDfa0_5()
557 {
558 return jjMoveNfa_5(1, 0);
559 }
560 private final int jjMoveNfa_5(int startState, int curPos)
561 {
562 int startsAt = 0;
563 jjnewStateCnt = 2;
564 int i = 1;
565 jjstateSet[0] = startState;
566 int kind = 0x7fffffff;
567 for (;;)
568 {
569 if (++jjround == 0x7fffffff)
570 ReInitRounds();
571 if (curChar < 64)
572 {
573 long l = 1L << curChar;
574 do
575 {
576 switch(jjstateSet[--i])
577 {
578 case 1:
579 if ((0xfffffffbffffffffL & l) != 0L)
580 {
581 if (kind > 25)
582 kind = 25;
583 jjCheckNAdd(0);
584 }
585 else if (curChar == 34)
586 {
587 if (kind > 26)
588 kind = 26;
589 }
590 break;
591 case 0:
592 if ((0xfffffffbffffffffL & l) == 0L)
593 break;
594 kind = 25;
595 jjCheckNAdd(0);
596 break;
597 default : break;
598 }
599 } while(i != startsAt);
600 }
601 else if (curChar < 128)
602 {
603 do
604 {
605 switch(jjstateSet[--i])
606 {
607 case 1:
608 case 0:
609 kind = 25;
610 jjCheckNAdd(0);
611 break;
612 default : break;
613 }
614 } while(i != startsAt);
615 }
616 else
617 {
618 int hiByte = (int)(curChar >> 8);
619 int i1 = hiByte >> 6;
620 long l1 = 1L << (hiByte & 077);
621 int i2 = (curChar & 0xff) >> 6;
622 long l2 = 1L << (curChar & 077);
623 do
624 {
625 switch(jjstateSet[--i])
626 {
627 case 1:
628 case 0:
629 if (!jjCanMove_0(hiByte, i1, i2, l1, l2))
630 break;
631 if (kind > 25)
632 kind = 25;
633 jjCheckNAdd(0);
634 break;
635 default : break;
636 }
637 } while(i != startsAt);
638 }
639 if (kind != 0x7fffffff)
640 {
641 jjmatchedKind = kind;
642 jjmatchedPos = curPos;
643 kind = 0x7fffffff;
644 }
645 ++curPos;
646 if ((i = jjnewStateCnt) == (startsAt = 2 - (jjnewStateCnt = startsAt)))
647 return curPos;
648 try { curChar = input_stream.readChar(); }
649 catch(java.io.IOException e) { return curPos; }
650 }
651 }
652 private final int jjMoveStringLiteralDfa0_7()
653 {
654 switch(curChar)
655 {
656 case 62:
657 return jjStopAtPos(0, 30);
658 default :
659 return jjMoveNfa_7(0, 0);
660 }
661 }
662 private final int jjMoveNfa_7(int startState, int curPos)
663 {
664 int startsAt = 0;
665 jjnewStateCnt = 1;
666 int i = 1;
667 jjstateSet[0] = startState;
668 int kind = 0x7fffffff;
669 for (;;)
670 {
671 if (++jjround == 0x7fffffff)
672 ReInitRounds();
673 if (curChar < 64)
674 {
675 long l = 1L << curChar;
676 do
677 {
678 switch(jjstateSet[--i])
679 {
680 case 0:
681 if ((0xbfffffffffffffffL & l) == 0L)
682 break;
683 kind = 29;
684 jjstateSet[jjnewStateCnt++] = 0;
685 break;
686 default : break;
687 }
688 } while(i != startsAt);
689 }
690 else if (curChar < 128)
691 {
692 do
693 {
694 switch(jjstateSet[--i])
695 {
696 case 0:
697 kind = 29;
698 jjstateSet[jjnewStateCnt++] = 0;
699 break;
700 default : break;
701 }
702 } while(i != startsAt);
703 }
704 else
705 {
706 int hiByte = (int)(curChar >> 8);
707 int i1 = hiByte >> 6;
708 long l1 = 1L << (hiByte & 077);
709 int i2 = (curChar & 0xff) >> 6;
710 long l2 = 1L << (curChar & 077);
711 do
712 {
713 switch(jjstateSet[--i])
714 {
715 case 0:
716 if (!jjCanMove_0(hiByte, i1, i2, l1, l2))
717 break;
718 if (kind > 29)
719 kind = 29;
720 jjstateSet[jjnewStateCnt++] = 0;
721 break;
722 default : break;
723 }
724 } while(i != startsAt);
725 }
726 if (kind != 0x7fffffff)
727 {
728 jjmatchedKind = kind;
729 jjmatchedPos = curPos;
730 kind = 0x7fffffff;
731 }
732 ++curPos;
733 if ((i = jjnewStateCnt) == (startsAt = 1 - (jjnewStateCnt = startsAt)))
734 return curPos;
735 try { curChar = input_stream.readChar(); }
736 catch(java.io.IOException e) { return curPos; }
737 }
738 }
739 private final int jjMoveStringLiteralDfa0_4()
740 {
741 return jjMoveNfa_4(1, 0);
742 }
743 private final int jjMoveNfa_4(int startState, int curPos)
744 {
745 int startsAt = 0;
746 jjnewStateCnt = 2;
747 int i = 1;
748 jjstateSet[0] = startState;
749 int kind = 0x7fffffff;
750 for (;;)
751 {
752 if (++jjround == 0x7fffffff)
753 ReInitRounds();
754 if (curChar < 64)
755 {
756 long l = 1L << curChar;
757 do
758 {
759 switch(jjstateSet[--i])
760 {
761 case 1:
762 if ((0xffffff7fffffffffL & l) != 0L)
763 {
764 if (kind > 23)
765 kind = 23;
766 jjCheckNAdd(0);
767 }
768 else if (curChar == 39)
769 {
770 if (kind > 24)
771 kind = 24;
772 }
773 break;
774 case 0:
775 if ((0xffffff7fffffffffL & l) == 0L)
776 break;
777 kind = 23;
778 jjCheckNAdd(0);
779 break;
780 default : break;
781 }
782 } while(i != startsAt);
783 }
784 else if (curChar < 128)
785 {
786 do
787 {
788 switch(jjstateSet[--i])
789 {
790 case 1:
791 case 0:
792 kind = 23;
793 jjCheckNAdd(0);
794 break;
795 default : break;
796 }
797 } while(i != startsAt);
798 }
799 else
800 {
801 int hiByte = (int)(curChar >> 8);
802 int i1 = hiByte >> 6;
803 long l1 = 1L << (hiByte & 077);
804 int i2 = (curChar & 0xff) >> 6;
805 long l2 = 1L << (curChar & 077);
806 do
807 {
808 switch(jjstateSet[--i])
809 {
810 case 1:
811 case 0:
812 if (!jjCanMove_0(hiByte, i1, i2, l1, l2))
813 break;
814 if (kind > 23)
815 kind = 23;
816 jjCheckNAdd(0);
817 break;
818 default : break;
819 }
820 } while(i != startsAt);
821 }
822 if (kind != 0x7fffffff)
823 {
824 jjmatchedKind = kind;
825 jjmatchedPos = curPos;
826 kind = 0x7fffffff;
827 }
828 ++curPos;
829 if ((i = jjnewStateCnt) == (startsAt = 2 - (jjnewStateCnt = startsAt)))
830 return curPos;
831 try { curChar = input_stream.readChar(); }
832 catch(java.io.IOException e) { return curPos; }
833 }
834 }
835 private final int jjMoveStringLiteralDfa0_3()
836 {
837 switch(curChar)
838 {
839 case 34:
840 return jjStopAtPos(0, 21);
841 case 39:
842 return jjStopAtPos(0, 20);
843 default :
844 return jjMoveNfa_3(0, 0);
845 }
846 }
847 private final int jjMoveNfa_3(int startState, int curPos)
848 {
849 int startsAt = 0;
850 jjnewStateCnt = 9;
851 int i = 1;
852 jjstateSet[0] = startState;
853 int kind = 0x7fffffff;
854 for (;;)
855 {
856 if (++jjround == 0x7fffffff)
857 ReInitRounds();
858 if (curChar < 64)
859 {
860 long l = 1L << curChar;
861 do
862 {
863 switch(jjstateSet[--i])
864 {
865 case 0:
866 if ((0x9fffff7affffd9ffL & l) != 0L)
867 {
868 if (kind > 19)
869 kind = 19;
870 jjCheckNAdd(1);
871 }
872 else if ((0x100002600L & l) != 0L)
873 {
874 if (kind > 22)
875 kind = 22;
876 jjCheckNAddTwoStates(2, 8);
877 }
878 if (curChar == 38)
879 jjstateSet[jjnewStateCnt++] = 7;
880 break;
881 case 1:
882 if ((0xbffffffeffffd9ffL & l) == 0L)
883 break;
884 if (kind > 19)
885 kind = 19;
886 jjCheckNAdd(1);
887 break;
888 case 2:
889 if ((0x100002600L & l) == 0L)
890 break;
891 kind = 22;
892 jjCheckNAddTwoStates(2, 8);
893 break;
894 case 3:
895 if (curChar != 59)
896 break;
897 if (kind > 22)
898 kind = 22;
899 jjCheckNAddTwoStates(2, 8);
900 break;
901 case 8:
902 if (curChar == 38)
903 jjstateSet[jjnewStateCnt++] = 7;
904 break;
905 default : break;
906 }
907 } while(i != startsAt);
908 }
909 else if (curChar < 128)
910 {
911 do
912 {
913 switch(jjstateSet[--i])
914 {
915 case 0:
916 case 1:
917 if (kind > 19)
918 kind = 19;
919 jjCheckNAdd(1);
920 break;
921 case 4:
922 if (curChar == 112)
923 jjstateSet[jjnewStateCnt++] = 3;
924 break;
925 case 5:
926 if (curChar == 115)
927 jjstateSet[jjnewStateCnt++] = 4;
928 break;
929 case 6:
930 if (curChar == 98)
931 jjstateSet[jjnewStateCnt++] = 5;
932 break;
933 case 7:
934 if (curChar == 110)
935 jjstateSet[jjnewStateCnt++] = 6;
936 break;
937 default : break;
938 }
939 } while(i != startsAt);
940 }
941 else
942 {
943 int hiByte = (int)(curChar >> 8);
944 int i1 = hiByte >> 6;
945 long l1 = 1L << (hiByte & 077);
946 int i2 = (curChar & 0xff) >> 6;
947 long l2 = 1L << (curChar & 077);
948 do
949 {
950 switch(jjstateSet[--i])
951 {
952 case 0:
953 case 1:
954 if (!jjCanMove_0(hiByte, i1, i2, l1, l2))
955 break;
956 if (kind > 19)
957 kind = 19;
958 jjCheckNAdd(1);
959 break;
960 default : break;
961 }
962 } while(i != startsAt);
963 }
964 if (kind != 0x7fffffff)
965 {
966 jjmatchedKind = kind;
967 jjmatchedPos = curPos;
968 kind = 0x7fffffff;
969 }
970 ++curPos;
971 if ((i = jjnewStateCnt) == (startsAt = 9 - (jjnewStateCnt = startsAt)))
972 return curPos;
973 try { curChar = input_stream.readChar(); }
974 catch(java.io.IOException e) { return curPos; }
975 }
976 }
977 private final int jjStopStringLiteralDfa_6(int pos, long active0)
978 {
979 switch (pos)
980 {
981 case 0:
982 if ((active0 & 0x10000000L) != 0L)
983 {
984 jjmatchedKind = 27;
985 return -1;
986 }
987 return -1;
988 case 1:
989 if ((active0 & 0x10000000L) != 0L)
990 {
991 if (jjmatchedPos == 0)
992 {
993 jjmatchedKind = 27;
994 jjmatchedPos = 0;
995 }
996 return -1;
997 }
998 return -1;
999 default :
1000 return -1;
1001 }
1002}
1003private final int jjStartNfa_6(int pos, long active0)
1004{
1005 return jjMoveNfa_6(jjStopStringLiteralDfa_6(pos, active0), pos + 1);
1006}
1007private final int jjMoveStringLiteralDfa0_6()
1008{
1009 switch(curChar)
1010 {
1011 case 45:
1012 return jjMoveStringLiteralDfa1_6(0x10000000L);
1013 default :
1014 return jjMoveNfa_6(1, 0);
1015 }
1016}
1017private final int jjMoveStringLiteralDfa1_6(long active0)
1018{
1019 try { curChar = input_stream.readChar(); }
1020 catch(java.io.IOException e) {
1021 jjStopStringLiteralDfa_6(0, active0);
1022 return 1;
1023 }
1024 switch(curChar)
1025 {
1026 case 45:
1027 return jjMoveStringLiteralDfa2_6(active0, 0x10000000L);
1028 default :
1029 break;
1030 }
1031 return jjStartNfa_6(0, active0);
1032}
1033private final int jjMoveStringLiteralDfa2_6(long old0, long active0)
1034{
1035 if (((active0 &= old0)) == 0L)
1036 return jjStartNfa_6(0, old0);
1037 try { curChar = input_stream.readChar(); }
1038 catch(java.io.IOException e) {
1039 jjStopStringLiteralDfa_6(1, active0);
1040 return 2;
1041 }
1042 switch(curChar)
1043 {
1044 case 62:
1045 if ((active0 & 0x10000000L) != 0L)
1046 return jjStopAtPos(2, 28);
1047 break;
1048 default :
1049 break;
1050 }
1051 return jjStartNfa_6(1, active0);
1052}
1053private final int jjMoveNfa_6(int startState, int curPos)
1054{
1055 int startsAt = 0;
1056 jjnewStateCnt = 2;
1057 int i = 1;
1058 jjstateSet[0] = startState;
1059 int kind = 0x7fffffff;
1060 for (;;)
1061 {
1062 if (++jjround == 0x7fffffff)
1063 ReInitRounds();
1064 if (curChar < 64)
1065 {
1066 long l = 1L << curChar;
1067 do
1068 {
1069 switch(jjstateSet[--i])
1070 {
1071 case 1:
1072 if ((0xffffdfffffffffffL & l) != 0L)
1073 {
1074 if (kind > 27)
1075 kind = 27;
1076 jjCheckNAdd(0);
1077 }
1078 else if (curChar == 45)
1079 {
1080 if (kind > 27)
1081 kind = 27;
1082 }
1083 break;
1084 case 0:
1085 if ((0xffffdfffffffffffL & l) == 0L)
1086 break;
1087 kind = 27;
1088 jjCheckNAdd(0);
1089 break;
1090 default : break;
1091 }
1092 } while(i != startsAt);
1093 }
1094 else if (curChar < 128)
1095 {
1096 do
1097 {
1098 switch(jjstateSet[--i])
1099 {
1100 case 1:
1101 case 0:
1102 kind = 27;
1103 jjCheckNAdd(0);
1104 break;
1105 default : break;
1106 }
1107 } while(i != startsAt);
1108 }
1109 else
1110 {
1111 int hiByte = (int)(curChar >> 8);
1112 int i1 = hiByte >> 6;
1113 long l1 = 1L << (hiByte & 077);
1114 int i2 = (curChar & 0xff) >> 6;
1115 long l2 = 1L << (curChar & 077);
1116 do
1117 {
1118 switch(jjstateSet[--i])
1119 {
1120 case 1:
1121 case 0:
1122 if (!jjCanMove_0(hiByte, i1, i2, l1, l2))
1123 break;
1124 if (kind > 27)
1125 kind = 27;
1126 jjCheckNAdd(0);
1127 break;
1128 default : break;
1129 }
1130 } while(i != startsAt);
1131 }
1132 if (kind != 0x7fffffff)
1133 {
1134 jjmatchedKind = kind;
1135 jjmatchedPos = curPos;
1136 kind = 0x7fffffff;
1137 }
1138 ++curPos;
1139 if ((i = jjnewStateCnt) == (startsAt = 2 - (jjnewStateCnt = startsAt)))
1140 return curPos;
1141 try { curChar = input_stream.readChar(); }
1142 catch(java.io.IOException e) { return curPos; }
1143 }
1144}
1145private final int jjMoveStringLiteralDfa0_1()
1146{
1147 return jjMoveNfa_1(1, 0);
1148}
1149private final int jjMoveNfa_1(int startState, int curPos)
1150{
1151 int startsAt = 0;
1152 jjnewStateCnt = 12;
1153 int i = 1;
1154 jjstateSet[0] = startState;
1155 int kind = 0x7fffffff;
1156 for (;;)
1157 {
1158 if (++jjround == 0x7fffffff)
1159 ReInitRounds();
1160 if (curChar < 64)
1161 {
1162 long l = 1L << curChar;
1163 do
1164 {
1165 switch(jjstateSet[--i])
1166 {
1167 case 1:
1168 if ((0xafffffffffffffffL & l) != 0L)
1169 {
1170 if (kind > 14)
1171 kind = 14;
1172 jjCheckNAdd(0);
1173 }
1174 else if ((0x5000000000000000L & l) != 0L)
1175 {
1176 if (kind > 14)
1177 kind = 14;
1178 }
1179 if (curChar == 60)
1180 jjstateSet[jjnewStateCnt++] = 10;
1181 break;
1182 case 0:
1183 if ((0xafffffffffffffffL & l) == 0L)
1184 break;
1185 if (kind > 14)
1186 kind = 14;
1187 jjCheckNAdd(0);
1188 break;
1189 case 3:
1190 if ((0xafffffffffffffffL & l) != 0L)
1191 jjAddStates(18, 19);
1192 break;
1193 case 4:
1194 if (curChar == 62 && kind > 15)
1195 kind = 15;
1196 break;
1197 case 10:
1198 if (curChar == 47)
1199 jjstateSet[jjnewStateCnt++] = 9;
1200 break;
1201 case 11:
1202 if (curChar == 60)
1203 jjstateSet[jjnewStateCnt++] = 10;
1204 break;
1205 default : break;
1206 }
1207 } while(i != startsAt);
1208 }
1209 else if (curChar < 128)
1210 {
1211 do
1212 {
1213 switch(jjstateSet[--i])
1214 {
1215 case 1:
1216 case 0:
1217 if (kind > 14)
1218 kind = 14;
1219 jjCheckNAdd(0);
1220 break;
1221 case 2:
1222 if (curChar == 116)
1223 jjCheckNAddTwoStates(3, 4);
1224 break;
1225 case 3:
1226 jjCheckNAddTwoStates(3, 4);
1227 break;
1228 case 5:
1229 if (curChar == 112)
1230 jjstateSet[jjnewStateCnt++] = 2;
1231 break;
1232 case 6:
1233 if (curChar == 105)
1234 jjstateSet[jjnewStateCnt++] = 5;
1235 break;
1236 case 7:
1237 if (curChar == 114)
1238 jjstateSet[jjnewStateCnt++] = 6;
1239 break;
1240 case 8:
1241 if (curChar == 99)
1242 jjstateSet[jjnewStateCnt++] = 7;
1243 break;
1244 case 9:
1245 if (curChar == 115)
1246 jjstateSet[jjnewStateCnt++] = 8;
1247 break;
1248 default : break;
1249 }
1250 } while(i != startsAt);
1251 }
1252 else
1253 {
1254 int hiByte = (int)(curChar >> 8);
1255 int i1 = hiByte >> 6;
1256 long l1 = 1L << (hiByte & 077);
1257 int i2 = (curChar & 0xff) >> 6;
1258 long l2 = 1L << (curChar & 077);
1259 do
1260 {
1261 switch(jjstateSet[--i])
1262 {
1263 case 1:
1264 case 0:
1265 if (!jjCanMove_0(hiByte, i1, i2, l1, l2))
1266 break;
1267 if (kind > 14)
1268 kind = 14;
1269 jjCheckNAdd(0);
1270 break;
1271 case 3:
1272 if (jjCanMove_0(hiByte, i1, i2, l1, l2))
1273 jjAddStates(18, 19);
1274 break;
1275 default : break;
1276 }
1277 } while(i != startsAt);
1278 }
1279 if (kind != 0x7fffffff)
1280 {
1281 jjmatchedKind = kind;
1282 jjmatchedPos = curPos;
1283 kind = 0x7fffffff;
1284 }
1285 ++curPos;
1286 if ((i = jjnewStateCnt) == (startsAt = 12 - (jjnewStateCnt = startsAt)))
1287 return curPos;
1288 try { curChar = input_stream.readChar(); }
1289 catch(java.io.IOException e) { return curPos; }
1290 }
1291}
1292private final int jjStartNfaWithStates_2(int pos, int kind, int state)
1293{
1294 jjmatchedKind = kind;
1295 jjmatchedPos = pos;
1296 try { curChar = input_stream.readChar(); }
1297 catch(java.io.IOException e) { return pos + 1; }
1298 return jjMoveNfa_2(state, pos + 1);
1299}
1300private final int jjMoveStringLiteralDfa0_2()
1301{
1302 switch(curChar)
1303 {
1304 case 34:
1305 return jjStopAtPos(0, 21);
1306 case 39:
1307 return jjStopAtPos(0, 20);
1308 case 61:
1309 return jjStartNfaWithStates_2(0, 17, 3);
1310 default :
1311 return jjMoveNfa_2(0, 0);
1312 }
1313}
1314private final int jjMoveNfa_2(int startState, int curPos)
1315{
1316 int startsAt = 0;
1317 jjnewStateCnt = 12;
1318 int i = 1;
1319 jjstateSet[0] = startState;
1320 int kind = 0x7fffffff;
1321 for (;;)
1322 {
1323 if (++jjround == 0x7fffffff)
1324 ReInitRounds();
1325 if (curChar < 64)
1326 {
1327 long l = 1L << curChar;
1328 do
1329 {
1330 switch(jjstateSet[--i])
1331 {
1332 case 0:
1333 if ((0x9fffff7affffd9ffL & l) != 0L)
1334 {
1335 if (kind > 16)
1336 kind = 16;
1337 jjCheckNAdd(1);
1338 }
1339 else if ((0x100002600L & l) != 0L)
1340 {
1341 if (kind > 22)
1342 kind = 22;
1343 jjCheckNAddTwoStates(5, 11);
1344 }
1345 else if (curChar == 61)
1346 jjstateSet[jjnewStateCnt++] = 3;
1347 else if (curChar == 62)
1348 {
1349 if (kind > 18)
1350 kind = 18;
1351 }
1352 if (curChar == 38)
1353 jjstateSet[jjnewStateCnt++] = 10;
1354 break;
1355 case 1:
1356 if ((0x9ffffffeffffd9ffL & l) == 0L)
1357 break;
1358 if (kind > 16)
1359 kind = 16;
1360 jjCheckNAdd(1);
1361 break;
1362 case 2:
1363 case 3:
1364 if (curChar == 62 && kind > 18)
1365 kind = 18;
1366 break;
1367 case 4:
1368 if (curChar == 61)
1369 jjstateSet[jjnewStateCnt++] = 3;
1370 break;
1371 case 5:
1372 if ((0x100002600L & l) == 0L)
1373 break;
1374 kind = 22;
1375 jjCheckNAddTwoStates(5, 11);
1376 break;
1377 case 6:
1378 if (curChar != 59)
1379 break;
1380 if (kind > 22)
1381 kind = 22;
1382 jjCheckNAddTwoStates(5, 11);
1383 break;
1384 case 11:
1385 if (curChar == 38)
1386 jjstateSet[jjnewStateCnt++] = 10;
1387 break;
1388 default : break;
1389 }
1390 } while(i != startsAt);
1391 }
1392 else if (curChar < 128)
1393 {
1394 do
1395 {
1396 switch(jjstateSet[--i])
1397 {
1398 case 0:
1399 case 1:
1400 if (kind > 16)
1401 kind = 16;
1402 jjCheckNAdd(1);
1403 break;
1404 case 7:
1405 if (curChar == 112)
1406 jjstateSet[jjnewStateCnt++] = 6;
1407 break;
1408 case 8:
1409 if (curChar == 115)
1410 jjstateSet[jjnewStateCnt++] = 7;
1411 break;
1412 case 9:
1413 if (curChar == 98)
1414 jjstateSet[jjnewStateCnt++] = 8;
1415 break;
1416 case 10:
1417 if (curChar == 110)
1418 jjstateSet[jjnewStateCnt++] = 9;
1419 break;
1420 default : break;
1421 }
1422 } while(i != startsAt);
1423 }
1424 else
1425 {
1426 int hiByte = (int)(curChar >> 8);
1427 int i1 = hiByte >> 6;
1428 long l1 = 1L << (hiByte & 077);
1429 int i2 = (curChar & 0xff) >> 6;
1430 long l2 = 1L << (curChar & 077);
1431 do
1432 {
1433 switch(jjstateSet[--i])
1434 {
1435 case 0:
1436 case 1:
1437 if (!jjCanMove_0(hiByte, i1, i2, l1, l2))
1438 break;
1439 if (kind > 16)
1440 kind = 16;
1441 jjCheckNAdd(1);
1442 break;
1443 default : break;
1444 }
1445 } while(i != startsAt);
1446 }
1447 if (kind != 0x7fffffff)
1448 {
1449 jjmatchedKind = kind;
1450 jjmatchedPos = curPos;
1451 kind = 0x7fffffff;
1452 }
1453 ++curPos;
1454 if ((i = jjnewStateCnt) == (startsAt = 12 - (jjnewStateCnt = startsAt)))
1455 return curPos;
1456 try { curChar = input_stream.readChar(); }
1457 catch(java.io.IOException e) { return curPos; }
1458 }
1459}
1460static final int[] jjnextStates = {
1461 26, 27, 30, 18, 20, 22, 5, 8, 0, 4, 6, 0, 4, 6, 5, 0,
1462 4, 6, 3, 4,
1463};
1464private static final boolean jjCanMove_0(int hiByte, int i1, int i2, long l1, long l2)
1465{
1466 switch(hiByte)
1467 {
1468 case 0:
1469 return ((jjbitVec2[i2] & l2) != 0L);
1470 default :
1471 if ((jjbitVec0[i1] & l1) != 0L)
1472 return true;
1473 return false;
1474 }
1475}
1476public static final String [] jjstrLiteralImages = {
1477"", "\74\163\143\162\151\160\164", null, null, "\74\41\55\55", "\74\41", null, null, null, null, null, null, null, null, null, null, null, "\75", null, null, "\47", "\42", null, null, null, null, null, null, "\55\55\76", null, "\76", }; public static final String [] lexStateNames = {
1481 "DEFAULT", "WithinScript", "WithinTag", "AfterEquals", "WithinQuote1", "WithinQuote2", "WithinComment1", "WithinComment2", };
1490public static final int[] jjnewLexState = {
1491 -1, 1, 2, 2, 6, 7, -1, -1, -1, -1, -1, -1, -1, -1, -1, 0, -1, 3, 0, 2, 4, 5, -1, -1, 2,
1492 -1, 2, -1, 0, -1, 0,
1493};
1494static final long[] jjtoToken = {
1495 0x7fbff47fL,
1496};
1497static final long[] jjtoSkip = {
1498 0x400000L,
1499};
1500protected SimpleCharStream input_stream;
1501private final int[] jjrounds = new int[34];
1502private final int[] jjstateSet = new int[68];
1503protected char curChar;
1504public HTMLParserTokenManager(SimpleCharStream stream){
1505 if (SimpleCharStream.staticFlag)
1506 throw new Error ("ERROR: Cannot use a static CharStream class with a non-static lexical analyzer."); input_stream = stream;
1508}
1509public HTMLParserTokenManager(SimpleCharStream stream, int lexState){
1510 this(stream);
1511 SwitchTo(lexState);
1512}
1513public void ReInit(SimpleCharStream stream)
1514{
1515 jjmatchedPos = jjnewStateCnt = 0;
1516 curLexState = defaultLexState;
1517 input_stream = stream;
1518 ReInitRounds();
1519}
1520private final void ReInitRounds()
1521{
1522 int i;
1523 jjround = 0x80000001;
1524 for (i = 34; i-- > 0;)
1525 jjrounds[i] = 0x80000000;
1526}
1527public void ReInit(SimpleCharStream stream, int lexState)
1528{
1529 ReInit(stream);
1530 SwitchTo(lexState);
1531}
1532public void SwitchTo(int lexState)
1533{
1534 if (lexState >= 8 || lexState < 0)
1535 throw new TokenMgrError("Error: Ignoring invalid lexical state : " + lexState + ". State unchanged.", TokenMgrError.INVALID_LEXICAL_STATE); else
1537 curLexState = lexState;
1538}
1539
1540protected Token jjFillToken()
1541{
1542 Token t = Token.newToken(jjmatchedKind);
1543 t.kind = jjmatchedKind;
1544 String im = jjstrLiteralImages[jjmatchedKind];
1545 t.image = (im == null) ? input_stream.GetImage() : im;
1546 t.beginLine = input_stream.getBeginLine();
1547 t.beginColumn = input_stream.getBeginColumn();
1548 t.endLine = input_stream.getEndLine();
1549 t.endColumn = input_stream.getEndColumn();
1550 return t;
1551}
1552
1553int curLexState = 0;
1554int defaultLexState = 0;
1555int jjnewStateCnt;
1556int jjround;
1557int jjmatchedPos;
1558int jjmatchedKind;
1559
1560public Token getNextToken()
1561{
1562 Token matchedToken;
1563 int curPos = 0;
1564
1565 EOFLoop :
1566 for (;;)
1567 {
1568 try
1569 {
1570 curChar = input_stream.BeginToken();
1571 }
1572 catch(java.io.IOException e)
1573 {
1574 jjmatchedKind = 0;
1575 matchedToken = jjFillToken();
1576 return matchedToken;
1577 }
1578
1579 switch(curLexState)
1580 {
1581 case 0:
1582 jjmatchedKind = 0x7fffffff;
1583 jjmatchedPos = 0;
1584 curPos = jjMoveStringLiteralDfa0_0();
1585 if (jjmatchedPos == 0 && jjmatchedKind > 13)
1586 {
1587 jjmatchedKind = 13;
1588 }
1589 break;
1590 case 1:
1591 jjmatchedKind = 0x7fffffff;
1592 jjmatchedPos = 0;
1593 curPos = jjMoveStringLiteralDfa0_1();
1594 break;
1595 case 2:
1596 jjmatchedKind = 0x7fffffff;
1597 jjmatchedPos = 0;
1598 curPos = jjMoveStringLiteralDfa0_2();
1599 break;
1600 case 3:
1601 jjmatchedKind = 0x7fffffff;
1602 jjmatchedPos = 0;
1603 curPos = jjMoveStringLiteralDfa0_3();
1604 break;
1605 case 4:
1606 jjmatchedKind = 0x7fffffff;
1607 jjmatchedPos = 0;
1608 curPos = jjMoveStringLiteralDfa0_4();
1609 break;
1610 case 5:
1611 jjmatchedKind = 0x7fffffff;
1612 jjmatchedPos = 0;
1613 curPos = jjMoveStringLiteralDfa0_5();
1614 break;
1615 case 6:
1616 jjmatchedKind = 0x7fffffff;
1617 jjmatchedPos = 0;
1618 curPos = jjMoveStringLiteralDfa0_6();
1619 break;
1620 case 7:
1621 jjmatchedKind = 0x7fffffff;
1622 jjmatchedPos = 0;
1623 curPos = jjMoveStringLiteralDfa0_7();
1624 break;
1625 }
1626 if (jjmatchedKind != 0x7fffffff)
1627 {
1628 if (jjmatchedPos + 1 < curPos)
1629 input_stream.backup(curPos - jjmatchedPos - 1);
1630 if ((jjtoToken[jjmatchedKind >> 6] & (1L << (jjmatchedKind & 077))) != 0L)
1631 {
1632 matchedToken = jjFillToken();
1633 if (jjnewLexState[jjmatchedKind] != -1)
1634 curLexState = jjnewLexState[jjmatchedKind];
1635 return matchedToken;
1636 }
1637 else
1638 {
1639 if (jjnewLexState[jjmatchedKind] != -1)
1640 curLexState = jjnewLexState[jjmatchedKind];
1641 continue EOFLoop;
1642 }
1643 }
1644 int error_line = input_stream.getEndLine();
1645 int error_column = input_stream.getEndColumn();
1646 String error_after = null;
1647 boolean EOFSeen = false;
1648 try { input_stream.readChar(); input_stream.backup(1); }
1649 catch (java.io.IOException e1) {
1650 EOFSeen = true;
1651 error_after = curPos <= 1 ? "" : input_stream.GetImage(); if (curChar == '\n' || curChar == '\r') {
1653 error_line++;
1654 error_column = 0;
1655 }
1656 else
1657 error_column++;
1658 }
1659 if (!EOFSeen) {
1660 input_stream.backup(1);
1661 error_after = curPos <= 1 ? "" : input_stream.GetImage(); }
1663 throw new TokenMgrError(EOFSeen, curLexState, error_line, error_column, error_after, curChar, TokenMgrError.LEXICAL_ERROR);
1664 }
1665}
1666
1667}
1668 |
Popular Tags |
Java API By Example, From Geeks To Geeks.