|
1
2 package org.python.parser;
3 import org.python.parser.ast.modType;
4
5 public class PythonGrammarTokenManager implements PythonGrammarConstants
6 {
7 int indentation[] = {0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0};
8 int level = 0;
9 int dedents = 0;
10 int parens = 0;
11 int indent;
12
13 boolean expect_indent = false;
14
15 boolean compound = false;
16
17 public boolean single_input = false;
18
19 public boolean partial = false;
21 public boolean stdprompt = false;
24
25 public boolean generator_allowed = false;
26
27 static Token addDedent(Token previous) {
28 Token t = new Token();
29 t.kind = DEDENT;
30 t.beginLine = previous.beginLine;
31 t.endLine = previous.endLine;
32 t.beginColumn = previous.beginColumn;
33 t.endColumn = previous.endColumn;
34 t.image = "<DEDENT>";
35 t.specialToken = null;
36 t.next = null;
37 previous.next = t;
38 return t;
39 }
40
41 void CommonTokenAction(Token t) {
42
49 if (t.kind == EOF) {
50 if (!partial || curLexState == MAYBE_FORCE_NEWLINE_IF_EOF) {
52 if (curLexState == DEFAULT) {
53 t.kind = NEWLINE;
54 }
55 else {
56 t.kind = DEDENT;
57 if (level >= 0) level -= 1;
58 }
59 while (level >= 0) {
60 level--;
61 t = addDedent(t);
62 }
63 if (!single_input) {
64 t.kind = EOF;
65 t.image = "<EOF>";
66 } else {
67 t.kind = NEWLINE;
68 t.image = "<FORCENL>";
69 single_input = false;
70 }
71 }
72 } else if (t.kind == YIELD) {
73 if (!generator_allowed) {
74 t.kind = NAME;
75 }
76 }
77 }
78
79 void indenting(int ind) {
80 indent = ind;
81 if (indent == indentation[level])
82 SwitchTo(INDENTATION_UNCHANGED);
83 else
84 SwitchTo(INDENTING);
85 }
86 public java.io.PrintStream  debugStream = System.out;
87 public void setDebugStream(java.io.PrintStream ds) { debugStream = ds; }
88 private final int jjMoveStringLiteralDfa0_12()
89 {
90 return 1;
91 }
92 private final int jjStopStringLiteralDfa_10(int pos, long active0, long active1)
93 {
94 switch (pos)
95 {
96 case 0:
97 if ((active1 & 0x80000000000L) != 0L)
98 {
99 jjmatchedKind = 119;
100 return -1;
101 }
102 return -1;
103 case 1:
104 if ((active1 & 0x80000000000L) != 0L)
105 {
106 if (jjmatchedPos == 0)
107 {
108 jjmatchedKind = 119;
109 jjmatchedPos = 0;
110 }
111 return -1;
112 }
113 return -1;
114 default :
115 return -1;
116 }
117 }
118 private final int jjStartNfa_10(int pos, long active0, long active1)
119 {
120 return jjMoveNfa_10(jjStopStringLiteralDfa_10(pos, active0, active1), pos + 1);
121 }
122 private final int jjStopAtPos(int pos, int kind)
123 {
124 jjmatchedKind = kind;
125 jjmatchedPos = pos;
126 return pos + 1;
127 }
128 private final int jjStartNfaWithStates_10(int pos, int kind, int state)
129 {
130 jjmatchedKind = kind;
131 jjmatchedPos = pos;
132 try { curChar = input_stream.readChar(); }
133 catch(java.io.IOException e) { return pos + 1; }
134 return jjMoveNfa_10(state, pos + 1);
135 }
136 private final int jjMoveStringLiteralDfa0_10()
137 {
138 switch(curChar)
139 {
140 case 10:
141 return jjStopAtPos(0, 117);
142 case 13:
143 jjmatchedKind = 118;
144 return jjMoveStringLiteralDfa1_10(0x10000000000000L);
145 case 34:
146 return jjMoveStringLiteralDfa1_10(0x80000000000L);
147 default :
148 return jjMoveNfa_10(0, 0);
149 }
150 }
151 private final int jjMoveStringLiteralDfa1_10(long active1)
152 {
153 try { curChar = input_stream.readChar(); }
154 catch(java.io.IOException e) {
155 jjStopStringLiteralDfa_10(0, 0L, active1);
156 return 1;
157 }
158 switch(curChar)
159 {
160 case 10:
161 if ((active1 & 0x10000000000000L) != 0L)
162 return jjStopAtPos(1, 116);
163 break;
164 case 34:
165 return jjMoveStringLiteralDfa2_10(active1, 0x80000000000L);
166 default :
167 break;
168 }
169 return jjStartNfa_10(0, 0L, active1);
170 }
171 private final int jjMoveStringLiteralDfa2_10(long old1, long active1)
172 {
173 if (((active1 &= old1)) == 0L)
174 return jjStartNfa_10(0, 0L, old1);
175 try { curChar = input_stream.readChar(); }
176 catch(java.io.IOException e) {
177 jjStopStringLiteralDfa_10(1, 0L, active1);
178 return 2;
179 }
180 switch(curChar)
181 {
182 case 34:
183 if ((active1 & 0x80000000000L) != 0L)
184 return jjStopAtPos(2, 107);
185 break;
186 default :
187 break;
188 }
189 return jjStartNfa_10(1, 0L, active1);
190 }
191 private final void jjCheckNAdd(int state)
192 {
193 if (jjrounds[state] != jjround)
194 {
195 jjstateSet[jjnewStateCnt++] = state;
196 jjrounds[state] = jjround;
197 }
198 }
199 private final void jjAddStates(int start, int end)
200 {
201 do {
202 jjstateSet[jjnewStateCnt++] = jjnextStates[start];
203 } while (start++ != end);
204 }
205 private final void jjCheckNAddTwoStates(int state1, int state2)
206 {
207 jjCheckNAdd(state1);
208 jjCheckNAdd(state2);
209 }
210 private final void jjCheckNAddStates(int start, int end)
211 {
212 do {
213 jjCheckNAdd(jjnextStates[start]);
214 } while (start++ != end);
215 }
216 private final void jjCheckNAddStates(int start)
217 {
218 jjCheckNAdd(jjnextStates[start]);
219 jjCheckNAdd(jjnextStates[start + 1]);
220 }
221 static final long[] jjbitVec0 = {
222 0xfffffffffffffffeL, 0xffffffffffffffffL, 0xffffffffffffffffL, 0xffffffffffffffffL
223 };
224 static final long[] jjbitVec2 = {
225 0x0L, 0x0L, 0xffffffffffffffffL, 0xffffffffffffffffL
226 };
227 private final int jjMoveNfa_10(int startState, int curPos)
228 {
229 int[] nextStates;
230 int startsAt = 0;
231 jjnewStateCnt = 3;
232 int i = 1;
233 jjstateSet[0] = startState;
234 int j, kind = 0x7fffffff;
235 for (;;)
236 {
237 if (++jjround == 0x7fffffff)
238 ReInitRounds();
239 if (curChar < 64)
240 {
241 long l = 1L << curChar;
242 MatchLoop: do
243 {
244 switch(jjstateSet[--i])
245 {
246 case 0:
247 if ((0xffffffffffffdbffL & l) != 0L && kind > 119)
248 kind = 119;
249 break;
250 case 2:
251 if ((0xffffffffffffdbffL & l) != 0L && kind > 120)
252 kind = 120;
253 break;
254 default : break;
255 }
256 } while(i != startsAt);
257 }
258 else if (curChar < 128)
259 {
260 long l = 1L << (curChar & 077);
261 MatchLoop: do
262 {
263 switch(jjstateSet[--i])
264 {
265 case 0:
266 if (kind > 119)
267 kind = 119;
268 if (curChar == 92)
269 jjstateSet[jjnewStateCnt++] = 2;
270 break;
271 case 1:
272 if (curChar == 92)
273 jjstateSet[jjnewStateCnt++] = 2;
274 break;
275 case 2:
276 if (kind > 120)
277 kind = 120;
278 break;
279 default : break;
280 }
281 } while(i != startsAt);
282 }
283 else
284 {
285 int hiByte = (int)(curChar >> 8);
286 int i1 = hiByte >> 6;
287 long l1 = 1L << (hiByte & 077);
288 int i2 = (curChar & 0xff) >> 6;
289 long l2 = 1L << (curChar & 077);
290 MatchLoop: do
291 {
292 switch(jjstateSet[--i])
293 {
294 case 0:
295 if (jjCanMove_0(hiByte, i1, i2, l1, l2) && kind > 119)
296 kind = 119;
297 break;
298 case 2:
299 if (jjCanMove_0(hiByte, i1, i2, l1, l2) && kind > 120)
300 kind = 120;
301 break;
302 default : break;
303 }
304 } while(i != startsAt);
305 }
306 if (kind != 0x7fffffff)
307 {
308 jjmatchedKind = kind;
309 jjmatchedPos = curPos;
310 kind = 0x7fffffff;
311 }
312 ++curPos;
313 if ((i = jjnewStateCnt) == (startsAt = 3 - (jjnewStateCnt = startsAt)))
314 return curPos;
315 try { curChar = input_stream.readChar(); }
316 catch(java.io.IOException e) { return curPos; }
317 }
318 }
319 private final int jjMoveStringLiteralDfa0_3()
320 {
321 return 1;
322 }
323 private final int jjStopStringLiteralDfa_8(int pos, long active0, long active1)
324 {
325 switch (pos)
326 {
327 case 0:
328 if ((active1 & 0x400000000000L) != 0L)
329 {
330 jjmatchedKind = 115;
331 return 2;
332 }
333 return -1;
334 case 1:
335 if ((active1 & 0x400000000000L) != 0L)
336 {
337 jjmatchedKind = 111;
338 jjmatchedPos = 1;
339 return -1;
340 }
341 return -1;
342 default :
343 return -1;
344 }
345 }
346 private final int jjStartNfa_8(int pos, long active0, long active1)
347 {
348 return jjMoveNfa_8(jjStopStringLiteralDfa_8(pos, active0, active1), pos + 1);
349 }
350 private final int jjStartNfaWithStates_8(int pos, int kind, int state)
351 {
352 jjmatchedKind = kind;
353 jjmatchedPos = pos;
354 try { curChar = input_stream.readChar(); }
355 catch(java.io.IOException e) { return pos + 1; }
356 return jjMoveNfa_8(state, pos + 1);
357 }
358 private final int jjMoveStringLiteralDfa0_8()
359 {
360 switch(curChar)
361 {
362 case 34:
363 return jjStopAtPos(0, 105);
364 case 92:
365 return jjMoveStringLiteralDfa1_8(0x400000000000L);
366 default :
367 return jjMoveNfa_8(0, 0);
368 }
369 }
370 private final int jjMoveStringLiteralDfa1_8(long active1)
371 {
372 try { curChar = input_stream.readChar(); }
373 catch(java.io.IOException e) {
374 jjStopStringLiteralDfa_8(0, 0L, active1);
375 return 1;
376 }
377 switch(curChar)
378 {
379 case 13:
380 return jjMoveStringLiteralDfa2_8(active1, 0x400000000000L);
381 default :
382 break;
383 }
384 return jjStartNfa_8(0, 0L, active1);
385 }
386 private final int jjMoveStringLiteralDfa2_8(long old1, long active1)
387 {
388 if (((active1 &= old1)) == 0L)
389 return jjStartNfa_8(0, 0L, old1);
390 try { curChar = input_stream.readChar(); }
391 catch(java.io.IOException e) {
392 jjStopStringLiteralDfa_8(1, 0L, active1);
393 return 2;
394 }
395 switch(curChar)
396 {
397 case 10:
398 if ((active1 & 0x400000000000L) != 0L)
399 return jjStopAtPos(2, 110);
400 break;
401 default :
402 break;
403 }
404 return jjStartNfa_8(1, 0L, active1);
405 }
406 private final int jjMoveNfa_8(int startState, int curPos)
407 {
408 int[] nextStates;
409 int startsAt = 0;
410 jjnewStateCnt = 4;
411 int i = 1;
412 jjstateSet[0] = startState;
413 int j, kind = 0x7fffffff;
414 for (;;)
415 {
416 if (++jjround == 0x7fffffff)
417 ReInitRounds();
418 if (curChar < 64)
419 {
420 long l = 1L << curChar;
421 MatchLoop: do
422 {
423 switch(jjstateSet[--i])
424 {
425 case 0:
426 if ((0xffffffffffffdbffL & l) != 0L && kind > 115)
427 kind = 115;
428 break;
429 case 2:
430 if ((0x2400L & l) != 0L)
431 {
432 if (kind > 111)
433 kind = 111;
434 }
435 else if (curChar == 34)
436 {
437 if (kind > 115)
438 kind = 115;
439 }
440 break;
441 case 3:
442 if (curChar == 34 && kind > 115)
443 kind = 115;
444 break;
445 default : break;
446 }
447 } while(i != startsAt);
448 }
449 else if (curChar < 128)
450 {
451 long l = 1L << (curChar & 077);
452 MatchLoop: do
453 {
454 switch(jjstateSet[--i])
455 {
456 case 0:
457 if (kind > 115)
458 kind = 115;
459 if (curChar == 92)
460 jjAddStates(0, 1);
461 break;
462 case 2:
463 if (curChar == 92 && kind > 115)
464 kind = 115;
465 break;
466 case 1:
467 if (curChar == 92)
468 jjAddStates(0, 1);
469 break;
470 default : break;
471 }
472 } while(i != startsAt);
473 }
474 else
475 {
476 int hiByte = (int)(curChar >> 8);
477 int i1 = hiByte >> 6;
478 long l1 = 1L << (hiByte & 077);
479 int i2 = (curChar & 0xff) >> 6;
480 long l2 = 1L << (curChar & 077);
481 MatchLoop: do
482 {
483 switch(jjstateSet[--i])
484 {
485 case 0:
486 if (jjCanMove_0(hiByte, i1, i2, l1, l2) && kind > 115)
487 kind = 115;
488 break;
489 default : break;
490 }
491 } while(i != startsAt);
492 }
493 if (kind != 0x7fffffff)
494 {
495 jjmatchedKind = kind;
496 jjmatchedPos = curPos;
497 kind = 0x7fffffff;
498 }
499 ++curPos;
500 if ((i = jjnewStateCnt) == (startsAt = 4 - (jjnewStateCnt = startsAt)))
501 return curPos;
502 try { curChar = input_stream.readChar(); }
503 catch(java.io.IOException e) { return curPos; }
504 }
505 }
506 private final int jjMoveStringLiteralDfa0_2()
507 {
508 return jjMoveNfa_2(0, 0);
509 }
510 private final int jjMoveNfa_2(int startState, int curPos)
511 {
512 int[] nextStates;
513 int startsAt = 0;
514 jjnewStateCnt = 1;
515 int i = 1;
516 jjstateSet[0] = startState;
517 int j, kind = 0x7fffffff;
518 for (;;)
519 {
520 if (++jjround == 0x7fffffff)
521 ReInitRounds();
522 if (curChar < 64)
523 {
524 long l = 1L << curChar;
525 MatchLoop: do
526 {
527 switch(jjstateSet[--i])
528 {
529 case 0:
530 if ((0x2400L & l) != 0L)
531 kind = 7;
532 break;
533 default : break;
534 }
535 } while(i != startsAt);
536 }
537 else if (curChar < 128)
538 {
539 long l = 1L << (curChar & 077);
540 MatchLoop: do
541 {
542 switch(jjstateSet[--i])
543 {
544 default : break;
545 }
546 } while(i != startsAt);
547 }
548 else
549 {
550 int hiByte = (int)(curChar >> 8);
551 int i1 = hiByte >> 6;
552 long l1 = 1L << (hiByte & 077);
553 int i2 = (curChar & 0xff) >> 6;
554 long l2 = 1L << (curChar & 077);
555 MatchLoop: do
556 {
557 switch(jjstateSet[--i])
558 {
559 default : break;
560 }
561 } while(i != startsAt);
562 }
563 if (kind != 0x7fffffff)
564 {
565 jjmatchedKind = kind;
566 jjmatchedPos = curPos;
567 kind = 0x7fffffff;
568 }
569 ++curPos;
570 if ((i = jjnewStateCnt) == (startsAt = 1 - (jjnewStateCnt = startsAt)))
571 return curPos;
572 try { curChar = input_stream.readChar(); }
573 catch(java.io.IOException e) { return curPos; }
574 }
575 }
576 private final int jjMoveStringLiteralDfa0_1()
577 {
578 return jjMoveNfa_1(0, 0);
579 }
580 private final int jjMoveNfa_1(int startState, int curPos)
581 {
582 int[] nextStates;
583 int startsAt = 0;
584 jjnewStateCnt = 1;
585 int i = 1;
586 jjstateSet[0] = startState;
587 int j, kind = 0x7fffffff;
588 for (;;)
589 {
590 if (++jjround == 0x7fffffff)
591 ReInitRounds();
592 if (curChar < 64)
593 {
594 long l = 1L << curChar;
595 MatchLoop: do
596 {
597 switch(jjstateSet[--i])
598 {
599 case 0:
600 if ((0x2400L & l) != 0L)
601 kind = 6;
602 break;
603 default : break;
604 }
605 } while(i != startsAt);
606 }
607 else if (curChar < 128)
608 {
609 long l = 1L << (curChar & 077);
610 MatchLoop: do
611 {
612 switch(jjstateSet[--i])
613 {
614 default : break;
615 }
616 } while(i != startsAt);
617 }
618 else
619 {
620 int hiByte = (int)(curChar >> 8);
621 int i1 = hiByte >> 6;
622 long l1 = 1L << (hiByte & 077);
623 int i2 = (curChar & 0xff) >> 6;
624 long l2 = 1L << (curChar & 077);
625 MatchLoop: do
626 {
627 switch(jjstateSet[--i])
628 {
629 default : break;
630 }
631 } while(i != startsAt);
632 }
633 if (kind != 0x7fffffff)
634 {
635 jjmatchedKind = kind;
636 jjmatchedPos = curPos;
637 kind = 0x7fffffff;
638 }
639 ++curPos;
640 if ((i = jjnewStateCnt) == (startsAt = 1 - (jjnewStateCnt = startsAt)))
641 return curPos;
642 try { curChar = input_stream.readChar(); }
643 catch(java.io.IOException e) { return curPos; }
644 }
645 }
646 private final int jjMoveStringLiteralDfa0_11()
647 {
648 return 1;
649 }
650 private final int jjMoveStringLiteralDfa0_6()
651 {
652 switch(curChar)
653 {
654 case 60:
655 return jjMoveStringLiteralDfa1_6(0x8000L);
656 default :
657 return 1;
658 }
659 }
660 private final int jjMoveStringLiteralDfa1_6(long active0)
661 {
662 try { curChar = input_stream.readChar(); }
663 catch(java.io.IOException e) {
664 return 1;
665 }
666 switch(curChar)
667 {
668 case 73:
669 return jjMoveStringLiteralDfa2_6(active0, 0x8000L);
670 default :
671 return 2;
672 }
673 }
674 private final int jjMoveStringLiteralDfa2_6(long old0, long active0)
675 {
676 if (((active0 &= old0)) == 0L)
677 return 2;
678 try { curChar = input_stream.readChar(); }
679 catch(java.io.IOException e) {
680 return 2;
681 }
682 switch(curChar)
683 {
684 case 78:
685 return jjMoveStringLiteralDfa3_6(active0, 0x8000L);
686 default :
687 return 3;
688 }
689 }
690 private final int jjMoveStringLiteralDfa3_6(long old0, long active0)
691 {
692 if (((active0 &= old0)) == 0L)
693 return 3;
694 try { curChar = input_stream.readChar(); }
695 catch(java.io.IOException e) {
696 return 3;
697 }
698 switch(curChar)
699 {
700 case 68:
701 return jjMoveStringLiteralDfa4_6(active0, 0x8000L);
702 default :
703 return 4;
704 }
705 }
706 private final int jjMoveStringLiteralDfa4_6(long old0, long active0)
707 {
708 if (((active0 &= old0)) == 0L)
709 return 4;
710 try { curChar = input_stream.readChar(); }
711 catch(java.io.IOException e) {
712 return 4;
713 }
714 switch(curChar)
715 {
716 case 69:
717 return jjMoveStringLiteralDfa5_6(active0, 0x8000L);
718 default :
719 return 5;
720 }
721 }
722 private final int jjMoveStringLiteralDfa5_6(long old0, long active0)
723 {
724 if (((active0 &= old0)) == 0L)
725 return 5;
726 try { curChar = input_stream.readChar(); }
727 catch(java.io.IOException e) {
728 return 5;
729 }
730 switch(curChar)
731 {
732 case 78:
733 return jjMoveStringLiteralDfa6_6(active0, 0x8000L);
734 default :
735 return 6;
736 }
737 }
738 private final int jjMoveStringLiteralDfa6_6(long old0, long active0)
739 {
740 if (((active0 &= old0)) == 0L)
741 return 6;
742 try { curChar = input_stream.readChar(); }
743 catch(java.io.IOException e) {
744 return 6;
745 }
746 switch(curChar)
747 {
748 case 84:
749 return jjMoveStringLiteralDfa7_6(active0, 0x8000L);
750 default :
751 return 7;
752 }
753 }
754 private final int jjMoveStringLiteralDfa7_6(long old0, long active0)
755 {
756 if (((active0 &= old0)) == 0L)
757 return 7;
758 try { curChar = input_stream.readChar(); }
759 catch(java.io.IOException e) {
760 return 7;
761 }
762 switch(curChar)
763 {
764 case 62:
765 if ((active0 & 0x8000L) != 0L)
766 return jjStopAtPos(7, 15);
767 break;
768 default :
769 return 8;
770 }
771 return 8;
772 }
773 private final int jjStopStringLiteralDfa_9(int pos, long active0, long active1)
774 {
775 switch (pos)
776 {
777 case 0:
778 if ((active1 & 0x40000000000L) != 0L)
779 {
780 jjmatchedKind = 119;
781 return -1;
782 }
783 return -1;
784 case 1:
785 if ((active1 & 0x40000000000L) != 0L)
786 {
787 if (jjmatchedPos == 0)
788 {
789 jjmatchedKind = 119;
790 jjmatchedPos = 0;
791 }
792 return -1;
793 }
794 return -1;
795 default :
796 return -1;
797 }
798 }
799 private final int jjStartNfa_9(int pos, long active0, long active1)
800 {
801 return jjMoveNfa_9(jjStopStringLiteralDfa_9(pos, active0, active1), pos + 1);
802 }
803 private final int jjStartNfaWithStates_9(int pos, int kind, int state)
804 {
805 jjmatchedKind = kind;
806 jjmatchedPos = pos;
807 try { curChar = input_stream.readChar(); }
808 catch(java.io.IOException e) { return pos + 1; }
809 return jjMoveNfa_9(state, pos + 1);
810 }
811 private final int jjMoveStringLiteralDfa0_9()
812 {
813 switch(curChar)
814 {
815 case 10:
816 return jjStopAtPos(0, 117);
817 case 13:
818 jjmatchedKind = 118;
819 return jjMoveStringLiteralDfa1_9(0x10000000000000L);
820 case 39:
821 return jjMoveStringLiteralDfa1_9(0x40000000000L);
822 default :
823 return jjMoveNfa_9(0, 0);
824 }
825 }
826 private final int jjMoveStringLiteralDfa1_9(long active1)
827 {
828 try { curChar = input_stream.readChar(); }
829 catch(java.io.IOException e) {
830 jjStopStringLiteralDfa_9(0, 0L, active1);
831 return 1;
832 }
833 switch(curChar)
834 {
835 case 10:
836 if ((active1 & 0x10000000000000L) != 0L)
837 return jjStopAtPos(1, 116);
838 break;
839 case 39:
840 return jjMoveStringLiteralDfa2_9(active1, 0x40000000000L);
841 default :
842 break;
843 }
844 return jjStartNfa_9(0, 0L, active1);
845 }
846 private final int jjMoveStringLiteralDfa2_9(long old1, long active1)
847 {
848 if (((active1 &= old1)) == 0L)
849 return jjStartNfa_9(0, 0L, old1);
850 try { curChar = input_stream.readChar(); }
851 catch(java.io.IOException e) {
852 jjStopStringLiteralDfa_9(1, 0L, active1);
853 return 2;
854 }
855 switch(curChar)
856 {
857 case 39:
858 if ((active1 & 0x40000000000L) != 0L)
859 return jjStopAtPos(2, 106);
860 break;
861 default :
862 break;
863 }
864 return jjStartNfa_9(1, 0L, active1);
865 }
866 private final int jjMoveNfa_9(int startState, int curPos)
867 {
868 int[] nextStates;
869 int startsAt = 0;
870 jjnewStateCnt = 3;
871 int i = 1;
872 jjstateSet[0] = startState;
873 int j, kind = 0x7fffffff;
874 for (;;)
875 {
876 if (++jjround == 0x7fffffff)
877 ReInitRounds();
878 if (curChar < 64)
879 {
880 long l = 1L << curChar;
881 MatchLoop: do
882 {
883 switch(jjstateSet[--i])
884 {
885 case 0:
886 if ((0xffffffffffffdbffL & l) != 0L && kind > 119)
887 kind = 119;
888 break;
889 case 2:
890 if ((0xffffffffffffdbffL & l) != 0L && kind > 120)
891 kind = 120;
892 break;
893 default : break;
894 }
895 } while(i != startsAt);
896 }
897 else if (curChar < 128)
898 {
899 long l = 1L << (curChar & 077);
900 MatchLoop: do
901 {
902 switch(jjstateSet[--i])
903 {
904 case 0:
905 if (kind > 119)
906 kind = 119;
907 if (curChar == 92)
908 jjstateSet[jjnewStateCnt++] = 2;
909 break;
910 case 1:
911 if (curChar == 92)
912 jjstateSet[jjnewStateCnt++] = 2;
913 break;
914 case 2:
915 if (kind > 120)
916 kind = 120;
917 break;
918 default : break;
919 }
920 } while(i != startsAt);
921 }
922 else
923 {
924 int hiByte = (int)(curChar >> 8);
925 int i1 = hiByte >> 6;
926 long l1 = 1L << (hiByte & 077);
927 int i2 = (curChar & 0xff) >> 6;
928 long l2 = 1L << (curChar & 077);
929 MatchLoop: do
930 {
931 switch(jjstateSet[--i])
932 {
933 case 0:
934 if (jjCanMove_0(hiByte, i1, i2, l1, l2) && kind > 119)
935 kind = 119;
936 break;
937 case 2:
938 if (jjCanMove_0(hiByte, i1, i2, l1, l2) && kind > 120)
939 kind = 120;
940 break;
941 default : break;
942 }
943 } while(i != startsAt);
944 }
945 if (kind != 0x7fffffff)
946 {
947 jjmatchedKind = kind;
948 jjmatchedPos = curPos;
949 kind = 0x7fffffff;
950 }
951 ++curPos;
952 if ((i = jjnewStateCnt) == (startsAt = 3 - (jjnewStateCnt = startsAt)))
953 return curPos;
954 try { curChar = input_stream.readChar(); }
955 catch(java.io.IOException e) { return curPos; }
956 }
957 }
958 private final int jjStopStringLiteralDfa_4(int pos, long active0)
959 {
960 switch (pos)
961 {
962 default :
963 return -1;
964 }
965 }
966 private final int jjStartNfa_4(int pos, long active0)
967 {
968 return jjMoveNfa_4(jjStopStringLiteralDfa_4(pos, active0), pos + 1);
969 }
970 private final int jjStartNfaWithStates_4(int pos, int kind, int state)
971 {
972 jjmatchedKind = kind;
973 jjmatchedPos = pos;
974 try { curChar = input_stream.readChar(); }
975 catch(java.io.IOException e) { return pos + 1; }
976 return jjMoveNfa_4(state, pos + 1);
977 }
978 private final int jjMoveStringLiteralDfa0_4()
979 {
980 switch(curChar)
981 {
982 case 9:
983 return jjStopAtPos(0, 9);
984 case 12:
985 return jjStopAtPos(0, 11);
986 case 32:
987 return jjStopAtPos(0, 10);
988 default :
989 return jjMoveNfa_4(1, 0);
990 }
991 }
992 private final int jjMoveNfa_4(int startState, int curPos)
993 {
994 int[] nextStates;
995 int startsAt = 0;
996 jjnewStateCnt = 8;
997 int i = 1;
998 jjstateSet[0] = startState;
999 int j, kind = 0x7fffffff;
1000 for (;;)
1001 {
1002 if (++jjround == 0x7fffffff)
1003 ReInitRounds();
1004 if (curChar < 64)
1005 {
1006 long l = 1L << curChar;
1007 MatchLoop: do
1008 {
1009 switch(jjstateSet[--i])
1010 {
1011 case 1:
1012 if ((0x2400L & l) != 0L)
1013 {
1014 if (kind > 12)
1015 kind = 12;
1016 }
1017 else if (curChar == 35)
1018 jjCheckNAddStates(2, 4);
1019 if (curChar == 13)
1020 jjstateSet[jjnewStateCnt++] = 0;
1021 break;
1022 case 0:
1023 if (curChar == 10 && kind > 12)
1024 kind = 12;
1025 break;
1026 case 2:
1027 if ((0x2400L & l) != 0L && kind > 12)
1028 kind = 12;
1029 break;
1030 case 3:
1031 if (curChar == 35)
1032 jjCheckNAddStates(2, 4);
1033 break;
1034 case 4:
1035 if ((0xffffffffffffdbffL & l) != 0L)
1036 jjCheckNAddStates(2, 4);
1037 break;
1038 case 5:
1039 if (curChar == 10 && kind > 17)
1040 kind = 17;
1041 break;
1042 case 6:
1043 if (curChar == 13)
1044 jjstateSet[jjnewStateCnt++] = 5;
1045 break;
1046 case 7:
1047 if ((0x2400L & l) != 0L && kind > 17)
1048 kind = 17;
1049 break;
1050 default : break;
1051 }
1052 } while(i != startsAt);
1053 }
1054 else if (curChar < 128)
1055 {
1056 long l = 1L << (curChar & 077);
1057 MatchLoop: do
1058 {
1059 switch(jjstateSet[--i])
1060 {
1061 case 4:
1062 jjAddStates(2, 4);
1063 break;
1064 default : break;
1065 }
1066 } while(i != startsAt);
1067 }
1068 else
1069 {
1070 int hiByte = (int)(curChar >> 8);
1071 int i1 = hiByte >> 6;
1072 long l1 = 1L << (hiByte & 077);
1073 int i2 = (curChar & 0xff) >> 6;
1074 long l2 = 1L << (curChar & 077);
1075 MatchLoop: do
1076 {
1077 switch(jjstateSet[--i])
1078 {
1079 case 4:
1080 if (jjCanMove_0(hiByte, i1, i2, l1, l2))
1081 jjAddStates(2, 4);
1082 break;
1083 default : break;
1084 }
1085 } while(i != startsAt);
1086 }
1087 if (kind != 0x7fffffff)
1088 {
1089 jjmatchedKind = kind;
1090 jjmatchedPos = curPos;
1091 kind = 0x7fffffff;
1092 }
1093 ++curPos;
1094 if ((i = jjnewStateCnt) == (startsAt = 8 - (jjnewStateCnt = startsAt)))
1095 return curPos;
1096 try { curChar = input_stream.readChar(); }
1097 catch(java.io.IOException e) { return curPos; }
1098 }
1099}
1100private final int jjStopStringLiteralDfa_0(int pos, long active0, long active1)
1101{
1102 switch (pos)
1103 {
1104 case 0:
1105 if ((active0 & 0xe000000000000000L) != 0L || (active1 & 0x7bdffffL) != 0L)
1106 {
1107 jjmatchedKind = 91;
1108 return 10;
1109 }
1110 if ((active0 & 0x4000000L) != 0L)
1111 return 70;
1112 if ((active1 & 0x420000L) != 0L)
1113 {
1114 jjmatchedKind = 91;
1115 return 71;
1116 }
1117 return -1;
1118 case 1:
1119 if ((active0 & 0x2000000000000000L) != 0L || (active1 & 0x600000bL) != 0L)
1120 return 10;
1121 if ((active0 & 0xc000000000000000L) != 0L || (active1 & 0x1fffff4L) != 0L)
1122 {
1123 if (jjmatchedPos != 1)
1124 {
1125 jjmatchedKind = 91;
1126 jjmatchedPos = 1;
1127 }
1128 return 10;
1129 }
1130 return -1;
1131 case 2:
1132 if ((active1 & 0x3dffa74L) != 0L)
1133 {
1134 jjmatchedKind = 91;
1135 jjmatchedPos = 2;
1136 return 10;
1137 }
1138 if ((active0 & 0xc000000000000000L) != 0L || (active1 & 0x200580L) != 0L)
1139 return 10;
1140 return -1;
1141 case 3:
1142 if ((active1 & 0x1104030L) != 0L)
1143 return 10;
1144 if ((active1 & 0x2cfba44L) != 0L)
1145 {
1146 jjmatchedKind = 91;
1147 jjmatchedPos = 3;
1148 return 10;
1149 }
1150 return -1;
1151 case 4:
1152 if ((active1 & 0x44a840L) != 0L)
1153 return 10;
1154 if ((active1 & 0x28b1204L) != 0L)
1155 {
1156 jjmatchedKind = 91;
1157 jjmatchedPos = 4;
1158 return 10;
1159 }
1160 return -1;
1161 case 5:
1162 if ((active1 & 0x28a0204L) != 0L)
1163 return 10;
1164 if ((active1 & 0x11000L) != 0L)
1165 {
1166 jjmatchedKind = 91;
1167 jjmatchedPos = 5;
1168 return 10;
1169 }
1170 return -1;
1171 case 6:
1172 if ((active1 & 0x1000L) != 0L)
1173 return 10;
1174 if ((active1 & 0x10000L) != 0L)
1175 {
1176 jjmatchedKind = 91;
1177 jjmatchedPos = 6;
1178 return 10;
1179 }
1180 return -1;
1181 default :
1182 return -1;
1183 }
1184}
1185private final int jjStartNfa_0(int pos, long active0, long active1)
1186{
1187 return jjMoveNfa_0(jjStopStringLiteralDfa_0(pos, active0, active1), pos + 1);
1188}
1189private final int jjStartNfaWithStates_0(int pos, int kind, int state)
1190{
1191 jjmatchedKind = kind;
1192 jjmatchedPos = pos;
1193 try { curChar = input_stream.readChar(); }
1194 catch(java.io.IOException e) { return pos + 1; }
1195 return jjMoveNfa_0(state, pos + 1);
1196}
1197private final int jjMoveStringLiteralDfa0_0()
1198{
1199 switch(curChar)
1200 {
1201 case 33:
1202 return jjMoveStringLiteralDfa1_0(0x1000000000000L, 0x0L);
1203 case 37:
1204 jjmatchedKind = 36;
1205 return jjMoveStringLiteralDfa1_0(0x40000000000000L, 0x0L);
1206 case 38:
1207 jjmatchedKind = 40;
1208 return jjMoveStringLiteralDfa1_0(0x80000000000000L, 0x0L);
1209 case 40:
1210 return jjStopAtPos(0, 18);
1211 case 41:
1212 return jjStopAtPos(0, 19);
1213 case 42:
1214 jjmatchedKind = 30;
1215 return jjMoveStringLiteralDfa1_0(0x1008000200000000L, 0x0L);
1216 case 43:
1217 jjmatchedKind = 28;
1218 return jjMoveStringLiteralDfa1_0(0x2000000000000L, 0x0L);
1219 case 44:
1220 return jjStopAtPos(0, 25);
1221 case 45:
1222 jjmatchedKind = 29;
1223 return jjMoveStringLiteralDfa1_0(0x4000000000000L, 0x0L);
1224 case 46:
1225 return jjStartNfaWithStates_0(0, 26, 70);
1226 case 47:
1227 jjmatchedKind = 31;
1228 return jjMoveStringLiteralDfa1_0(0x30000100000000L, 0x0L);
1229 case 58:
1230 return jjStopAtPos(0, 27);
1231 case 59:
1232 return jjStopAtPos(0, 24);
1233 case 60:
1234 jjmatchedKind = 43;
1235 return jjMoveStringLiteralDfa1_0(0x400a00400000000L, 0x0L);
1236 case 61:
1237 jjmatchedKind = 41;
1238 return jjMoveStringLiteralDfa1_0(0x100000000000L, 0x0L);
1239 case 62:
1240 jjmatchedKind = 42;
1241 return jjMoveStringLiteralDfa1_0(0x800400800000000L, 0x0L);
1242 case 91:
1243 return jjStopAtPos(0, 22);
1244 case 93:
1245 return jjStopAtPos(0, 23);
1246 case 94:
1247 jjmatchedKind = 38;
1248 return jjMoveStringLiteralDfa1_0(0x200000000000000L, 0x0L);
1249 case 96:
1250 return jjStopAtPos(0, 121);
1251 case 97:
1252 return jjMoveStringLiteralDfa1_0(0x4000000000000000L, 0x6000000L);
1253 case 98:
1254 return jjMoveStringLiteralDfa1_0(0x0L, 0x8000L);
1255 case 99:
1256 return jjMoveStringLiteralDfa1_0(0x0L, 0x10800L);
1257 case 100:
1258 return jjMoveStringLiteralDfa1_0(0x0L, 0x200400L);
1259 case 101:
1260 return jjMoveStringLiteralDfa1_0(0x0L, 0x1000230L);
1261 case 102:
1262 return jjMoveStringLiteralDfa1_0(0x0L, 0x101080L);
1263 case 103:
1264 return jjMoveStringLiteralDfa1_0(0x0L, 0x800000L);
1265 case 105:
1266 return jjMoveStringLiteralDfa1_0(0x0L, 0x8000bL);
1267 case 108:
1268 return jjMoveStringLiteralDfa1_0(0x0L, 0x4L);
1269 case 110:
1270 return jjMoveStringLiteralDfa1_0(0x8000000000000000L, 0x0L);
1271 case 111:
1272 return jjMoveStringLiteralDfa1_0(0x2000000000000000L, 0x0L);
1273 case 112:
1274 return jjMoveStringLiteralDfa1_0(0x0L, 0x6000L);
1275 case 114:
1276 return jjMoveStringLiteralDfa1_0(0x0L, 0x420000L);
1277 case 116:
1278 return jjMoveStringLiteralDfa1_0(0x0L, 0x100L);
1279 case 119:
1280 return jjMoveStringLiteralDfa1_0(0x0L, 0x40L);
1281 case 121:
1282 return jjMoveStringLiteralDfa1_0(0x0L, 0x40000L);
1283 case 123:
1284 return jjStopAtPos(0, 20);
1285 case 124:
1286 jjmatchedKind = 39;
1287 return jjMoveStringLiteralDfa1_0(0x100000000000000L, 0x0L);
1288 case 125:
1289 return jjStopAtPos(0, 21);
1290 case 126:
1291 return jjStopAtPos(0, 37);
1292 default :
1293 return jjMoveNfa_0(0, 0);
1294 }
1295}
1296private final int jjMoveStringLiteralDfa1_0(long active0, long active1)
1297{
1298 try { curChar = input_stream.readChar(); }
1299 catch(java.io.IOException e) {
1300 jjStopStringLiteralDfa_0(0, active0, active1);
1301 return 1;
1302 }
1303 switch(curChar)
1304 {
1305 case 42:
1306 if ((active0 & 0x200000000L) != 0L)
1307 {
1308 jjmatchedKind = 33;
1309 jjmatchedPos = 1;
1310 }
1311 return jjMoveStringLiteralDfa2_0(active0, 0x1000000000000000L, active1, 0L);
1312 case 47:
1313 if ((active0 & 0x100000000L) != 0L)
1314 {
1315 jjmatchedKind = 32;
1316 jjmatchedPos = 1;
1317 }
1318 return jjMoveStringLiteralDfa2_0(active0, 0x20000000000000L, active1, 0L);
1319 case 60:
1320 if ((active0 & 0x400000000L) != 0L)
1321 {
1322 jjmatchedKind = 34;
1323 jjmatchedPos = 1;
1324 }
1325 return jjMoveStringLiteralDfa2_0(active0, 0x400000000000000L, active1, 0L);
1326 case 61:
1327 if ((active0 & 0x100000000000L) != 0L)
1328 return jjStopAtPos(1, 44);
1329 else if ((active0 & 0x200000000000L) != 0L)
1330 return jjStopAtPos(1, 45);
1331 else if ((active0 & 0x400000000000L) != 0L)
1332 return jjStopAtPos(1, 46);
1333 else if ((active0 & 0x1000000000000L) != 0L)
1334 return jjStopAtPos(1, 48);
1335 else if ((active0 & 0x2000000000000L) != 0L)
1336 return jjStopAtPos(1, 49);
1337 else if ((active0 & 0x4000000000000L) != 0L)
1338 return jjStopAtPos(1, 50);
1339 else if ((active0 & 0x8000000000000L) != 0L)
1340 return jjStopAtPos(1, 51);
1341 else if ((active0 & 0x10000000000000L) != 0L)
1342 return jjStopAtPos(1, 52);
1343 else if ((active0 & 0x40000000000000L) != 0L)
1344 return jjStopAtPos(1, 54);
1345 else if ((active0 & 0x80000000000000L) != 0L)
1346 return jjStopAtPos(1, 55);
1347 else if ((active0 & 0x100000000000000L) != 0L)
1348 return jjStopAtPos(1, 56);
1349 else if ((active0 & 0x200000000000000L) != 0L)
1350 return jjStopAtPos(1, 57);
1351 break;
1352 case 62:
1353 if ((active0 & 0x800000000L) != 0L)
1354 {
1355 jjmatchedKind = 35;
1356 jjmatchedPos = 1;
1357 }
1358 else if ((active0 & 0x800000000000L) != 0L)
1359 return jjStopAtPos(1, 47);
1360 return jjMoveStringLiteralDfa2_0(active0, 0x800000000000000L, active1, 0L);
1361 case 97:
1362 return jjMoveStringLiteralDfa2_0(active0, 0L, active1, 0x404004L);
1363 case 101:
1364 return jjMoveStringLiteralDfa2_0(active0, 0L, active1, 0x220400L);
1365 case 102:
1366 if ((active1 & 0x8L) != 0L)
1367 return jjStartNfaWithStates_0(1, 67, 10);
1368 break;
1369 case 104:
1370 return jjMoveStringLiteralDfa2_0(active0, 0L, active1, 0x40L);
1371 case 105:
1372 return jjMoveStringLiteralDfa2_0(active0, 0L, active1, 0x41000L);
1373 case 108:
1374 return jjMoveStringLiteralDfa2_0(active0, 0L, active1, 0x800830L);
1375 case 109:
1376 return jjMoveStringLiteralDfa2_0(active0, 0L, active1, 0x80000L);
1377 case 110:
1378 if ((active1 & 0x2L) != 0L)
1379 return jjStartNfaWithStates_0(1, 65, 10);
1380 return jjMoveStringLiteralDfa2_0(active0, 0x4000000000000000L, active1, 0L);
1381 case 111:
1382 return jjMoveStringLiteralDfa2_0(active0, 0x8000000000000000L, active1, 0x10080L);
1383 case 114:
1384 if ((active0 & 0x2000000000000000L) != 0L)
1385 return jjStartNfaWithStates_0(1, 61, 10);
1386 return jjMoveStringLiteralDfa2_0(active0, 0L, active1, 0x10a100L);
1387 case 115:
1388 if ((active1 & 0x1L) != 0L)
1389 return jjStartNfaWithStates_0(1, 64, 10);
1390 else if ((active1 & 0x4000000L) != 0L)
1391 {
1392 jjmatchedKind = 90;
1393 jjmatchedPos = 1;
1394 }
1395 return jjMoveStringLiteralDfa2_0(active0, 0L, active1, 0x2000000L);
1396 case 120:
1397 return jjMoveStringLiteralDfa2_0(active0, 0L, active1, 0x1000200L);
1398 default :
1399 break;
1400 }
1401 return jjStartNfa_0(0, active0, active1);
1402}
1403private final int jjMoveStringLiteralDfa2_0(long old0, long active0, long old1, long active1)
1404{
1405 if (((active0 &= old0) | (active1 &= old1)) == 0L)
1406 return jjStartNfa_0(0, old0, old1);
1407 try { curChar = input_stream.readChar(); }
1408 catch(java.io.IOException e) {
1409 jjStopStringLiteralDfa_0(1, active0, active1);
1410 return 2;
1411 }
1412 switch(curChar)
1413 {
1414 case 61:
1415 if ((active0 & 0x20000000000000L) != 0L)
1416 return jjStopAtPos(2, 53);
1417 else if ((active0 & 0x400000000000000L) != 0L)
1418 return jjStopAtPos(2, 58);
1419 else if ((active0 & 0x800000000000000L) != 0L)
1420 return jjStopAtPos(2, 59);
1421 else if ((active0 & 0x1000000000000000L) != 0L)
1422 return jjStopAtPos(2, 60);
1423 break;
1424 case 97:
1425 return jjMoveStringLiteralDfa3_0(active0, 0L, active1, 0x800L);
1426 case 99:
1427 return jjMoveStringLiteralDfa3_0(active0, 0L, active1, 0x200L);
1428 case 100:
1429 if ((active0 & 0x4000000000000000L) != 0L)
1430 return jjStartNfaWithStates_0(2, 62, 10);
1431 break;
1432 case 101:
1433 return jjMoveStringLiteralDfa3_0(active0, 0L, active1, 0x1048000L);
1434 case 102:
1435 if ((active1 & 0x400L) != 0L)
1436 return jjStartNfaWithStates_0(2, 74, 10);
1437 break;
1438 case 105:
1439 return jjMoveStringLiteralDfa3_0(active0, 0L, active1, 0x402060L);
1440 case 108:
1441 if ((active1 & 0x200000L) != 0L)
1442 return jjStartNfaWithStates_0(2, 85, 10);
1443 break;
1444 case 109:
1445 return jjMoveStringLiteralDfa3_0(active0, 0L, active1, 0x4L);
1446 case 110:
1447 return jjMoveStringLiteralDfa3_0(active0, 0L, active1, 0x11000L);
1448 case 111:
1449 return jjMoveStringLiteralDfa3_0(active0, 0L, active1, 0x900000L);
1450 case 112:
1451 return jjMoveStringLiteralDfa3_0(active0, 0L, active1, 0x80000L);
1452 case 114:
1453 if ((active1 & 0x80L) != 0L)
1454 return jjStartNfaWithStates_0(2, 71, 10);
1455 break;
1456 case 115:
1457 return jjMoveStringLiteralDfa3_0(active0, 0L, active1, 0x2004010L);
1458 case 116:
1459 if ((active0 & 0x8000000000000000L) != 0L)
1460 return jjStartNfaWithStates_0(2, 63, 10);
1461 return jjMoveStringLiteralDfa3_0(active0, 0L, active1, 0x20000L);
1462 case 121:
1463 if ((active1 & 0x100L) != 0L)
1464 return jjStartNfaWithStates_0(2, 72, 10);
1465 break;
1466 default :
1467 break;
1468 }
1469 return jjStartNfa_0(1, active0, active1);
1470}
1471private final int jjMoveStringLiteralDfa3_0(long old0, long active0, long old1, long active1)
1472{
1473 if (((active0 &= old0) | (active1 &= old1)) == 0L)
1474 return jjStartNfa_0(1, old0, old1);
1475 try { curChar = input_stream.readChar(); }
1476 catch(java.io.IOException e) {
1477 jjStopStringLiteralDfa_0(2, 0L, active1);
1478 return 3;
1479 }
1480 switch(curChar)
1481 {
1482 case 97:
1483 return jjMoveStringLiteralDfa4_0(active1, 0x9000L);
1484 case 98:
1485 return jjMoveStringLiteralDfa4_0(active1, 0x800004L);
1486 case 99:
1487 if ((active1 & 0x1000000L) != 0L)
1488 return jjStartNfaWithStates_0(3, 88, 10);
1489 break;
1490 case 101:
1491 if ((active1 & 0x10L) != 0L)
1492 return jjStartNfaWithStates_0(3, 68, 10);
1493 return jjMoveStringLiteralDfa4_0(active1, 0x2000200L);
1494 case 102:
1495 if ((active1 & 0x20L) != 0L)
1496 return jjStartNfaWithStates_0(3, 69, 10);
1497 break;
1498 case 108:
1499 return jjMoveStringLiteralDfa4_0(active1, 0x40040L);
1500 case 109:
1501 if ((active1 & 0x100000L) != 0L)
1502 return jjStartNfaWithStates_0(3, 84, 10);
1503 break;
1504 case 110:
1505 return jjMoveStringLiteralDfa4_0(active1, 0x2000L);
1506 case 111:
1507 return jjMoveStringLiteralDfa4_0(active1, 0x80000L);
1508 case 115:
1509 if ((active1 & 0x4000L) != 0L)
1510 return jjStartNfaWithStates_0(3, 78, 10);
1511 return jjMoveStringLiteralDfa4_0(active1, 0x400800L);
1512 case 116:
1513 return jjMoveStringLiteralDfa4_0(active1, 0x10000L);
1514 case 117:
1515 return jjMoveStringLiteralDfa4_0(active1, 0x20000L);
1516 default :
1517 break;
1518 }
1519 return jjStartNfa_0(2, 0L, active1);
1520}
1521private final int jjMoveStringLiteralDfa4_0(long old1, long active1)
1522{
1523 if (((active1 &= old1)) == 0L)
1524 return jjStartNfa_0(2, 0L, old1);
1525 try { curChar = input_stream.readChar(); }
1526 catch(java.io.IOException e) {
1527 jjStopStringLiteralDfa_0(3, 0L, active1);
1528 return 4;
1529 }
1530 switch(curChar)
1531 {
1532 case 97:
1533 return jjMoveStringLiteralDfa5_0(active1, 0x800000L);
1534 case 100:
1535 if ((active1 & 0x40000L) != 0L)
1536 return jjStartNfaWithStates_0(4, 82, 10);
1537 return jjMoveStringLiteralDfa5_0(active1, 0x4L);
1538 case 101:
1539 if ((active1 & 0x40L) != 0L)
1540 return jjStartNfaWithStates_0(4, 70, 10);
1541 else if ((active1 & 0x400000L) != 0L)
1542 return jjStartNfaWithStates_0(4, 86, 10);
1543 break;
1544 case 105:
1545 return jjMoveStringLiteralDfa5_0(active1, 0x10000L);
1546 case 107:
1547 if ((active1 & 0x8000L) != 0L)
1548 return jjStartNfaWithStates_0(4, 79, 10);
1549 break;
1550 case 108:
1551 return jjMoveStringLiteralDfa5_0(active1, 0x1000L);
1552 case 112:
1553 return jjMoveStringLiteralDfa5_0(active1, 0x200L);
1554 case 114:
1555 return jjMoveStringLiteralDfa5_0(active1, 0x20a0000L);
1556 case 115:
1557 if ((active1 & 0x800L) != 0L)
1558 return jjStartNfaWithStates_0(4, 75, 10);
1559 break;
1560 case 116:
1561 if ((active1 & 0x2000L) != 0L)
1562 return jjStartNfaWithStates_0(4, 77, 10);
1563 break;
1564 default :
1565 break;
1566 }
1567 return jjStartNfa_0(3, 0L, active1);
1568}
1569private final int jjMoveStringLiteralDfa5_0(long old1, long active1)
1570{
1571 if (((active1 &= old1)) == 0L)
1572 return jjStartNfa_0(3, 0L, old1);
1573 try { curChar = input_stream.readChar(); }
1574 catch(java.io.IOException e) {
1575 jjStopStringLiteralDfa_0(4, 0L, active1);
1576 return 5;
1577 }
1578 switch(curChar)
1579 {
1580 case 97:
1581 if ((active1 & 0x4L) != 0L)
1582 return jjStartNfaWithStates_0(5, 66, 10);
1583 break;
1584 case 108:
1585 if ((active1 & 0x800000L) != 0L)
1586 return jjStartNfaWithStates_0(5, 87, 10);
1587 return jjMoveStringLiteralDfa6_0(active1, 0x1000L);
1588 case 110:
1589 if ((active1 & 0x20000L) != 0L)
1590 return jjStartNfaWithStates_0(5, 81, 10);
1591 return jjMoveStringLiteralDfa6_0(active1, 0x10000L);
1592 case 116:
1593 if ((active1 & 0x200L) != 0L)
1594 return jjStartNfaWithStates_0(5, 73, 10);
1595 else if ((active1 & 0x80000L) != 0L)
1596 return jjStartNfaWithStates_0(5, 83, 10);
1597 else if ((active1 & 0x2000000L) != 0L)
1598 return jjStartNfaWithStates_0(5, 89, 10);
1599 break;
1600 default :
1601 break;
1602 }
1603 return jjStartNfa_0(4, 0L, active1);
1604}
1605private final int jjMoveStringLiteralDfa6_0(long old1, long active1)
1606{
1607 if (((active1 &= old1)) == 0L)
1608 return jjStartNfa_0(4, 0L, old1);
1609 try { curChar = input_stream.readChar(); }
1610 catch(java.io.IOException e) {
1611 jjStopStringLiteralDfa_0(5, 0L, active1);
1612 return 6;
1613 }
1614 switch(curChar)
1615 {
1616 case 117:
1617 return jjMoveStringLiteralDfa7_0(active1, 0x10000L);
1618 case 121:
1619 if ((active1 & 0x1000L) != 0L)
1620 return jjStartNfaWithStates_0(6, 76, 10);
1621 break;
1622 default :
1623 break;
1624 }
1625 return jjStartNfa_0(5, 0L, active1);
1626}
1627private final int jjMoveStringLiteralDfa7_0(long old1, long active1)
1628{
1629 if (((active1 &= old1)) == 0L)
1630 return jjStartNfa_0(5, 0L, old1);
1631 try { curChar = input_stream.readChar(); }
1632 catch(java.io.IOException e) {
1633 jjStopStringLiteralDfa_0(6, 0L, active1);
1634 return 7;
1635 }
1636 switch(curChar)
1637 {
1638 case 101:
1639 if ((active1 & 0x10000L) != 0L)
1640 return jjStartNfaWithStates_0(7, 80, 10);
1641 break;
1642 default :
1643 break;
1644 }
1645 return jjStartNfa_0(6, 0L, active1);
1646}
1647private final int jjMoveNfa_0(int startState, int curPos)
1648{
1649 int[] nextStates;
1650 int startsAt = 0;
1651 jjnewStateCnt = 70;
1652 int i = 1;
1653 jjstateSet[0] = startState;
1654 int j, kind = 0x7fffffff;
1655 for (;;)
1656 {
1657 if (++jjround == 0x7fffffff)
1658 ReInitRounds();
1659 if (curChar < 64)
1660 {
1661 long l = 1L << curChar;
1662 MatchLoop: do
1663 {
1664 switch(jjstateSet[--i])
1665 {
1666 case 70:
1667 if ((0x3ff000000000000L & l) != 0L)
1668 jjCheckNAddStates(5, 7);
1669 if ((0x3ff000000000000L & l) != 0L)
1670 {
1671 if (kind > 96)
1672 kind = 96;
1673 jjCheckNAddTwoStates(35, 36);
1674 }
1675 break;
1676 case 71:
1677 if ((0x3ff000000000000L & l) != 0L)
1678 {
1679 if (kind > 91)
1680 kind = 91;
1681 jjCheckNAdd(10);
1682 }
1683 else if (curChar == 34)
1684 jjstateSet[jjnewStateCnt++] = 17;
1685 else if (curChar == 39)
1686 jjstateSet[jjnewStateCnt++] = 14;
1687 if (curChar == 34)
1688 {
1689 if (kind > 101)
1690 kind = 101;
1691 }
1692 else if (curChar == 39)
1693 {
1694 if (kind > 100)
1695 kind = 100;
1696 }
1697 break;
1698 case 0:
1699 if ((0x3ff000000000000L & l) != 0L)
1700 jjCheckNAddStates(8, 15);
1701 else if ((0x2400L & l) != 0L)
1702 {
1703 if (kind > 5)
1704 kind = 5;
1705 }
1706 else if (curChar == 46)
1707 jjCheckNAddTwoStates(35, 39);
1708 else if (curChar == 34)
1709 jjstateSet[jjnewStateCnt++] = 17;
1710 else if (curChar == 39)
1711 jjstateSet[jjnewStateCnt++] = 14;
1712 else if (curChar == 35)
1713 {
1714 if (kind > 16)
1715 kind = 16;
1716 jjCheckNAdd(8);
1717 }
1718 if ((0x3fe000000000000L & l) != 0L)
1719 {
1720 if (kind > 93)
1721 kind = 93;
1722 jjCheckNAddStates(16, 20);
1723 }
1724 else if (curChar == 48)
1725 {
1726 if (kind > 93)
1727 kind = 93;
1728 jjCheckNAddStates(21, 26);
1729 }
1730 else if (curChar == 34)
1731 {
1732 if (kind > 101)
1733 kind = 101;
1734 }
1735 else if (curChar == 39)
1736 {
1737 if (kind > 100)
1738 kind = 100;
1739 }
1740 else if (curChar == 13)
1741 jjstateSet[jjnewStateCnt++] = 4;
1742 break;
1743 case 1:
1744 if (curChar == 10 && kind > 4)
1745 kind = 4;
1746 break;
1747 case 2:
1748 if (curChar == 13)
1749 jjstateSet[jjnewStateCnt++] = 1;
1750 break;
1751 case 3:
1752 if ((0x2400L & l) != 0L && kind > 4)
1753 kind = 4;
1754 break;
1755 case 4:
1756 if (curChar == 10 && kind > 5)
1757 kind = 5;
1758 break;
1759 case 5:
1760 if (curChar == 13)
1761 jjstateSet[jjnewStateCnt++] = 4;
1762 break;
1763 case 6:
1764 if ((0x2400L & l) != 0L && kind > 5)
1765 kind = 5;
1766 break;
1767 case 7:
1768 if (curChar != 35)
1769 break;
1770 if (kind > 16)
1771 kind = 16;
1772 jjCheckNAdd(8);
1773 break;
1774 case 8:
1775 if ((0xffffffffffffdbffL & l) == 0L)
1776 break;
1777 if (kind > 16)
1778 kind = 16;
1779 jjCheckNAdd(8);
1780 break;
1781 case 10:
1782 if ((0x3ff000000000000L & l) == 0L)
1783 break;
1784 if (kind > 91)
1785 kind = 91;
1786 jjCheckNAdd(10);
1787 break;
1788 case 11:
1789 if (curChar == 39 && kind > 100)
1790 kind = 100;
1791 break;
1792 case 12:
1793 if (curChar == 34 && kind > 101)
1794 kind = 101;
1795 break;
1796 case 13:
1797 if (curChar == 39 && kind > 102)
1798 kind = 102;
1799 break;
1800 case 14:
1801 if (curChar == 39)
1802 jjstateSet[jjnewStateCnt++] = 13;
1803 break;
1804 case 15:
1805 if (curChar == 39)
1806 jjstateSet[jjnewStateCnt++] = 14;
1807 break;
1808 case 16:
1809 if (curChar == 34 && kind > 103)
1810 kind = 103;
1811 break;
1812 case 17:
1813 if (curChar == 34)
1814 jjstateSet[jjnewStateCnt++] = 16;
1815 break;
1816 case 18:
1817 if (curChar == 34)
1818 jjstateSet[jjnewStateCnt++] = 17;
1819 break;
1820 case 19:
1821 if ((0x3fe000000000000L & l) == 0L)
1822 break;
1823 if (kind > 93)
1824 kind = 93;
1825 jjCheckNAddStates(16, 20);
1826 break;
1827 case 20:
1828 if ((0x3ff000000000000L & l) == 0L)
1829 break;
1830 if (kind > 93)
1831 kind = 93;
1832 jjCheckNAddTwoStates(20, 21);
1833 break;
1834 case 22:
1835 if ((0x3ff000000000000L & l) != 0L)
1836 jjCheckNAddStates(27, 29);
1837 break;
1838 case 25:
1839 if (curChar != 48)
1840 break;
1841 if (kind > 93)
1842 kind = 93;
1843 jjCheckNAddStates(21, 26);
1844 break;
1845 case 27:
1846 if ((0x3ff000000000000L & l) == 0L)
1847 break;
1848 if (kind > 94)
1849 kind = 94;
1850 jjAddStates(30, 31);
1851 break;
1852 case 29:
1853 if ((0xff000000000000L & l) == 0L)
1854 break;
1855 if (kind > 95)
1856 kind = 95;
1857 jjCheckNAddTwoStates(29, 30);
1858 break;
1859 case 31:
1860 if ((0x3fe000000000000L & l) != 0L)
1861 jjCheckNAddStates(32, 34);
1862 break;
1863 case 32:
1864 if ((0x3ff000000000000L & l) != 0L)
1865 jjCheckNAddStates(32, 34);
1866 break;
1867 case 33:
1868 if (curChar == 48)
1869 jjCheckNAdd(24);
1870 break;
1871 case 34:
1872 if (curChar == 46)
1873 jjCheckNAddTwoStates(35, 39);
1874 break;
1875 case 35:
1876 if ((0x3ff000000000000L & l) == 0L)
1877 break;
1878 if (kind > 96)
1879 kind = 96;
1880 jjCheckNAddTwoStates(35, 36);
1881 break;
1882 case 37:
1883 if ((0x280000000000L & l) != 0L)
1884 jjCheckNAdd(38);
1885 break;
1886 case 38:
1887 if ((0x3ff000000000000L & l) == 0L)
1888 break;
1889 if (kind > 96)
1890 kind = 96;
1891 jjCheckNAdd(38);
1892 break;
1893 case 39:
1894 if ((0x3ff000000000000L & l) != 0L)
1895 jjCheckNAddStates(5, 7);
1896 break;
1897 case 41:
1898 if ((0x280000000000L & l) != 0L)
1899 jjCheckNAdd(42);
1900 break;
1901 case 42:
1902 if ((0x3ff000000000000L & l) != 0L)
1903 jjCheckNAddTwoStates(42, 24);
1904 break;
1905 case 49:
1906 if ((0x3ff000000000000L & l) != 0L)
1907 jjCheckNAddStates(8, 15);
1908 break;
1909 case 50:
1910 if ((0x3ff000000000000L & l) != 0L)
1911 jjCheckNAddTwoStates(50, 51);
1912 break;
1913 case 51:
1914 if (curChar != 46)
1915 break;
1916 if (kind > 96)
1917 kind = 96;
1918 jjCheckNAddTwoStates(52, 53);
1919 break;
1920 case 52:
1921 if ((0x3ff000000000000L & l) == 0L)
1922 break;
1923 if (kind > 96)
1924 kind = 96;
1925 jjCheckNAddTwoStates(52, 53);
1926 break;
1927 case 54:
1928 if ((0x280000000000L & l) != 0L)
1929 jjCheckNAdd(55);
1930 break;
1931 case 55:
1932 if ((0x3ff000000000000L & l) == 0L)
1933 break;
1934 if (kind > 96)
1935 kind = 96;
1936 jjCheckNAdd(55);
1937 break;
1938 case 56:
1939 if ((0x3ff000000000000L & l) != 0L)
1940 jjCheckNAddTwoStates(56, 57);
1941 break;
1942 case 58:
1943 if ((0x280000000000L & l) != 0L)
1944 jjCheckNAdd(59);
1945 break;
1946 case 59:
1947 if ((0x3ff000000000000L & l) == 0L)
1948 break;
1949 if (kind > 96)
1950 kind = 96;
1951 jjCheckNAdd(59);
1952 break;
1953 case 60:
1954 if ((0x3ff000000000000L & l) != 0L)
1955 jjCheckNAddTwoStates(60, 61);
1956 break;
1957 case 62:
1958 if ((0x280000000000L & l) != 0L)
1959 jjCheckNAdd(63);
1960 break;
1961 case 63:
1962 if ((0x3ff000000000000L & l) != 0L)
1963 jjCheckNAddTwoStates(63, 24);
1964 break;
1965 case 64:
1966 if ((0x3ff000000000000L & l) != 0L)
1967 jjCheckNAddTwoStates(64, 65);
1968 break;
1969 case 65:
1970 if (curChar == 46)
1971 jjCheckNAddStates(35, 37);
1972 break;
1973 case 66:
1974 if ((0x3ff000000000000L & l) != 0L)
1975 jjCheckNAddStates(35, 37);
1976 break;
1977 case 68:
1978 if ((0x280000000000L & l) != 0L)
1979 jjCheckNAdd(69);
1980 break;
1981 case 69:
1982 if ((0x3ff000000000000L & l) != 0L)
1983 jjCheckNAddTwoStates(69, 24);
1984 break;
1985 default : break;
1986 }
1987 } while(i != startsAt);
1988 }
1989 else if (curChar < 128)
1990 {
1991 long l = 1L << (curChar & 077);
1992 MatchLoop: do
1993 {
1994 switch(jjstateSet[--i])
1995 {
1996 case 71:
1997 case 10:
1998 if ((0x7fffffe87fffffeL & l) == 0L)
1999 break;
2000 if (kind > 91)
2001 kind = 91;
2002 jjCheckNAdd(10);
2003 break;
2004 case 0:
2005 if ((0x7fffffe87fffffeL & l) != 0L)
2006 {
2007 if (kind > 91)
2008 kind = 91;
2009 jjCheckNAdd(10);
2010 }
2011 else if (curChar == 92)
2012 jjAddStates(0, 1);
2013 if ((0x4000000040000L & l) != 0L)
2014 jjCheckNAddStates(38, 41);
2015 else if ((0x20000000200000L & l) != 0L)
2016 jjCheckNAddStates(42, 49);
2017 break;
2018 case 8:
2019 if (kind > 16)
2020 kind = 16;
2021 jjstateSet[jjnewStateCnt++] = 8;
2022 break;
2023 case 9:
2024 if ((0x7fffffe87fffffeL & l) == 0L)
2025 break;
2026 if (kind > 91)
2027 kind = 91;
2028 jjCheckNAdd(10);
2029 break;
2030 case 21:
2031 if ((0x100000001000L & l) != 0L && kind > 93)
2032 kind = 93;
2033 break;
2034 case 23:
2035 if ((0x100000001000L & l) != 0L)
2036 jjstateSet[jjnewStateCnt++] = 24;
2037 break;
2038 case 24:
2039 if ((0x40000000400L & l) != 0L && kind > 97)
2040 kind = 97;
2041 break;
2042 case 26:
2043 if ((0x100000001000000L & l) != 0L)
2044 jjCheckNAdd(27);
2045 break;
2046 case 27:
2047 if ((0x7e0000007eL & l) == 0L)
2048 break;
2049 if (kind > 94)
2050 kind = 94;
2051 jjCheckNAddTwoStates(27, 28);
2052 break;
2053 case 28:
2054 if ((0x100000001000L & l) != 0L && kind > 94)
2055 kind = 94;
2056 break;
2057 case 30:
2058 if ((0x100000001000L & l) != 0L && kind > 95)
2059 kind = 95;
2060 break;
2061 case 36:
2062 if ((0x2000000020L & l) != 0L)
2063 jjAddStates(50, 51);
2064 break;
2065 case 40:
2066 if ((0x2000000020L & l) != 0L)
2067 jjAddStates(52, 53);
2068 break;
2069 case 43:
2070 if ((0x20000000200000L & l) != 0L)
2071 jjCheckNAddStates(42, 49);
2072 break;
2073 case 44:
2074 if ((0x4000000040000L & l) != 0L)
2075 jjCheckNAdd(11);
2076 break;
2077 case 45:
2078 if ((0x4000000040000L & l) != 0L)
2079 jjCheckNAdd(12);
2080 break;
2081 case 46:
2082 if ((0x4000000040000L & l) != 0L)
2083 jjCheckNAdd(15);
2084 break;
2085 case 47:
2086 if ((0x4000000040000L & l) != 0L)
2087 jjCheckNAdd(18);
2088 break;
2089 case 48:
2090 if ((0x4000000040000L & l) != 0L)
2091 jjCheckNAddStates(38, 41);
2092 break;
2093 case 53:
2094 if ((0x2000000020L & l) != 0L)
2095 jjAddStates(54, 55);
2096 break;
2097 case 57:
2098 if ((0x2000000020L & l) != 0L)
2099 jjAddStates(56, 57);
2100 break;
2101 case 61:
2102 if ((0x2000000020L & l) != 0L)
2103 jjAddStates(58, 59);
2104 break;
2105 case 67:
2106 if ((0x2000000020L & l) != 0L)
2107 jjAddStates(60, 61);
2108 break;
2109 default : break;
2110 }
2111 } while(i != startsAt);
2112 }
2113 else
2114 {
2115 int hiByte = (int)(curChar >> 8);
2116 int i1 = hiByte >> 6;
2117 long l1 = 1L << (hiByte & 077);
2118 int i2 = (curChar & 0xff) >> 6;
2119 long l2 = 1L << (curChar & 077);
2120 MatchLoop: do
2121 {
2122 switch(jjstateSet[--i])
2123 {
2124 case 8:
2125 if (!jjCanMove_0(hiByte, i1, i2, l1, l2))
2126 break;
2127 if (kind > 16)
2128 kind = 16;
2129 jjstateSet[jjnewStateCnt++] = 8;
2130 break;
2131 default : break;
2132 }
2133 } while(i != startsAt);
2134 }
2135 if (kind != 0x7fffffff)
2136 {
2137 jjmatchedKind = kind;
2138 jjmatchedPos = curPos;
2139 kind = 0x7fffffff;
2140 }
2141 ++curPos;
2142 if ((i = jjnewStateCnt) == (startsAt = 70 - (jjnewStateCnt = startsAt)))
2143 return curPos;
2144 try { curChar = input_stream.readChar(); }
2145 catch(java.io.IOException e) { return curPos; }
2146 }
2147}
2148private final int jjStopStringLiteralDfa_7(int pos, long active0, long active1)
2149{
2150 switch (pos)
2151 {
2152 case 0:
2153 if ((active1 & 0x100000000000L) != 0L)
2154 {
2155 jjmatchedKind = 114;
2156 return 2;
2157 }
2158 return -1;
2159 case 1:
2160 if ((active1 & 0x100000000000L) != 0L)
2161 {
2162 jjmatchedKind = 109;
2163 jjmatchedPos = 1;
2164 return -1;
2165 }
2166 return -1;
2167 default :
2168 return -1;
2169 }
2170}
2171private final int jjStartNfa_7(int pos, long active0, long active1)
2172{
2173 return jjMoveNfa_7(jjStopStringLiteralDfa_7(pos, active0, active1), pos + 1);
2174}
2175private final int jjStartNfaWithStates_7(int pos, int kind, int state)
2176{
2177 jjmatchedKind = kind;
2178 jjmatchedPos = pos;
2179 try { curChar = input_stream.readChar(); }
2180 catch(java.io.IOException e) { return pos + 1; }
2181 return jjMoveNfa_7(state, pos + 1);
2182}
2183private final int jjMoveStringLiteralDfa0_7()
2184{
2185 switch(curChar)
2186 {
2187 case 39:
2188 return jjStopAtPos(0, 104);
2189 case 92:
2190 return jjMoveStringLiteralDfa1_7(0x100000000000L);
2191 default :
2192 return jjMoveNfa_7(0, 0);
2193 }
2194}
2195private final int jjMoveStringLiteralDfa1_7(long active1)
2196{
2197 try { curChar = input_stream.readChar(); }
2198 catch(java.io.IOException e) {
2199 jjStopStringLiteralDfa_7(0, 0L, active1);
2200 return 1;
2201 }
2202 switch(curChar)
2203 {
2204 case 13:
2205 return jjMoveStringLiteralDfa2_7(active1, 0x100000000000L);
2206 default :
2207 break;
2208 }
2209 return jjStartNfa_7(0, 0L, active1);
2210}
2211private final int jjMoveStringLiteralDfa2_7(long old1, long active1)
2212{
2213 if (((active1 &= old1)) == 0L)
2214 return jjStartNfa_7(0, 0L, old1);
2215 try { curChar = input_stream.readChar(); }
2216 catch(java.io.IOException e) {
2217 jjStopStringLiteralDfa_7(1, 0L, active1);
2218 return 2;
2219 }
2220 switch(curChar)
2221 {
2222 case 10:
2223 if ((active1 & 0x100000000000L) != 0L)
2224 return jjStopAtPos(2, 108);
2225 break;
2226 default :
2227 break;
2228 }
2229 return jjStartNfa_7(1, 0L, active1);
2230}
2231private final int jjMoveNfa_7(int startState, int curPos)
2232{
2233 int[] nextStates;
2234 int startsAt = 0;
2235 jjnewStateCnt = 4;
2236 int i = 1;
2237 jjstateSet[0] = startState;
2238 int j, kind = 0x7fffffff;
2239 for (;;)
2240 {
2241 if (++jjround == 0x7fffffff)
2242 ReInitRounds();
2243 if (curChar < 64)
2244 {
2245 long l = 1L << curChar;
2246 MatchLoop: do
2247 {
2248 switch(jjstateSet[--i])
2249 {
2250 case 0:
2251 if ((0xffffffffffffdbffL & l) != 0L && kind > 114)
2252 kind = 114;
2253 break;
2254 case 2:
2255 if ((0x2400L & l) != 0L)
2256 {
2257 if (kind > 109)
2258 kind = 109;
2259 }
2260 else if (curChar == 39)
2261 {
2262 if (kind > 114)
2263 kind = 114;
2264 }
2265 break;
2266 case 3:
2267 if (curChar == 39 && kind > 114)
2268 kind = 114;
2269 break;
2270 default : break;
2271 }
2272 } while(i != startsAt);
2273 }
2274 else if (curChar < 128)
2275 {
2276 long l = 1L << (curChar & 077);
2277 MatchLoop: do
2278 {
2279 switch(jjstateSet[--i])
2280 {
2281 case 0:
2282 if (kind > 114)
2283 kind = 114;
2284 if (curChar == 92)
2285 jjAddStates(0, 1);
2286 break;
2287 case 2:
2288 if (curChar == 92 && kind > 114)
2289 kind = 114;
2290 break;
2291 case 1:
2292 if (curChar == 92)
2293 jjAddStates(0, 1);
2294 break;
2295 default : break;
2296 }
2297 } while(i != startsAt);
2298 }
2299 else
2300 {
2301 int hiByte = (int)(curChar >> 8);
2302 int i1 = hiByte >> 6;
2303 long l1 = 1L << (hiByte & 077);
2304 int i2 = (curChar & 0xff) >> 6;
2305 long l2 = 1L << (curChar & 077);
2306 MatchLoop: do
2307 {
2308 switch(jjstateSet[--i])
2309 {
2310 case 0:
2311 if (jjCanMove_0(hiByte, i1, i2, l1, l2) && kind > 114)
2312 kind = 114;
2313 break;
2314 default : break;
2315 }
2316 } while(i != startsAt);
2317 }
2318 if (kind != 0x7fffffff)
2319 {
2320 jjmatchedKind = kind;
2321 jjmatchedPos = curPos;
2322 kind = 0x7fffffff;
2323 }
2324 ++curPos;
2325 if ((i = jjnewStateCnt) == (startsAt = 4 - (jjnewStateCnt = startsAt)))
2326 return curPos;
2327 try { curChar = input_stream.readChar(); }
2328 catch(java.io.IOException e) { return curPos; }
2329 }
2330}
2331private final int jjStopStringLiteralDfa_5(int pos, long active0)
2332{
2333 switch (pos)
2334 {
2335 default :
2336 return -1;
2337 }
2338}
2339private final int jjStartNfa_5(int pos, long active0)
2340{
2341 return jjMoveNfa_5(jjStopStringLiteralDfa_5(pos, active0), pos + 1);
2342}
2343private final int jjStartNfaWithStates_5(int pos, int kind, int state)
2344{
2345 jjmatchedKind = kind;
2346 jjmatchedPos = pos;
2347 try { curChar = input_stream.readChar(); }
2348 catch(java.io.IOException e) { return pos + 1; }
2349 return jjMoveNfa_5(state, pos + 1);
2350}
2351private final int jjMoveStringLiteralDfa0_5()
2352{
2353 switch(curChar)
2354 {
2355 case 9:
2356 return jjStopAtPos(0, 9);
2357 case 12:
2358 return jjStopAtPos(0, 11);
2359 case 32:
2360 return jjStopAtPos(0, 10);
2361 default :
2362 return jjMoveNfa_5(1, 0);
2363 }
2364}
2365private final int jjMoveNfa_5(int startState, int curPos)
2366{
2367 int[] nextStates;
2368 int startsAt = 0;
2369 jjnewStateCnt = 8;
2370 int i = 1;
2371 jjstateSet[0] = startState;
2372 int j, kind = 0x7fffffff;
2373 for (;;)
2374 {
2375 if (++jjround == 0x7fffffff)
2376 ReInitRounds();
2377 if (curChar < 64)
2378 {
2379 long l = 1L << curChar;
2380 MatchLoop: do
2381 {
2382 switch(jjstateSet[--i])
2383 {
2384 case 1:
2385 if ((0x2400L & l) != 0L)
2386 {
2387 if (kind > 12)
2388 kind = 12;
2389 }
2390 else if (curChar == 35)
2391 jjCheckNAddStates(2, 4);
2392 if (curChar == 13)
2393 jjstateSet[jjnewStateCnt++] = 0;
2394 break;
2395 case 0:
2396 if (curChar == 10 && kind > 12)
2397 kind = 12;
2398 break;
2399 case 2:
2400 if ((0x2400L & l) != 0L && kind > 12)
2401 kind = 12;
2402 break;
2403 case 3:
2404 if (curChar == 35)
2405 jjCheckNAddStates(2, 4);
2406 break;
2407 case 4:
2408 if ((0xffffffffffffdbffL & l) != 0L)
2409 jjCheckNAddStates(2, 4);
2410 break;
2411 case 5:
2412 if (curChar == 10 && kind > 17)
2413 kind = 17;
2414 break;
2415 case 6:
2416 if (curChar == 13)
2417 jjstateSet[jjnewStateCnt++] = 5;
2418 break;
2419 case 7:
2420 if ((0x2400L & l) != 0L && kind > 17)
2421 kind = 17;
2422 break;
2423 default : break;
2424 }
2425 } while(i != startsAt);
2426 }
2427 else if (curChar < 128)
2428 {
2429 long l = 1L << (curChar & 077);
2430 MatchLoop: do
2431 {
2432 switch(jjstateSet[--i])
2433 {
2434 case 4:
2435 jjAddStates(2, 4);
2436 break;
2437 default : break;
2438 }
2439 } while(i != startsAt);
2440 }
2441 else
2442 {
2443 int hiByte = (int)(curChar >> 8);
2444 int i1 = hiByte >> 6;
2445 long l1 = 1L << (hiByte & 077);
2446 int i2 = (curChar & 0xff) >> 6;
2447 long l2 = 1L << (curChar & 077);
2448 MatchLoop: do
2449 {
2450 switch(jjstateSet[--i])
2451 {
2452 case 4:
2453 if (jjCanMove_0(hiByte, i1, i2, l1, l2))
2454 jjAddStates(2, 4);
2455 break;
2456 default : break;
2457 }
2458 } while(i != startsAt);
2459 }
2460 if (kind != 0x7fffffff)
2461 {
2462 jjmatchedKind = kind;
2463 jjmatchedPos = curPos;
2464 kind = 0x7fffffff;
2465 }
2466 ++curPos;
2467 if ((i = jjnewStateCnt) == (startsAt = 8 - (jjnewStateCnt = startsAt)))
2468 return curPos;
2469 try { curChar = input_stream.readChar(); }
2470 catch(java.io.IOException e) { return curPos; }
2471 }
2472}
2473static final int[] jjnextStates = {
2474 2, 3, 4, 6, 7, 39, 40, 24, 50, 51, 56, 57, 60, 61, 64, 65,
2475 20, 21, 22, 23, 24, 26, 29, 30, 31, 33, 24, 22, 23, 24, 27, 28,
2476 32, 23, 24, 66, 67, 24, 11, 12, 15, 18, 44, 11, 45, 12, 46, 15,
2477 47, 18, 37, 38, 41, 42, 54, 55, 58, 59, 62, 63, 68, 69,
2478};
2479private static final boolean jjCanMove_0(int hiByte, int i1, int i2, long l1, long l2)
2480{
2481 switch(hiByte)
2482 {
2483 case 0:
2484 return ((jjbitVec2[i2] & l2) != 0L);
2485 default :
2486 if ((jjbitVec0[i1] & l1) != 0L)
2487 return true;
2488 return false;
2489 }
2490}
2491public static final String [] jjstrLiteralImages = {
2492"", null, null, null, null, null, null, null, null, null, null, null, null,
2493null, null, "\74\111\116\104\105\116\124\76", null, null, "\50", "\51", "\173",
2494"\175", "\133", "\135", "\73", "\54", "\56", "\72", "\53", "\55", "\52", "\57",
2495"\57\57", "\52\52", "\74\74", "\76\76", "\45", "\176", "\136", "\174", "\46", "\75",
2496"\76", "\74", "\75\75", "\74\75", "\76\75", "\74\76", "\41\75", "\53\75", "\55\75",
2497"\52\75", "\57\75", "\57\57\75", "\45\75", "\46\75", "\174\75", "\136\75", "\74\74\75",
2498"\76\76\75", "\52\52\75", "\157\162", "\141\156\144", "\156\157\164", "\151\163",
2499"\151\156", "\154\141\155\142\144\141", "\151\146", "\145\154\163\145",
2500"\145\154\151\146", "\167\150\151\154\145", "\146\157\162", "\164\162\171",
2501"\145\170\143\145\160\164", "\144\145\146", "\143\154\141\163\163", "\146\151\156\141\154\154\171",
2502"\160\162\151\156\164", "\160\141\163\163", "\142\162\145\141\153",
2503"\143\157\156\164\151\156\165\145", "\162\145\164\165\162\156", "\171\151\145\154\144",
2504"\151\155\160\157\162\164", "\146\162\157\155", "\144\145\154", "\162\141\151\163\145",
2505"\147\154\157\142\141\154", "\145\170\145\143", "\141\163\163\145\162\164", "\141\163", null, null, null,
2506null, null, null, null, null, null, null, null, null, null, null, null, null, null,
2507null, null, null, null, null, null, null, null, null, null, null, null, null,
2508"\140", };
2509public static final String [] lexStateNames = {
2510 "DEFAULT",
2511 "FORCE_NEWLINE1",
2512 "FORCE_NEWLINE2",
2513 "MAYBE_FORCE_NEWLINE_IF_EOF",
2514 "INDENTING",
2515 "INDENTATION_UNCHANGED",
2516 "UNREACHABLE",
2517 "IN_STRING11",
2518 "IN_STRING21",
2519 "IN_STRING13",
2520 "IN_STRING23",
2521 "IN_STRING1NLC",
2522 "IN_STRING2NLC",
2523};
2524public static final int[] jjnewLexState = {
2525 -1, -1, -1, -1, -1, -1, 5, 4, -1, -1, -1, -1, -1, 0, 0, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
2526 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
2527 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
2528 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
2529 7, 8, 9, 10, 0, 0, 0, 0, 11, 11, 12, 12, 7, 8, -1, -1, -1, -1, -1, -1, -1, -1,
2530};
2531static final long[] jjtoToken = {
2532 0xfffffffffffcc0c1L, 0x2000f03efffffffL,
2533};
2534static final long[] jjtoSkip = {
2535 0x33f3eL, 0x0L,
2536};
2537static final long[] jjtoSpecial = {
2538 0x30000L, 0x0L,
2539};
2540static final long[] jjtoMore = {
2541 0x0L, 0x1fff0f000000000L,
2542};
2543protected CharStream input_stream;
2544private final int[] jjrounds = new int[70];
2545private final int[] jjstateSet = new int[140];
2546StringBuffer image;
2547int jjimageLen;
2548int lengthOfMatch;
2549protected char curChar;
2550public PythonGrammarTokenManager(CharStream stream)
2551{
2552 input_stream = stream;
2553}
2554public PythonGrammarTokenManager(CharStream stream, int lexState)
2555{
2556 this(stream);
2557 SwitchTo(lexState);
2558}
2559public void ReInit(CharStream stream)
2560{
2561 jjmatchedPos = jjnewStateCnt = 0;
2562 curLexState = defaultLexState;
2563 input_stream = stream;
2564 ReInitRounds();
2565}
2566private final void ReInitRounds()
2567{
2568 int i;
2569 jjround = 0x80000001;
2570 for (i = 70; i-- > 0;)
2571 jjrounds[i] = 0x80000000;
2572}
2573public void ReInit(CharStream stream, int lexState)
2574{
2575 ReInit(stream);
2576 SwitchTo(lexState);
2577}
2578public void SwitchTo(int lexState)
2579{
2580 if (lexState >= 13 || lexState < 0)
2581 throw new TokenMgrError("Error: Ignoring invalid lexical state : " + lexState + ". State unchanged.", TokenMgrError.INVALID_LEXICAL_STATE);
2582 else
2583 curLexState = lexState;
2584}
2585
2586protected Token jjFillToken()
2587{
2588 Token t = Token.newToken(jjmatchedKind);
2589 t.kind = jjmatchedKind;
2590 if (jjmatchedPos < 0)
2591 {
2592 if (image == null)
2593 t.image = "";
2594 else
2595 t.image = image.toString();
2596 t.beginLine = t.endLine = input_stream.getBeginLine();
2597 t.beginColumn = t.endColumn = input_stream.getBeginColumn();
2598 }
2599 else
2600 {
2601 String im = jjstrLiteralImages[jjmatchedKind];
2602 t.image = (im == null) ? input_stream.GetImage() : im;
2603 t.beginLine = input_stream.getBeginLine();
2604 t.beginColumn = input_stream.getBeginColumn();
2605 t.endLine = input_stream.getEndLine();
2606 t.endColumn = input_stream.getEndColumn();
2607 }
2608 return t;
2609}
2610
2611int curLexState = 0;
2612int defaultLexState = 0;
2613int jjnewStateCnt;
2614int jjround;
2615int jjmatchedPos;
2616int jjmatchedKind;
2617
2618public Token getNextToken()
2619{
2620 int kind;
2621 Token specialToken = null;
2622 Token matchedToken;
2623 int curPos = 0;
2624
2625 EOFLoop :
2626 for (;;)
2627 {
2628 try
2629 {
2630 curChar = input_stream.BeginToken();
2631 }
2632 catch(java.io.IOException e)
2633 {
2634 jjmatchedKind = 0;
2635 matchedToken = jjFillToken();
2636 matchedToken.specialToken = specialToken;
2637 CommonTokenAction(matchedToken);
2638 return matchedToken;
2639 }
2640 image = null;
2641 jjimageLen = 0;
2642
2643 for (;;)
2644 {
2645 switch(curLexState)
2646 {
2647 case 0:
2648 try { input_stream.backup(0);
2649 while (curChar <= 32 && (0x100001200L & (1L << curChar)) != 0L)
2650 curChar = input_stream.BeginToken();
2651 }
2652 catch (java.io.IOException e1) { continue EOFLoop; }
2653 jjmatchedKind = 0x7fffffff;
2654 jjmatchedPos = 0;
2655 curPos = jjMoveStringLiteralDfa0_0();
2656 break;
2657 case 1:
2658 jjmatchedKind = 0x7fffffff;
2659 jjmatchedPos = 0;
2660 curPos = jjMoveStringLiteralDfa0_1();
2661 break;
2662 case 2:
2663 jjmatchedKind = 0x7fffffff;
2664 jjmatchedPos = 0;
2665 curPos = jjMoveStringLiteralDfa0_2();
2666 break;
2667 case 3:
2668 jjmatchedKind = 8;
2669 jjmatchedPos = -1;
2670 curPos = 0;
2671 curPos = jjMoveStringLiteralDfa0_3();
2672 break;
2673 case 4:
2674 jjmatchedKind = 14;
2675 jjmatchedPos = -1;
2676 curPos = 0;
2677 curPos = jjMoveStringLiteralDfa0_4();
2678 break;
2679 case 5:
2680 jjmatchedKind = 13;
2681 jjmatchedPos = -1;
2682 curPos = 0;
2683 curPos = jjMoveStringLiteralDfa0_5();
2684 break;
2685 case 6:
2686 jjmatchedKind = 0x7fffffff;
2687 jjmatchedPos = 0;
2688 curPos = jjMoveStringLiteralDfa0_6();
2689 break;
2690 case 7:
2691 jjmatchedKind = 0x7fffffff;
2692 jjmatchedPos = 0;
2693 curPos = jjMoveStringLiteralDfa0_7();
2694 break;
2695 case 8:
2696 jjmatchedKind = 0x7fffffff;
2697 jjmatchedPos = 0;
2698 curPos = jjMoveStringLiteralDfa0_8();
2699 break;
2700 case 9:
2701 jjmatchedKind = 0x7fffffff;
2702 jjmatchedPos = 0;
2703 curPos = jjMoveStringLiteralDfa0_9();
2704 break;
2705 case 10:
2706 jjmatchedKind = 0x7fffffff;
2707 jjmatchedPos = 0;
2708 curPos = jjMoveStringLiteralDfa0_10();
2709 break;
2710 case 11:
2711 jjmatchedKind = 112;
2712 jjmatchedPos = -1;
2713 curPos = 0;
2714 curPos = jjMoveStringLiteralDfa0_11();
2715 break;
2716 case 12:
2717 jjmatchedKind = 113;
2718 jjmatchedPos = -1;
2719 curPos = 0;
2720 curPos = jjMoveStringLiteralDfa0_12();
2721 break;
2722 }
2723 if (jjmatchedKind != 0x7fffffff)
2724 {
2725 if (jjmatchedPos + 1 < curPos)
2726 input_stream.backup(curPos - jjmatchedPos - 1);
2727 if ((jjtoToken[jjmatchedKind >> 6] & (1L << (jjmatchedKind & 077))) != 0L)
2728 {
2729 matchedToken = jjFillToken();
2730 matchedToken.specialToken = specialToken;
2731 TokenLexicalActions(matchedToken);
2732 if (jjnewLexState[jjmatchedKind] != -1)
2733 curLexState = jjnewLexState[jjmatchedKind];
2734 CommonTokenAction(matchedToken);
2735 return matchedToken;
2736 }
2737 else if ((jjtoSkip[jjmatchedKind >> 6] & (1L << (jjmatchedKind & 077))) != 0L)
2738 {
2739 if ((jjtoSpecial[jjmatchedKind >> 6] & (1L << (jjmatchedKind & 077))) != 0L)
2740 {
2741 matchedToken = jjFillToken();
2742 if (specialToken == null)
2743 specialToken = matchedToken;
2744 else
2745 {
2746 matchedToken.specialToken = specialToken;
2747 specialToken = (specialToken.next = matchedToken);
2748 }
2749 SkipLexicalActions(matchedToken);
2750 }
2751 else
2752 SkipLexicalActions(null);
2753 if (jjnewLexState[jjmatchedKind] != -1)
2754 curLexState = jjnewLexState[jjmatchedKind];
2755 continue EOFLoop;
2756 }
2757 MoreLexicalActions();
2758 if (jjnewLexState[jjmatchedKind] != -1)
2759 curLexState = jjnewLexState[jjmatchedKind];
2760 curPos = 0;
2761 jjmatchedKind = 0x7fffffff;
2762 try {
2763 curChar = input_stream.readChar();
2764 continue;
2765 }
2766 catch (java.io.IOException e1) { }
2767 }
2768 int error_line = input_stream.getEndLine();
2769 int error_column = input_stream.getEndColumn();
2770 String error_after = null;
2771 boolean EOFSeen = false;
2772 try { input_stream.readChar(); input_stream.backup(1); }
2773 catch (java.io.IOException e1) {
2774 EOFSeen = true;
2775 error_after = curPos <= 1 ? "" : input_stream.GetImage();
2776 if (curChar == '\n' || curChar == '\r') {
2777 error_line++;
2778 error_column = 0;
2779 }
2780 else
2781 error_column++;
2782 }
2783 if (!EOFSeen) {
2784 input_stream.backup(1);
2785 error_after = curPos <= 1 ? "" : input_stream.GetImage();
2786 }
2787 throw new TokenMgrError(EOFSeen, curLexState, error_line, error_column, error_after, curChar, TokenMgrError.LEXICAL_ERROR);
2788 }
2789 }
2790}
2791
2792int[] jjemptyLineNo = new int[13];
2793int[] jjemptyColNo = new int[13];
2794boolean[] jjbeenHere = new boolean[13];
2795void SkipLexicalActions(Token matchedToken)
2796{
2797 switch(jjmatchedKind)
2798 {
2799 case 5 :
2800 if (image == null)
2801 image = new StringBuffer (new String (input_stream.GetSuffix(jjimageLen + (lengthOfMatch = jjmatchedPos + 1))));
2802 else
2803 image.append(input_stream.GetSuffix(jjimageLen + (lengthOfMatch = jjmatchedPos + 1)));
2804 if (parens == 0) {
2805 indent = 0;
2806 input_stream.backup(1);
2807 if (level == 0)
2808 SwitchTo(FORCE_NEWLINE1);
2809 else
2810 SwitchTo(FORCE_NEWLINE2);
2811 }
2812 break;
2813 case 8 :
2814 if (jjmatchedPos == -1)
2815 {
2816 if (jjbeenHere[3] &&
2817 jjemptyLineNo[3] == input_stream.getBeginLine() &&
2818 jjemptyColNo[3] == input_stream.getBeginColumn())
2819 throw new TokenMgrError(("Error: Bailing out of infinite loop caused by repeated empty string matches at line " + input_stream.getBeginLine() + ", column " + input_stream.getBeginColumn() + "."), TokenMgrError.LOOP_DETECTED);
2820 jjemptyLineNo[3] = input_stream.getBeginLine();
2821 jjemptyColNo[3] = input_stream.getBeginColumn();
2822 jjbeenHere[3] = true;
2823 }
2824 if (image == null)
2825 image = new StringBuffer (new String (input_stream.GetSuffix(jjimageLen + (lengthOfMatch = jjmatchedPos + 1))));
2826 else
2827 image.append(input_stream.GetSuffix(jjimageLen + (lengthOfMatch = jjmatchedPos + 1)));
2828 indenting(0);
2829 break;
2830 case 9 :
2831 if (image == null)
2832 image = new StringBuffer (new String (input_stream.GetSuffix(jjimageLen + (lengthOfMatch = jjmatchedPos + 1))));
2833 else
2834 image.append(input_stream.GetSuffix(jjimageLen + (lengthOfMatch = jjmatchedPos + 1)));
2835 indenting((indent/8+1)*8);
2836 break;
2837 case 10 :
2838 if (image == null)
2839 image = new StringBuffer (new String (input_stream.GetSuffix(jjimageLen + (lengthOfMatch = jjmatchedPos + 1))));
2840 else
2841 image.append(input_stream.GetSuffix(jjimageLen + (lengthOfMatch = jjmatchedPos + 1)));
2842 indenting(indent+1);
2843 break;
2844 case 11 :
2845 if (image == null)
2846 image = new StringBuffer (new String (input_stream.GetSuffix(jjimageLen + (lengthOfMatch = jjmatchedPos + 1))));
2847 else
2848 image.append(input_stream.GetSuffix(jjimageLen + (lengthOfMatch = jjmatchedPos + 1)));
2849 indenting(0);
2850 break;
2851 case 12 :
2852 if (image == null)
2853 image = new StringBuffer (new String (input_stream.GetSuffix(jjimageLen + (lengthOfMatch = jjmatchedPos + 1))));
2854 else
2855 image.append(input_stream.GetSuffix(jjimageLen + (lengthOfMatch = jjmatchedPos + 1)));
2856 if (partial && single_input && indent == 0 &&
2862 parens == 0 && (stdprompt || !expect_indent)) {
2863 SwitchTo(MAYBE_FORCE_NEWLINE_IF_EOF);
2867 }
2868 else
2869 indenting(0);
2870 break;
2871 case 17 :
2872 if (image == null)
2873 image = new StringBuffer (new String (input_stream.GetSuffix(jjimageLen + (lengthOfMatch = jjmatchedPos + 1))));
2874 else
2875 image.append(input_stream.GetSuffix(jjimageLen + (lengthOfMatch = jjmatchedPos + 1)));
2876 indenting(0);
2877 break;
2878 default :
2879 break;
2880 }
2881}
2882void MoreLexicalActions()
2883{
2884 jjimageLen += (lengthOfMatch = jjmatchedPos + 1);
2885 switch(jjmatchedKind)
2886 {
2887 case 108 :
2888 if (image == null)
2889 image = new StringBuffer (new String (input_stream.GetSuffix(jjimageLen)));
2890 else
2891 image.append(input_stream.GetSuffix(jjimageLen));
2892 jjimageLen = 0;
2893 image.setLength(image.length()-3);
2894 break;
2895 case 109 :
2896 if (image == null)
2897 image = new StringBuffer (new String (input_stream.GetSuffix(jjimageLen)));
2898 else
2899 image.append(input_stream.GetSuffix(jjimageLen));
2900 jjimageLen = 0;
2901 image.setLength(image.length()-2);
2902 break;
2903 case 110 :
2904 if (image == null)
2905 image = new StringBuffer (new String (input_stream.GetSuffix(jjimageLen)));
2906 else
2907 image.append(input_stream.GetSuffix(jjimageLen));
2908 jjimageLen = 0;
2909 image.setLength(image.length()-3);
2910 break;
2911 case 111 :
2912 if (image == null)
2913 image = new StringBuffer (new String (input_stream.GetSuffix(jjimageLen)));
2914 else
2915 image.append(input_stream.GetSuffix(jjimageLen));
2916 jjimageLen = 0;
2917 image.setLength(image.length()-2);
2918 break;
2919 case 116 :
2920 if (image == null)
2921 image = new StringBuffer (new String (input_stream.GetSuffix(jjimageLen)));
2922 else
2923 image.append(input_stream.GetSuffix(jjimageLen));
2924 jjimageLen = 0;
2925 int l = image.length();
2926 image.setLength(l-1);
2927 image.setCharAt(l-2, '\n');
2928 break;
2929 case 118 :
2930 if (image == null)
2931 image = new StringBuffer (new String (input_stream.GetSuffix(jjimageLen)));
2932 else
2933 image.append(input_stream.GetSuffix(jjimageLen));
2934 jjimageLen = 0;
2935 image.setCharAt(image.length()-1, '\n');
2936 break;
2937 default :
2938 break;
2939 }
2940}
2941void TokenLexicalActions(Token matchedToken)
2942{
2943 switch(jjmatchedKind)
2944 {
2945 case 7 :
2946 if (image == null)
2947 image = new StringBuffer (new String (input_stream.GetSuffix(jjimageLen + (lengthOfMatch = jjmatchedPos + 1))));
2948 else
2949 image.append(input_stream.GetSuffix(jjimageLen + (lengthOfMatch = jjmatchedPos + 1)));
2950 matchedToken.kind = NEWLINE;
2951 break;
2952 case 14 :
2953 if (image == null)
2954 image = new StringBuffer (new String (input_stream.GetSuffix(jjimageLen + (lengthOfMatch = jjmatchedPos + 1))));
2955 else
2956 image.append(input_stream.GetSuffix(jjimageLen + (lengthOfMatch = jjmatchedPos + 1)));
2957 if (indent > indentation[level]) {
2958 level++;
2959 indentation[level] = indent;
2960 matchedToken.kind=INDENT;
2961 matchedToken.image = "<INDENT>";
2962 }
2963 else if (level > 0) {
2964 Token t = matchedToken;
2965 level -= 1;
2966 while (level > 0 && indent < indentation[level]) {
2967 level--;
2968 t = addDedent(t);
2969 }
2970 if (indent != indentation[level]) {
2971 throw new TokenMgrError("inconsistent dedent",
2972 t.endLine, t.endColumn);
2973 }
2974 t.next = null;
2975 }
2976 break;
2977 case 18 :
2978 if (image == null)
2979 image = new StringBuffer (jjstrLiteralImages[18]);
2980 else
2981 image.append(jjstrLiteralImages[18]);
2982 parens++;
2983 break;
2984 case 19 :
2985 if (image == null)
2986 image = new StringBuffer (jjstrLiteralImages[19]);
2987 else
2988 image.append(jjstrLiteralImages[19]);
2989 parens--;
2990 break;
2991 case 20 :
2992 if (image == null)
2993 image = new StringBuffer (jjstrLiteralImages[20]);
2994 else
2995 image.append(jjstrLiteralImages[20]);
2996 parens++;
2997 break;
2998 case 21 :
2999 if (image == null)
3000 image = new StringBuffer (jjstrLiteralImages[21]);
3001 else
3002 image.append(jjstrLiteralImages[21]);
3003 parens--;
3004 break;
3005 case 22 :
3006 if (image == null)
3007 image = new StringBuffer (jjstrLiteralImages[22]);
3008 else
3009 image.append(jjstrLiteralImages[22]);
3010 parens++;
3011 break;
3012 case 23 :
3013 if (image == null)
3014 image = new StringBuffer (jjstrLiteralImages[23]);
3015 else
3016 image.append(jjstrLiteralImages[23]);
3017 parens--;
3018 break;
3019 case 104 :
3020 if (image == null)
3021 image = new StringBuffer (new String (input_stream.GetSuffix(jjimageLen + (lengthOfMatch = jjmatchedPos + 1))));
3022 else
3023 image.append(input_stream.GetSuffix(jjimageLen + (lengthOfMatch = jjmatchedPos + 1)));
3024 matchedToken.image = image.toString();
3025 break;
3026 case 105 :
3027 if (image == null)
3028 image = new StringBuffer (new String (input_stream.GetSuffix(jjimageLen + (lengthOfMatch = jjmatchedPos + 1))));
3029 else
3030 image.append(input_stream.GetSuffix(jjimageLen + (lengthOfMatch = jjmatchedPos + 1)));
3031 matchedToken.image = image.toString();
3032 break;
3033 case 106 :
3034 if (image == null)
3035 image = new StringBuffer (new String (input_stream.GetSuffix(jjimageLen + (lengthOfMatch = jjmatchedPos + 1))));
3036 else
3037 image.append(input_stream.GetSuffix(jjimageLen + (lengthOfMatch = jjmatchedPos + 1)));
3038 matchedToken.image = image.toString();
3039 break;
3040 case 107 :
3041 if (image == null)
3042 image = new StringBuffer (new String (input_stream.GetSuffix(jjimageLen + (lengthOfMatch = jjmatchedPos + 1))));
3043 else
3044 image.append(input_stream.GetSuffix(jjimageLen + (lengthOfMatch = jjmatchedPos + 1)));
3045 matchedToken.image = image.toString();
3046 break;
3047 default :
3048 break;
3049 }
3050}
3051}
3052 |
Popular Tags |
Java API By Example, From Geeks To Geeks.