1
2 package org.exolab.castor.xml.dtd.parser;
3
4 public class DTDParserTokenManager implements DTDParserConstants
5 {
6 private final int jjMoveStringLiteralDfa0_12()
7 {
8 return jjMoveNfa_12(0, 0);
9 }
10 private final void jjCheckNAdd(int state)
11 {
12 if (jjrounds[state] != jjround)
13 {
14 jjstateSet[jjnewStateCnt++] = state;
15 jjrounds[state] = jjround;
16 }
17 }
18 private final void jjAddStates(int start, int end)
19 {
20 do {
21 jjstateSet[jjnewStateCnt++] = jjnextStates[start];
22 } while (start++ != end);
23 }
24 private final void jjCheckNAddTwoStates(int state1, int state2)
25 {
26 jjCheckNAdd(state1);
27 jjCheckNAdd(state2);
28 }
29 private final int jjMoveNfa_12(int startState, int curPos)
30 {
31 int startsAt = 0;
32 jjnewStateCnt = 6;
33 int i = 1;
34 jjstateSet[0] = startState;
35 int kind = 0x7fffffff;
36 for (;;)
37 {
38 if (++jjround == 0x7fffffff)
39 ReInitRounds();
40 if (curChar < 64)
41 {
42 long l = 1L << curChar;
43 MatchLoop: do
44 {
45 switch(jjstateSet[--i])
46 {
47 case 0:
48 if (curChar == 39)
49 jjCheckNAddTwoStates(4, 5);
50 else if (curChar == 34)
51 jjCheckNAddTwoStates(1, 2);
52 break;
53 case 1:
54 if ((0xafffffbb00002400L & l) != 0L)
55 jjCheckNAddTwoStates(1, 2);
56 break;
57 case 2:
58 if (curChar == 34 && kind > 76)
59 kind = 76;
60 break;
61 case 3:
62 if (curChar == 39)
63 jjCheckNAddTwoStates(4, 5);
64 break;
65 case 4:
66 if ((0xafffff3f00002400L & l) != 0L)
67 jjCheckNAddTwoStates(4, 5);
68 break;
69 case 5:
70 if (curChar == 39 && kind > 76)
71 kind = 76;
72 break;
73 default : break;
74 }
75 } while(i != startsAt);
76 }
77 else if (curChar < 128)
78 {
79 long l = 1L << (curChar & 077);
80 MatchLoop: do
81 {
82 switch(jjstateSet[--i])
83 {
84 case 1:
85 if ((0x7fffffe87ffffffL & l) != 0L)
86 jjAddStates(0, 1);
87 break;
88 case 4:
89 if ((0x7fffffe87ffffffL & l) != 0L)
90 jjAddStates(2, 3);
91 break;
92 default : break;
93 }
94 } while(i != startsAt);
95 }
96 else
97 {
98 MatchLoop: do
99 {
100 switch(jjstateSet[--i])
101 {
102 default : break;
103 }
104 } while(i != startsAt);
105 }
106 if (kind != 0x7fffffff)
107 {
108 jjmatchedKind = kind;
109 jjmatchedPos = curPos;
110 kind = 0x7fffffff;
111 }
112 ++curPos;
113 if ((i = jjnewStateCnt) == (startsAt = 6 - (jjnewStateCnt = startsAt)))
114 return curPos;
115 try { curChar = input_stream.readChar(); }
116 catch(java.io.IOException e) { return curPos; }
117 }
118 }
119 private final int jjStopAtPos(int pos, int kind)
120 {
121 jjmatchedKind = kind;
122 jjmatchedPos = pos;
123 return pos + 1;
124 }
125 private final int jjMoveStringLiteralDfa0_9()
126 {
127 switch(curChar)
128 {
129 case 39:
130 return jjStopAtPos(0, 67);
131 default :
132 return jjMoveNfa_9(0, 0);
133 }
134 }
135 static final long[] jjbitVec0 = {
136 0x0L, 0x0L, 0xffffffffffffffffL, 0xffffffffffffffffL
137 };
138 private final int jjMoveNfa_9(int startState, int curPos)
139 {
140 int startsAt = 0;
141 jjnewStateCnt = 1;
142 int i = 1;
143 jjstateSet[0] = startState;
144 int kind = 0x7fffffff;
145 for (;;)
146 {
147 if (++jjround == 0x7fffffff)
148 ReInitRounds();
149 if (curChar < 64)
150 {
151 long l = 1L << curChar;
152 MatchLoop: do
153 {
154 switch(jjstateSet[--i])
155 {
156 case 0:
157 if ((0xffffff5fffffffffL & l) != 0L)
158 kind = 66;
159 break;
160 default : break;
161 }
162 } while(i != startsAt);
163 }
164 else if (curChar < 128)
165 {
166 MatchLoop: do
167 {
168 switch(jjstateSet[--i])
169 {
170 case 0:
171 kind = 66;
172 break;
173 default : break;
174 }
175 } while(i != startsAt);
176 }
177 else
178 {
179 int i2 = (curChar & 0xff) >> 6;
180 long l2 = 1L << (curChar & 077);
181 MatchLoop: do
182 {
183 switch(jjstateSet[--i])
184 {
185 case 0:
186 if ((jjbitVec0[i2] & l2) != 0L && kind > 66)
187 kind = 66;
188 break;
189 default : break;
190 }
191 } while(i != startsAt);
192 }
193 if (kind != 0x7fffffff)
194 {
195 jjmatchedKind = kind;
196 jjmatchedPos = curPos;
197 kind = 0x7fffffff;
198 }
199 ++curPos;
200 if ((i = jjnewStateCnt) == (startsAt = 1 - (jjnewStateCnt = startsAt)))
201 return curPos;
202 try { curChar = input_stream.readChar(); }
203 catch(java.io.IOException e) { return curPos; }
204 }
205 }
206 private final int jjMoveStringLiteralDfa0_4()
207 {
208 switch(curChar)
209 {
210 case 39:
211 return jjStopAtPos(0, 51);
212 default :
213 return jjMoveNfa_4(0, 0);
214 }
215 }
216 private final int jjMoveNfa_4(int startState, int curPos)
217 {
218 int startsAt = 0;
219 jjnewStateCnt = 1;
220 int i = 1;
221 jjstateSet[0] = startState;
222 int kind = 0x7fffffff;
223 for (;;)
224 {
225 if (++jjround == 0x7fffffff)
226 ReInitRounds();
227 if (curChar < 64)
228 {
229 long l = 1L << curChar;
230 MatchLoop: do
231 {
232 switch(jjstateSet[--i])
233 {
234 case 0:
235 if ((0xefffff7fffffffffL & l) != 0L)
236 kind = 50;
237 break;
238 default : break;
239 }
240 } while(i != startsAt);
241 }
242 else if (curChar < 128)
243 {
244 MatchLoop: do
245 {
246 switch(jjstateSet[--i])
247 {
248 case 0:
249 kind = 50;
250 break;
251 default : break;
252 }
253 } while(i != startsAt);
254 }
255 else
256 {
257 int i2 = (curChar & 0xff) >> 6;
258 long l2 = 1L << (curChar & 077);
259 MatchLoop: do
260 {
261 switch(jjstateSet[--i])
262 {
263 case 0:
264 if ((jjbitVec0[i2] & l2) != 0L && kind > 50)
265 kind = 50;
266 break;
267 default : break;
268 }
269 } while(i != startsAt);
270 }
271 if (kind != 0x7fffffff)
272 {
273 jjmatchedKind = kind;
274 jjmatchedPos = curPos;
275 kind = 0x7fffffff;
276 }
277 ++curPos;
278 if ((i = jjnewStateCnt) == (startsAt = 1 - (jjnewStateCnt = startsAt)))
279 return curPos;
280 try { curChar = input_stream.readChar(); }
281 catch(java.io.IOException e) { return curPos; }
282 }
283 }
284 private final int jjMoveStringLiteralDfa0_11()
285 {
286 switch(curChar)
287 {
288 case 62:
289 return jjStopAtPos(0, 74);
290 default :
291 return jjMoveNfa_11(0, 0);
292 }
293 }
294 private final int jjMoveNfa_11(int startState, int curPos)
295 {
296 int startsAt = 0;
297 jjnewStateCnt = 7;
298 int i = 1;
299 jjstateSet[0] = startState;
300 int kind = 0x7fffffff;
301 for (;;)
302 {
303 if (++jjround == 0x7fffffff)
304 ReInitRounds();
305 if (curChar < 64)
306 {
307 long l = 1L << curChar;
308 MatchLoop: do
309 {
310 switch(jjstateSet[--i])
311 {
312 case 0:
313 if ((0x100002600L & l) != 0L)
314 {
315 if (kind > 73)
316 kind = 73;
317 jjCheckNAdd(6);
318 }
319 else if (curChar == 39)
320 jjCheckNAddTwoStates(4, 5);
321 else if (curChar == 34)
322 jjCheckNAddTwoStates(1, 2);
323 break;
324 case 1:
325 if ((0xfffffffbffffffffL & l) != 0L)
326 jjCheckNAddTwoStates(1, 2);
327 break;
328 case 2:
329 if (curChar == 34 && kind > 72)
330 kind = 72;
331 break;
332 case 3:
333 if (curChar == 39)
334 jjCheckNAddTwoStates(4, 5);
335 break;
336 case 4:
337 if ((0xffffff7fffffffffL & l) != 0L)
338 jjCheckNAddTwoStates(4, 5);
339 break;
340 case 5:
341 if (curChar == 39 && kind > 72)
342 kind = 72;
343 break;
344 case 6:
345 if ((0x100002600L & l) == 0L)
346 break;
347 if (kind > 73)
348 kind = 73;
349 jjCheckNAdd(6);
350 break;
351 default : break;
352 }
353 } while(i != startsAt);
354 }
355 else if (curChar < 128)
356 {
357 MatchLoop: do
358 {
359 switch(jjstateSet[--i])
360 {
361 case 1:
362 jjAddStates(0, 1);
363 break;
364 case 4:
365 jjAddStates(2, 3);
366 break;
367 default : break;
368 }
369 } while(i != startsAt);
370 }
371 else
372 {
373 int i2 = (curChar & 0xff) >> 6;
374 long l2 = 1L << (curChar & 077);
375 MatchLoop: do
376 {
377 switch(jjstateSet[--i])
378 {
379 case 1:
380 if ((jjbitVec0[i2] & l2) != 0L)
381 jjAddStates(0, 1);
382 break;
383 case 4:
384 if ((jjbitVec0[i2] & l2) != 0L)
385 jjAddStates(2, 3);
386 break;
387 default : break;
388 }
389 } while(i != startsAt);
390 }
391 if (kind != 0x7fffffff)
392 {
393 jjmatchedKind = kind;
394 jjmatchedPos = curPos;
395 kind = 0x7fffffff;
396 }
397 ++curPos;
398 if ((i = jjnewStateCnt) == (startsAt = 7 - (jjnewStateCnt = startsAt)))
399 return curPos;
400 try { curChar = input_stream.readChar(); }
401 catch(java.io.IOException e) { return curPos; }
402 }
403 }
404 private final int jjMoveStringLiteralDfa0_8()
405 {
406 switch(curChar)
407 {
408 case 34:
409 return jjStopAtPos(0, 65);
410 default :
411 return jjMoveNfa_8(0, 0);
412 }
413 }
414 private final int jjMoveNfa_8(int startState, int curPos)
415 {
416 int startsAt = 0;
417 jjnewStateCnt = 1;
418 int i = 1;
419 jjstateSet[0] = startState;
420 int kind = 0x7fffffff;
421 for (;;)
422 {
423 if (++jjround == 0x7fffffff)
424 ReInitRounds();
425 if (curChar < 64)
426 {
427 long l = 1L << curChar;
428 MatchLoop: do
429 {
430 switch(jjstateSet[--i])
431 {
432 case 0:
433 if ((0xffffffdbffffffffL & l) != 0L)
434 kind = 64;
435 break;
436 default : break;
437 }
438 } while(i != startsAt);
439 }
440 else if (curChar < 128)
441 {
442 MatchLoop: do
443 {
444 switch(jjstateSet[--i])
445 {
446 case 0:
447 kind = 64;
448 break;
449 default : break;
450 }
451 } while(i != startsAt);
452 }
453 else
454 {
455 int i2 = (curChar & 0xff) >> 6;
456 long l2 = 1L << (curChar & 077);
457 MatchLoop: do
458 {
459 switch(jjstateSet[--i])
460 {
461 case 0:
462 if ((jjbitVec0[i2] & l2) != 0L && kind > 64)
463 kind = 64;
464 break;
465 default : break;
466 }
467 } while(i != startsAt);
468 }
469 if (kind != 0x7fffffff)
470 {
471 jjmatchedKind = kind;
472 jjmatchedPos = curPos;
473 kind = 0x7fffffff;
474 }
475 ++curPos;
476 if ((i = jjnewStateCnt) == (startsAt = 1 - (jjnewStateCnt = startsAt)))
477 return curPos;
478 try { curChar = input_stream.readChar(); }
479 catch(java.io.IOException e) { return curPos; }
480 }
481 }
482 private final int jjStopStringLiteralDfa_0(int pos, long active0)
483 {
484 switch (pos)
485 {
486 case 0:
487 if ((active0 & 0xc000L) != 0L)
488 {
489 jjmatchedKind = 23;
490 return 2;
491 }
492 return -1;
493 case 1:
494 if ((active0 & 0xc000L) != 0L)
495 {
496 jjmatchedKind = 23;
497 jjmatchedPos = 1;
498 return 2;
499 }
500 return -1;
501 case 2:
502 if ((active0 & 0x4000L) != 0L)
503 return 2;
504 if ((active0 & 0x8000L) != 0L)
505 {
506 jjmatchedKind = 23;
507 jjmatchedPos = 2;
508 return 2;
509 }
510 return -1;
511 case 3:
512 if ((active0 & 0x8000L) != 0L)
513 {
514 jjmatchedKind = 23;
515 jjmatchedPos = 3;
516 return 2;
517 }
518 return -1;
519 case 4:
520 if ((active0 & 0x8000L) != 0L)
521 return 2;
522 return -1;
523 default :
524 return -1;
525 }
526 }
527 private final int jjStartNfa_0(int pos, long active0)
528 {
529 return jjMoveNfa_0(jjStopStringLiteralDfa_0(pos, active0), pos + 1);
530 }
531 private final int jjStartNfaWithStates_0(int pos, int kind, int state)
532 {
533 jjmatchedKind = kind;
534 jjmatchedPos = pos;
535 try { curChar = input_stream.readChar(); }
536 catch(java.io.IOException e) { return pos + 1; }
537 return jjMoveNfa_0(state, pos + 1);
538 }
539 private final int jjMoveStringLiteralDfa0_0()
540 {
541 switch(curChar)
542 {
543 case 35:
544 return jjMoveStringLiteralDfa1_0(0x40000L);
545 case 40:
546 return jjStopAtPos(0, 7);
547 case 41:
548 return jjStopAtPos(0, 8);
549 case 42:
550 return jjStopAtPos(0, 11);
551 case 43:
552 return jjStopAtPos(0, 13);
553 case 44:
554 return jjStopAtPos(0, 10);
555 case 60:
556 return jjMoveStringLiteralDfa1_0(0x790000L);
557 case 62:
558 return jjStopAtPos(0, 17);
559 case 63:
560 return jjStopAtPos(0, 12);
561 case 65:
562 return jjMoveStringLiteralDfa1_0(0x4000L);
563 case 69:
564 return jjMoveStringLiteralDfa1_0(0x8000L);
565 case 124:
566 return jjStopAtPos(0, 9);
567 default :
568 return jjMoveNfa_0(1, 0);
569 }
570 }
571 private final int jjMoveStringLiteralDfa1_0(long active0)
572 {
573 try { curChar = input_stream.readChar(); }
574 catch(java.io.IOException e) {
575 jjStopStringLiteralDfa_0(0, active0);
576 return 1;
577 }
578 switch(curChar)
579 {
580 case 33:
581 return jjMoveStringLiteralDfa2_0(active0, 0x790000L);
582 case 77:
583 return jjMoveStringLiteralDfa2_0(active0, 0x8000L);
584 case 78:
585 return jjMoveStringLiteralDfa2_0(active0, 0x4000L);
586 case 80:
587 return jjMoveStringLiteralDfa2_0(active0, 0x40000L);
588 default :
589 break;
590 }
591 return jjStartNfa_0(0, active0);
592 }
593 private final int jjMoveStringLiteralDfa2_0(long old0, long active0)
594 {
595 if (((active0 &= old0)) == 0L)
596 return jjStartNfa_0(0, old0);
597 try { curChar = input_stream.readChar(); }
598 catch(java.io.IOException e) {
599 jjStopStringLiteralDfa_0(1, active0);
600 return 2;
601 }
602 switch(curChar)
603 {
604 case 45:
605 return jjMoveStringLiteralDfa3_0(active0, 0x100000L);
606 case 65:
607 return jjMoveStringLiteralDfa3_0(active0, 0x80000L);
608 case 67:
609 return jjMoveStringLiteralDfa3_0(active0, 0x40000L);
610 case 69:
611 return jjMoveStringLiteralDfa3_0(active0, 0x210000L);
612 case 78:
613 return jjMoveStringLiteralDfa3_0(active0, 0x400000L);
614 case 80:
615 return jjMoveStringLiteralDfa3_0(active0, 0x8000L);
616 case 89:
617 if ((active0 & 0x4000L) != 0L)
618 return jjStartNfaWithStates_0(2, 14, 2);
619 break;
620 default :
621 break;
622 }
623 return jjStartNfa_0(1, active0);
624 }
625 private final int jjMoveStringLiteralDfa3_0(long old0, long active0)
626 {
627 if (((active0 &= old0)) == 0L)
628 return jjStartNfa_0(1, old0);
629 try { curChar = input_stream.readChar(); }
630 catch(java.io.IOException e) {
631 jjStopStringLiteralDfa_0(2, active0);
632 return 3;
633 }
634 switch(curChar)
635 {
636 case 45:
637 if ((active0 & 0x100000L) != 0L)
638 return jjStopAtPos(3, 20);
639 break;
640 case 68:
641 return jjMoveStringLiteralDfa4_0(active0, 0x40000L);
642 case 76:
643 return jjMoveStringLiteralDfa4_0(active0, 0x10000L);
644 case 78:
645 return jjMoveStringLiteralDfa4_0(active0, 0x200000L);
646 case 79:
647 return jjMoveStringLiteralDfa4_0(active0, 0x400000L);
648 case 84:
649 return jjMoveStringLiteralDfa4_0(active0, 0x88000L);
650 default :
651 break;
652 }
653 return jjStartNfa_0(2, active0);
654 }
655 private final int jjMoveStringLiteralDfa4_0(long old0, long active0)
656 {
657 if (((active0 &= old0)) == 0L)
658 return jjStartNfa_0(2, old0);
659 try { curChar = input_stream.readChar(); }
660 catch(java.io.IOException e) {
661 jjStopStringLiteralDfa_0(3, active0);
662 return 4;
663 }
664 switch(curChar)
665 {
666 case 65:
667 return jjMoveStringLiteralDfa5_0(active0, 0x40000L);
668 case 69:
669 return jjMoveStringLiteralDfa5_0(active0, 0x10000L);
670 case 84:
671 return jjMoveStringLiteralDfa5_0(active0, 0x680000L);
672 case 89:
673 if ((active0 & 0x8000L) != 0L)
674 return jjStartNfaWithStates_0(4, 15, 2);
675 break;
676 default :
677 break;
678 }
679 return jjStartNfa_0(3, active0);
680 }
681 private final int jjMoveStringLiteralDfa5_0(long old0, long active0)
682 {
683 if (((active0 &= old0)) == 0L)
684 return jjStartNfa_0(3, old0);
685 try { curChar = input_stream.readChar(); }
686 catch(java.io.IOException e) {
687 jjStopStringLiteralDfa_0(4, active0);
688 return 5;
689 }
690 switch(curChar)
691 {
692 case 65:
693 return jjMoveStringLiteralDfa6_0(active0, 0x400000L);
694 case 73:
695 return jjMoveStringLiteralDfa6_0(active0, 0x200000L);
696 case 76:
697 return jjMoveStringLiteralDfa6_0(active0, 0x80000L);
698 case 77:
699 return jjMoveStringLiteralDfa6_0(active0, 0x10000L);
700 case 84:
701 return jjMoveStringLiteralDfa6_0(active0, 0x40000L);
702 default :
703 break;
704 }
705 return jjStartNfa_0(4, active0);
706 }
707 private final int jjMoveStringLiteralDfa6_0(long old0, long active0)
708 {
709 if (((active0 &= old0)) == 0L)
710 return jjStartNfa_0(4, old0);
711 try { curChar = input_stream.readChar(); }
712 catch(java.io.IOException e) {
713 jjStopStringLiteralDfa_0(5, active0);
714 return 6;
715 }
716 switch(curChar)
717 {
718 case 65:
719 if ((active0 & 0x40000L) != 0L)
720 return jjStopAtPos(6, 18);
721 break;
722 case 69:
723 return jjMoveStringLiteralDfa7_0(active0, 0x10000L);
724 case 73:
725 return jjMoveStringLiteralDfa7_0(active0, 0x80000L);
726 case 84:
727 return jjMoveStringLiteralDfa7_0(active0, 0x600000L);
728 default :
729 break;
730 }
731 return jjStartNfa_0(5, active0);
732 }
733 private final int jjMoveStringLiteralDfa7_0(long old0, long active0)
734 {
735 if (((active0 &= old0)) == 0L)
736 return jjStartNfa_0(5, old0);
737 try { curChar = input_stream.readChar(); }
738 catch(java.io.IOException e) {
739 jjStopStringLiteralDfa_0(6, active0);
740 return 7;
741 }
742 switch(curChar)
743 {
744 case 73:
745 return jjMoveStringLiteralDfa8_0(active0, 0x400000L);
746 case 78:
747 return jjMoveStringLiteralDfa8_0(active0, 0x10000L);
748 case 83:
749 return jjMoveStringLiteralDfa8_0(active0, 0x80000L);
750 case 89:
751 if ((active0 & 0x200000L) != 0L)
752 return jjStopAtPos(7, 21);
753 break;
754 default :
755 break;
756 }
757 return jjStartNfa_0(6, active0);
758 }
759 private final int jjMoveStringLiteralDfa8_0(long old0, long active0)
760 {
761 if (((active0 &= old0)) == 0L)
762 return jjStartNfa_0(6, old0);
763 try { curChar = input_stream.readChar(); }
764 catch(java.io.IOException e) {
765 jjStopStringLiteralDfa_0(7, active0);
766 return 8;
767 }
768 switch(curChar)
769 {
770 case 79:
771 return jjMoveStringLiteralDfa9_0(active0, 0x400000L);
772 case 84:
773 if ((active0 & 0x10000L) != 0L)
774 return jjStopAtPos(8, 16);
775 else if ((active0 & 0x80000L) != 0L)
776 return jjStopAtPos(8, 19);
777 break;
778 default :
779 break;
780 }
781 return jjStartNfa_0(7, active0);
782 }
783 private final int jjMoveStringLiteralDfa9_0(long old0, long active0)
784 {
785 if (((active0 &= old0)) == 0L)
786 return jjStartNfa_0(7, old0);
787 try { curChar = input_stream.readChar(); }
788 catch(java.io.IOException e) {
789 jjStopStringLiteralDfa_0(8, active0);
790 return 9;
791 }
792 switch(curChar)
793 {
794 case 78:
795 if ((active0 & 0x400000L) != 0L)
796 return jjStopAtPos(9, 22);
797 break;
798 default :
799 break;
800 }
801 return jjStartNfa_0(8, active0);
802 }
803 static final long[] jjbitVec1 = {
804 0x0L, 0xffffffffffffc000L, 0xfffff0007fffffffL, 0x7fffffL
805 };
806 static final long[] jjbitVec3 = {
807 0x0L, 0x0L, 0x0L, 0xff7fffffff7fffffL
808 };
809 static final long[] jjbitVec4 = {
810 0x7ff3ffffffffffffL, 0x7ffffffffffffdfeL, 0xffffffffffffffffL, 0xfc31ffffffffe00fL
811 };
812 static final long[] jjbitVec5 = {
813 0xffffffL, 0xffffffffffff0000L, 0xf80001ffffffffffL, 0x3L
814 };
815 static final long[] jjbitVec6 = {
816 0x0L, 0x0L, 0xfffffffbffffd740L, 0xffffd547f7fffL
817 };
818 static final long[] jjbitVec7 = {
819 0xffffffffffffdffeL, 0xffffffffdffeffffL, 0xffffffffffff0003L, 0x33fcfffffff199fL
820 };
821 static final long[] jjbitVec8 = {
822 0xfffe000000000000L, 0xfffffffe027fffffL, 0x7fL, 0x707ffffff0000L
823 };
824 static final long[] jjbitVec9 = {
825 0x7fffffe00000000L, 0xfffe0000000007feL, 0x7cffffffffffffffL, 0x60002f7fffL
826 };
827 static final long[] jjbitVec10 = {
828 0x23ffffffffffffe0L, 0x3ff000000L, 0x3c5fdfffff99fe0L, 0x30003b0000000L
829 };
830 static final long[] jjbitVec11 = {
831 0x36dfdfffff987e0L, 0x1c00005e000000L, 0x23edfdfffffbafe0L, 0x100000000L
832 };
833 static final long[] jjbitVec12 = {
834 0x23cdfdfffff99fe0L, 0x3b0000000L, 0x3bfc718d63dc7e0L, 0x0L
835 };
836 static final long[] jjbitVec13 = {
837 0x3effdfffffddfe0L, 0x300000000L, 0x3effdfffffddfe0L, 0x340000000L
838 };
839 static final long[] jjbitVec14 = {
840 0x3fffdfffffddfe0L, 0x300000000L, 0x0L, 0x0L
841 };
842 static final long[] jjbitVec15 = {
843 0xd7ffffffffffeL, 0x3fL, 0x200d6caefef02596L, 0x1fL
844 };
845 static final long[] jjbitVec16 = {
846 0x0L, 0x3fffffffeffL, 0x0L, 0x0L
847 };
848 static final long[] jjbitVec17 = {
849 0x0L, 0x0L, 0xffffffff00000000L, 0x7fffffffff003fL
850 };
851 static final long[] jjbitVec18 = {
852 0x500000000007daedL, 0x2c62ab82315001L, 0xf580c90040000000L, 0x201080000000007L
853 };
854 static final long[] jjbitVec19 = {
855 0xffffffffffffffffL, 0xffffffffffffffffL, 0xffffffff0fffffffL, 0x3ffffffffffffffL
856 };
857 static final long[] jjbitVec20 = {
858 0xffffffff3f3fffffL, 0x3fffffffaaff3f3fL, 0x5fdfffffffffffffL, 0x1fdc1fff0fcf1fdcL
859 };
860 static final long[] jjbitVec21 = {
861 0x4c4000000000L, 0x0L, 0x7L, 0x0L
862 };
863 static final long[] jjbitVec22 = {
864 0x3fe00000080L, 0xfffffffffffffffeL, 0xfffffffe001fffffL, 0x7ffffffffffffffL
865 };
866 static final long[] jjbitVec23 = {
867 0x1fffffffffe0L, 0x0L, 0x0L, 0x0L
868 };
869 static final long[] jjbitVec24 = {
870 0xffffffffffffffffL, 0xffffffffffffffffL, 0x3fffffffffL, 0x0L
871 };
872 static final long[] jjbitVec25 = {
873 0xffffffffffffffffL, 0xffffffffffffffffL, 0xfffffffffL, 0x0L
874 };
875 static final long[] jjbitVec26 = {
876 0x0L, 0x0L, 0x80000000000000L, 0xff7fffffff7fffffL
877 };
878 static final long[] jjbitVec27 = {
879 0xffffffL, 0xffffffffffff0000L, 0xf80001ffffffffffL, 0x30003L
880 };
881 static final long[] jjbitVec28 = {
882 0xffffffffffffffffL, 0x30000003fL, 0xfffffffbffffd7c0L, 0xffffd547f7fffL
883 };
884 static final long[] jjbitVec29 = {
885 0xffffffffffffdffeL, 0xffffffffdffeffffL, 0xffffffffffff007bL, 0x33fcfffffff199fL
886 };
887 static final long[] jjbitVec30 = {
888 0xfffe000000000000L, 0xfffffffe027fffffL, 0xbbfffffbfffe007fL, 0x707ffffff0016L
889 };
890 static final long[] jjbitVec31 = {
891 0x7fffffe00000000L, 0xffff03ff0007ffffL, 0x7cffffffffffffffL, 0x3ff3dffffef7fffL
892 };
893 static final long[] jjbitVec32 = {
894 0xf3ffffffffffffeeL, 0xffcfff1e3fffL, 0xd3c5fdfffff99feeL, 0x3ffcfb080399fL
895 };
896 static final long[] jjbitVec33 = {
897 0xd36dfdfffff987e4L, 0x1fffc05e003987L, 0xf3edfdfffffbafeeL, 0xffc100003bbfL
898 };
899 static final long[] jjbitVec34 = {
900 0xf3cdfdfffff99feeL, 0xffc3b0c0398fL, 0xc3bfc718d63dc7ecL, 0xff8000803dc7L
901 };
902 static final long[] jjbitVec35 = {
903 0xc3effdfffffddfeeL, 0xffc300603ddfL, 0xc3effdfffffddfecL, 0xffc340603ddfL
904 };
905 static final long[] jjbitVec36 = {
906 0xc3fffdfffffddfecL, 0xffc300803dcfL, 0x0L, 0x0L
907 };
908 static final long[] jjbitVec37 = {
909 0x7ff7ffffffffffeL, 0x3ff7fffL, 0x3bff6caefef02596L, 0x3ff3f5fL
910 };
911 static final long[] jjbitVec38 = {
912 0xc2a003ff03000000L, 0xfffe03fffffffeffL, 0x2fe3ffffebf0fdfL, 0x0L
913 };
914 static final long[] jjbitVec39 = {
915 0x0L, 0x0L, 0x0L, 0x21fff0000L
916 };
917 static final long[] jjbitVec40 = {
918 0x3efffe000000a0L, 0xfffffffffffffffeL, 0xfffffffe661fffffL, 0x77ffffffffffffffL
919 };
920 private final int jjMoveNfa_0(int startState, int curPos)
921 {
922 int startsAt = 0;
923 jjnewStateCnt = 3;
924 int i = 1;
925 jjstateSet[0] = startState;
926 int kind = 0x7fffffff;
927 for (;;)
928 {
929 if (++jjround == 0x7fffffff)
930 ReInitRounds();
931 if (curChar < 64)
932 {
933 long l = 1L << curChar;
934 MatchLoop: do
935 {
936 switch(jjstateSet[--i])
937 {
938 case 1:
939 if ((0x100002600L & l) != 0L)
940 {
941 if (kind > 6)
942 kind = 6;
943 jjCheckNAdd(0);
944 }
945 else if (curChar == 58)
946 {
947 if (kind > 23)
948 kind = 23;
949 jjCheckNAdd(2);
950 }
951 break;
952 case 0:
953 if ((0x100002600L & l) == 0L)
954 break;
955 kind = 6;
956 jjCheckNAdd(0);
957 break;
958 case 2:
959 if ((0x7ff600000000000L & l) == 0L)
960 break;
961 if (kind > 23)
962 kind = 23;
963 jjCheckNAdd(2);
964 break;
965 default : break;
966 }
967 } while(i != startsAt);
968 }
969 else if (curChar < 128)
970 {
971 long l = 1L << (curChar & 077);
972 MatchLoop: do
973 {
974 switch(jjstateSet[--i])
975 {
976 case 1:
977 case 2:
978 if ((0x7fffffe87fffffeL & l) == 0L)
979 break;
980 if (kind > 23)
981 kind = 23;
982 jjCheckNAdd(2);
983 break;
984 default : break;
985 }
986 } while(i != startsAt);
987 }
988 else
989 {
990 int i2 = (curChar & 0xff) >> 6;
991 long l2 = 1L << (curChar & 077);
992 MatchLoop: do
993 {
994 switch(jjstateSet[--i])
995 {
996 case 1:
997 if ((jjbitVec3[i2] & l2) == 0L)
998 break;
999 if (kind > 23)
1000 kind = 23;
1001 jjCheckNAdd(2);
1002 break;
1003 case 2:
1004 if ((jjbitVec26[i2] & l2) == 0L)
1005 break;
1006 if (kind > 23)
1007 kind = 23;
1008 jjCheckNAdd(2);
1009 break;
1010 default : break;
1011 }
1012 } while(i != startsAt);
1013 }
1014 if (kind != 0x7fffffff)
1015 {
1016 jjmatchedKind = kind;
1017 jjmatchedPos = curPos;
1018 kind = 0x7fffffff;
1019 }
1020 ++curPos;
1021 if ((i = jjnewStateCnt) == (startsAt = 3 - (jjnewStateCnt = startsAt)))
1022 return curPos;
1023 try { curChar = input_stream.readChar(); }
1024 catch(java.io.IOException e) { return curPos; }
1025 }
1026 }
1027 private final int jjMoveStringLiteralDfa0_3()
1028 {
1029 switch(curChar)
1030 {
1031 case 34:
1032 return jjStopAtPos(0, 49);
1033 default :
1034 return jjMoveNfa_3(0, 0);
1035 }
1036 }
1037 private final int jjMoveNfa_3(int startState, int curPos)
1038 {
1039 int startsAt = 0;
1040 jjnewStateCnt = 1;
1041 int i = 1;
1042 jjstateSet[0] = startState;
1043 int kind = 0x7fffffff;
1044 for (;;)
1045 {
1046 if (++jjround == 0x7fffffff)
1047 ReInitRounds();
1048 if (curChar < 64)
1049 {
1050 long l = 1L << curChar;
1051 MatchLoop: do
1052 {
1053 switch(jjstateSet[--i])
1054 {
1055 case 0:
1056 if ((0xeffffffbffffffffL & l) != 0L)
1057 kind = 48;
1058 break;
1059 default : break;
1060 }
1061 } while(i != startsAt);
1062 }
1063 else if (curChar < 128)
1064 {
1065 MatchLoop: do
1066 {
1067 switch(jjstateSet[--i])
1068 {
1069 case 0:
1070 kind = 48;
1071 break;
1072 default : break;
1073 }
1074 } while(i != startsAt);
1075 }
1076 else
1077 {
1078 int i2 = (curChar & 0xff) >> 6;
1079 long l2 = 1L << (curChar & 077);
1080 MatchLoop: do
1081 {
1082 switch(jjstateSet[--i])
1083 {
1084 case 0:
1085 if ((jjbitVec0[i2] & l2) != 0L && kind > 48)
1086 kind = 48;
1087 break;
1088 default : break;
1089 }
1090 } while(i != startsAt);
1091 }
1092 if (kind != 0x7fffffff)
1093 {
1094 jjmatchedKind = kind;
1095 jjmatchedPos = curPos;
1096 kind = 0x7fffffff;
1097 }
1098 ++curPos;
1099 if ((i = jjnewStateCnt) == (startsAt = 1 - (jjnewStateCnt = startsAt)))
1100 return curPos;
1101 try { curChar = input_stream.readChar(); }
1102 catch(java.io.IOException e) { return curPos; }
1103 }
1104 }
1105 private final int jjStopStringLiteralDfa_1(int pos, long active0)
1106 {
1107 switch (pos)
1108 {
1109 default :
1110 return -1;
1111 }
1112 }
1113 private final int jjStartNfa_1(int pos, long active0)
1114 {
1115 return jjMoveNfa_1(jjStopStringLiteralDfa_1(pos, active0), pos + 1);
1116 }
1117 private final int jjMoveStringLiteralDfa0_1()
1118 {
1119 switch(curChar)
1120 {
1121 case 45:
1122 jjmatchedKind = 25;
1123 return jjMoveStringLiteralDfa1_1(0x4000000L);
1124 default :
1125 return jjMoveNfa_1(0, 0);
1126 }
1127 }
1128 private final int jjMoveStringLiteralDfa1_1(long active0)
1129 {
1130 try { curChar = input_stream.readChar(); }
1131 catch(java.io.IOException e) {
1132 jjStopStringLiteralDfa_1(0, active0);
1133 return 1;
1134 }
1135 switch(curChar)
1136 {
1137 case 45:
1138 return jjMoveStringLiteralDfa2_1(active0, 0x4000000L);
1139 default :
1140 break;
1141 }
1142 return jjStartNfa_1(0, active0);
1143 }
1144 private final int jjMoveStringLiteralDfa2_1(long old0, long active0)
1145 {
1146 if (((active0 &= old0)) == 0L)
1147 return jjStartNfa_1(0, old0);
1148 try { curChar = input_stream.readChar(); }
1149 catch(java.io.IOException e) {
1150 jjStopStringLiteralDfa_1(1, active0);
1151 return 2;
1152 }
1153 switch(curChar)
1154 {
1155 case 62:
1156 if ((active0 & 0x4000000L) != 0L)
1157 return jjStopAtPos(2, 26);
1158 break;
1159 default :
1160 break;
1161 }
1162 return jjStartNfa_1(1, active0);
1163 }
1164 static final long[] jjbitVec41 = {
1165 0xfffffffffffffffeL, 0xffffffffffffffffL, 0xffffffffffffffffL, 0x7fffffff00ffffffL
1166 };
1167 static final long[] jjbitVec42 = {
1168 0xffffffffffffffffL, 0xffffffffffffffffL, 0xffffffffffffffffL, 0x3fffffffffffffffL
1169 };
1170 private final int jjMoveNfa_1(int startState, int curPos)
1171 {
1172 int startsAt = 0;
1173 jjnewStateCnt = 1;
1174 int i = 1;
1175 jjstateSet[0] = startState;
1176 int kind = 0x7fffffff;
1177 for (;;)
1178 {
1179 if (++jjround == 0x7fffffff)
1180 ReInitRounds();
1181 if (curChar < 64)
1182 {
1183 long l = 1L << curChar;
1184 MatchLoop: do
1185 {
1186 switch(jjstateSet[--i])
1187 {
1188 case 0:
1189 if ((0xffffdfff00002600L & l) != 0L)
1190 kind = 24;
1191 break;
1192 default : break;
1193 }
1194 } while(i != startsAt);
1195 }
1196 else if (curChar < 128)
1197 {
1198 MatchLoop: do
1199 {
1200 switch(jjstateSet[--i])
1201 {
1202 case 0:
1203 kind = 24;
1204 break;
1205 default : break;
1206 }
1207 } while(i != startsAt);
1208 }
1209 else
1210 {
1211 int i2 = (curChar & 0xff) >> 6;
1212 long l2 = 1L << (curChar & 077);
1213 MatchLoop: do
1214 {
1215 switch(jjstateSet[--i])
1216 {
1217 case 0:
1218 if ((jjbitVec0[i2] & l2) != 0L && kind > 24)
1219 kind = 24;
1220 break;
1221 default : break;
1222 }
1223 } while(i != startsAt);
1224 }
1225 if (kind != 0x7fffffff)
1226 {
1227 jjmatchedKind = kind;
1228 jjmatchedPos = curPos;
1229 kind = 0x7fffffff;
1230 }
1231 ++curPos;
1232 if ((i = jjnewStateCnt) == (startsAt = 1 - (jjnewStateCnt = startsAt)))
1233 return curPos;
1234 try { curChar = input_stream.readChar(); }
1235 catch(java.io.IOException e) { return curPos; }
1236 }
1237 }
1238 private final int jjStopStringLiteralDfa_2(int pos, long active0)
1239 {
1240 switch (pos)
1241 {
1242 case 0:
1243 if ((active0 & 0xff80000000L) != 0L)
1244 {
1245 jjmatchedKind = 46;
1246 return 4;
1247 }
1248 return -1;
1249 case 1:
1250 if ((active0 & 0xf880000000L) != 0L)
1251 {
1252 if (jjmatchedPos != 1)
1253 {
1254 jjmatchedKind = 46;
1255 jjmatchedPos = 1;
1256 }
1257 return 4;
1258 }
1259 if ((active0 & 0x700000000L) != 0L)
1260 return 4;
1261 return -1;
1262 case 2:
1263 if ((active0 & 0xfe80000000L) != 0L)
1264 {
1265 jjmatchedKind = 46;
1266 jjmatchedPos = 2;
1267 return 4;
1268 }
1269 return -1;
1270 case 3:
1271 if ((active0 & 0xfe80000000L) != 0L)
1272 {
1273 jjmatchedKind = 46;
1274 jjmatchedPos = 3;
1275 return 4;
1276 }
1277 return -1;
1278 case 4:
1279 if ((active0 & 0xf800000000L) != 0L)
1280 {
1281 if (jjmatchedPos != 4)
1282 {
1283 jjmatchedKind = 46;
1284 jjmatchedPos = 4;
1285 }
1286 return 4;
1287 }
1288 if ((active0 & 0x680000000L) != 0L)
1289 return 4;
1290 return -1;
1291 case 5:
1292 if ((active0 & 0xc00000000L) != 0L)
1293 return 4;
1294 if ((active0 & 0xf000000000L) != 0L)
1295 {
1296 jjmatchedKind = 46;
1297 jjmatchedPos = 5;
1298 return 4;
1299 }
1300 return -1;
1301 case 6:
1302 if ((active0 & 0x9000000000L) != 0L)
1303 {
1304 if (jjmatchedPos != 6)
1305 {
1306 jjmatchedKind = 46;
1307 jjmatchedPos = 6;
1308 }
1309 return 4;
1310 }
1311 if ((active0 & 0x6000000000L) != 0L)
1312 return 4;
1313 return -1;
1314 case 7:
1315 if ((active0 & 0xd000000000L) != 0L)
1316 return 4;
1317 return -1;
1318 default :
1319 return -1;
1320 }
1321 }
1322 private final int jjStartNfa_2(int pos, long active0)
1323 {
1324 return jjMoveNfa_2(jjStopStringLiteralDfa_2(pos, active0), pos + 1);
1325 }
1326 private final int jjStartNfaWithStates_2(int pos, int kind, int state)
1327 {
1328 jjmatchedKind = kind;
1329 jjmatchedPos = pos;
1330 try { curChar = input_stream.readChar(); }
1331 catch(java.io.IOException e) { return pos + 1; }
1332 return jjMoveNfa_2(state, pos + 1);
1333 }
1334 private final int jjMoveStringLiteralDfa0_2()
1335 {
1336 switch(curChar)
1337 {
1338 case 34:
1339 return jjStopAtPos(0, 43);
1340 case 35:
1341 return jjMoveStringLiteralDfa1_2(0x70000000000L);
1342 case 39:
1343 return jjStopAtPos(0, 44);
1344 case 40:
1345 return jjStopAtPos(0, 28);
1346 case 41:
1347 return jjStopAtPos(0, 29);
1348 case 62:
1349 return jjStopAtPos(0, 45);
1350 case 67:
1351 return jjMoveStringLiteralDfa1_2(0x80000000L);
1352 case 69:
1353 return jjMoveStringLiteralDfa1_2(0x1800000000L);
1354 case 73:
1355 return jjMoveStringLiteralDfa1_2(0x700000000L);
1356 case 78:
1357 return jjMoveStringLiteralDfa1_2(0xe000000000L);
1358 case 124:
1359 return jjStopAtPos(0, 30);
1360 default :
1361 return jjMoveNfa_2(1, 0);
1362 }
1363 }
1364 private final int jjMoveStringLiteralDfa1_2(long active0)
1365 {
1366 try { curChar = input_stream.readChar(); }
1367 catch(java.io.IOException e) {
1368 jjStopStringLiteralDfa_2(0, active0);
1369 return 1;
1370 }
1371 switch(curChar)
1372 {
1373 case 68:
1374 if ((active0 & 0x100000000L) != 0L)
1375 {
1376 jjmatchedKind = 32;
1377 jjmatchedPos = 1;
1378 }
1379 return jjMoveStringLiteralDfa2_2(active0, 0x680000000L);
1380 case 70:
1381 return jjMoveStringLiteralDfa2_2(active0, 0x40000000000L);
1382 case 73:
1383 return jjMoveStringLiteralDfa2_2(active0, 0x20000000000L);
1384 case 77:
1385 return jjMoveStringLiteralDfa2_2(active0, 0x6000000000L);
1386 case 78:
1387 return jjMoveStringLiteralDfa2_2(active0, 0x1800000000L);
1388 case 79:
1389 return jjMoveStringLiteralDfa2_2(active0, 0x8000000000L);
1390 case 82:
1391 return jjMoveStringLiteralDfa2_2(active0, 0x10000000000L);
1392 default :
1393 break;
1394 }
1395 return jjStartNfa_2(0, active0);
1396 }
1397 private final int jjMoveStringLiteralDfa2_2(long old0, long active0)
1398 {
1399 if (((active0 &= old0)) == 0L)
1400 return jjStartNfa_2(0, old0);
1401 try { curChar = input_stream.readChar(); }
1402 catch(java.io.IOException e) {
1403 jjStopStringLiteralDfa_2(1, active0);
1404 return 2;
1405 }
1406 switch(curChar)
1407 {
1408 case 65:
1409 return jjMoveStringLiteralDfa3_2(active0, 0x80000000L);
1410 case 69:
1411 return jjMoveStringLiteralDfa3_2(active0, 0x10000000000L);
1412 case 73:
1413 return jjMoveStringLiteralDfa3_2(active0, 0x40000000000L);
1414 case 77:
1415 return jjMoveStringLiteralDfa3_2(active0, 0x20000000000L);
1416 case 82:
1417 return jjMoveStringLiteralDfa3_2(active0, 0x600000000L);
1418 case 84:
1419 return jjMoveStringLiteralDfa3_2(active0, 0xf800000000L);
1420 default :
1421 break;
1422 }
1423 return jjStartNfa_2(1, active0);
1424 }
1425 private final int jjMoveStringLiteralDfa3_2(long old0, long active0)
1426 {
1427 if (((active0 &= old0)) == 0L)
1428 return jjStartNfa_2(1, old0);
1429 try { curChar = input_stream.readChar(); }
1430 catch(java.io.IOException e) {
1431 jjStopStringLiteralDfa_2(2, active0);
1432 return 3;
1433 }
1434 switch(curChar)
1435 {
1436 case 65:
1437 return jjMoveStringLiteralDfa4_2(active0, 0x8000000000L);
1438 case 69:
1439 return jjMoveStringLiteralDfa4_2(active0, 0x600000000L);
1440 case 73:
1441 return jjMoveStringLiteralDfa4_2(active0, 0x1800000000L);
1442 case 79:
1443 return jjMoveStringLiteralDfa4_2(active0, 0x6000000000L);
1444 case 80:
1445 return jjMoveStringLiteralDfa4_2(active0, 0x20000000000L);
1446 case 81:
1447 return jjMoveStringLiteralDfa4_2(active0, 0x10000000000L);
1448 case 84:
1449 return jjMoveStringLiteralDfa4_2(active0, 0x80000000L);
1450 case 88:
1451 return jjMoveStringLiteralDfa4_2(active0, 0x40000000000L);
1452 default :
1453 break;
1454 }
1455 return jjStartNfa_2(2, active0);
1456 }
1457 private final int jjMoveStringLiteralDfa4_2(long old0, long active0)
1458 {
1459 if (((active0 &= old0)) == 0L)
1460 return jjStartNfa_2(2, old0);
1461 try { curChar = input_stream.readChar(); }
1462 catch(java.io.IOException e) {
1463 jjStopStringLiteralDfa_2(3, active0);
1464 return 4;
1465 }
1466 switch(curChar)
1467 {
1468 case 65:
1469 if ((active0 & 0x80000000L) != 0L)
1470 return jjStartNfaWithStates_2(4, 31, 4);
1471 break;
1472 case 69:
1473 return jjMoveStringLiteralDfa5_2(active0, 0x40000000000L);
1474 case 70:
1475 if ((active0 & 0x200000000L) != 0L)
1476 {
1477 jjmatchedKind = 33;
1478 jjmatchedPos = 4;
1479 }
1480 return jjMoveStringLiteralDfa5_2(active0, 0x400000000L);
1481 case 75:
1482 return jjMoveStringLiteralDfa5_2(active0, 0x6000000000L);
1483 case 76:
1484 return jjMoveStringLiteralDfa5_2(active0, 0x20000000000L);
1485 case 84:
1486 return jjMoveStringLiteralDfa5_2(active0, 0x9800000000L);
1487 case 85:
1488 return jjMoveStringLiteralDfa5_2(active0, 0x10000000000L);
1489 default :
1490 break;
1491 }
1492 return jjStartNfa_2(3, active0);
1493 }
1494 private final int jjMoveStringLiteralDfa5_2(long old0, long active0)
1495 {
1496 if (((active0 &= old0)) == 0L)
1497 return jjStartNfa_2(3, old0);
1498 try { curChar = input_stream.readChar(); }
1499 catch(java.io.IOException e) {
1500 jjStopStringLiteralDfa_2(4, active0);
1501 return 5;
1502 }
1503 switch(curChar)
1504 {
1505 case 68:
1506 if ((active0 & 0x40000000000L) != 0L)
1507 return jjStopAtPos(5, 42);
1508 break;
1509 case 69:
1510 return jjMoveStringLiteralDfa6_2(active0, 0x6000000000L);
1511 case 73:
1512 return jjMoveStringLiteralDfa6_2(active0, 0x39000000000L);
1513 case 83:
1514 if ((active0 & 0x400000000L) != 0L)
1515 return jjStartNfaWithStates_2(5, 34, 4);
1516 break;
1517 case 89:
1518 if ((active0 & 0x800000000L) != 0L)
1519 return jjStartNfaWithStates_2(5, 35, 4);
1520 break;
1521 default :
1522 break;
1523 }
1524 return jjStartNfa_2(4, active0);
1525 }
1526 private final int jjMoveStringLiteralDfa6_2(long old0, long active0)
1527 {
1528 if (((active0 &= old0)) == 0L)
1529 return jjStartNfa_2(4, old0);
1530 try { curChar = input_stream.readChar(); }
1531 catch(java.io.IOException e) {
1532 jjStopStringLiteralDfa_2(5, active0);
1533 return 6;
1534 }
1535 switch(curChar)
1536 {
1537 case 69:
1538 return jjMoveStringLiteralDfa7_2(active0, 0x21000000000L);
1539 case 78:
1540 if ((active0 & 0x2000000000L) != 0L)
1541 {
1542 jjmatchedKind = 37;
1543 jjmatchedPos = 6;
1544 }
1545 return jjMoveStringLiteralDfa7_2(active0, 0x4000000000L);
1546 case 79:
1547 return jjMoveStringLiteralDfa7_2(active0, 0x8000000000L);
1548 case 82:
1549 return jjMoveStringLiteralDfa7_2(active0, 0x10000000000L);
1550 default :
1551 break;
1552 }
1553 return jjStartNfa_2(5, active0);
1554 }
1555 private final int jjMoveStringLiteralDfa7_2(long old0, long active0)
1556 {
1557 if (((active0 &= old0)) == 0L)
1558 return jjStartNfa_2(5, old0);
1559 try { curChar = input_stream.readChar(); }
1560 catch(java.io.IOException e) {
1561 jjStopStringLiteralDfa_2(6, active0);
1562 return 7;
1563 }
1564 switch(curChar)
1565 {
1566 case 68:
1567 if ((active0 & 0x20000000000L) != 0L)
1568 return jjStopAtPos(7, 41);
1569 break;
1570 case 69:
1571 return jjMoveStringLiteralDfa8_2(active0, 0x10000000000L);
1572 case 78:
1573 if ((active0 & 0x8000000000L) != 0L)
1574 return jjStartNfaWithStates_2(7, 39, 4);
1575 break;
1576 case 83:
1577 if ((active0 & 0x1000000000L) != 0L)
1578 return jjStartNfaWithStates_2(7, 36, 4);
1579 else if ((active0 & 0x4000000000L) != 0L)
1580 return jjStartNfaWithStates_2(7, 38, 4);
1581 break;
1582 default :
1583 break;
1584 }
1585 return jjStartNfa_2(6, active0);
1586 }
1587 private final int jjMoveStringLiteralDfa8_2(long old0, long active0)
1588 {
1589 if (((active0 &= old0)) == 0L)
1590 return jjStartNfa_2(6, old0);
1591 try { curChar = input_stream.readChar(); }
1592 catch(java.io.IOException e) {
1593 jjStopStringLiteralDfa_2(7, active0);
1594 return 8;
1595 }
1596 switch(curChar)
1597 {
1598 case 68:
1599 if ((active0 & 0x10000000000L) != 0L)
1600 return jjStopAtPos(8, 40);
1601 break;
1602 default :
1603 break;
1604 }
1605 return jjStartNfa_2(7, active0);
1606 }
1607 private final int jjMoveNfa_2(int startState, int curPos)
1608 {
1609 int startsAt = 0;
1610 jjnewStateCnt = 4;
1611 int i = 1;
1612 jjstateSet[0] = startState;
1613 int kind = 0x7fffffff;
1614 for (;;)
1615 {
1616 if (++jjround == 0x7fffffff)
1617 ReInitRounds();
1618 if (curChar < 64)
1619 {
1620 long l = 1L << curChar;
1621 MatchLoop: do
1622 {
1623 switch(jjstateSet[--i])
1624 {
1625 case 1:
1626 if ((0x7ff600000000000L & l) != 0L)
1627 {
1628 if (kind > 47)
1629 kind = 47;
1630 jjCheckNAdd(3);
1631 }
1632 else if ((0x100002600L & l) != 0L)
1633 {
1634 if (kind > 27)
1635 kind = 27;
1636 jjCheckNAdd(0);
1637 }
1638 if (curChar == 58)
1639 {
1640 if (kind > 46)
1641 kind = 46;
1642 jjCheckNAdd(2);
1643 }
1644 break;
1645 case 4:
1646 if ((0x7ff600000000000L & l) != 0L)
1647 {
1648 if (kind > 47)
1649 kind = 47;
1650 jjCheckNAdd(3);
1651 }
1652 if ((0x7ff600000000000L & l) != 0L)
1653 {
1654 if (kind > 46)
1655 kind = 46;
1656 jjCheckNAdd(2);
1657 }
1658 break;
1659 case 0:
1660 if ((0x100002600L & l) == 0L)
1661 break;
1662 kind = 27;
1663 jjCheckNAdd(0);
1664 break;
1665 case 2:
1666 if ((0x7ff600000000000L & l) == 0L)
1667 break;
1668 if (kind > 46)
1669 kind = 46;
1670 jjCheckNAdd(2);
1671 break;
1672 case 3:
1673 if ((0x7ff600000000000L & l) == 0L)
1674 break;
1675 if (kind > 47)
1676 kind = 47;
1677 jjCheckNAdd(3);
1678 break;
1679 default : break;
1680 }
1681 } while(i != startsAt);
1682 }
1683 else if (curChar < 128)
1684 {
1685 long l = 1L << (curChar & 077);
1686 MatchLoop: do
1687 {
1688 switch(jjstateSet[--i])
1689 {
1690 case 1:
1691 if ((0x7fffffe87fffffeL & l) != 0L)
1692 {
1693 if (kind > 47)
1694 kind = 47;
1695 jjCheckNAdd(3);
1696 }
1697 if ((0x7fffffe87fffffeL & l) != 0L)
1698 {
1699 if (kind > 46)
1700 kind = 46;
1701 jjCheckNAdd(2);
1702 }
1703 break;
1704 case 4:
1705 if ((0x7fffffe87fffffeL & l) != 0L)
1706 {
1707 if (kind > 47)
1708 kind = 47;
1709 jjCheckNAdd(3);
1710 }
1711 if ((0x7fffffe87fffffeL & l) != 0L)
1712 {
1713 if (kind > 46)
1714 kind = 46;
1715 jjCheckNAdd(2);
1716 }
1717 break;
1718 case 2:
1719 if ((0x7fffffe87fffffeL & l) == 0L)
1720 break;
1721 if (kind > 46)
1722 kind = 46;
1723 jjCheckNAdd(2);
1724 break;
1725 case 3:
1726 if ((0x7fffffe87fffffeL & l) == 0L)
1727 break;
1728 if (kind > 47)
1729 kind = 47;
1730 jjCheckNAdd(3);
1731 break;
1732 default : break;
1733 }
1734 } while(i != startsAt);
1735 }
1736 else
1737 {
1738 int i2 = (curChar & 0xff) >> 6;
1739 long l2 = 1L << (curChar & 077);
1740 MatchLoop: do
1741 {
1742 switch(jjstateSet[--i])
1743 {
1744 case 1:
1745 if ((jjbitVec3[i2] & l2) != 0L)
1746 {
1747 if (kind > 46)
1748 kind = 46;
1749 jjCheckNAdd(2);
1750 }
1751 if ((jjbitVec26[i2] & l2) != 0L)
1752 {
1753 if (kind > 47)
1754 kind = 47;
1755 jjCheckNAdd(3);
1756 }
1757 break;
1758 case 4:
1759 if ((jjbitVec26[i2] & l2) != 0L)
1760 {
1761 if (kind > 46)
1762 kind = 46;
1763 jjCheckNAdd(2);
1764 }
1765 if ((jjbitVec26[i2] & l2) != 0L)
1766 {
1767 if (kind > 47)
1768 kind = 47;
1769 jjCheckNAdd(3);
1770 }
1771 break;
1772 case 2:
1773 if ((jjbitVec26[i2] & l2) == 0L)
1774 break;
1775 if (kind > 46)
1776 kind = 46;
1777 jjCheckNAdd(2);
1778 break;
1779 case 3:
1780 if ((jjbitVec26[i2] & l2) == 0L)
1781 break;
1782 if (kind > 47)
1783 kind = 47;
1784 jjCheckNAdd(3);
1785 break;
1786 default : break;
1787 }
1788 } while(i != startsAt);
1789 }
1790 if (kind != 0x7fffffff)
1791 {
1792 jjmatchedKind = kind;
1793 jjmatchedPos = curPos;
1794 kind = 0x7fffffff;
1795 }
1796 ++curPos;
1797 if ((i = jjnewStateCnt) == (startsAt = 4 - (jjnewStateCnt = startsAt)))
1798 return curPos;
1799 try { curChar = input_stream.readChar(); }
1800 catch(java.io.IOException e) { return curPos; }
1801 }
1802 }
1803 private final int jjMoveStringLiteralDfa0_10()
1804 {
1805 return jjMoveNfa_10(7, 0);
1806 }
1807 private final int jjMoveNfa_10(int startState, int curPos)
1808 {
1809 int startsAt = 0;
1810 jjnewStateCnt = 17;
1811 int i = 1;
1812 jjstateSet[0] = startState;
1813 int kind = 0x7fffffff;
1814 for (;;)
1815 {
1816 if (++jjround == 0x7fffffff)
1817 ReInitRounds();
1818 if (curChar < 64)
1819 {
1820 long l = 1L << curChar;
1821 MatchLoop: do
1822 {
1823 switch(jjstateSet[--i])
1824 {
1825 case 7:
1826 if ((0x100002600L & l) != 0L)
1827 {
1828 if (kind > 68)
1829 kind = 68;
1830 jjCheckNAdd(0);
1831 }
1832 else if (curChar == 58)
1833 {
1834 if (kind > 71)
1835 kind = 71;
1836 jjCheckNAdd(16);
1837 }
1838 break;
1839 case 0:
1840 if ((0x100002600L & l) == 0L)
1841 break;
1842 if (kind > 68)
1843 kind = 68;
1844 jjCheckNAdd(0);
1845 break;
1846 case 2:
1847 if ((0x100002600L & l) == 0L)
1848 break;
1849 if (kind > 69)
1850 kind = 69;
1851 jjstateSet[jjnewStateCnt++] = 2;
1852 break;
1853 case 9:
1854 if ((0x100002600L & l) == 0L)
1855 break;
1856 if (kind > 70)
1857 kind = 70;
1858 jjstateSet[jjnewStateCnt++] = 9;
1859 break;
1860 case 15:
1861 if (curChar != 58)
1862 break;
1863 if (kind > 71)
1864 kind = 71;
1865 jjCheckNAdd(16);
1866 break;
1867 case 16:
1868 if ((0x7ff600000000000L & l) == 0L)
1869 break;
1870 if (kind > 71)
1871 kind = 71;
1872 jjCheckNAdd(16);
1873 break;
1874 default : break;
1875 }
1876 } while(i != startsAt);
1877 }
1878 else if (curChar < 128)
1879 {
1880 long l = 1L << (curChar & 077);
1881 MatchLoop: do
1882 {
1883 switch(jjstateSet[--i])
1884 {
1885 case 7:
1886 if ((0x7fffffe87fffffeL & l) != 0L)
1887 {
1888 if (kind > 71)
1889 kind = 71;
1890 jjCheckNAdd(16);
1891 }
1892 if (curChar == 83)
1893 jjstateSet[jjnewStateCnt++] = 13;
1894 else if (curChar == 80)
1895 jjstateSet[jjnewStateCnt++] = 6;
1896 break;
1897 case 1:
1898 if (curChar == 67)
1899 jjstateSet[jjnewStateCnt++] = 2;
1900 break;
1901 case 3:
1902 if (curChar == 73)
1903 jjstateSet[jjnewStateCnt++] = 1;
1904 break;
1905 case 4:
1906 if (curChar == 76)
1907 jjstateSet[jjnewStateCnt++] = 3;
1908 break;
1909 case 5:
1910 if (curChar == 66)
1911 jjstateSet[jjnewStateCnt++] = 4;
1912 break;
1913 case 6:
1914 if (curChar == 85)
1915 jjstateSet[jjnewStateCnt++] = 5;
1916 break;
1917 case 8:
1918 if (curChar == 77)
1919 jjstateSet[jjnewStateCnt++] = 9;
1920 break;
1921 case 10:
1922 if (curChar == 69)
1923 jjstateSet[jjnewStateCnt++] = 8;
1924 break;
1925 case 11:
1926 if (curChar == 84)
1927 jjstateSet[jjnewStateCnt++] = 10;
1928 break;
1929 case 12:
1930 if (curChar == 83)
1931 jjstateSet[jjnewStateCnt++] = 11;
1932 break;
1933 case 13:
1934 if (curChar == 89)
1935 jjstateSet[jjnewStateCnt++] = 12;
1936 break;
1937 case 14:
1938 if (curChar == 83)
1939 jjstateSet[jjnewStateCnt++] = 13;
1940 break;
1941 case 15:
1942 case 16:
1943 if ((0x7fffffe87fffffeL & l) == 0L)
1944 break;
1945 if (kind > 71)
1946 kind = 71;
1947 jjCheckNAdd(16);
1948 break;
1949 default : break;
1950 }
1951 } while(i != startsAt);
1952 }
1953 else
1954 {
1955 int i2 = (curChar & 0xff) >> 6;
1956 long l2 = 1L << (curChar & 077);
1957 MatchLoop: do
1958 {
1959 switch(jjstateSet[--i])
1960 {
1961 case 7:
1962 if ((jjbitVec3[i2] & l2) == 0L)
1963 break;
1964 if (kind > 71)
1965 kind = 71;
1966 jjCheckNAdd(16);
1967 break;
1968 case 16:
1969 if ((jjbitVec26[i2] & l2) == 0L)
1970 break;
1971 if (kind > 71)
1972 kind = 71;
1973 jjCheckNAdd(16);
1974 break;
1975 default : break;
1976 }
1977 } while(i != startsAt);
1978 }
1979 if (kind != 0x7fffffff)
1980 {
1981 jjmatchedKind = kind;
1982 jjmatchedPos = curPos;
1983 kind = 0x7fffffff;
1984 }
1985 ++curPos;
1986 if ((i = jjnewStateCnt) == (startsAt = 17 - (jjnewStateCnt = startsAt)))
1987 return curPos;
1988 try { curChar = input_stream.readChar(); }
1989 catch(java.io.IOException e) { return curPos; }
1990 }
1991 }
1992 private final int jjStopStringLiteralDfa_5(int pos, long active0)
1993 {
1994 switch (pos)
1995 {
1996 case 0:
1997 if ((active0 & 0x400000000000000L) != 0L)
1998 {
1999 jjmatchedKind = 59;
2000 return 16;
2001 }
2002 return -1;
2003 case 1:
2004 if ((active0 & 0x400000000000000L) != 0L)
2005 {
2006 jjmatchedKind = 59;
2007 jjmatchedPos = 1;
2008 return 16;
2009 }
2010 return -1;
2011 case 2:
2012 if ((active0 & 0x400000000000000L) != 0L)
2013 {
2014 jjmatchedKind = 59;
2015 jjmatchedPos = 2;
2016 return 16;
2017 }
2018 return -1;
2019 case 3:
2020 if ((active0 & 0x400000000000000L) != 0L)
2021 {
2022 jjmatchedKind = 59;
2023 jjmatchedPos = 3;
2024 return 16;
2025 }
2026 return -1;
2027 default :
2028 return -1;
2029 }
2030 }
2031 private final int jjStartNfa_5(int pos, long active0)
2032 {
2033 return jjMoveNfa_5(jjStopStringLiteralDfa_5(pos, active0), pos + 1);
2034 }
2035 private final int jjStartNfaWithStates_5(int pos, int kind, int state)
2036 {
2037 jjmatchedKind = kind;
2038 jjmatchedPos = pos;
2039 try { curChar = input_stream.readChar(); }
2040 catch(java.io.IOException e) { return pos + 1; }
2041 return jjMoveNfa_5(state, pos + 1);
2042 }
2043 private final int jjMoveStringLiteralDfa0_5()
2044 {
2045 switch(curChar)
2046 {
2047 case 34:
2048 return jjStopAtPos(0, 54);
2049 case 39:
2050 return jjStopAtPos(0, 55);
2051 case 62:
2052 return jjStopAtPos(0, 53);
2053 case 78:
2054 return jjMoveStringLiteralDfa1_5(0x400000000000000L);
2055 default :
2056 return jjMoveNfa_5(7, 0);
2057 }
2058 }
2059 private final int jjMoveStringLiteralDfa1_5(long active0)
2060 {
2061 try { curChar = input_stream.readChar(); }
2062 catch(java.io.IOException e) {
2063 jjStopStringLiteralDfa_5(0, active0);
2064 return 1;
2065 }
2066 switch(curChar)
2067 {
2068 case 68:
2069 return jjMoveStringLiteralDfa2_5(active0, 0x400000000000000L);
2070 default :
2071 break;
2072 }
2073 return jjStartNfa_5(0, active0);
2074 }
2075 private final int jjMoveStringLiteralDfa2_5(long old0, long active0)
2076 {
2077 if (((active0 &= old0)) == 0L)
2078 return jjStartNfa_5(0, old0);
2079 try { curChar = input_stream.readChar(); }
2080 catch(java.io.IOException e) {
2081 jjStopStringLiteralDfa_5(1, active0);
2082 return 2;
2083 }
2084 switch(curChar)
2085 {
2086 case 65:
2087 return jjMoveStringLiteralDfa3_5(active0, 0x400000000000000L);
2088 default :
2089 break;
2090 }
2091 return jjStartNfa_5(1, active0);
2092 }
2093 private final int jjMoveStringLiteralDfa3_5(long old0, long active0)
2094 {
2095 if (((active0 &= old0)) == 0L)
2096 return jjStartNfa_5(1, old0);
2097 try { curChar = input_stream.readChar(); }
2098 catch(java.io.IOException e) {
2099 jjStopStringLiteralDfa_5(2, active0);
2100 return 3;
2101 }
2102 switch(curChar)
2103 {
2104 case 84:
2105 return jjMoveStringLiteralDfa4_5(active0, 0x400000000000000L);
2106 default :
2107 break;
2108 }
2109 return jjStartNfa_5(2, active0);
2110 }
2111 private final int jjMoveStringLiteralDfa4_5(long old0, long active0)
2112 {
2113 if (((active0 &= old0)) == 0L)
2114 return jjStartNfa_5(2, old0);
2115 try { curChar = input_stream.readChar(); }
2116 catch(java.io.IOException e) {
2117 jjStopStringLiteralDfa_5(3, active0);
2118 return 4;
2119 }
2120 switch(curChar)
2121 {
2122 case 65:
2123 if ((active0 & 0x400000000000000L) != 0L)
2124 return jjStartNfaWithStates_5(4, 58, 16);
2125 break;
2126 default :
2127 break;
2128 }
2129 return jjStartNfa_5(3, active0);
2130 }
2131 private final int jjMoveNfa_5(int startState, int curPos)
2132 {
2133 int startsAt = 0;
2134 jjnewStateCnt = 17;
2135 int i = 1;
2136 jjstateSet[0] = startState;
2137 int kind = 0x7fffffff;
2138 for (;;)
2139 {
2140 if (++jjround == 0x7fffffff)
2141 ReInitRounds();
2142 if (curChar < 64)
2143 {
2144 long l = 1L << curChar;
2145 MatchLoop: do
2146 {
2147 switch(jjstateSet[--i])
2148 {
2149 case 7:
2150 if ((0x100002600L & l) != 0L)
2151 {
2152 if (kind > 52)
2153 kind = 52;
2154 jjCheckNAdd(0);
2155 }
2156 else if (curChar == 58)
2157 {
2158 if (kind > 59)
2159 kind = 59;
2160 jjCheckNAdd(16);
2161 }
2162 break;
2163 case 0:
2164 if ((0x100002600L & l) == 0L)
2165 break;
2166 if (kind > 52)
2167 kind = 52;
2168 jjCheckNAdd(0);
2169 break;
2170 case 2:
2171 if ((0x100002600L & l) == 0L)
2172 break;
2173 if (kind > 56)
2174 kind = 56;
2175 jjstateSet[jjnewStateCnt++] = 2;
2176 break;
2177 case 9:
2178 if ((0x100002600L & l) == 0L)
2179 break;
2180 if (kind > 57)
2181 kind = 57;
2182 jjstateSet[jjnewStateCnt++] = 9;
2183 break;
2184 case 15:
2185 if (curChar != 58)
2186 break;
2187 if (kind > 59)
2188 kind = 59;
2189 jjCheckNAdd(16);
2190 break;
2191 case 16:
2192 if ((0x7ff600000000000L & l) == 0L)
2193 break;
2194 if (kind > 59)
2195 kind = 59;
2196 jjCheckNAdd(16);
2197 break;
2198 default : break;
2199 }
2200 } while(i != startsAt);
2201 }
2202 else if (curChar < 128)
2203 {
2204 long l = 1L << (curChar & 077);
2205 MatchLoop: do
2206 {
2207 switch(jjstateSet[--i])
2208 {
2209 case 7:
2210 if ((0x7fffffe87fffffeL & l) != 0L)
2211 {
2212 if (kind > 59)
2213 kind = 59;
2214 jjCheckNAdd(16);
2215 }
2216 if (curChar == 83)
2217 jjstateSet[jjnewStateCnt++] = 13;
2218 else if (curChar == 80)
2219 jjstateSet[jjnewStateCnt++] = 6;
2220 break;
2221 case 1:
2222 if (curChar == 67)
2223 jjstateSet[jjnewStateCnt++] = 2;
2224 break;
2225 case 3:
2226 if (curChar == 73)
2227 jjstateSet[jjnewStateCnt++] = 1;
2228 break;
2229 case 4:
2230 if (curChar == 76)
2231 jjstateSet[jjnewStateCnt++] = 3;
2232 break;
2233 case 5:
2234 if (curChar == 66)
2235 jjstateSet[jjnewStateCnt++] = 4;
2236 break;
2237 case 6:
2238 if (curChar == 85)
2239 jjstateSet[jjnewStateCnt++] = 5;
2240 break;
2241 case 8:
2242 if (curChar == 77)
2243 jjstateSet[jjnewStateCnt++] = 9;
2244 break;
2245 case 10:
2246 if (curChar == 69)
2247 jjstateSet[jjnewStateCnt++] = 8;
2248 break;
2249 case 11:
2250 if (curChar == 84)
2251 jjstateSet[jjnewStateCnt++] = 10;
2252 break;
2253 case 12:
2254 if (curChar == 83)
2255 jjstateSet[jjnewStateCnt++] = 11;
2256 break;
2257 case 13:
2258 if (curChar == 89)
2259 jjstateSet[jjnewStateCnt++] = 12;
2260 break;
2261 case 14:
2262 if (curChar == 83)
2263 jjstateSet[jjnewStateCnt++] = 13;
2264 break;
2265 case 15:
2266 case 16:
2267 if ((0x7fffffe87fffffeL & l) == 0L)
2268 break;
2269 if (kind > 59)
2270 kind = 59;
2271 jjCheckNAdd(16);
2272 break;
2273 default : break;
2274 }
2275 } while(i != startsAt);
2276 }
2277 else
2278 {
2279 int i2 = (curChar & 0xff) >> 6;
2280 long l2 = 1L << (curChar & 077);
2281 MatchLoop: do
2282 {
2283 switch(jjstateSet[--i])
2284 {
2285 case 7:
2286 if ((jjbitVec3[i2] & l2) == 0L)
2287 break;
2288 if (kind > 59)
2289 kind = 59;
2290 jjCheckNAdd(16);
2291 break;
2292 case 16:
2293 if ((jjbitVec26[i2] & l2) == 0L)
2294 break;
2295 if (kind > 59)
2296 kind = 59;
2297 jjCheckNAdd(16);
2298 break;
2299 default : break;
2300 }
2301 } while(i != startsAt);
2302 }
2303 if (kind != 0x7fffffff)
2304 {
2305 jjmatchedKind = kind;
2306 jjmatchedPos = curPos;
2307 kind = 0x7fffffff;
2308 }
2309 ++curPos;
2310 if ((i = jjnewStateCnt) == (startsAt = 17 - (jjnewStateCnt = startsAt)))
2311 return curPos;
2312 try { curChar = input_stream.readChar(); }
2313 catch(java.io.IOException e) { return curPos; }
2314 }
2315 }
2316 private final int jjMoveStringLiteralDfa0_7()
2317 {
2318 return jjMoveNfa_7(0, 0);
2319 }
2320 private final int jjMoveNfa_7(int startState, int curPos)
2321 {
2322 int startsAt = 0;
2323 jjnewStateCnt = 7;
2324 int i = 1;
2325 jjstateSet[0] = startState;
2326 int kind = 0x7fffffff;
2327 for (;;)
2328 {
2329 if (++jjround == 0x7fffffff)
2330 ReInitRounds();
2331 if (curChar < 64)
2332 {
2333 long l = 1L << curChar;
2334 MatchLoop: do
2335 {
2336 switch(jjstateSet[--i])
2337 {
2338 case 0:
2339 if ((0x100002600L & l) != 0L)
2340 {
2341 if (kind > 63)
2342 kind = 63;
2343 jjCheckNAdd(6);
2344 }
2345 else if (curChar == 39)
2346 jjCheckNAddTwoStates(4, 5);
2347 else if (curChar == 34)
2348 jjCheckNAddTwoStates(1, 2);
2349 break;
2350 case 1:
2351 if ((0xafffffbb00002400L & l) != 0L)
2352 jjCheckNAddTwoStates(1, 2);
2353 break;
2354 case 2:
2355 if (curChar == 34 && kind > 62)
2356 kind = 62;
2357 break;
2358 case 3:
2359 if (curChar == 39)
2360 jjCheckNAddTwoStates(4, 5);
2361 break;
2362 case 4:
2363 if ((0xafffff3f00002400L & l) != 0L)
2364 jjCheckNAddTwoStates(4, 5);
2365 break;
2366 case 5:
2367 if (curChar == 39 && kind > 62)
2368 kind = 62;
2369 break;
2370 case 6:
2371 if ((0x100002600L & l) == 0L)
2372 break;
2373 if (kind > 63)
2374 kind = 63;
2375 jjCheckNAdd(6);
2376 break;
2377 default : break;
2378 }
2379 } while(i != startsAt);
2380 }
2381 else if (curChar < 128)
2382 {
2383 long l = 1L << (curChar & 077);
2384 MatchLoop: do
2385 {
2386 switch(jjstateSet[--i])
2387 {
2388 case 1:
2389 if ((0x7fffffe87ffffffL & l) != 0L)
2390 jjAddStates(0, 1);
2391 break;
2392 case 4:
2393 if ((0x7fffffe87ffffffL & l) != 0L)
2394 jjAddStates(2, 3);
2395 break;
2396 default : break;
2397 }
2398 } while(i != startsAt);
2399 }
2400 else
2401 {
2402 MatchLoop: do
2403 {
2404 switch(jjstateSet[--i])
2405 {
2406 default : break;
2407 }
2408 } while(i != startsAt);
2409 }
2410 if (kind != 0x7fffffff)
2411 {
2412 jjmatchedKind = kind;
2413 jjmatchedPos = curPos;
2414 kind = 0x7fffffff;
2415 }
2416 ++curPos;
2417 if ((i = jjnewStateCnt) == (startsAt = 7 - (jjnewStateCnt = startsAt)))
2418 return curPos;
2419 try { curChar = input_stream.readChar(); }
2420 catch(java.io.IOException e) { return curPos; }
2421 }
2422 }
2423 private final int jjMoveStringLiteralDfa0_6()
2424 {
2425 return jjMoveNfa_6(0, 0);
2426 }
2427 private final int jjMoveNfa_6(int startState, int curPos)
2428 {
2429 int startsAt = 0;
2430 jjnewStateCnt = 6;
2431 int i = 1;
2432 jjstateSet[0] = startState;
2433 int kind = 0x7fffffff;
2434 for (;;)
2435 {
2436 if (++jjround == 0x7fffffff)
2437 ReInitRounds();
2438 if (curChar < 64)
2439 {
2440 long l = 1L << curChar;
2441 MatchLoop: do
2442 {
2443 switch(jjstateSet[--i])
2444 {
2445 case 0:
2446 if (curChar == 39)
2447 jjCheckNAddTwoStates(4, 5);
2448 else if (curChar == 34)
2449 jjCheckNAddTwoStates(1, 2);
2450 break;
2451 case 1:
2452 if ((0xfffffffbffffffffL & l) != 0L)
2453 jjCheckNAddTwoStates(1, 2);
2454 break;
2455 case 2:
2456 if (curChar == 34 && kind > 60)
2457 kind = 60;
2458 break;
2459 case 3:
2460 if (curChar == 39)
2461 jjCheckNAddTwoStates(4, 5);
2462 break;
2463 case 4:
2464 if ((0xffffff7fffffffffL & l) != 0L)
2465 jjCheckNAddTwoStates(4, 5);
2466 break;
2467 case 5:
2468 if (curChar == 39 && kind > 60)
2469 kind = 60;
2470 break;
2471 default : break;
2472 }
2473 } while(i != startsAt);
2474 }
2475 else if (curChar < 128)
2476 {
2477 MatchLoop: do
2478 {
2479 switch(jjstateSet[--i])
2480 {
2481 case 1:
2482 jjAddStates(0, 1);
2483 break;
2484 case 4:
2485 jjAddStates(2, 3);
2486 break;
2487 default : break;
2488 }
2489 } while(i != startsAt);
2490 }
2491 else
2492 {
2493 int i2 = (curChar & 0xff) >> 6;
2494 long l2 = 1L << (curChar & 077);
2495 MatchLoop: do
2496 {
2497 switch(jjstateSet[--i])
2498 {
2499 case 1:
2500 if ((jjbitVec0[i2] & l2) != 0L)
2501 jjAddStates(0, 1);
2502 break;
2503 case 4:
2504 if ((jjbitVec0[i2] & l2) != 0L)
2505 jjAddStates(2, 3);
2506 break;
2507 default : break;
2508 }
2509 } while(i != startsAt);
2510 }
2511 if (kind != 0x7fffffff)
2512 {
2513 jjmatchedKind = kind;
2514 jjmatchedPos = curPos;
2515 kind = 0x7fffffff;
2516 }
2517 ++curPos;
2518 if ((i = jjnewStateCnt) == (startsAt = 6 - (jjnewStateCnt = startsAt)))
2519 return curPos;
2520 try { curChar = input_stream.readChar(); }
2521 catch(java.io.IOException e) { return curPos; }
2522 }
2523 }
2524 static final int[] jjnextStates = {
2525 1, 2, 4, 5,
2526 };
2527 public static final String[] jjstrLiteralImages = {
2528 "", null, null, null, null, null, null, "\50", "\51", "\174", "\54", "\52",
2529 "\77", "\53", "\101\116\131", "\105\115\120\124\131",
2530 "\74\41\105\114\105\115\105\116\124", "\76", "\43\120\103\104\101\124\101", "\74\41\101\124\124\114\111\123\124",
2531 "\74\41\55\55", "\74\41\105\116\124\111\124\131", "\74\41\116\117\124\101\124\111\117\116",
2532 null, null, "\55", "\55\55\76", null, "\50", "\51", "\174", "\103\104\101\124\101",
2533 "\111\104", "\111\104\122\105\106", "\111\104\122\105\106\123",
2534 "\105\116\124\111\124\131", "\105\116\124\111\124\111\105\123", "\116\115\124\117\113\105\116",
2535 "\116\115\124\117\113\105\116\123", "\116\117\124\101\124\111\117\116", "\43\122\105\121\125\111\122\105\104",
2536 "\43\111\115\120\114\111\105\104", "\43\106\111\130\105\104", "\42", "\47", "\76", null, null, null, "\42", null,
2537 "\47", null, "\76", "\42", "\47", null, null, "\116\104\101\124\101", null, null,
2538 null, null, null, null, "\42", null, "\47", null, null, null, null, null, null,
2539 "\76", null, null, };
2540 public static final String[] lexStateNames = {
2541 "DEFAULT",
2542 "WithinComment",
2543 "WithinAttrDecl",
2544 "WithinAttrValueDQ",
2545 "WithinAttrValueSQ",
2546 "WithinGEDecl",
2547 "System_GE",
2548 "Public_GE",
2549 "WithinGEValueDQ",
2550 "WithinGEValueSQ",
2551 "WithinNotationDecl",
2552 "System_NOT",
2553 "Public_NOT",
2554 };
2555 public static final int[] jjnewLexState = {
2556 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 2, 1, 5, 10, -1, -1,
2557 -1, 0, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 3, 4, 0, -1, -1, -1, 2,
2558 -1, 2, -1, 0, 8, 9, 7, 6, -1, -1, 5, -1, -1, 6, -1, 5, -1, 5, -1, 12, 11, -1, -1, -1, 0,
2559 -1, 11,
2560 };
2561 private CharStream input_stream;
2562 private final int[] jjrounds = new int[17];
2563 private final int[] jjstateSet = new int[34];
2564 protected char curChar;
2565 public DTDParserTokenManager(CharStream stream)
2566 {
2567 input_stream = stream;
2568 }
2569 public DTDParserTokenManager(CharStream stream, int lexState)
2570 {
2571 this(stream);
2572 SwitchTo(lexState);
2573 }
2574 public void ReInit(CharStream stream)
2575 {
2576 jjmatchedPos = jjnewStateCnt = 0;
2577 curLexState = defaultLexState;
2578 input_stream = stream;
2579 ReInitRounds();
2580 }
2581 private final void ReInitRounds()
2582 {
2583 int i;
2584 jjround = 0x80000001;
2585 for (i = 17; i-- > 0;)
2586 jjrounds[i] = 0x80000000;
2587 }
2588
2589 public void ReInit(CharStream stream, int lexState) {
2590 ReInit(stream);
2591 SwitchTo(lexState);
2592 }
2593
2594 public void SwitchTo(int lexState) {
2595 if (lexState >= 13 || lexState < 0) {
2596 throw new TokenMgrError("Error: Ignoring invalid lexical state : " + lexState + ". State unchanged.", TokenMgrError.INVALID_LEXICAL_STATE);
2597 }
2598 curLexState = lexState;
2599 }
2600
2601 private final Token jjFillToken() {
2602 Token t = Token.newToken(jjmatchedKind);
2603 t.kind = jjmatchedKind;
2604 String im = jjstrLiteralImages[jjmatchedKind];
2605 t.image = (im == null) ? input_stream.GetImage() : im;
2606 t.beginLine = input_stream.getBeginLine();
2607 t.beginColumn = input_stream.getBeginColumn();
2608 t.endLine = input_stream.getEndLine();
2609 t.endColumn = input_stream.getEndColumn();
2610 return t;
2611 }
2612
2613 int curLexState = 0;
2614 int defaultLexState = 0;
2615 int jjnewStateCnt;
2616 int jjround;
2617 int jjmatchedPos;
2618 int jjmatchedKind;
2619
2620 public final Token getNextToken() {
2621 Token matchedToken;
2622 int curPos = 0;
2623
2624 EOFLoop :
2625 for (;;)
2626 {
2627 try
2628 {
2629 curChar = input_stream.BeginToken();
2630 }
2631 catch(java.io.IOException e)
2632 {
2633 jjmatchedKind = 0;
2634 matchedToken = jjFillToken();
2635 return matchedToken;
2636 }
2637
2638 switch(curLexState)
2639 {
2640 case 0:
2641 jjmatchedKind = 0x7fffffff;
2642 jjmatchedPos = 0;
2643 curPos = jjMoveStringLiteralDfa0_0();
2644 break;
2645 case 1:
2646 jjmatchedKind = 0x7fffffff;
2647 jjmatchedPos = 0;
2648 curPos = jjMoveStringLiteralDfa0_1();
2649 break;
2650 case 2:
2651 jjmatchedKind = 0x7fffffff;
2652 jjmatchedPos = 0;
2653 curPos = jjMoveStringLiteralDfa0_2();
2654 break;
2655 case 3:
2656 jjmatchedKind = 0x7fffffff;
2657 jjmatchedPos = 0;
2658 curPos = jjMoveStringLiteralDfa0_3();
2659 break;
2660 case 4:
2661 jjmatchedKind = 0x7fffffff;
2662 jjmatchedPos = 0;
2663 curPos = jjMoveStringLiteralDfa0_4();
2664 break;
2665 case 5:
2666 jjmatchedKind = 0x7fffffff;
2667 jjmatchedPos = 0;
2668 curPos = jjMoveStringLiteralDfa0_5();
2669 break;
2670 case 6:
2671 jjmatchedKind = 0x7fffffff;
2672 jjmatchedPos = 0;
2673 curPos = jjMoveStringLiteralDfa0_6();
2674 break;
2675 case 7:
2676 jjmatchedKind = 0x7fffffff;
2677 jjmatchedPos = 0;
2678 curPos = jjMoveStringLiteralDfa0_7();
2679 break;
2680 case 8:
2681 jjmatchedKind = 0x7fffffff;
2682 jjmatchedPos = 0;
2683 curPos = jjMoveStringLiteralDfa0_8();
2684 break;
2685 case 9:
2686 jjmatchedKind = 0x7fffffff;
2687 jjmatchedPos = 0;
2688 curPos = jjMoveStringLiteralDfa0_9();
2689 break;
2690 case 10:
2691 jjmatchedKind = 0x7fffffff;
2692 jjmatchedPos = 0;
2693 curPos = jjMoveStringLiteralDfa0_10();
2694 break;
2695 case 11:
2696 jjmatchedKind = 0x7fffffff;
2697 jjmatchedPos = 0;
2698 curPos = jjMoveStringLiteralDfa0_11();
2699 break;
2700 case 12:
2701 jjmatchedKind = 0x7fffffff;
2702 jjmatchedPos = 0;
2703 curPos = jjMoveStringLiteralDfa0_12();
2704 break;
2705 }
2706 if (jjmatchedKind != 0x7fffffff)
2707 {
2708 if (jjmatchedPos + 1 < curPos)
2709 input_stream.backup(curPos - jjmatchedPos - 1);
2710 matchedToken = jjFillToken();
2711 if (jjnewLexState[jjmatchedKind] != -1)
2712 curLexState = jjnewLexState[jjmatchedKind];
2713 return matchedToken;
2714 }
2715 int error_line = input_stream.getEndLine();
2716 int error_column = input_stream.getEndColumn();
2717 String error_after = null;
2718 boolean EOFSeen = false;
2719 try { input_stream.readChar(); input_stream.backup(1); }
2720 catch (java.io.IOException e1) {
2721 EOFSeen = true;
2722 error_after = curPos <= 1 ? "" : input_stream.GetImage();
2723 if (curChar == '\n' || curChar == '\r') {
2724 error_line++;
2725 error_column = 0;
2726 }
2727 else
2728 error_column++;
2729 }
2730 if (!EOFSeen) {
2731 input_stream.backup(1);
2732 error_after = curPos <= 1 ? "" : input_stream.GetImage();
2733 }
2734 throw new TokenMgrError(EOFSeen, curLexState, error_line, error_column, error_after, curChar, TokenMgrError.LEXICAL_ERROR);
2735 }
2736 }
2737
2738 }