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