1
2 package net.sourceforge.pmd.lang.python.ast;
3 import net.sourceforge.pmd.lang.ast.CharStream;
4 import net.sourceforge.pmd.lang.ast.TokenMgrError;
5
6
7 public class PythonParserTokenManager extends net.sourceforge.pmd.lang.ast.AbstractTokenManager implements PythonParserConstants
8 {
9
10
11 public java.io.PrintStream debugStream = System.out;
12
13 public void setDebugStream(java.io.PrintStream ds) { debugStream = ds; }
14 private int jjMoveStringLiteralDfa0_13()
15 {
16 return 1;
17 }
18 private final int jjStopStringLiteralDfa_11(int pos, long active0, long active1, long active2)
19 {
20 switch (pos)
21 {
22 case 0:
23 if ((active1 & 0x4000000000000L) != 0L)
24 {
25 jjmatchedKind = 139;
26 return -1;
27 }
28 return -1;
29 case 1:
30 if ((active1 & 0x4000000000000L) != 0L)
31 {
32 if (jjmatchedPos == 0)
33 {
34 jjmatchedKind = 139;
35 jjmatchedPos = 0;
36 }
37 return -1;
38 }
39 return -1;
40 default :
41 return -1;
42 }
43 }
44 private final int jjStartNfa_11(int pos, long active0, long active1, long active2)
45 {
46 return jjMoveNfa_11(jjStopStringLiteralDfa_11(pos, active0, active1, active2), pos + 1);
47 }
48 private int jjStopAtPos(int pos, int kind)
49 {
50 jjmatchedKind = kind;
51 jjmatchedPos = pos;
52 return pos + 1;
53 }
54 private int jjMoveStringLiteralDfa0_11()
55 {
56 switch(curChar)
57 {
58 case 10:
59 return jjStopAtPos(0, 137);
60 case 13:
61 jjmatchedKind = 138;
62 return jjMoveStringLiteralDfa1_11(0x0L, 0x100L);
63 case 39:
64 return jjMoveStringLiteralDfa1_11(0x4000000000000L, 0x0L);
65 default :
66 return jjMoveNfa_11(0, 0);
67 }
68 }
69 private int jjMoveStringLiteralDfa1_11(long active1, long active2)
70 {
71 try { curChar = input_stream.readChar(); }
72 catch(java.io.IOException e) {
73 jjStopStringLiteralDfa_11(0, 0L, active1, active2);
74 return 1;
75 }
76 switch(curChar)
77 {
78 case 10:
79 if ((active2 & 0x100L) != 0L)
80 return jjStopAtPos(1, 136);
81 break;
82 case 39:
83 return jjMoveStringLiteralDfa2_11(active1, 0x4000000000000L, active2, 0L);
84 default :
85 break;
86 }
87 return jjStartNfa_11(0, 0L, active1, active2);
88 }
89 private int jjMoveStringLiteralDfa2_11(long old1, long active1, long old2, long active2)
90 {
91 if (((active1 &= old1) | (active2 &= old2)) == 0L)
92 return jjStartNfa_11(0, 0L, old1, old2);
93 try { curChar = input_stream.readChar(); }
94 catch(java.io.IOException e) {
95 jjStopStringLiteralDfa_11(1, 0L, active1, 0L);
96 return 2;
97 }
98 switch(curChar)
99 {
100 case 39:
101 if ((active1 & 0x4000000000000L) != 0L)
102 return jjStopAtPos(2, 114);
103 break;
104 default :
105 break;
106 }
107 return jjStartNfa_11(1, 0L, active1, 0L);
108 }
109 static final long[] jjbitVec0 = {
110 0xfffffffffffffffeL, 0xffffffffffffffffL, 0xffffffffffffffffL, 0xffffffffffffffffL
111 };
112 static final long[] jjbitVec2 = {
113 0x0L, 0x0L, 0xffffffffffffffffL, 0xffffffffffffffffL
114 };
115 private int jjMoveNfa_11(int startState, int curPos)
116 {
117 int startsAt = 0;
118 jjnewStateCnt = 3;
119 int i = 1;
120 jjstateSet[0] = startState;
121 int kind = 0x7fffffff;
122 for (;;)
123 {
124 if (++jjround == 0x7fffffff)
125 ReInitRounds();
126 if (curChar < 64)
127 {
128 long l = 1L << curChar;
129 do
130 {
131 switch(jjstateSet[--i])
132 {
133 case 0:
134 if ((0xffffffffffffdbffL & l) != 0L && kind > 139)
135 kind = 139;
136 break;
137 case 2:
138 if ((0xffffffffffffdbffL & l) != 0L && kind > 140)
139 kind = 140;
140 break;
141 default : break;
142 }
143 } while(i != startsAt);
144 }
145 else if (curChar < 128)
146 {
147 long l = 1L << (curChar & 077);
148 do
149 {
150 switch(jjstateSet[--i])
151 {
152 case 0:
153 if (kind > 139)
154 kind = 139;
155 if (curChar == 92)
156 jjstateSet[jjnewStateCnt++] = 2;
157 break;
158 case 1:
159 if (curChar == 92)
160 jjstateSet[jjnewStateCnt++] = 2;
161 break;
162 case 2:
163 if (kind > 140)
164 kind = 140;
165 break;
166 default : break;
167 }
168 } while(i != startsAt);
169 }
170 else
171 {
172 int hiByte = (int)(curChar >> 8);
173 int i1 = hiByte >> 6;
174 long l1 = 1L << (hiByte & 077);
175 int i2 = (curChar & 0xff) >> 6;
176 long l2 = 1L << (curChar & 077);
177 do
178 {
179 switch(jjstateSet[--i])
180 {
181 case 0:
182 if (jjCanMove_0(hiByte, i1, i2, l1, l2) && kind > 139)
183 kind = 139;
184 break;
185 case 2:
186 if (jjCanMove_0(hiByte, i1, i2, l1, l2) && kind > 140)
187 kind = 140;
188 break;
189 default : break;
190 }
191 } while(i != startsAt);
192 }
193 if (kind != 0x7fffffff)
194 {
195 jjmatchedKind = kind;
196 jjmatchedPos = curPos;
197 kind = 0x7fffffff;
198 }
199 ++curPos;
200 if ((i = jjnewStateCnt) == (startsAt = 3 - (jjnewStateCnt = startsAt)))
201 return curPos;
202 try { curChar = input_stream.readChar(); }
203 catch(java.io.IOException e) { return curPos; }
204 }
205 }
206 private final int jjStopStringLiteralDfa_9(int pos, long active0, long active1)
207 {
208 switch (pos)
209 {
210 case 0:
211 if ((active1 & 0x100000000000000L) != 0L)
212 {
213 jjmatchedKind = 134;
214 return 2;
215 }
216 return -1;
217 case 1:
218 if ((active1 & 0x100000000000000L) != 0L)
219 {
220 jjmatchedKind = 121;
221 jjmatchedPos = 1;
222 return -1;
223 }
224 return -1;
225 default :
226 return -1;
227 }
228 }
229 private final int jjStartNfa_9(int pos, long active0, long active1)
230 {
231 return jjMoveNfa_9(jjStopStringLiteralDfa_9(pos, active0, active1), pos + 1);
232 }
233 private int jjMoveStringLiteralDfa0_9()
234 {
235 switch(curChar)
236 {
237 case 39:
238 return jjStopAtPos(0, 112);
239 case 92:
240 return jjMoveStringLiteralDfa1_9(0x100000000000000L);
241 default :
242 return jjMoveNfa_9(0, 0);
243 }
244 }
245 private int jjMoveStringLiteralDfa1_9(long active1)
246 {
247 try { curChar = input_stream.readChar(); }
248 catch(java.io.IOException e) {
249 jjStopStringLiteralDfa_9(0, 0L, active1);
250 return 1;
251 }
252 switch(curChar)
253 {
254 case 13:
255 return jjMoveStringLiteralDfa2_9(active1, 0x100000000000000L);
256 default :
257 break;
258 }
259 return jjStartNfa_9(0, 0L, active1);
260 }
261 private int jjMoveStringLiteralDfa2_9(long old1, long active1)
262 {
263 if (((active1 &= old1)) == 0L)
264 return jjStartNfa_9(0, 0L, old1);
265 try { curChar = input_stream.readChar(); }
266 catch(java.io.IOException e) {
267 jjStopStringLiteralDfa_9(1, 0L, active1);
268 return 2;
269 }
270 switch(curChar)
271 {
272 case 10:
273 if ((active1 & 0x100000000000000L) != 0L)
274 return jjStopAtPos(2, 120);
275 break;
276 default :
277 break;
278 }
279 return jjStartNfa_9(1, 0L, active1);
280 }
281 private int jjMoveNfa_9(int startState, int curPos)
282 {
283 int startsAt = 0;
284 jjnewStateCnt = 4;
285 int i = 1;
286 jjstateSet[0] = startState;
287 int kind = 0x7fffffff;
288 for (;;)
289 {
290 if (++jjround == 0x7fffffff)
291 ReInitRounds();
292 if (curChar < 64)
293 {
294 long l = 1L << curChar;
295 do
296 {
297 switch(jjstateSet[--i])
298 {
299 case 0:
300 if ((0xffffffffffffdbffL & l) != 0L && kind > 134)
301 kind = 134;
302 break;
303 case 2:
304 if ((0x2400L & l) != 0L)
305 {
306 if (kind > 121)
307 kind = 121;
308 }
309 else if (curChar == 39)
310 {
311 if (kind > 134)
312 kind = 134;
313 }
314 break;
315 case 3:
316 if (curChar == 39 && kind > 134)
317 kind = 134;
318 break;
319 default : break;
320 }
321 } while(i != startsAt);
322 }
323 else if (curChar < 128)
324 {
325 long l = 1L << (curChar & 077);
326 do
327 {
328 switch(jjstateSet[--i])
329 {
330 case 0:
331 if (kind > 134)
332 kind = 134;
333 if (curChar == 92)
334 jjAddStates(0, 1);
335 break;
336 case 2:
337 if (curChar == 92 && kind > 134)
338 kind = 134;
339 break;
340 case 1:
341 if (curChar == 92)
342 jjAddStates(0, 1);
343 break;
344 default : break;
345 }
346 } while(i != startsAt);
347 }
348 else
349 {
350 int hiByte = (int)(curChar >> 8);
351 int i1 = hiByte >> 6;
352 long l1 = 1L << (hiByte & 077);
353 int i2 = (curChar & 0xff) >> 6;
354 long l2 = 1L << (curChar & 077);
355 do
356 {
357 switch(jjstateSet[--i])
358 {
359 case 0:
360 if (jjCanMove_0(hiByte, i1, i2, l1, l2) && kind > 134)
361 kind = 134;
362 break;
363 default : break;
364 }
365 } while(i != startsAt);
366 }
367 if (kind != 0x7fffffff)
368 {
369 jjmatchedKind = kind;
370 jjmatchedPos = curPos;
371 kind = 0x7fffffff;
372 }
373 ++curPos;
374 if ((i = jjnewStateCnt) == (startsAt = 4 - (jjnewStateCnt = startsAt)))
375 return curPos;
376 try { curChar = input_stream.readChar(); }
377 catch(java.io.IOException e) { return curPos; }
378 }
379 }
380 private int jjMoveStringLiteralDfa0_14()
381 {
382 return 1;
383 }
384 private final int jjStopStringLiteralDfa_4(int pos, long active0, long active1, long active2)
385 {
386 switch (pos)
387 {
388 case 0:
389 if ((active1 & 0x80000000000L) != 0L)
390 {
391 jjmatchedKind = 139;
392 return -1;
393 }
394 return -1;
395 case 1:
396 if ((active1 & 0x80000000000L) != 0L)
397 {
398 if (jjmatchedPos == 0)
399 {
400 jjmatchedKind = 139;
401 jjmatchedPos = 0;
402 }
403 return -1;
404 }
405 return -1;
406 default :
407 return -1;
408 }
409 }
410 private final int jjStartNfa_4(int pos, long active0, long active1, long active2)
411 {
412 return jjMoveNfa_4(jjStopStringLiteralDfa_4(pos, active0, active1, active2), pos + 1);
413 }
414 private int jjMoveStringLiteralDfa0_4()
415 {
416 switch(curChar)
417 {
418 case 10:
419 return jjStopAtPos(0, 137);
420 case 13:
421 jjmatchedKind = 138;
422 return jjMoveStringLiteralDfa1_4(0x0L, 0x100L);
423 case 34:
424 return jjMoveStringLiteralDfa1_4(0x80000000000L, 0x0L);
425 default :
426 return jjMoveNfa_4(0, 0);
427 }
428 }
429 private int jjMoveStringLiteralDfa1_4(long active1, long active2)
430 {
431 try { curChar = input_stream.readChar(); }
432 catch(java.io.IOException e) {
433 jjStopStringLiteralDfa_4(0, 0L, active1, active2);
434 return 1;
435 }
436 switch(curChar)
437 {
438 case 10:
439 if ((active2 & 0x100L) != 0L)
440 return jjStopAtPos(1, 136);
441 break;
442 case 34:
443 return jjMoveStringLiteralDfa2_4(active1, 0x80000000000L, active2, 0L);
444 default :
445 break;
446 }
447 return jjStartNfa_4(0, 0L, active1, active2);
448 }
449 private int jjMoveStringLiteralDfa2_4(long old1, long active1, long old2, long active2)
450 {
451 if (((active1 &= old1) | (active2 &= old2)) == 0L)
452 return jjStartNfa_4(0, 0L, old1, old2);
453 try { curChar = input_stream.readChar(); }
454 catch(java.io.IOException e) {
455 jjStopStringLiteralDfa_4(1, 0L, active1, 0L);
456 return 2;
457 }
458 switch(curChar)
459 {
460 case 34:
461 if ((active1 & 0x80000000000L) != 0L)
462 return jjStopAtPos(2, 107);
463 break;
464 default :
465 break;
466 }
467 return jjStartNfa_4(1, 0L, active1, 0L);
468 }
469 private int jjMoveNfa_4(int startState, int curPos)
470 {
471 int startsAt = 0;
472 jjnewStateCnt = 3;
473 int i = 1;
474 jjstateSet[0] = startState;
475 int kind = 0x7fffffff;
476 for (;;)
477 {
478 if (++jjround == 0x7fffffff)
479 ReInitRounds();
480 if (curChar < 64)
481 {
482 long l = 1L << curChar;
483 do
484 {
485 switch(jjstateSet[--i])
486 {
487 case 0:
488 if ((0xffffffffffffdbffL & l) != 0L && kind > 139)
489 kind = 139;
490 break;
491 case 2:
492 if ((0xffffffffffffdbffL & l) != 0L && kind > 140)
493 kind = 140;
494 break;
495 default : break;
496 }
497 } while(i != startsAt);
498 }
499 else if (curChar < 128)
500 {
501 long l = 1L << (curChar & 077);
502 do
503 {
504 switch(jjstateSet[--i])
505 {
506 case 0:
507 if (kind > 139)
508 kind = 139;
509 if (curChar == 92)
510 jjstateSet[jjnewStateCnt++] = 2;
511 break;
512 case 1:
513 if (curChar == 92)
514 jjstateSet[jjnewStateCnt++] = 2;
515 break;
516 case 2:
517 if (kind > 140)
518 kind = 140;
519 break;
520 default : break;
521 }
522 } while(i != startsAt);
523 }
524 else
525 {
526 int hiByte = (int)(curChar >> 8);
527 int i1 = hiByte >> 6;
528 long l1 = 1L << (hiByte & 077);
529 int i2 = (curChar & 0xff) >> 6;
530 long l2 = 1L << (curChar & 077);
531 do
532 {
533 switch(jjstateSet[--i])
534 {
535 case 0:
536 if (jjCanMove_0(hiByte, i1, i2, l1, l2) && kind > 139)
537 kind = 139;
538 break;
539 case 2:
540 if (jjCanMove_0(hiByte, i1, i2, l1, l2) && kind > 140)
541 kind = 140;
542 break;
543 default : break;
544 }
545 } while(i != startsAt);
546 }
547 if (kind != 0x7fffffff)
548 {
549 jjmatchedKind = kind;
550 jjmatchedPos = curPos;
551 kind = 0x7fffffff;
552 }
553 ++curPos;
554 if ((i = jjnewStateCnt) == (startsAt = 3 - (jjnewStateCnt = startsAt)))
555 return curPos;
556 try { curChar = input_stream.readChar(); }
557 catch(java.io.IOException e) { return curPos; }
558 }
559 }
560 private final int jjStopStringLiteralDfa_2(int pos, long active0, long active1)
561 {
562 switch (pos)
563 {
564 case 0:
565 if ((active1 & 0x40000000000000L) != 0L)
566 {
567 jjmatchedKind = 135;
568 return 2;
569 }
570 return -1;
571 case 1:
572 if ((active1 & 0x40000000000000L) != 0L)
573 {
574 jjmatchedKind = 119;
575 jjmatchedPos = 1;
576 return -1;
577 }
578 return -1;
579 default :
580 return -1;
581 }
582 }
583 private final int jjStartNfa_2(int pos, long active0, long active1)
584 {
585 return jjMoveNfa_2(jjStopStringLiteralDfa_2(pos, active0, active1), pos + 1);
586 }
587 private int jjMoveStringLiteralDfa0_2()
588 {
589 switch(curChar)
590 {
591 case 34:
592 return jjStopAtPos(0, 105);
593 case 92:
594 return jjMoveStringLiteralDfa1_2(0x40000000000000L);
595 default :
596 return jjMoveNfa_2(0, 0);
597 }
598 }
599 private int jjMoveStringLiteralDfa1_2(long active1)
600 {
601 try { curChar = input_stream.readChar(); }
602 catch(java.io.IOException e) {
603 jjStopStringLiteralDfa_2(0, 0L, active1);
604 return 1;
605 }
606 switch(curChar)
607 {
608 case 13:
609 return jjMoveStringLiteralDfa2_2(active1, 0x40000000000000L);
610 default :
611 break;
612 }
613 return jjStartNfa_2(0, 0L, active1);
614 }
615 private int jjMoveStringLiteralDfa2_2(long old1, long active1)
616 {
617 if (((active1 &= old1)) == 0L)
618 return jjStartNfa_2(0, 0L, old1);
619 try { curChar = input_stream.readChar(); }
620 catch(java.io.IOException e) {
621 jjStopStringLiteralDfa_2(1, 0L, active1);
622 return 2;
623 }
624 switch(curChar)
625 {
626 case 10:
627 if ((active1 & 0x40000000000000L) != 0L)
628 return jjStopAtPos(2, 118);
629 break;
630 default :
631 break;
632 }
633 return jjStartNfa_2(1, 0L, active1);
634 }
635 private int jjMoveNfa_2(int startState, int curPos)
636 {
637 int startsAt = 0;
638 jjnewStateCnt = 4;
639 int i = 1;
640 jjstateSet[0] = startState;
641 int kind = 0x7fffffff;
642 for (;;)
643 {
644 if (++jjround == 0x7fffffff)
645 ReInitRounds();
646 if (curChar < 64)
647 {
648 long l = 1L << curChar;
649 do
650 {
651 switch(jjstateSet[--i])
652 {
653 case 0:
654 if ((0xffffffffffffdbffL & l) != 0L && kind > 135)
655 kind = 135;
656 break;
657 case 2:
658 if ((0x2400L & l) != 0L)
659 {
660 if (kind > 119)
661 kind = 119;
662 }
663 else if (curChar == 34)
664 {
665 if (kind > 135)
666 kind = 135;
667 }
668 break;
669 case 3:
670 if (curChar == 34 && kind > 135)
671 kind = 135;
672 break;
673 default : break;
674 }
675 } while(i != startsAt);
676 }
677 else if (curChar < 128)
678 {
679 long l = 1L << (curChar & 077);
680 do
681 {
682 switch(jjstateSet[--i])
683 {
684 case 0:
685 if (kind > 135)
686 kind = 135;
687 if (curChar == 92)
688 jjAddStates(0, 1);
689 break;
690 case 2:
691 if (curChar == 92 && kind > 135)
692 kind = 135;
693 break;
694 case 1:
695 if (curChar == 92)
696 jjAddStates(0, 1);
697 break;
698 default : break;
699 }
700 } while(i != startsAt);
701 }
702 else
703 {
704 int hiByte = (int)(curChar >> 8);
705 int i1 = hiByte >> 6;
706 long l1 = 1L << (hiByte & 077);
707 int i2 = (curChar & 0xff) >> 6;
708 long l2 = 1L << (curChar & 077);
709 do
710 {
711 switch(jjstateSet[--i])
712 {
713 case 0:
714 if (jjCanMove_0(hiByte, i1, i2, l1, l2) && kind > 135)
715 kind = 135;
716 break;
717 default : break;
718 }
719 } while(i != startsAt);
720 }
721 if (kind != 0x7fffffff)
722 {
723 jjmatchedKind = kind;
724 jjmatchedPos = curPos;
725 kind = 0x7fffffff;
726 }
727 ++curPos;
728 if ((i = jjnewStateCnt) == (startsAt = 4 - (jjnewStateCnt = startsAt)))
729 return curPos;
730 try { curChar = input_stream.readChar(); }
731 catch(java.io.IOException e) { return curPos; }
732 }
733 }
734 private final int jjStopStringLiteralDfa_12(int pos, long active0, long active1, long active2)
735 {
736 switch (pos)
737 {
738 case 0:
739 if ((active1 & 0x8000000000000L) != 0L)
740 {
741 jjmatchedKind = 139;
742 return -1;
743 }
744 return -1;
745 case 1:
746 if ((active1 & 0x8000000000000L) != 0L)
747 {
748 if (jjmatchedPos == 0)
749 {
750 jjmatchedKind = 139;
751 jjmatchedPos = 0;
752 }
753 return -1;
754 }
755 return -1;
756 default :
757 return -1;
758 }
759 }
760 private final int jjStartNfa_12(int pos, long active0, long active1, long active2)
761 {
762 return jjMoveNfa_12(jjStopStringLiteralDfa_12(pos, active0, active1, active2), pos + 1);
763 }
764 private int jjMoveStringLiteralDfa0_12()
765 {
766 switch(curChar)
767 {
768 case 10:
769 return jjStopAtPos(0, 137);
770 case 13:
771 jjmatchedKind = 138;
772 return jjMoveStringLiteralDfa1_12(0x0L, 0x100L);
773 case 34:
774 return jjMoveStringLiteralDfa1_12(0x8000000000000L, 0x0L);
775 default :
776 return jjMoveNfa_12(0, 0);
777 }
778 }
779 private int jjMoveStringLiteralDfa1_12(long active1, long active2)
780 {
781 try { curChar = input_stream.readChar(); }
782 catch(java.io.IOException e) {
783 jjStopStringLiteralDfa_12(0, 0L, active1, active2);
784 return 1;
785 }
786 switch(curChar)
787 {
788 case 10:
789 if ((active2 & 0x100L) != 0L)
790 return jjStopAtPos(1, 136);
791 break;
792 case 34:
793 return jjMoveStringLiteralDfa2_12(active1, 0x8000000000000L, active2, 0L);
794 default :
795 break;
796 }
797 return jjStartNfa_12(0, 0L, active1, active2);
798 }
799 private int jjMoveStringLiteralDfa2_12(long old1, long active1, long old2, long active2)
800 {
801 if (((active1 &= old1) | (active2 &= old2)) == 0L)
802 return jjStartNfa_12(0, 0L, old1, old2);
803 try { curChar = input_stream.readChar(); }
804 catch(java.io.IOException e) {
805 jjStopStringLiteralDfa_12(1, 0L, active1, 0L);
806 return 2;
807 }
808 switch(curChar)
809 {
810 case 34:
811 if ((active1 & 0x8000000000000L) != 0L)
812 return jjStopAtPos(2, 115);
813 break;
814 default :
815 break;
816 }
817 return jjStartNfa_12(1, 0L, active1, 0L);
818 }
819 private int jjMoveNfa_12(int startState, int curPos)
820 {
821 int startsAt = 0;
822 jjnewStateCnt = 3;
823 int i = 1;
824 jjstateSet[0] = startState;
825 int kind = 0x7fffffff;
826 for (;;)
827 {
828 if (++jjround == 0x7fffffff)
829 ReInitRounds();
830 if (curChar < 64)
831 {
832 long l = 1L << curChar;
833 do
834 {
835 switch(jjstateSet[--i])
836 {
837 case 0:
838 if ((0xffffffffffffdbffL & l) != 0L && kind > 139)
839 kind = 139;
840 break;
841 case 2:
842 if ((0xffffffffffffdbffL & l) != 0L && kind > 140)
843 kind = 140;
844 break;
845 default : break;
846 }
847 } while(i != startsAt);
848 }
849 else if (curChar < 128)
850 {
851 long l = 1L << (curChar & 077);
852 do
853 {
854 switch(jjstateSet[--i])
855 {
856 case 0:
857 if (kind > 139)
858 kind = 139;
859 if (curChar == 92)
860 jjstateSet[jjnewStateCnt++] = 2;
861 break;
862 case 1:
863 if (curChar == 92)
864 jjstateSet[jjnewStateCnt++] = 2;
865 break;
866 case 2:
867 if (kind > 140)
868 kind = 140;
869 break;
870 default : break;
871 }
872 } while(i != startsAt);
873 }
874 else
875 {
876 int hiByte = (int)(curChar >> 8);
877 int i1 = hiByte >> 6;
878 long l1 = 1L << (hiByte & 077);
879 int i2 = (curChar & 0xff) >> 6;
880 long l2 = 1L << (curChar & 077);
881 do
882 {
883 switch(jjstateSet[--i])
884 {
885 case 0:
886 if (jjCanMove_0(hiByte, i1, i2, l1, l2) && kind > 139)
887 kind = 139;
888 break;
889 case 2:
890 if (jjCanMove_0(hiByte, i1, i2, l1, l2) && kind > 140)
891 kind = 140;
892 break;
893 default : break;
894 }
895 } while(i != startsAt);
896 }
897 if (kind != 0x7fffffff)
898 {
899 jjmatchedKind = kind;
900 jjmatchedPos = curPos;
901 kind = 0x7fffffff;
902 }
903 ++curPos;
904 if ((i = jjnewStateCnt) == (startsAt = 3 - (jjnewStateCnt = startsAt)))
905 return curPos;
906 try { curChar = input_stream.readChar(); }
907 catch(java.io.IOException e) { return curPos; }
908 }
909 }
910 private final int jjStopStringLiteralDfa_7(int pos, long active0, long active1, long active2)
911 {
912 switch (pos)
913 {
914 case 0:
915 if ((active1 & 0x400000000000L) != 0L)
916 {
917 jjmatchedKind = 139;
918 return -1;
919 }
920 return -1;
921 case 1:
922 if ((active1 & 0x400000000000L) != 0L)
923 {
924 if (jjmatchedPos == 0)
925 {
926 jjmatchedKind = 139;
927 jjmatchedPos = 0;
928 }
929 return -1;
930 }
931 return -1;
932 default :
933 return -1;
934 }
935 }
936 private final int jjStartNfa_7(int pos, long active0, long active1, long active2)
937 {
938 return jjMoveNfa_7(jjStopStringLiteralDfa_7(pos, active0, active1, active2), pos + 1);
939 }
940 private int jjMoveStringLiteralDfa0_7()
941 {
942 switch(curChar)
943 {
944 case 10:
945 return jjStopAtPos(0, 137);
946 case 13:
947 jjmatchedKind = 138;
948 return jjMoveStringLiteralDfa1_7(0x0L, 0x100L);
949 case 39:
950 return jjMoveStringLiteralDfa1_7(0x400000000000L, 0x0L);
951 default :
952 return jjMoveNfa_7(0, 0);
953 }
954 }
955 private int jjMoveStringLiteralDfa1_7(long active1, long active2)
956 {
957 try { curChar = input_stream.readChar(); }
958 catch(java.io.IOException e) {
959 jjStopStringLiteralDfa_7(0, 0L, active1, active2);
960 return 1;
961 }
962 switch(curChar)
963 {
964 case 10:
965 if ((active2 & 0x100L) != 0L)
966 return jjStopAtPos(1, 136);
967 break;
968 case 39:
969 return jjMoveStringLiteralDfa2_7(active1, 0x400000000000L, active2, 0L);
970 default :
971 break;
972 }
973 return jjStartNfa_7(0, 0L, active1, active2);
974 }
975 private int jjMoveStringLiteralDfa2_7(long old1, long active1, long old2, long active2)
976 {
977 if (((active1 &= old1) | (active2 &= old2)) == 0L)
978 return jjStartNfa_7(0, 0L, old1, old2);
979 try { curChar = input_stream.readChar(); }
980 catch(java.io.IOException e) {
981 jjStopStringLiteralDfa_7(1, 0L, active1, 0L);
982 return 2;
983 }
984 switch(curChar)
985 {
986 case 39:
987 if ((active1 & 0x400000000000L) != 0L)
988 return jjStopAtPos(2, 110);
989 break;
990 default :
991 break;
992 }
993 return jjStartNfa_7(1, 0L, active1, 0L);
994 }
995 private int jjMoveNfa_7(int startState, int curPos)
996 {
997 int startsAt = 0;
998 jjnewStateCnt = 3;
999 int i = 1;
1000 jjstateSet[0] = startState;
1001 int kind = 0x7fffffff;
1002 for (;;)
1003 {
1004 if (++jjround == 0x7fffffff)
1005 ReInitRounds();
1006 if (curChar < 64)
1007 {
1008 long l = 1L << curChar;
1009 do
1010 {
1011 switch(jjstateSet[--i])
1012 {
1013 case 0:
1014 if ((0xffffffffffffdbffL & l) != 0L && kind > 139)
1015 kind = 139;
1016 break;
1017 case 2:
1018 if ((0xffffffffffffdbffL & l) != 0L && kind > 140)
1019 kind = 140;
1020 break;
1021 default : break;
1022 }
1023 } while(i != startsAt);
1024 }
1025 else if (curChar < 128)
1026 {
1027 long l = 1L << (curChar & 077);
1028 do
1029 {
1030 switch(jjstateSet[--i])
1031 {
1032 case 0:
1033 if (kind > 139)
1034 kind = 139;
1035 if (curChar == 92)
1036 jjstateSet[jjnewStateCnt++] = 2;
1037 break;
1038 case 1:
1039 if (curChar == 92)
1040 jjstateSet[jjnewStateCnt++] = 2;
1041 break;
1042 case 2:
1043 if (kind > 140)
1044 kind = 140;
1045 break;
1046 default : break;
1047 }
1048 } while(i != startsAt);
1049 }
1050 else
1051 {
1052 int hiByte = (int)(curChar >> 8);
1053 int i1 = hiByte >> 6;
1054 long l1 = 1L << (hiByte & 077);
1055 int i2 = (curChar & 0xff) >> 6;
1056 long l2 = 1L << (curChar & 077);
1057 do
1058 {
1059 switch(jjstateSet[--i])
1060 {
1061 case 0:
1062 if (jjCanMove_0(hiByte, i1, i2, l1, l2) && kind > 139)
1063 kind = 139;
1064 break;
1065 case 2:
1066 if (jjCanMove_0(hiByte, i1, i2, l1, l2) && kind > 140)
1067 kind = 140;
1068 break;
1069 default : break;
1070 }
1071 } while(i != startsAt);
1072 }
1073 if (kind != 0x7fffffff)
1074 {
1075 jjmatchedKind = kind;
1076 jjmatchedPos = curPos;
1077 kind = 0x7fffffff;
1078 }
1079 ++curPos;
1080 if ((i = jjnewStateCnt) == (startsAt = 3 - (jjnewStateCnt = startsAt)))
1081 return curPos;
1082 try { curChar = input_stream.readChar(); }
1083 catch(java.io.IOException e) { return curPos; }
1084 }
1085 }
1086 private final int jjStopStringLiteralDfa_10(int pos, long active0, long active1)
1087 {
1088 switch (pos)
1089 {
1090 case 0:
1091 if ((active1 & 0x400000000000000L) != 0L)
1092 {
1093 jjmatchedKind = 135;
1094 return 2;
1095 }
1096 return -1;
1097 case 1:
1098 if ((active1 & 0x400000000000000L) != 0L)
1099 {
1100 jjmatchedKind = 123;
1101 jjmatchedPos = 1;
1102 return -1;
1103 }
1104 return -1;
1105 default :
1106 return -1;
1107 }
1108 }
1109 private final int jjStartNfa_10(int pos, long active0, long active1)
1110 {
1111 return jjMoveNfa_10(jjStopStringLiteralDfa_10(pos, active0, active1), pos + 1);
1112 }
1113 private int jjMoveStringLiteralDfa0_10()
1114 {
1115 switch(curChar)
1116 {
1117 case 34:
1118 return jjStopAtPos(0, 113);
1119 case 92:
1120 return jjMoveStringLiteralDfa1_10(0x400000000000000L);
1121 default :
1122 return jjMoveNfa_10(0, 0);
1123 }
1124 }
1125 private int jjMoveStringLiteralDfa1_10(long active1)
1126 {
1127 try { curChar = input_stream.readChar(); }
1128 catch(java.io.IOException e) {
1129 jjStopStringLiteralDfa_10(0, 0L, active1);
1130 return 1;
1131 }
1132 switch(curChar)
1133 {
1134 case 13:
1135 return jjMoveStringLiteralDfa2_10(active1, 0x400000000000000L);
1136 default :
1137 break;
1138 }
1139 return jjStartNfa_10(0, 0L, active1);
1140 }
1141 private int jjMoveStringLiteralDfa2_10(long old1, long active1)
1142 {
1143 if (((active1 &= old1)) == 0L)
1144 return jjStartNfa_10(0, 0L, old1);
1145 try { curChar = input_stream.readChar(); }
1146 catch(java.io.IOException e) {
1147 jjStopStringLiteralDfa_10(1, 0L, active1);
1148 return 2;
1149 }
1150 switch(curChar)
1151 {
1152 case 10:
1153 if ((active1 & 0x400000000000000L) != 0L)
1154 return jjStopAtPos(2, 122);
1155 break;
1156 default :
1157 break;
1158 }
1159 return jjStartNfa_10(1, 0L, active1);
1160 }
1161 private int jjMoveNfa_10(int startState, int curPos)
1162 {
1163 int startsAt = 0;
1164 jjnewStateCnt = 4;
1165 int i = 1;
1166 jjstateSet[0] = startState;
1167 int kind = 0x7fffffff;
1168 for (;;)
1169 {
1170 if (++jjround == 0x7fffffff)
1171 ReInitRounds();
1172 if (curChar < 64)
1173 {
1174 long l = 1L << curChar;
1175 do
1176 {
1177 switch(jjstateSet[--i])
1178 {
1179 case 0:
1180 if ((0xffffffffffffdbffL & l) != 0L && kind > 135)
1181 kind = 135;
1182 break;
1183 case 2:
1184 if ((0x2400L & l) != 0L)
1185 {
1186 if (kind > 123)
1187 kind = 123;
1188 }
1189 else if (curChar == 34)
1190 {
1191 if (kind > 135)
1192 kind = 135;
1193 }
1194 break;
1195 case 3:
1196 if (curChar == 34 && kind > 135)
1197 kind = 135;
1198 break;
1199 default : break;
1200 }
1201 } while(i != startsAt);
1202 }
1203 else if (curChar < 128)
1204 {
1205 long l = 1L << (curChar & 077);
1206 do
1207 {
1208 switch(jjstateSet[--i])
1209 {
1210 case 0:
1211 if (kind > 135)
1212 kind = 135;
1213 if (curChar == 92)
1214 jjAddStates(0, 1);
1215 break;
1216 case 2:
1217 if (curChar == 92 && kind > 135)
1218 kind = 135;
1219 break;
1220 case 1:
1221 if (curChar == 92)
1222 jjAddStates(0, 1);
1223 break;
1224 default : break;
1225 }
1226 } while(i != startsAt);
1227 }
1228 else
1229 {
1230 int hiByte = (int)(curChar >> 8);
1231 int i1 = hiByte >> 6;
1232 long l1 = 1L << (hiByte & 077);
1233 int i2 = (curChar & 0xff) >> 6;
1234 long l2 = 1L << (curChar & 077);
1235 do
1236 {
1237 switch(jjstateSet[--i])
1238 {
1239 case 0:
1240 if (jjCanMove_0(hiByte, i1, i2, l1, l2) && kind > 135)
1241 kind = 135;
1242 break;
1243 default : break;
1244 }
1245 } while(i != startsAt);
1246 }
1247 if (kind != 0x7fffffff)
1248 {
1249 jjmatchedKind = kind;
1250 jjmatchedPos = curPos;
1251 kind = 0x7fffffff;
1252 }
1253 ++curPos;
1254 if ((i = jjnewStateCnt) == (startsAt = 4 - (jjnewStateCnt = startsAt)))
1255 return curPos;
1256 try { curChar = input_stream.readChar(); }
1257 catch(java.io.IOException e) { return curPos; }
1258 }
1259 }
1260 private final int jjStopStringLiteralDfa_5(int pos, long active0, long active1)
1261 {
1262 switch (pos)
1263 {
1264 case 0:
1265 if ((active1 & 0x1000000000000000L) != 0L)
1266 {
1267 jjmatchedKind = 134;
1268 return 2;
1269 }
1270 return -1;
1271 case 1:
1272 if ((active1 & 0x1000000000000000L) != 0L)
1273 {
1274 jjmatchedKind = 125;
1275 jjmatchedPos = 1;
1276 return -1;
1277 }
1278 return -1;
1279 default :
1280 return -1;
1281 }
1282 }
1283 private final int jjStartNfa_5(int pos, long active0, long active1)
1284 {
1285 return jjMoveNfa_5(jjStopStringLiteralDfa_5(pos, active0, active1), pos + 1);
1286 }
1287 private int jjMoveStringLiteralDfa0_5()
1288 {
1289 switch(curChar)
1290 {
1291 case 39:
1292 return jjStopAtPos(0, 108);
1293 case 92:
1294 return jjMoveStringLiteralDfa1_5(0x1000000000000000L);
1295 default :
1296 return jjMoveNfa_5(0, 0);
1297 }
1298 }
1299 private int jjMoveStringLiteralDfa1_5(long active1)
1300 {
1301 try { curChar = input_stream.readChar(); }
1302 catch(java.io.IOException e) {
1303 jjStopStringLiteralDfa_5(0, 0L, active1);
1304 return 1;
1305 }
1306 switch(curChar)
1307 {
1308 case 13:
1309 return jjMoveStringLiteralDfa2_5(active1, 0x1000000000000000L);
1310 default :
1311 break;
1312 }
1313 return jjStartNfa_5(0, 0L, active1);
1314 }
1315 private int jjMoveStringLiteralDfa2_5(long old1, long active1)
1316 {
1317 if (((active1 &= old1)) == 0L)
1318 return jjStartNfa_5(0, 0L, old1);
1319 try { curChar = input_stream.readChar(); }
1320 catch(java.io.IOException e) {
1321 jjStopStringLiteralDfa_5(1, 0L, active1);
1322 return 2;
1323 }
1324 switch(curChar)
1325 {
1326 case 10:
1327 if ((active1 & 0x1000000000000000L) != 0L)
1328 return jjStopAtPos(2, 124);
1329 break;
1330 default :
1331 break;
1332 }
1333 return jjStartNfa_5(1, 0L, active1);
1334 }
1335 private int jjMoveNfa_5(int startState, int curPos)
1336 {
1337 int startsAt = 0;
1338 jjnewStateCnt = 4;
1339 int i = 1;
1340 jjstateSet[0] = startState;
1341 int kind = 0x7fffffff;
1342 for (;;)
1343 {
1344 if (++jjround == 0x7fffffff)
1345 ReInitRounds();
1346 if (curChar < 64)
1347 {
1348 long l = 1L << curChar;
1349 do
1350 {
1351 switch(jjstateSet[--i])
1352 {
1353 case 0:
1354 if ((0xffffffffffffdbffL & l) != 0L && kind > 134)
1355 kind = 134;
1356 break;
1357 case 2:
1358 if ((0x2400L & l) != 0L)
1359 {
1360 if (kind > 125)
1361 kind = 125;
1362 }
1363 else if (curChar == 39)
1364 {
1365 if (kind > 134)
1366 kind = 134;
1367 }
1368 break;
1369 case 3:
1370 if (curChar == 39 && kind > 134)
1371 kind = 134;
1372 break;
1373 default : break;
1374 }
1375 } while(i != startsAt);
1376 }
1377 else if (curChar < 128)
1378 {
1379 long l = 1L << (curChar & 077);
1380 do
1381 {
1382 switch(jjstateSet[--i])
1383 {
1384 case 0:
1385 if (kind > 134)
1386 kind = 134;
1387 if (curChar == 92)
1388 jjAddStates(0, 1);
1389 break;
1390 case 2:
1391 if (curChar == 92 && kind > 134)
1392 kind = 134;
1393 break;
1394 case 1:
1395 if (curChar == 92)
1396 jjAddStates(0, 1);
1397 break;
1398 default : break;
1399 }
1400 } while(i != startsAt);
1401 }
1402 else
1403 {
1404 int hiByte = (int)(curChar >> 8);
1405 int i1 = hiByte >> 6;
1406 long l1 = 1L << (hiByte & 077);
1407 int i2 = (curChar & 0xff) >> 6;
1408 long l2 = 1L << (curChar & 077);
1409 do
1410 {
1411 switch(jjstateSet[--i])
1412 {
1413 case 0:
1414 if (jjCanMove_0(hiByte, i1, i2, l1, l2) && kind > 134)
1415 kind = 134;
1416 break;
1417 default : break;
1418 }
1419 } while(i != startsAt);
1420 }
1421 if (kind != 0x7fffffff)
1422 {
1423 jjmatchedKind = kind;
1424 jjmatchedPos = curPos;
1425 kind = 0x7fffffff;
1426 }
1427 ++curPos;
1428 if ((i = jjnewStateCnt) == (startsAt = 4 - (jjnewStateCnt = startsAt)))
1429 return curPos;
1430 try { curChar = input_stream.readChar(); }
1431 catch(java.io.IOException e) { return curPos; }
1432 }
1433 }
1434 private int jjMoveStringLiteralDfa0_15()
1435 {
1436 return 1;
1437 }
1438 private int jjMoveStringLiteralDfa0_17()
1439 {
1440 return 1;
1441 }
1442 private int jjMoveStringLiteralDfa0_16()
1443 {
1444 return 1;
1445 }
1446 private int jjMoveStringLiteralDfa0_18()
1447 {
1448 return 1;
1449 }
1450 private final int jjStopStringLiteralDfa_0(int pos, long active0, long active1)
1451 {
1452 switch (pos)
1453 {
1454 case 0:
1455 if ((active1 & 0x840L) != 0L)
1456 {
1457 jjmatchedKind = 82;
1458 return 95;
1459 }
1460 if ((active1 & 0x10L) != 0L)
1461 {
1462 jjmatchedKind = 82;
1463 return 61;
1464 }
1465 if ((active0 & 0xfffc000000000000L) != 0L || (active1 & 0x1f7afL) != 0L)
1466 {
1467 jjmatchedKind = 82;
1468 return 10;
1469 }
1470 if ((active0 & 0x8000L) != 0L)
1471 return 96;
1472 return -1;
1473 case 1:
1474 if ((active0 & 0xfe98000000000000L) != 0L || (active1 & 0x13fefL) != 0L)
1475 {
1476 if (jjmatchedPos != 1)
1477 {
1478 jjmatchedKind = 82;
1479 jjmatchedPos = 1;
1480 }
1481 return 10;
1482 }
1483 if ((active0 & 0x164000000000000L) != 0L || (active1 & 0xc000L) != 0L)
1484 return 10;
1485 if ((active1 & 0x10L) != 0L)
1486 {
1487 if (jjmatchedPos != 1)
1488 {
1489 jjmatchedKind = 82;
1490 jjmatchedPos = 1;
1491 }
1492 return 97;
1493 }
1494 return -1;
1495 case 2:
1496 if ((active0 & 0xb018000000000000L) != 0L || (active1 & 0x400L) != 0L)
1497 return 10;
1498 if ((active0 & 0x4e80000000000000L) != 0L || (active1 & 0x17bffL) != 0L)
1499 {
1500 jjmatchedKind = 82;
1501 jjmatchedPos = 2;
1502 return 10;
1503 }
1504 return -1;
1505 case 3:
1506 if ((active0 & 0x600000000000000L) != 0L || (active1 & 0x12208L) != 0L)
1507 return 10;
1508 if ((active0 & 0x4880000000000000L) != 0L || (active1 & 0x59f7L) != 0L)
1509 {
1510 jjmatchedKind = 82;
1511 jjmatchedPos = 3;
1512 return 10;
1513 }
1514 return -1;
1515 case 4:
1516 if ((active0 & 0x800000000000000L) != 0L || (active1 & 0x895L) != 0L)
1517 return 10;
1518 if ((active0 & 0x4080000000000000L) != 0L || (active1 & 0x5162L) != 0L)
1519 {
1520 jjmatchedKind = 82;
1521 jjmatchedPos = 4;
1522 return 10;
1523 }
1524 return -1;
1525 case 5:
1526 if ((active0 & 0x4080000000000000L) != 0L || (active1 & 0x5140L) != 0L)
1527 return 10;
1528 if ((active1 & 0x22L) != 0L)
1529 {
1530 jjmatchedKind = 82;
1531 jjmatchedPos = 5;
1532 return 10;
1533 }
1534 return -1;
1535 case 6:
1536 if ((active1 & 0x2L) != 0L)
1537 return 10;
1538 if ((active1 & 0x20L) != 0L)
1539 {
1540 jjmatchedKind = 82;
1541 jjmatchedPos = 6;
1542 return 10;
1543 }
1544 return -1;
1545 default :
1546 return -1;
1547 }
1548 }
1549 private final int jjStartNfa_0(int pos, long active0, long active1)
1550 {
1551 return jjMoveNfa_0(jjStopStringLiteralDfa_0(pos, active0, active1), pos + 1);
1552 }
1553 private int jjMoveStringLiteralDfa0_0()
1554 {
1555 switch(curChar)
1556 {
1557 case 33:
1558 return jjMoveStringLiteralDfa1_0(0x2000000000L, 0x0L);
1559 case 37:
1560 jjmatchedKind = 25;
1561 return jjMoveStringLiteralDfa1_0(0x80000000000L, 0x0L);
1562 case 38:
1563 jjmatchedKind = 29;
1564 return jjMoveStringLiteralDfa1_0(0x100000000000L, 0x0L);
1565 case 40:
1566 return jjStopAtPos(0, 7);
1567 case 41:
1568 return jjStopAtPos(0, 8);
1569 case 42:
1570 jjmatchedKind = 19;
1571 return jjMoveStringLiteralDfa1_0(0x2010000400000L, 0x0L);
1572 case 43:
1573 jjmatchedKind = 17;
1574 return jjMoveStringLiteralDfa1_0(0x4000000000L, 0x0L);
1575 case 44:
1576 return jjStopAtPos(0, 14);
1577 case 45:
1578 jjmatchedKind = 18;
1579 return jjMoveStringLiteralDfa1_0(0x8000000000L, 0x0L);
1580 case 46:
1581 return jjStartNfaWithStates_0(0, 15, 96);
1582 case 47:
1583 jjmatchedKind = 20;
1584 return jjMoveStringLiteralDfa1_0(0x60000200000L, 0x0L);
1585 case 58:
1586 return jjStopAtPos(0, 16);
1587 case 59:
1588 return jjStopAtPos(0, 13);
1589 case 60:
1590 jjmatchedKind = 32;
1591 return jjMoveStringLiteralDfa1_0(0x801400800000L, 0x0L);
1592 case 61:
1593 jjmatchedKind = 30;
1594 return jjMoveStringLiteralDfa1_0(0x200000000L, 0x0L);
1595 case 62:
1596 jjmatchedKind = 31;
1597 return jjMoveStringLiteralDfa1_0(0x1000801000000L, 0x0L);
1598 case 64:
1599 return jjStopAtPos(0, 81);
1600 case 91:
1601 return jjStopAtPos(0, 11);
1602 case 93:
1603 return jjStopAtPos(0, 12);
1604 case 94:
1605 jjmatchedKind = 27;
1606 return jjMoveStringLiteralDfa1_0(0x400000000000L, 0x0L);
1607 case 97:
1608 return jjMoveStringLiteralDfa1_0(0x8000000000000L, 0xc000L);
1609 case 98:
1610 return jjMoveStringLiteralDfa1_0(0x0L, 0x10L);
1611 case 99:
1612 return jjMoveStringLiteralDfa1_0(0x0L, 0x21L);
1613 case 100:
1614 return jjMoveStringLiteralDfa1_0(0x8000000000000000L, 0x400L);
1615 case 101:
1616 return jjMoveStringLiteralDfa1_0(0x4600000000000000L, 0x2000L);
1617 case 102:
1618 return jjMoveStringLiteralDfa1_0(0x1000000000000000L, 0x202L);
1619 case 103:
1620 return jjMoveStringLiteralDfa1_0(0x0L, 0x1000L);
1621 case 105:
1622 return jjMoveStringLiteralDfa1_0(0x160000000000000L, 0x100L);
1623 case 108:
1624 return jjMoveStringLiteralDfa1_0(0x80000000000000L, 0x0L);
1625 case 110:
1626 return jjMoveStringLiteralDfa1_0(0x10000000000000L, 0x0L);
1627 case 111:
1628 return jjMoveStringLiteralDfa1_0(0x4000000000000L, 0x0L);
1629 case 112:
1630 return jjMoveStringLiteralDfa1_0(0x0L, 0xcL);
1631 case 114:
1632 return jjMoveStringLiteralDfa1_0(0x0L, 0x840L);
1633 case 116:
1634 return jjMoveStringLiteralDfa1_0(0x2000000000000000L, 0x0L);
1635 case 119:
1636 return jjMoveStringLiteralDfa1_0(0x800000000000000L, 0x10000L);
1637 case 121:
1638 return jjMoveStringLiteralDfa1_0(0x0L, 0x80L);
1639 case 123:
1640 return jjStopAtPos(0, 9);
1641 case 124:
1642 jjmatchedKind = 28;
1643 return jjMoveStringLiteralDfa1_0(0x200000000000L, 0x0L);
1644 case 125:
1645 return jjStopAtPos(0, 10);
1646 case 126:
1647 return jjStopAtPos(0, 26);
1648 default :
1649 return jjMoveNfa_0(0, 0);
1650 }
1651 }
1652 private int jjMoveStringLiteralDfa1_0(long active0, long active1)
1653 {
1654 try { curChar = input_stream.readChar(); }
1655 catch(java.io.IOException e) {
1656 jjStopStringLiteralDfa_0(0, active0, active1);
1657 return 1;
1658 }
1659 switch(curChar)
1660 {
1661 case 42:
1662 if ((active0 & 0x400000L) != 0L)
1663 {
1664 jjmatchedKind = 22;
1665 jjmatchedPos = 1;
1666 }
1667 return jjMoveStringLiteralDfa2_0(active0, 0x2000000000000L, active1, 0L);
1668 case 47:
1669 if ((active0 & 0x200000L) != 0L)
1670 {
1671 jjmatchedKind = 21;
1672 jjmatchedPos = 1;
1673 }
1674 return jjMoveStringLiteralDfa2_0(active0, 0x40000000000L, active1, 0L);
1675 case 60:
1676 if ((active0 & 0x800000L) != 0L)
1677 {
1678 jjmatchedKind = 23;
1679 jjmatchedPos = 1;
1680 }
1681 return jjMoveStringLiteralDfa2_0(active0, 0x800000000000L, active1, 0L);
1682 case 61:
1683 if ((active0 & 0x200000000L) != 0L)
1684 return jjStopAtPos(1, 33);
1685 else if ((active0 & 0x400000000L) != 0L)
1686 return jjStopAtPos(1, 34);
1687 else if ((active0 & 0x800000000L) != 0L)
1688 return jjStopAtPos(1, 35);
1689 else if ((active0 & 0x2000000000L) != 0L)
1690 return jjStopAtPos(1, 37);
1691 else if ((active0 & 0x4000000000L) != 0L)
1692 return jjStopAtPos(1, 38);
1693 else if ((active0 & 0x8000000000L) != 0L)
1694 return jjStopAtPos(1, 39);
1695 else if ((active0 & 0x10000000000L) != 0L)
1696 return jjStopAtPos(1, 40);
1697 else if ((active0 & 0x20000000000L) != 0L)
1698 return jjStopAtPos(1, 41);
1699 else if ((active0 & 0x80000000000L) != 0L)
1700 return jjStopAtPos(1, 43);
1701 else if ((active0 & 0x100000000000L) != 0L)
1702 return jjStopAtPos(1, 44);
1703 else if ((active0 & 0x200000000000L) != 0L)
1704 return jjStopAtPos(1, 45);
1705 else if ((active0 & 0x400000000000L) != 0L)
1706 return jjStopAtPos(1, 46);
1707 break;
1708 case 62:
1709 if ((active0 & 0x1000000L) != 0L)
1710 {
1711 jjmatchedKind = 24;
1712 jjmatchedPos = 1;
1713 }
1714 else if ((active0 & 0x1000000000L) != 0L)
1715 return jjStopAtPos(1, 36);
1716 return jjMoveStringLiteralDfa2_0(active0, 0x1000000000000L, active1, 0L);
1717 case 97:
1718 return jjMoveStringLiteralDfa2_0(active0, 0x80000000000000L, active1, 0x808L);
1719 case 101:
1720 return jjMoveStringLiteralDfa2_0(active0, 0x8000000000000000L, active1, 0x440L);
1721 case 102:
1722 if ((active0 & 0x100000000000000L) != 0L)
1723 return jjStartNfaWithStates_0(1, 56, 10);
1724 break;
1725 case 104:
1726 return jjMoveStringLiteralDfa2_0(active0, 0x800000000000000L, active1, 0L);
1727 case 105:
1728 return jjMoveStringLiteralDfa2_0(active0, 0L, active1, 0x10082L);
1729 case 108:
1730 return jjMoveStringLiteralDfa2_0(active0, 0x600000000000000L, active1, 0x1001L);
1731 case 109:
1732 return jjMoveStringLiteralDfa2_0(active0, 0L, active1, 0x100L);
1733 case 110:
1734 if ((active0 & 0x40000000000000L) != 0L)
1735 return jjStartNfaWithStates_0(1, 54, 10);
1736 return jjMoveStringLiteralDfa2_0(active0, 0x8000000000000L, active1, 0L);
1737 case 111:
1738 return jjMoveStringLiteralDfa2_0(active0, 0x1010000000000000L, active1, 0x20L);
1739 case 114:
1740 if ((active0 & 0x4000000000000L) != 0L)
1741 return jjStartNfaWithStates_0(1, 50, 10);
1742 return jjMoveStringLiteralDfa2_0(active0, 0x2000000000000000L, active1, 0x214L);
1743 case 115:
1744 if ((active0 & 0x20000000000000L) != 0L)
1745 return jjStartNfaWithStates_0(1, 53, 10);
1746 else if ((active1 & 0x8000L) != 0L)
1747 {
1748 jjmatchedKind = 79;
1749 jjmatchedPos = 1;
1750 }
1751 return jjMoveStringLiteralDfa2_0(active0, 0L, active1, 0x4000L);
1752 case 120:
1753 return jjMoveStringLiteralDfa2_0(active0, 0x4000000000000000L, active1, 0x2000L);
1754 default :
1755 break;
1756 }
1757 return jjStartNfa_0(0, active0, active1);
1758 }
1759 private int jjMoveStringLiteralDfa2_0(long old0, long active0, long old1, long active1)
1760 {
1761 if (((active0 &= old0) | (active1 &= old1)) == 0L)
1762 return jjStartNfa_0(0, old0, old1);
1763 try { curChar = input_stream.readChar(); }
1764 catch(java.io.IOException e) {
1765 jjStopStringLiteralDfa_0(1, active0, active1);
1766 return 2;
1767 }
1768 switch(curChar)
1769 {
1770 case 61:
1771 if ((active0 & 0x40000000000L) != 0L)
1772 return jjStopAtPos(2, 42);
1773 else if ((active0 & 0x800000000000L) != 0L)
1774 return jjStopAtPos(2, 47);
1775 else if ((active0 & 0x1000000000000L) != 0L)
1776 return jjStopAtPos(2, 48);
1777 else if ((active0 & 0x2000000000000L) != 0L)
1778 return jjStopAtPos(2, 49);
1779 break;
1780 case 97:
1781 return jjMoveStringLiteralDfa3_0(active0, 0L, active1, 0x1L);
1782 case 99:
1783 return jjMoveStringLiteralDfa3_0(active0, 0x4000000000000000L, active1, 0L);
1784 case 100:
1785 if ((active0 & 0x8000000000000L) != 0L)
1786 return jjStartNfaWithStates_0(2, 51, 10);
1787 break;
1788 case 101:
1789 return jjMoveStringLiteralDfa3_0(active0, 0L, active1, 0x2090L);
1790 case 102:
1791 if ((active0 & 0x8000000000000000L) != 0L)
1792 return jjStartNfaWithStates_0(2, 63, 10);
1793 break;
1794 case 105:
1795 return jjMoveStringLiteralDfa3_0(active0, 0xc00000000000000L, active1, 0x804L);
1796 case 108:
1797 if ((active1 & 0x400L) != 0L)
1798 return jjStartNfaWithStates_0(2, 74, 10);
1799 break;
1800 case 109:
1801 return jjMoveStringLiteralDfa3_0(active0, 0x80000000000000L, active1, 0L);
1802 case 110:
1803 return jjMoveStringLiteralDfa3_0(active0, 0L, active1, 0x22L);
1804 case 111:
1805 return jjMoveStringLiteralDfa3_0(active0, 0L, active1, 0x1200L);
1806 case 112:
1807 return jjMoveStringLiteralDfa3_0(active0, 0L, active1, 0x100L);
1808 case 114:
1809 if ((active0 & 0x1000000000000000L) != 0L)
1810 return jjStartNfaWithStates_0(2, 60, 10);
1811 break;
1812 case 115:
1813 return jjMoveStringLiteralDfa3_0(active0, 0x200000000000000L, active1, 0x4008L);
1814 case 116:
1815 if ((active0 & 0x10000000000000L) != 0L)
1816 return jjStartNfaWithStates_0(2, 52, 10);
1817 return jjMoveStringLiteralDfa3_0(active0, 0L, active1, 0x10040L);
1818 case 121:
1819 if ((active0 & 0x2000000000000000L) != 0L)
1820 return jjStartNfaWithStates_0(2, 61, 10);
1821 break;
1822 default :
1823 break;
1824 }
1825 return jjStartNfa_0(1, active0, active1);
1826 }
1827 private int jjMoveStringLiteralDfa3_0(long old0, long active0, long old1, long active1)
1828 {
1829 if (((active0 &= old0) | (active1 &= old1)) == 0L)
1830 return jjStartNfa_0(1, old0, old1);
1831 try { curChar = input_stream.readChar(); }
1832 catch(java.io.IOException e) {
1833 jjStopStringLiteralDfa_0(2, active0, active1);
1834 return 3;
1835 }
1836 switch(curChar)
1837 {
1838 case 97:
1839 return jjMoveStringLiteralDfa4_0(active0, 0L, active1, 0x12L);
1840 case 98:
1841 return jjMoveStringLiteralDfa4_0(active0, 0x80000000000000L, active1, 0x1000L);
1842 case 99:
1843 if ((active1 & 0x2000L) != 0L)
1844 return jjStartNfaWithStates_0(3, 77, 10);
1845 break;
1846 case 101:
1847 if ((active0 & 0x200000000000000L) != 0L)
1848 return jjStartNfaWithStates_0(3, 57, 10);
1849 return jjMoveStringLiteralDfa4_0(active0, 0x4000000000000000L, active1, 0x4000L);
1850 case 102:
1851 if ((active0 & 0x400000000000000L) != 0L)
1852 return jjStartNfaWithStates_0(3, 58, 10);
1853 break;
1854 case 104:
1855 if ((active1 & 0x10000L) != 0L)
1856 return jjStartNfaWithStates_0(3, 80, 10);
1857 break;
1858 case 108:
1859 return jjMoveStringLiteralDfa4_0(active0, 0x800000000000000L, active1, 0x80L);
1860 case 109:
1861 if ((active1 & 0x200L) != 0L)
1862 return jjStartNfaWithStates_0(3, 73, 10);
1863 break;
1864 case 110:
1865 return jjMoveStringLiteralDfa4_0(active0, 0L, active1, 0x4L);
1866 case 111:
1867 return jjMoveStringLiteralDfa4_0(active0, 0L, active1, 0x100L);
1868 case 115:
1869 if ((active1 & 0x8L) != 0L)
1870 return jjStartNfaWithStates_0(3, 67, 10);
1871 return jjMoveStringLiteralDfa4_0(active0, 0L, active1, 0x801L);
1872 case 116:
1873 return jjMoveStringLiteralDfa4_0(active0, 0L, active1, 0x20L);
1874 case 117:
1875 return jjMoveStringLiteralDfa4_0(active0, 0L, active1, 0x40L);
1876 default :
1877 break;
1878 }
1879 return jjStartNfa_0(2, active0, active1);
1880 }
1881 private int jjMoveStringLiteralDfa4_0(long old0, long active0, long old1, long active1)
1882 {
1883 if (((active0 &= old0) | (active1 &= old1)) == 0L)
1884 return jjStartNfa_0(2, old0, old1);
1885 try { curChar = input_stream.readChar(); }
1886 catch(java.io.IOException e) {
1887 jjStopStringLiteralDfa_0(3, active0, active1);
1888 return 4;
1889 }
1890 switch(curChar)
1891 {
1892 case 97:
1893 return jjMoveStringLiteralDfa5_0(active0, 0L, active1, 0x1000L);
1894 case 100:
1895 if ((active1 & 0x80L) != 0L)
1896 return jjStartNfaWithStates_0(4, 71, 10);
1897 return jjMoveStringLiteralDfa5_0(active0, 0x80000000000000L, active1, 0L);
1898 case 101:
1899 if ((active0 & 0x800000000000000L) != 0L)
1900 return jjStartNfaWithStates_0(4, 59, 10);
1901 else if ((active1 & 0x800L) != 0L)
1902 return jjStartNfaWithStates_0(4, 75, 10);
1903 break;
1904 case 105:
1905 return jjMoveStringLiteralDfa5_0(active0, 0L, active1, 0x20L);
1906 case 107:
1907 if ((active1 & 0x10L) != 0L)
1908 return jjStartNfaWithStates_0(4, 68, 10);
1909 break;
1910 case 108:
1911 return jjMoveStringLiteralDfa5_0(active0, 0L, active1, 0x2L);
1912 case 112:
1913 return jjMoveStringLiteralDfa5_0(active0, 0x4000000000000000L, active1, 0L);
1914 case 114:
1915 return jjMoveStringLiteralDfa5_0(active0, 0L, active1, 0x4140L);
1916 case 115:
1917 if ((active1 & 0x1L) != 0L)
1918 return jjStartNfaWithStates_0(4, 64, 10);
1919 break;
1920 case 116:
1921 if ((active1 & 0x4L) != 0L)
1922 return jjStartNfaWithStates_0(4, 66, 10);
1923 break;
1924 default :
1925 break;
1926 }
1927 return jjStartNfa_0(3, active0, active1);
1928 }
1929 private int jjMoveStringLiteralDfa5_0(long old0, long active0, long old1, long active1)
1930 {
1931 if (((active0 &= old0) | (active1 &= old1)) == 0L)
1932 return jjStartNfa_0(3, old0, old1);
1933 try { curChar = input_stream.readChar(); }
1934 catch(java.io.IOException e) {
1935 jjStopStringLiteralDfa_0(4, active0, active1);
1936 return 5;
1937 }
1938 switch(curChar)
1939 {
1940 case 97:
1941 if ((active0 & 0x80000000000000L) != 0L)
1942 return jjStartNfaWithStates_0(5, 55, 10);
1943 break;
1944 case 108:
1945 if ((active1 & 0x1000L) != 0L)
1946 return jjStartNfaWithStates_0(5, 76, 10);
1947 return jjMoveStringLiteralDfa6_0(active0, 0L, active1, 0x2L);
1948 case 110:
1949 if ((active1 & 0x40L) != 0L)
1950 return jjStartNfaWithStates_0(5, 70, 10);
1951 return jjMoveStringLiteralDfa6_0(active0, 0L, active1, 0x20L);
1952 case 116:
1953 if ((active0 & 0x4000000000000000L) != 0L)
1954 return jjStartNfaWithStates_0(5, 62, 10);
1955 else if ((active1 & 0x100L) != 0L)
1956 return jjStartNfaWithStates_0(5, 72, 10);
1957 else if ((active1 & 0x4000L) != 0L)
1958 return jjStartNfaWithStates_0(5, 78, 10);
1959 break;
1960 default :
1961 break;
1962 }
1963 return jjStartNfa_0(4, active0, active1);
1964 }
1965 private int jjMoveStringLiteralDfa6_0(long old0, long active0, long old1, long active1)
1966 {
1967 if (((active0 &= old0) | (active1 &= old1)) == 0L)
1968 return jjStartNfa_0(4, old0, old1);
1969 try { curChar = input_stream.readChar(); }
1970 catch(java.io.IOException e) {
1971 jjStopStringLiteralDfa_0(5, 0L, active1);
1972 return 6;
1973 }
1974 switch(curChar)
1975 {
1976 case 117:
1977 return jjMoveStringLiteralDfa7_0(active1, 0x20L);
1978 case 121:
1979 if ((active1 & 0x2L) != 0L)
1980 return jjStartNfaWithStates_0(6, 65, 10);
1981 break;
1982 default :
1983 break;
1984 }
1985 return jjStartNfa_0(5, 0L, active1);
1986 }
1987 private int jjMoveStringLiteralDfa7_0(long old1, long active1)
1988 {
1989 if (((active1 &= old1)) == 0L)
1990 return jjStartNfa_0(5, 0L, old1);
1991 try { curChar = input_stream.readChar(); }
1992 catch(java.io.IOException e) {
1993 jjStopStringLiteralDfa_0(6, 0L, active1);
1994 return 7;
1995 }
1996 switch(curChar)
1997 {
1998 case 101:
1999 if ((active1 & 0x20L) != 0L)
2000 return jjStartNfaWithStates_0(7, 69, 10);
2001 break;
2002 default :
2003 break;
2004 }
2005 return jjStartNfa_0(6, 0L, active1);
2006 }
2007 private int jjStartNfaWithStates_0(int pos, int kind, int state)
2008 {
2009 jjmatchedKind = kind;
2010 jjmatchedPos = pos;
2011 try { curChar = input_stream.readChar(); }
2012 catch(java.io.IOException e) { return pos + 1; }
2013 return jjMoveNfa_0(state, pos + 1);
2014 }
2015 private int jjMoveNfa_0(int startState, int curPos)
2016 {
2017 int startsAt = 0;
2018 jjnewStateCnt = 95;
2019 int i = 1;
2020 jjstateSet[0] = startState;
2021 int kind = 0x7fffffff;
2022 for (;;)
2023 {
2024 if (++jjround == 0x7fffffff)
2025 ReInitRounds();
2026 if (curChar < 64)
2027 {
2028 long l = 1L << curChar;
2029 do
2030 {
2031 switch(jjstateSet[--i])
2032 {
2033 case 0:
2034 if ((0x3ff000000000000L & l) != 0L)
2035 jjCheckNAddStates(2, 9);
2036 else if ((0x2400L & l) != 0L)
2037 {
2038 if (kind > 5)
2039 kind = 5;
2040 }
2041 else if (curChar == 46)
2042 jjCheckNAddTwoStates(39, 43);
2043 else if (curChar == 34)
2044 jjstateSet[jjnewStateCnt++] = 17;
2045 else if (curChar == 39)
2046 jjstateSet[jjnewStateCnt++] = 14;
2047 else if (curChar == 35)
2048 {
2049 if (kind > 6)
2050 kind = 6;
2051 jjCheckNAdd(8);
2052 }
2053 if ((0x3fe000000000000L & l) != 0L)
2054 {
2055 if (kind > 84)
2056 kind = 84;
2057 jjCheckNAddStates(10, 14);
2058 }
2059 else if (curChar == 48)
2060 {
2061 if (kind > 84)
2062 kind = 84;
2063 jjCheckNAddStates(15, 24);
2064 }
2065 else if (curChar == 34)
2066 {
2067 if (kind > 101)
2068 kind = 101;
2069 }
2070 else if (curChar == 39)
2071 {
2072 if (kind > 100)
2073 kind = 100;
2074 }
2075 else if (curChar == 13)
2076 jjstateSet[jjnewStateCnt++] = 4;
2077 break;
2078 case 97:
2079 if ((0x3ff000000000000L & l) != 0L)
2080 {
2081 if (kind > 82)
2082 kind = 82;
2083 jjCheckNAdd(10);
2084 }
2085 else if (curChar == 34)
2086 jjstateSet[jjnewStateCnt++] = 71;
2087 else if (curChar == 39)
2088 jjstateSet[jjnewStateCnt++] = 67;
2089 if (curChar == 34)
2090 {
2091 if (kind > 97)
2092 kind = 97;
2093 }
2094 else if (curChar == 39)
2095 {
2096 if (kind > 96)
2097 kind = 96;
2098 }
2099 break;
2100 case 96:
2101 if ((0x3ff000000000000L & l) != 0L)
2102 jjCheckNAddStates(25, 27);
2103 if ((0x3ff000000000000L & l) != 0L)
2104 {
2105 if (kind > 88)
2106 kind = 88;
2107 jjCheckNAddTwoStates(39, 40);
2108 }
2109 break;
2110 case 61:
2111 if ((0x3ff000000000000L & l) != 0L)
2112 {
2113 if (kind > 82)
2114 kind = 82;
2115 jjCheckNAdd(10);
2116 }
2117 else if (curChar == 34)
2118 jjstateSet[jjnewStateCnt++] = 71;
2119 else if (curChar == 39)
2120 jjstateSet[jjnewStateCnt++] = 67;
2121 if (curChar == 34)
2122 {
2123 if (kind > 97)
2124 kind = 97;
2125 }
2126 else if (curChar == 39)
2127 {
2128 if (kind > 96)
2129 kind = 96;
2130 }
2131 break;
2132 case 95:
2133 if ((0x3ff000000000000L & l) != 0L)
2134 {
2135 if (kind > 82)
2136 kind = 82;
2137 jjCheckNAdd(10);
2138 }
2139 else if (curChar == 34)
2140 jjstateSet[jjnewStateCnt++] = 17;
2141 else if (curChar == 39)
2142 jjstateSet[jjnewStateCnt++] = 14;
2143 if (curChar == 34)
2144 {
2145 if (kind > 101)
2146 kind = 101;
2147 }
2148 else if (curChar == 39)
2149 {
2150 if (kind > 100)
2151 kind = 100;
2152 }
2153 break;
2154 case 1:
2155 if (curChar == 10 && kind > 4)
2156 kind = 4;
2157 break;
2158 case 2:
2159 if (curChar == 13)
2160 jjstateSet[jjnewStateCnt++] = 1;
2161 break;
2162 case 3:
2163 if ((0x2400L & l) != 0L && kind > 4)
2164 kind = 4;
2165 break;
2166 case 4:
2167 if (curChar == 10 && kind > 5)
2168 kind = 5;
2169 break;
2170 case 5:
2171 if (curChar == 13)
2172 jjstateSet[jjnewStateCnt++] = 4;
2173 break;
2174 case 6:
2175 if ((0x2400L & l) != 0L && kind > 5)
2176 kind = 5;
2177 break;
2178 case 7:
2179 if (curChar != 35)
2180 break;
2181 if (kind > 6)
2182 kind = 6;
2183 jjCheckNAdd(8);
2184 break;
2185 case 8:
2186 if ((0xffffffffffffdbffL & l) == 0L)
2187 break;
2188 if (kind > 6)
2189 kind = 6;
2190 jjCheckNAdd(8);
2191 break;
2192 case 10:
2193 if ((0x3ff000000000000L & l) == 0L)
2194 break;
2195 if (kind > 82)
2196 kind = 82;
2197 jjCheckNAdd(10);
2198 break;
2199 case 11:
2200 if (curChar == 39 && kind > 100)
2201 kind = 100;
2202 break;
2203 case 12:
2204 if (curChar == 34 && kind > 101)
2205 kind = 101;
2206 break;
2207 case 13:
2208 if (curChar == 39 && kind > 102)
2209 kind = 102;
2210 break;
2211 case 14:
2212 if (curChar == 39)
2213 jjstateSet[jjnewStateCnt++] = 13;
2214 break;
2215 case 15:
2216 if (curChar == 39)
2217 jjstateSet[jjnewStateCnt++] = 14;
2218 break;
2219 case 16:
2220 if (curChar == 34 && kind > 103)
2221 kind = 103;
2222 break;
2223 case 17:
2224 if (curChar == 34)
2225 jjstateSet[jjnewStateCnt++] = 16;
2226 break;
2227 case 18:
2228 if (curChar == 34)
2229 jjstateSet[jjnewStateCnt++] = 17;
2230 break;
2231 case 19:
2232 if ((0x3fe000000000000L & l) == 0L)
2233 break;
2234 if (kind > 84)
2235 kind = 84;
2236 jjCheckNAddStates(10, 14);
2237 break;
2238 case 20:
2239 if ((0x3ff000000000000L & l) == 0L)
2240 break;
2241 if (kind > 84)
2242 kind = 84;
2243 jjCheckNAddTwoStates(20, 21);
2244 break;
2245 case 22:
2246 if ((0x3ff000000000000L & l) != 0L)
2247 jjCheckNAddStates(28, 30);
2248 break;
2249 case 25:
2250 if (curChar != 48)
2251 break;
2252 if (kind > 84)
2253 kind = 84;
2254 jjCheckNAddStates(15, 24);
2255 break;
2256 case 27:
2257 if ((0x3ff000000000000L & l) == 0L)
2258 break;
2259 if (kind > 85)
2260 kind = 85;
2261 jjAddStates(31, 32);
2262 break;
2263 case 30:
2264 if ((0xff000000000000L & l) == 0L)
2265 break;
2266 if (kind > 86)
2267 kind = 86;
2268 jjCheckNAddTwoStates(30, 31);
2269 break;
2270 case 33:
2271 if ((0x3000000000000L & l) == 0L)
2272 break;
2273 if (kind > 87)
2274 kind = 87;
2275 jjCheckNAddTwoStates(33, 34);
2276 break;
2277 case 35:
2278 if ((0x3fe000000000000L & l) != 0L)
2279 jjCheckNAddStates(33, 35);
2280 break;
2281 case 36:
2282 if ((0x3ff000000000000L & l) != 0L)
2283 jjCheckNAddStates(33, 35);
2284 break;
2285 case 37:
2286 if (curChar == 48)
2287 jjCheckNAdd(24);
2288 break;
2289 case 38:
2290 if (curChar == 46)
2291 jjCheckNAddTwoStates(39, 43);
2292 break;
2293 case 39:
2294 if ((0x3ff000000000000L & l) == 0L)
2295 break;
2296 if (kind > 88)
2297 kind = 88;
2298 jjCheckNAddTwoStates(39, 40);
2299 break;
2300 case 41:
2301 if ((0x280000000000L & l) != 0L)
2302 jjCheckNAdd(42);
2303 break;
2304 case 42:
2305 if ((0x3ff000000000000L & l) == 0L)
2306 break;
2307 if (kind > 88)
2308 kind = 88;
2309 jjCheckNAdd(42);
2310 break;
2311 case 43:
2312 if ((0x3ff000000000000L & l) != 0L)
2313 jjCheckNAddStates(25, 27);
2314 break;
2315 case 45:
2316 if ((0x280000000000L & l) != 0L)
2317 jjCheckNAdd(46);
2318 break;
2319 case 46:
2320 if ((0x3ff000000000000L & l) != 0L)
2321 jjCheckNAddTwoStates(46, 24);
2322 break;
2323 case 49:
2324 if (curChar == 39 && kind > 92)
2325 kind = 92;
2326 break;
2327 case 51:
2328 if (curChar == 34 && kind > 93)
2329 kind = 93;
2330 break;
2331 case 53:
2332 if (curChar == 39 && kind > 94)
2333 kind = 94;
2334 break;
2335 case 54:
2336 if (curChar == 39)
2337 jjstateSet[jjnewStateCnt++] = 53;
2338 break;
2339 case 55:
2340 if (curChar == 39)
2341 jjstateSet[jjnewStateCnt++] = 54;
2342 break;
2343 case 57:
2344 if (curChar == 34 && kind > 95)
2345 kind = 95;
2346 break;
2347 case 58:
2348 if (curChar == 34)
2349 jjstateSet[jjnewStateCnt++] = 57;
2350 break;
2351 case 59:
2352 if (curChar == 34)
2353 jjstateSet[jjnewStateCnt++] = 58;
2354 break;
2355 case 62:
2356 if (curChar == 39 && kind > 96)
2357 kind = 96;
2358 break;
2359 case 64:
2360 if (curChar == 34 && kind > 97)
2361 kind = 97;
2362 break;
2363 case 66:
2364 if (curChar == 39 && kind > 98)
2365 kind = 98;
2366 break;
2367 case 67:
2368 if (curChar == 39)
2369 jjstateSet[jjnewStateCnt++] = 66;
2370 break;
2371 case 68:
2372 if (curChar == 39)
2373 jjstateSet[jjnewStateCnt++] = 67;
2374 break;
2375 case 70:
2376 if (curChar == 34 && kind > 99)
2377 kind = 99;
2378 break;
2379 case 71:
2380 if (curChar == 34)
2381 jjstateSet[jjnewStateCnt++] = 70;
2382 break;
2383 case 72:
2384 if (curChar == 34)
2385 jjstateSet[jjnewStateCnt++] = 71;
2386 break;
2387 case 74:
2388 if ((0x3ff000000000000L & l) != 0L)
2389 jjCheckNAddStates(2, 9);
2390 break;
2391 case 75:
2392 if ((0x3ff000000000000L & l) != 0L)
2393 jjCheckNAddTwoStates(75, 76);
2394 break;
2395 case 76:
2396 if (curChar != 46)
2397 break;
2398 if (kind > 88)
2399 kind = 88;
2400 jjCheckNAddTwoStates(77, 78);
2401 break;
2402 case 77:
2403 if ((0x3ff000000000000L & l) == 0L)
2404 break;
2405 if (kind > 88)
2406 kind = 88;
2407 jjCheckNAddTwoStates(77, 78);
2408 break;
2409 case 79:
2410 if ((0x280000000000L & l) != 0L)
2411 jjCheckNAdd(80);
2412 break;
2413 case 80:
2414 if ((0x3ff000000000000L & l) == 0L)
2415 break;
2416 if (kind > 88)
2417 kind = 88;
2418 jjCheckNAdd(80);
2419 break;
2420 case 81:
2421 if ((0x3ff000000000000L & l) != 0L)
2422 jjCheckNAddTwoStates(81, 82);
2423 break;
2424 case 83:
2425 if ((0x280000000000L & l) != 0L)
2426 jjCheckNAdd(84);
2427 break;
2428 case 84:
2429 if ((0x3ff000000000000L & l) == 0L)
2430 break;
2431 if (kind > 88)
2432 kind = 88;
2433 jjCheckNAdd(84);
2434 break;
2435 case 85:
2436 if ((0x3ff000000000000L & l) != 0L)
2437 jjCheckNAddTwoStates(85, 86);
2438 break;
2439 case 87:
2440 if ((0x280000000000L & l) != 0L)
2441 jjCheckNAdd(88);
2442 break;
2443 case 88:
2444 if ((0x3ff000000000000L & l) != 0L)
2445 jjCheckNAddTwoStates(88, 24);
2446 break;
2447 case 89:
2448 if ((0x3ff000000000000L & l) != 0L)
2449 jjCheckNAddTwoStates(89, 90);
2450 break;
2451 case 90:
2452 if (curChar == 46)
2453 jjCheckNAddStates(36, 38);
2454 break;
2455 case 91:
2456 if ((0x3ff000000000000L & l) != 0L)
2457 jjCheckNAddStates(36, 38);
2458 break;
2459 case 93:
2460 if ((0x280000000000L & l) != 0L)
2461 jjCheckNAdd(94);
2462 break;
2463 case 94:
2464 if ((0x3ff000000000000L & l) != 0L)
2465 jjCheckNAddTwoStates(94, 24);
2466 break;
2467 default : break;
2468 }
2469 } while(i != startsAt);
2470 }
2471 else if (curChar < 128)
2472 {
2473 long l = 1L << (curChar & 077);
2474 do
2475 {
2476 switch(jjstateSet[--i])
2477 {
2478 case 0:
2479 if ((0x7fffffe87fffffeL & l) != 0L)
2480 {
2481 if (kind > 82)
2482 kind = 82;
2483 jjCheckNAdd(10);
2484 }
2485 else if (curChar == 92)
2486 jjAddStates(0, 1);
2487 if ((0x4000000040000L & l) != 0L)
2488 jjAddStates(39, 42);
2489 else if ((0x400000004L & l) != 0L)
2490 jjCheckNAddStates(43, 50);
2491 else if ((0x20000000200000L & l) != 0L)
2492 jjCheckNAddStates(51, 58);
2493 break;
2494 case 97:
2495 case 10:
2496 if ((0x7fffffe87fffffeL & l) == 0L)
2497 break;
2498 if (kind > 82)
2499 kind = 82;
2500 jjCheckNAdd(10);
2501 break;
2502 case 61:
2503 if ((0x7fffffe87fffffeL & l) != 0L)
2504 {
2505 if (kind > 82)
2506 kind = 82;
2507 jjCheckNAdd(10);
2508 }
2509 if ((0x4000000040000L & l) != 0L)
2510 jjCheckNAdd(72);
2511 if ((0x4000000040000L & l) != 0L)
2512 jjCheckNAdd(68);
2513 if ((0x4000000040000L & l) != 0L)
2514 jjCheckNAdd(64);
2515 if ((0x4000000040000L & l) != 0L)
2516 jjCheckNAdd(62);
2517 break;
2518 case 95:
2519 if ((0x7fffffe87fffffeL & l) == 0L)
2520 break;
2521 if (kind > 82)
2522 kind = 82;
2523 jjCheckNAdd(10);
2524 break;
2525 case 8:
2526 if (kind > 6)
2527 kind = 6;
2528 jjstateSet[jjnewStateCnt++] = 8;
2529 break;
2530 case 9:
2531 if ((0x7fffffe87fffffeL & l) == 0L)
2532 break;
2533 if (kind > 82)
2534 kind = 82;
2535 jjCheckNAdd(10);
2536 break;
2537 case 21:
2538 if ((0x100000001000L & l) != 0L && kind > 84)
2539 kind = 84;
2540 break;
2541 case 23:
2542 if ((0x100000001000L & l) != 0L)
2543 jjstateSet[jjnewStateCnt++] = 24;
2544 break;
2545 case 24:
2546 if ((0x40000000400L & l) != 0L && kind > 89)
2547 kind = 89;
2548 break;
2549 case 26:
2550 if ((0x100000001000000L & l) != 0L)
2551 jjCheckNAdd(27);
2552 break;
2553 case 27:
2554 if ((0x7e0000007eL & l) == 0L)
2555 break;
2556 if (kind > 85)
2557 kind = 85;
2558 jjCheckNAddTwoStates(27, 28);
2559 break;
2560 case 28:
2561 if ((0x100000001000L & l) != 0L && kind > 85)
2562 kind = 85;
2563 break;
2564 case 29:
2565 if ((0x800000008000L & l) == 0L)
2566 break;
2567 if (kind > 86)
2568 kind = 86;
2569 jjAddStates(59, 60);
2570 break;
2571 case 31:
2572 if ((0x100000001000L & l) != 0L && kind > 86)
2573 kind = 86;
2574 break;
2575 case 32:
2576 if ((0x400000004L & l) == 0L)
2577 break;
2578 if (kind > 87)
2579 kind = 87;
2580 jjAddStates(61, 62);
2581 break;
2582 case 34:
2583 if ((0x100000001000L & l) != 0L && kind > 87)
2584 kind = 87;
2585 break;
2586 case 40:
2587 if ((0x2000000020L & l) != 0L)
2588 jjAddStates(63, 64);
2589 break;
2590 case 44:
2591 if ((0x2000000020L & l) != 0L)
2592 jjAddStates(65, 66);
2593 break;
2594 case 47:
2595 if ((0x20000000200000L & l) != 0L)
2596 jjCheckNAddStates(51, 58);
2597 break;
2598 case 48:
2599 if ((0x4000000040000L & l) != 0L)
2600 jjCheckNAdd(49);
2601 break;
2602 case 50:
2603 if ((0x4000000040000L & l) != 0L)
2604 jjCheckNAdd(51);
2605 break;
2606 case 52:
2607 if ((0x4000000040000L & l) != 0L)
2608 jjCheckNAdd(55);
2609 break;
2610 case 56:
2611 if ((0x4000000040000L & l) != 0L)
2612 jjCheckNAdd(59);
2613 break;
2614 case 60:
2615 if ((0x400000004L & l) != 0L)
2616 jjCheckNAddStates(43, 50);
2617 break;
2618 case 63:
2619 if ((0x4000000040000L & l) != 0L)
2620 jjCheckNAdd(64);
2621 break;
2622 case 65:
2623 if ((0x4000000040000L & l) != 0L)
2624 jjCheckNAdd(68);
2625 break;
2626 case 69:
2627 if ((0x4000000040000L & l) != 0L)
2628 jjCheckNAdd(72);
2629 break;
2630 case 73:
2631 if ((0x4000000040000L & l) != 0L)
2632 jjAddStates(39, 42);
2633 break;
2634 case 78:
2635 if ((0x2000000020L & l) != 0L)
2636 jjAddStates(67, 68);
2637 break;
2638 case 82:
2639 if ((0x2000000020L & l) != 0L)
2640 jjAddStates(69, 70);
2641 break;
2642 case 86:
2643 if ((0x2000000020L & l) != 0L)
2644 jjAddStates(71, 72);
2645 break;
2646 case 92:
2647 if ((0x2000000020L & l) != 0L)
2648 jjAddStates(73, 74);
2649 break;
2650 default : break;
2651 }
2652 } while(i != startsAt);
2653 }
2654 else
2655 {
2656 int hiByte = (int)(curChar >> 8);
2657 int i1 = hiByte >> 6;
2658 long l1 = 1L << (hiByte & 077);
2659 int i2 = (curChar & 0xff) >> 6;
2660 long l2 = 1L << (curChar & 077);
2661 do
2662 {
2663 switch(jjstateSet[--i])
2664 {
2665 case 8:
2666 if (!jjCanMove_0(hiByte, i1, i2, l1, l2))
2667 break;
2668 if (kind > 6)
2669 kind = 6;
2670 jjstateSet[jjnewStateCnt++] = 8;
2671 break;
2672 default : break;
2673 }
2674 } while(i != startsAt);
2675 }
2676 if (kind != 0x7fffffff)
2677 {
2678 jjmatchedKind = kind;
2679 jjmatchedPos = curPos;
2680 kind = 0x7fffffff;
2681 }
2682 ++curPos;
2683 if ((i = jjnewStateCnt) == (startsAt = 95 - (jjnewStateCnt = startsAt)))
2684 return curPos;
2685 try { curChar = input_stream.readChar(); }
2686 catch(java.io.IOException e) { return curPos; }
2687 }
2688 }
2689 private final int jjStopStringLiteralDfa_8(int pos, long active0, long active1, long active2)
2690 {
2691 switch (pos)
2692 {
2693 case 0:
2694 if ((active1 & 0x800000000000L) != 0L)
2695 {
2696 jjmatchedKind = 139;
2697 return -1;
2698 }
2699 return -1;
2700 case 1:
2701 if ((active1 & 0x800000000000L) != 0L)
2702 {
2703 if (jjmatchedPos == 0)
2704 {
2705 jjmatchedKind = 139;
2706 jjmatchedPos = 0;
2707 }
2708 return -1;
2709 }
2710 return -1;
2711 default :
2712 return -1;
2713 }
2714 }
2715 private final int jjStartNfa_8(int pos, long active0, long active1, long active2)
2716 {
2717 return jjMoveNfa_8(jjStopStringLiteralDfa_8(pos, active0, active1, active2), pos + 1);
2718 }
2719 private int jjMoveStringLiteralDfa0_8()
2720 {
2721 switch(curChar)
2722 {
2723 case 10:
2724 return jjStopAtPos(0, 137);
2725 case 13:
2726 jjmatchedKind = 138;
2727 return jjMoveStringLiteralDfa1_8(0x0L, 0x100L);
2728 case 34:
2729 return jjMoveStringLiteralDfa1_8(0x800000000000L, 0x0L);
2730 default :
2731 return jjMoveNfa_8(0, 0);
2732 }
2733 }
2734 private int jjMoveStringLiteralDfa1_8(long active1, long active2)
2735 {
2736 try { curChar = input_stream.readChar(); }
2737 catch(java.io.IOException e) {
2738 jjStopStringLiteralDfa_8(0, 0L, active1, active2);
2739 return 1;
2740 }
2741 switch(curChar)
2742 {
2743 case 10:
2744 if ((active2 & 0x100L) != 0L)
2745 return jjStopAtPos(1, 136);
2746 break;
2747 case 34:
2748 return jjMoveStringLiteralDfa2_8(active1, 0x800000000000L, active2, 0L);
2749 default :
2750 break;
2751 }
2752 return jjStartNfa_8(0, 0L, active1, active2);
2753 }
2754 private int jjMoveStringLiteralDfa2_8(long old1, long active1, long old2, long active2)
2755 {
2756 if (((active1 &= old1) | (active2 &= old2)) == 0L)
2757 return jjStartNfa_8(0, 0L, old1, old2);
2758 try { curChar = input_stream.readChar(); }
2759 catch(java.io.IOException e) {
2760 jjStopStringLiteralDfa_8(1, 0L, active1, 0L);
2761 return 2;
2762 }
2763 switch(curChar)
2764 {
2765 case 34:
2766 if ((active1 & 0x800000000000L) != 0L)
2767 return jjStopAtPos(2, 111);
2768 break;
2769 default :
2770 break;
2771 }
2772 return jjStartNfa_8(1, 0L, active1, 0L);
2773 }
2774 private int jjMoveNfa_8(int startState, int curPos)
2775 {
2776 int startsAt = 0;
2777 jjnewStateCnt = 3;
2778 int i = 1;
2779 jjstateSet[0] = startState;
2780 int kind = 0x7fffffff;
2781 for (;;)
2782 {
2783 if (++jjround == 0x7fffffff)
2784 ReInitRounds();
2785 if (curChar < 64)
2786 {
2787 long l = 1L << curChar;
2788 do
2789 {
2790 switch(jjstateSet[--i])
2791 {
2792 case 0:
2793 if ((0xffffffffffffdbffL & l) != 0L && kind > 139)
2794 kind = 139;
2795 break;
2796 case 2:
2797 if ((0xffffffffffffdbffL & l) != 0L && kind > 140)
2798 kind = 140;
2799 break;
2800 default : break;
2801 }
2802 } while(i != startsAt);
2803 }
2804 else if (curChar < 128)
2805 {
2806 long l = 1L << (curChar & 077);
2807 do
2808 {
2809 switch(jjstateSet[--i])
2810 {
2811 case 0:
2812 if (kind > 139)
2813 kind = 139;
2814 if (curChar == 92)
2815 jjstateSet[jjnewStateCnt++] = 2;
2816 break;
2817 case 1:
2818 if (curChar == 92)
2819 jjstateSet[jjnewStateCnt++] = 2;
2820 break;
2821 case 2:
2822 if (kind > 140)
2823 kind = 140;
2824 break;
2825 default : break;
2826 }
2827 } while(i != startsAt);
2828 }
2829 else
2830 {
2831 int hiByte = (int)(curChar >> 8);
2832 int i1 = hiByte >> 6;
2833 long l1 = 1L << (hiByte & 077);
2834 int i2 = (curChar & 0xff) >> 6;
2835 long l2 = 1L << (curChar & 077);
2836 do
2837 {
2838 switch(jjstateSet[--i])
2839 {
2840 case 0:
2841 if (jjCanMove_0(hiByte, i1, i2, l1, l2) && kind > 139)
2842 kind = 139;
2843 break;
2844 case 2:
2845 if (jjCanMove_0(hiByte, i1, i2, l1, l2) && kind > 140)
2846 kind = 140;
2847 break;
2848 default : break;
2849 }
2850 } while(i != startsAt);
2851 }
2852 if (kind != 0x7fffffff)
2853 {
2854 jjmatchedKind = kind;
2855 jjmatchedPos = curPos;
2856 kind = 0x7fffffff;
2857 }
2858 ++curPos;
2859 if ((i = jjnewStateCnt) == (startsAt = 3 - (jjnewStateCnt = startsAt)))
2860 return curPos;
2861 try { curChar = input_stream.readChar(); }
2862 catch(java.io.IOException e) { return curPos; }
2863 }
2864 }
2865 private final int jjStopStringLiteralDfa_6(int pos, long active0, long active1)
2866 {
2867 switch (pos)
2868 {
2869 case 0:
2870 if ((active1 & 0x4000000000000000L) != 0L)
2871 {
2872 jjmatchedKind = 135;
2873 return 2;
2874 }
2875 return -1;
2876 case 1:
2877 if ((active1 & 0x4000000000000000L) != 0L)
2878 {
2879 jjmatchedKind = 127;
2880 jjmatchedPos = 1;
2881 return -1;
2882 }
2883 return -1;
2884 default :
2885 return -1;
2886 }
2887 }
2888 private final int jjStartNfa_6(int pos, long active0, long active1)
2889 {
2890 return jjMoveNfa_6(jjStopStringLiteralDfa_6(pos, active0, active1), pos + 1);
2891 }
2892 private int jjMoveStringLiteralDfa0_6()
2893 {
2894 switch(curChar)
2895 {
2896 case 34:
2897 return jjStopAtPos(0, 109);
2898 case 92:
2899 return jjMoveStringLiteralDfa1_6(0x4000000000000000L);
2900 default :
2901 return jjMoveNfa_6(0, 0);
2902 }
2903 }
2904 private int jjMoveStringLiteralDfa1_6(long active1)
2905 {
2906 try { curChar = input_stream.readChar(); }
2907 catch(java.io.IOException e) {
2908 jjStopStringLiteralDfa_6(0, 0L, active1);
2909 return 1;
2910 }
2911 switch(curChar)
2912 {
2913 case 13:
2914 return jjMoveStringLiteralDfa2_6(active1, 0x4000000000000000L);
2915 default :
2916 break;
2917 }
2918 return jjStartNfa_6(0, 0L, active1);
2919 }
2920 private int jjMoveStringLiteralDfa2_6(long old1, long active1)
2921 {
2922 if (((active1 &= old1)) == 0L)
2923 return jjStartNfa_6(0, 0L, old1);
2924 try { curChar = input_stream.readChar(); }
2925 catch(java.io.IOException e) {
2926 jjStopStringLiteralDfa_6(1, 0L, active1);
2927 return 2;
2928 }
2929 switch(curChar)
2930 {
2931 case 10:
2932 if ((active1 & 0x4000000000000000L) != 0L)
2933 return jjStopAtPos(2, 126);
2934 break;
2935 default :
2936 break;
2937 }
2938 return jjStartNfa_6(1, 0L, active1);
2939 }
2940 private int jjMoveNfa_6(int startState, int curPos)
2941 {
2942 int startsAt = 0;
2943 jjnewStateCnt = 4;
2944 int i = 1;
2945 jjstateSet[0] = startState;
2946 int kind = 0x7fffffff;
2947 for (;;)
2948 {
2949 if (++jjround == 0x7fffffff)
2950 ReInitRounds();
2951 if (curChar < 64)
2952 {
2953 long l = 1L << curChar;
2954 do
2955 {
2956 switch(jjstateSet[--i])
2957 {
2958 case 0:
2959 if ((0xffffffffffffdbffL & l) != 0L && kind > 135)
2960 kind = 135;
2961 break;
2962 case 2:
2963 if ((0x2400L & l) != 0L)
2964 {
2965 if (kind > 127)
2966 kind = 127;
2967 }
2968 else if (curChar == 34)
2969 {
2970 if (kind > 135)
2971 kind = 135;
2972 }
2973 break;
2974 case 3:
2975 if (curChar == 34 && kind > 135)
2976 kind = 135;
2977 break;
2978 default : break;
2979 }
2980 } while(i != startsAt);
2981 }
2982 else if (curChar < 128)
2983 {
2984 long l = 1L << (curChar & 077);
2985 do
2986 {
2987 switch(jjstateSet[--i])
2988 {
2989 case 0:
2990 if (kind > 135)
2991 kind = 135;
2992 if (curChar == 92)
2993 jjAddStates(0, 1);
2994 break;
2995 case 2:
2996 if (curChar == 92 && kind > 135)
2997 kind = 135;
2998 break;
2999 case 1:
3000 if (curChar == 92)
3001 jjAddStates(0, 1);
3002 break;
3003 default : break;
3004 }
3005 } while(i != startsAt);
3006 }
3007 else
3008 {
3009 int hiByte = (int)(curChar >> 8);
3010 int i1 = hiByte >> 6;
3011 long l1 = 1L << (hiByte & 077);
3012 int i2 = (curChar & 0xff) >> 6;
3013 long l2 = 1L << (curChar & 077);
3014 do
3015 {
3016 switch(jjstateSet[--i])
3017 {
3018 case 0:
3019 if (jjCanMove_0(hiByte, i1, i2, l1, l2) && kind > 135)
3020 kind = 135;
3021 break;
3022 default : break;
3023 }
3024 } while(i != startsAt);
3025 }
3026 if (kind != 0x7fffffff)
3027 {
3028 jjmatchedKind = kind;
3029 jjmatchedPos = curPos;
3030 kind = 0x7fffffff;
3031 }
3032 ++curPos;
3033 if ((i = jjnewStateCnt) == (startsAt = 4 - (jjnewStateCnt = startsAt)))
3034 return curPos;
3035 try { curChar = input_stream.readChar(); }
3036 catch(java.io.IOException e) { return curPos; }
3037 }
3038 }
3039 private final int jjStopStringLiteralDfa_3(int pos, long active0, long active1, long active2)
3040 {
3041 switch (pos)
3042 {
3043 case 0:
3044 if ((active1 & 0x40000000000L) != 0L)
3045 {
3046 jjmatchedKind = 139;
3047 return -1;
3048 }
3049 return -1;
3050 case 1:
3051 if ((active1 & 0x40000000000L) != 0L)
3052 {
3053 if (jjmatchedPos == 0)
3054 {
3055 jjmatchedKind = 139;
3056 jjmatchedPos = 0;
3057 }
3058 return -1;
3059 }
3060 return -1;
3061 default :
3062 return -1;
3063 }
3064 }
3065 private final int jjStartNfa_3(int pos, long active0, long active1, long active2)
3066 {
3067 return jjMoveNfa_3(jjStopStringLiteralDfa_3(pos, active0, active1, active2), pos + 1);
3068 }
3069 private int jjMoveStringLiteralDfa0_3()
3070 {
3071 switch(curChar)
3072 {
3073 case 10:
3074 return jjStopAtPos(0, 137);
3075 case 13:
3076 jjmatchedKind = 138;
3077 return jjMoveStringLiteralDfa1_3(0x0L, 0x100L);
3078 case 39:
3079 return jjMoveStringLiteralDfa1_3(0x40000000000L, 0x0L);
3080 default :
3081 return jjMoveNfa_3(0, 0);
3082 }
3083 }
3084 private int jjMoveStringLiteralDfa1_3(long active1, long active2)
3085 {
3086 try { curChar = input_stream.readChar(); }
3087 catch(java.io.IOException e) {
3088 jjStopStringLiteralDfa_3(0, 0L, active1, active2);
3089 return 1;
3090 }
3091 switch(curChar)
3092 {
3093 case 10:
3094 if ((active2 & 0x100L) != 0L)
3095 return jjStopAtPos(1, 136);
3096 break;
3097 case 39:
3098 return jjMoveStringLiteralDfa2_3(active1, 0x40000000000L, active2, 0L);
3099 default :
3100 break;
3101 }
3102 return jjStartNfa_3(0, 0L, active1, active2);
3103 }
3104 private int jjMoveStringLiteralDfa2_3(long old1, long active1, long old2, long active2)
3105 {
3106 if (((active1 &= old1) | (active2 &= old2)) == 0L)
3107 return jjStartNfa_3(0, 0L, old1, old2);
3108 try { curChar = input_stream.readChar(); }
3109 catch(java.io.IOException e) {
3110 jjStopStringLiteralDfa_3(1, 0L, active1, 0L);
3111 return 2;
3112 }
3113 switch(curChar)
3114 {
3115 case 39:
3116 if ((active1 & 0x40000000000L) != 0L)
3117 return jjStopAtPos(2, 106);
3118 break;
3119 default :
3120 break;
3121 }
3122 return jjStartNfa_3(1, 0L, active1, 0L);
3123 }
3124 private int jjMoveNfa_3(int startState, int curPos)
3125 {
3126 int startsAt = 0;
3127 jjnewStateCnt = 3;
3128 int i = 1;
3129 jjstateSet[0] = startState;
3130 int kind = 0x7fffffff;
3131 for (;;)
3132 {
3133 if (++jjround == 0x7fffffff)
3134 ReInitRounds();
3135 if (curChar < 64)
3136 {
3137 long l = 1L << curChar;
3138 do
3139 {
3140 switch(jjstateSet[--i])
3141 {
3142 case 0:
3143 if ((0xffffffffffffdbffL & l) != 0L && kind > 139)
3144 kind = 139;
3145 break;
3146 case 2:
3147 if ((0xffffffffffffdbffL & l) != 0L && kind > 140)
3148 kind = 140;
3149 break;
3150 default : break;
3151 }
3152 } while(i != startsAt);
3153 }
3154 else if (curChar < 128)
3155 {
3156 long l = 1L << (curChar & 077);
3157 do
3158 {
3159 switch(jjstateSet[--i])
3160 {
3161 case 0:
3162 if (kind > 139)
3163 kind = 139;
3164 if (curChar == 92)
3165 jjstateSet[jjnewStateCnt++] = 2;
3166 break;
3167 case 1:
3168 if (curChar == 92)
3169 jjstateSet[jjnewStateCnt++] = 2;
3170 break;
3171 case 2:
3172 if (kind > 140)
3173 kind = 140;
3174 break;
3175 default : break;
3176 }
3177 } while(i != startsAt);
3178 }
3179 else
3180 {
3181 int hiByte = (int)(curChar >> 8);
3182 int i1 = hiByte >> 6;
3183 long l1 = 1L << (hiByte & 077);
3184 int i2 = (curChar & 0xff) >> 6;
3185 long l2 = 1L << (curChar & 077);
3186 do
3187 {
3188 switch(jjstateSet[--i])
3189 {
3190 case 0:
3191 if (jjCanMove_0(hiByte, i1, i2, l1, l2) && kind > 139)
3192 kind = 139;
3193 break;
3194 case 2:
3195 if (jjCanMove_0(hiByte, i1, i2, l1, l2) && kind > 140)
3196 kind = 140;
3197 break;
3198 default : break;
3199 }
3200 } while(i != startsAt);
3201 }
3202 if (kind != 0x7fffffff)
3203 {
3204 jjmatchedKind = kind;
3205 jjmatchedPos = curPos;
3206 kind = 0x7fffffff;
3207 }
3208 ++curPos;
3209 if ((i = jjnewStateCnt) == (startsAt = 3 - (jjnewStateCnt = startsAt)))
3210 return curPos;
3211 try { curChar = input_stream.readChar(); }
3212 catch(java.io.IOException e) { return curPos; }
3213 }
3214 }
3215 private final int jjStopStringLiteralDfa_1(int pos, long active0, long active1)
3216 {
3217 switch (pos)
3218 {
3219 case 0:
3220 if ((active1 & 0x10000000000000L) != 0L)
3221 {
3222 jjmatchedKind = 134;
3223 return 2;
3224 }
3225 return -1;
3226 case 1:
3227 if ((active1 & 0x10000000000000L) != 0L)
3228 {
3229 jjmatchedKind = 117;
3230 jjmatchedPos = 1;
3231 return -1;
3232 }
3233 return -1;
3234 default :
3235 return -1;
3236 }
3237 }
3238 private final int jjStartNfa_1(int pos, long active0, long active1)
3239 {
3240 return jjMoveNfa_1(jjStopStringLiteralDfa_1(pos, active0, active1), pos + 1);
3241 }
3242 private int jjMoveStringLiteralDfa0_1()
3243 {
3244 switch(curChar)
3245 {
3246 case 39:
3247 return jjStopAtPos(0, 104);
3248 case 92:
3249 return jjMoveStringLiteralDfa1_1(0x10000000000000L);
3250 default :
3251 return jjMoveNfa_1(0, 0);
3252 }
3253 }
3254 private int jjMoveStringLiteralDfa1_1(long active1)
3255 {
3256 try { curChar = input_stream.readChar(); }
3257 catch(java.io.IOException e) {
3258 jjStopStringLiteralDfa_1(0, 0L, active1);
3259 return 1;
3260 }
3261 switch(curChar)
3262 {
3263 case 13:
3264 return jjMoveStringLiteralDfa2_1(active1, 0x10000000000000L);
3265 default :
3266 break;
3267 }
3268 return jjStartNfa_1(0, 0L, active1);
3269 }
3270 private int jjMoveStringLiteralDfa2_1(long old1, long active1)
3271 {
3272 if (((active1 &= old1)) == 0L)
3273 return jjStartNfa_1(0, 0L, old1);
3274 try { curChar = input_stream.readChar(); }
3275 catch(java.io.IOException e) {
3276 jjStopStringLiteralDfa_1(1, 0L, active1);
3277 return 2;
3278 }
3279 switch(curChar)
3280 {
3281 case 10:
3282 if ((active1 & 0x10000000000000L) != 0L)
3283 return jjStopAtPos(2, 116);
3284 break;
3285 default :
3286 break;
3287 }
3288 return jjStartNfa_1(1, 0L, active1);
3289 }
3290 private int jjMoveNfa_1(int startState, int curPos)
3291 {
3292 int startsAt = 0;
3293 jjnewStateCnt = 4;
3294 int i = 1;
3295 jjstateSet[0] = startState;
3296 int kind = 0x7fffffff;
3297 for (;;)
3298 {
3299 if (++jjround == 0x7fffffff)
3300 ReInitRounds();
3301 if (curChar < 64)
3302 {
3303 long l = 1L << curChar;
3304 do
3305 {
3306 switch(jjstateSet[--i])
3307 {
3308 case 0:
3309 if ((0xffffffffffffdbffL & l) != 0L && kind > 134)
3310 kind = 134;
3311 break;
3312 case 2:
3313 if ((0x2400L & l) != 0L)
3314 {
3315 if (kind > 117)
3316 kind = 117;
3317 }
3318 else if (curChar == 39)
3319 {
3320 if (kind > 134)
3321 kind = 134;
3322 }
3323 break;
3324 case 3:
3325 if (curChar == 39 && kind > 134)
3326 kind = 134;
3327 break;
3328 default : break;
3329 }
3330 } while(i != startsAt);
3331 }
3332 else if (curChar < 128)
3333 {
3334 long l = 1L << (curChar & 077);
3335 do
3336 {
3337 switch(jjstateSet[--i])
3338 {
3339 case 0:
3340 if (kind > 134)
3341 kind = 134;
3342 if (curChar == 92)
3343 jjAddStates(0, 1);
3344 break;
3345 case 2:
3346 if (curChar == 92 && kind > 134)
3347 kind = 134;
3348 break;
3349 case 1:
3350 if (curChar == 92)
3351 jjAddStates(0, 1);
3352 break;
3353 default : break;
3354 }
3355 } while(i != startsAt);
3356 }
3357 else
3358 {
3359 int hiByte = (int)(curChar >> 8);
3360 int i1 = hiByte >> 6;
3361 long l1 = 1L << (hiByte & 077);
3362 int i2 = (curChar & 0xff) >> 6;
3363 long l2 = 1L << (curChar & 077);
3364 do
3365 {
3366 switch(jjstateSet[--i])
3367 {
3368 case 0:
3369 if (jjCanMove_0(hiByte, i1, i2, l1, l2) && kind > 134)
3370 kind = 134;
3371 break;
3372 default : break;
3373 }
3374 } while(i != startsAt);
3375 }
3376 if (kind != 0x7fffffff)
3377 {
3378 jjmatchedKind = kind;
3379 jjmatchedPos = curPos;
3380 kind = 0x7fffffff;
3381 }
3382 ++curPos;
3383 if ((i = jjnewStateCnt) == (startsAt = 4 - (jjnewStateCnt = startsAt)))
3384 return curPos;
3385 try { curChar = input_stream.readChar(); }
3386 catch(java.io.IOException e) { return curPos; }
3387 }
3388 }
3389 static final int[] jjnextStates = {
3390 2, 3, 75, 76, 81, 82, 85, 86, 89, 90, 20, 21, 22, 23, 24, 26,
3391 29, 30, 31, 32, 33, 34, 35, 37, 24, 43, 44, 24, 22, 23, 24, 27,
3392 28, 36, 23, 24, 91, 92, 24, 11, 12, 15, 18, 61, 62, 63, 64, 65,
3393 68, 69, 72, 48, 49, 50, 51, 52, 55, 56, 59, 30, 31, 33, 34, 41,
3394 42, 45, 46, 79, 80, 83, 84, 87, 88, 93, 94,
3395 };
3396 private static final boolean jjCanMove_0(int hiByte, int i1, int i2, long l1, long l2)
3397 {
3398 switch(hiByte)
3399 {
3400 case 0:
3401 return ((jjbitVec2[i2] & l2) != 0L);
3402 default :
3403 if ((jjbitVec0[i1] & l1) != 0L)
3404 return true;
3405 return false;
3406 }
3407 }
3408
3409
3410 public static final String[] jjstrLiteralImages = {
3411 "", null, null, null, null, null, null, "\50", "\51", "\173", "\175", "\133",
3412 "\135", "\73", "\54", "\56", "\72", "\53", "\55", "\52", "\57", "\57\57", "\52\52",
3413 "\74\74", "\76\76", "\45", "\176", "\136", "\174", "\46", "\75", "\76", "\74", "\75\75",
3414 "\74\75", "\76\75", "\74\76", "\41\75", "\53\75", "\55\75", "\52\75", "\57\75",
3415 "\57\57\75", "\45\75", "\46\75", "\174\75", "\136\75", "\74\74\75", "\76\76\75",
3416 "\52\52\75", "\157\162", "\141\156\144", "\156\157\164", "\151\163", "\151\156",
3417 "\154\141\155\142\144\141", "\151\146", "\145\154\163\145", "\145\154\151\146", "\167\150\151\154\145",
3418 "\146\157\162", "\164\162\171", "\145\170\143\145\160\164", "\144\145\146",
3419 "\143\154\141\163\163", "\146\151\156\141\154\154\171", "\160\162\151\156\164", "\160\141\163\163",
3420 "\142\162\145\141\153", "\143\157\156\164\151\156\165\145", "\162\145\164\165\162\156",
3421 "\171\151\145\154\144", "\151\155\160\157\162\164", "\146\162\157\155", "\144\145\154",
3422 "\162\141\151\163\145", "\147\154\157\142\141\154", "\145\170\145\143", "\141\163\163\145\162\164",
3423 "\141\163", "\167\151\164\150", "\100", null, null, null, null, null, null, null, null,
3424 null, null, null, null, null, null, null, null, null, null, null, null, null, null,
3425 null, null, null, null, null, null, null, null, null, null, null, null, null, null,
3426 null, null, null, null, null, null, null, null, null, null, null, null, null, null,
3427 null, null, null, null, null, null, null, null, null, };
3428
3429
3430 public static final String[] lexStateNames = {
3431 "DEFAULT",
3432 "IN_STRING11",
3433 "IN_STRING21",
3434 "IN_STRING13",
3435 "IN_STRING23",
3436 "IN_BSTRING11",
3437 "IN_BSTRING21",
3438 "IN_BSTRING13",
3439 "IN_BSTRING23",
3440 "IN_USTRING11",
3441 "IN_USTRING21",
3442 "IN_USTRING13",
3443 "IN_USTRING23",
3444 "IN_STRING1NLC",
3445 "IN_STRING2NLC",
3446 "IN_USTRING1NLC",
3447 "IN_USTRING2NLC",
3448 "IN_BSTRING1NLC",
3449 "IN_BSTRING2NLC",
3450 };
3451
3452
3453 public static final int[] jjnewLexState = {
3454 -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,
3455 -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,
3456 -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,
3457 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 9, 10, 11, 12, 5, 6, 7, 8,
3458 1, 2, 3, 4, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 13, 13, 14, 14, 15, 15, 16, 16, 17,
3459 17, 18, 18, 1, 2, 9, 10, 5, 6, -1, -1, -1, -1, -1, -1, -1,
3460 };
3461 static final long[] jjtoToken = {
3462 0xffffffffffffff81L, 0xfff0003f7ffffL, 0x0L,
3463 };
3464 static final long[] jjtoSkip = {
3465 0x7eL, 0x0L, 0x0L,
3466 };
3467 static final long[] jjtoMore = {
3468 0x0L, 0xfff000fff0000000L, 0x1fffL,
3469 };
3470 protected CharStream input_stream;
3471 private final int[] jjrounds = new int[95];
3472 private final int[] jjstateSet = new int[190];
3473 private final StringBuilder jjimage = new StringBuilder();
3474 private StringBuilder image = jjimage;
3475 private int jjimageLen;
3476 private int lengthOfMatch;
3477 protected char curChar;
3478
3479 public PythonParserTokenManager(CharStream stream){
3480 input_stream = stream;
3481 }
3482
3483
3484 public PythonParserTokenManager(CharStream stream, int lexState){
3485 this(stream);
3486 SwitchTo(lexState);
3487 }
3488
3489
3490 public void ReInit(CharStream stream)
3491 {
3492 jjmatchedPos = jjnewStateCnt = 0;
3493 curLexState = defaultLexState;
3494 input_stream = stream;
3495 ReInitRounds();
3496 }
3497 private void ReInitRounds()
3498 {
3499 int i;
3500 jjround = 0x80000001;
3501 for (i = 95; i-- > 0;)
3502 jjrounds[i] = 0x80000000;
3503 }
3504
3505
3506 public void ReInit(CharStream stream, int lexState)
3507 {
3508 ReInit(stream);
3509 SwitchTo(lexState);
3510 }
3511
3512
3513 public void SwitchTo(int lexState)
3514 {
3515 if (lexState >= 19 || lexState < 0)
3516 throw new TokenMgrError("Error: Ignoring invalid lexical state : " + lexState + ". State unchanged.", TokenMgrError.INVALID_LEXICAL_STATE);
3517 else
3518 curLexState = lexState;
3519 }
3520
3521 protected Token jjFillToken()
3522 {
3523 final Token t;
3524 final String curTokenImage;
3525 final int beginLine;
3526 final int endLine;
3527 final int beginColumn;
3528 final int endColumn;
3529 if (jjmatchedPos < 0)
3530 {
3531 if (image == null)
3532 curTokenImage = "";
3533 else
3534 curTokenImage = image.toString();
3535 beginLine = endLine = input_stream.getBeginLine();
3536 beginColumn = endColumn = input_stream.getBeginColumn();
3537 }
3538 else
3539 {
3540 String im = jjstrLiteralImages[jjmatchedKind];
3541 curTokenImage = (im == null) ? input_stream.GetImage() : im;
3542 beginLine = input_stream.getBeginLine();
3543 beginColumn = input_stream.getBeginColumn();
3544 endLine = input_stream.getEndLine();
3545 endColumn = input_stream.getEndColumn();
3546 }
3547 t = Token.newToken(jjmatchedKind, curTokenImage);
3548
3549 t.beginLine = beginLine;
3550 t.endLine = endLine;
3551 t.beginColumn = beginColumn;
3552 t.endColumn = endColumn;
3553
3554 return t;
3555 }
3556
3557 int curLexState = 0;
3558 int defaultLexState = 0;
3559 int jjnewStateCnt;
3560 int jjround;
3561 int jjmatchedPos;
3562 int jjmatchedKind;
3563
3564
3565 public Token getNextToken()
3566 {
3567 Token matchedToken;
3568 int curPos = 0;
3569
3570 EOFLoop :
3571 for (;;)
3572 {
3573 try
3574 {
3575 curChar = input_stream.BeginToken();
3576 }
3577 catch(java.io.IOException e)
3578 {
3579 jjmatchedKind = 0;
3580 matchedToken = jjFillToken();
3581 return matchedToken;
3582 }
3583 image = jjimage;
3584 image.setLength(0);
3585 jjimageLen = 0;
3586
3587 for (;;)
3588 {
3589 switch(curLexState)
3590 {
3591 case 0:
3592 try { input_stream.backup(0);
3593 while (curChar <= 32 && (0x100001200L & (1L << curChar)) != 0L)
3594 curChar = input_stream.BeginToken();
3595 }
3596 catch (java.io.IOException e1) { continue EOFLoop; }
3597 jjmatchedKind = 0x7fffffff;
3598 jjmatchedPos = 0;
3599 curPos = jjMoveStringLiteralDfa0_0();
3600 break;
3601 case 1:
3602 jjmatchedKind = 0x7fffffff;
3603 jjmatchedPos = 0;
3604 curPos = jjMoveStringLiteralDfa0_1();
3605 break;
3606 case 2:
3607 jjmatchedKind = 0x7fffffff;
3608 jjmatchedPos = 0;
3609 curPos = jjMoveStringLiteralDfa0_2();
3610 break;
3611 case 3:
3612 jjmatchedKind = 0x7fffffff;
3613 jjmatchedPos = 0;
3614 curPos = jjMoveStringLiteralDfa0_3();
3615 break;
3616 case 4:
3617 jjmatchedKind = 0x7fffffff;
3618 jjmatchedPos = 0;
3619 curPos = jjMoveStringLiteralDfa0_4();
3620 break;
3621 case 5:
3622 jjmatchedKind = 0x7fffffff;
3623 jjmatchedPos = 0;
3624 curPos = jjMoveStringLiteralDfa0_5();
3625 break;
3626 case 6:
3627 jjmatchedKind = 0x7fffffff;
3628 jjmatchedPos = 0;
3629 curPos = jjMoveStringLiteralDfa0_6();
3630 break;
3631 case 7:
3632 jjmatchedKind = 0x7fffffff;
3633 jjmatchedPos = 0;
3634 curPos = jjMoveStringLiteralDfa0_7();
3635 break;
3636 case 8:
3637 jjmatchedKind = 0x7fffffff;
3638 jjmatchedPos = 0;
3639 curPos = jjMoveStringLiteralDfa0_8();
3640 break;
3641 case 9:
3642 jjmatchedKind = 0x7fffffff;
3643 jjmatchedPos = 0;
3644 curPos = jjMoveStringLiteralDfa0_9();
3645 break;
3646 case 10:
3647 jjmatchedKind = 0x7fffffff;
3648 jjmatchedPos = 0;
3649 curPos = jjMoveStringLiteralDfa0_10();
3650 break;
3651 case 11:
3652 jjmatchedKind = 0x7fffffff;
3653 jjmatchedPos = 0;
3654 curPos = jjMoveStringLiteralDfa0_11();
3655 break;
3656 case 12:
3657 jjmatchedKind = 0x7fffffff;
3658 jjmatchedPos = 0;
3659 curPos = jjMoveStringLiteralDfa0_12();
3660 break;
3661 case 13:
3662 jjmatchedKind = 128;
3663 jjmatchedPos = -1;
3664 curPos = 0;
3665 curPos = jjMoveStringLiteralDfa0_13();
3666 break;
3667 case 14:
3668 jjmatchedKind = 129;
3669 jjmatchedPos = -1;
3670 curPos = 0;
3671 curPos = jjMoveStringLiteralDfa0_14();
3672 break;
3673 case 15:
3674 jjmatchedKind = 130;
3675 jjmatchedPos = -1;
3676 curPos = 0;
3677 curPos = jjMoveStringLiteralDfa0_15();
3678 break;
3679 case 16:
3680 jjmatchedKind = 131;
3681 jjmatchedPos = -1;
3682 curPos = 0;
3683 curPos = jjMoveStringLiteralDfa0_16();
3684 break;
3685 case 17:
3686 jjmatchedKind = 132;
3687 jjmatchedPos = -1;
3688 curPos = 0;
3689 curPos = jjMoveStringLiteralDfa0_17();
3690 break;
3691 case 18:
3692 jjmatchedKind = 133;
3693 jjmatchedPos = -1;
3694 curPos = 0;
3695 curPos = jjMoveStringLiteralDfa0_18();
3696 break;
3697 }
3698 if (jjmatchedKind != 0x7fffffff)
3699 {
3700 if (jjmatchedPos + 1 < curPos)
3701 input_stream.backup(curPos - jjmatchedPos - 1);
3702 if ((jjtoToken[jjmatchedKind >> 6] & (1L << (jjmatchedKind & 077))) != 0L)
3703 {
3704 matchedToken = jjFillToken();
3705 TokenLexicalActions(matchedToken);
3706 if (jjnewLexState[jjmatchedKind] != -1)
3707 curLexState = jjnewLexState[jjmatchedKind];
3708 return matchedToken;
3709 }
3710 else if ((jjtoSkip[jjmatchedKind >> 6] & (1L << (jjmatchedKind & 077))) != 0L)
3711 {
3712 if (jjnewLexState[jjmatchedKind] != -1)
3713 curLexState = jjnewLexState[jjmatchedKind];
3714 continue EOFLoop;
3715 }
3716 MoreLexicalActions();
3717 if (jjnewLexState[jjmatchedKind] != -1)
3718 curLexState = jjnewLexState[jjmatchedKind];
3719 curPos = 0;
3720 jjmatchedKind = 0x7fffffff;
3721 try {
3722 curChar = input_stream.readChar();
3723 continue;
3724 }
3725 catch (java.io.IOException e1) { }
3726 }
3727 int error_line = input_stream.getEndLine();
3728 int error_column = input_stream.getEndColumn();
3729 String error_after = null;
3730 boolean EOFSeen = false;
3731 try { input_stream.readChar(); input_stream.backup(1); }
3732 catch (java.io.IOException e1) {
3733 EOFSeen = true;
3734 error_after = curPos <= 1 ? "" : input_stream.GetImage();
3735 if (curChar == '\n' || curChar == '\r') {
3736 error_line++;
3737 error_column = 0;
3738 }
3739 else
3740 error_column++;
3741 }
3742 if (!EOFSeen) {
3743 input_stream.backup(1);
3744 error_after = curPos <= 1 ? "" : input_stream.GetImage();
3745 }
3746 throw new TokenMgrError(EOFSeen, curLexState, error_line, error_column, error_after, curChar, TokenMgrError.LEXICAL_ERROR);
3747 }
3748 }
3749 }
3750
3751 void MoreLexicalActions()
3752 {
3753 jjimageLen += (lengthOfMatch = jjmatchedPos + 1);
3754 switch(jjmatchedKind)
3755 {
3756 case 116 :
3757 image.append(input_stream.GetSuffix(jjimageLen));
3758 jjimageLen = 0;
3759 image.setLength(image.length()-3);
3760 break;
3761 case 117 :
3762 image.append(input_stream.GetSuffix(jjimageLen));
3763 jjimageLen = 0;
3764 image.setLength(image.length()-2);
3765 break;
3766 case 118 :
3767 image.append(input_stream.GetSuffix(jjimageLen));
3768 jjimageLen = 0;
3769 image.setLength(image.length()-3);
3770 break;
3771 case 119 :
3772 image.append(input_stream.GetSuffix(jjimageLen));
3773 jjimageLen = 0;
3774 image.setLength(image.length()-2);
3775 break;
3776 case 120 :
3777 image.append(input_stream.GetSuffix(jjimageLen));
3778 jjimageLen = 0;
3779 image.setLength(image.length()-3);
3780 break;
3781 case 121 :
3782 image.append(input_stream.GetSuffix(jjimageLen));
3783 jjimageLen = 0;
3784 image.setLength(image.length()-2);
3785 break;
3786 case 122 :
3787 image.append(input_stream.GetSuffix(jjimageLen));
3788 jjimageLen = 0;
3789 image.setLength(image.length()-3);
3790 break;
3791 case 123 :
3792 image.append(input_stream.GetSuffix(jjimageLen));
3793 jjimageLen = 0;
3794 image.setLength(image.length()-2);
3795 break;
3796 case 124 :
3797 image.append(input_stream.GetSuffix(jjimageLen));
3798 jjimageLen = 0;
3799 image.setLength(image.length()-3);
3800 break;
3801 case 125 :
3802 image.append(input_stream.GetSuffix(jjimageLen));
3803 jjimageLen = 0;
3804 image.setLength(image.length()-2);
3805 break;
3806 case 126 :
3807 image.append(input_stream.GetSuffix(jjimageLen));
3808 jjimageLen = 0;
3809 image.setLength(image.length()-3);
3810 break;
3811 case 127 :
3812 image.append(input_stream.GetSuffix(jjimageLen));
3813 jjimageLen = 0;
3814 image.setLength(image.length()-2);
3815 break;
3816 case 136 :
3817 image.append(input_stream.GetSuffix(jjimageLen));
3818 jjimageLen = 0;
3819 int l = image.length();
3820 image.setLength(l-1);
3821 image.setCharAt(l-2, '\u005cn');
3822 break;
3823 case 138 :
3824 image.append(input_stream.GetSuffix(jjimageLen));
3825 jjimageLen = 0;
3826 image.setCharAt(image.length()-1, '\u005cn');
3827 break;
3828 default :
3829 break;
3830 }
3831 }
3832 void TokenLexicalActions(Token matchedToken)
3833 {
3834 switch(jjmatchedKind)
3835 {
3836 case 104 :
3837 image.append(input_stream.GetSuffix(jjimageLen + (lengthOfMatch = jjmatchedPos + 1)));
3838 matchedToken.image = image.toString();
3839 break;
3840 case 105 :
3841 image.append(input_stream.GetSuffix(jjimageLen + (lengthOfMatch = jjmatchedPos + 1)));
3842 matchedToken.image = image.toString();
3843 break;
3844 case 106 :
3845 image.append(input_stream.GetSuffix(jjimageLen + (lengthOfMatch = jjmatchedPos + 1)));
3846 matchedToken.image = image.toString();
3847 break;
3848 case 107 :
3849 image.append(input_stream.GetSuffix(jjimageLen + (lengthOfMatch = jjmatchedPos + 1)));
3850 matchedToken.image = image.toString();
3851 break;
3852 case 108 :
3853 image.append(input_stream.GetSuffix(jjimageLen + (lengthOfMatch = jjmatchedPos + 1)));
3854 matchedToken.image = image.toString();
3855 break;
3856 case 109 :
3857 image.append(input_stream.GetSuffix(jjimageLen + (lengthOfMatch = jjmatchedPos + 1)));
3858 matchedToken.image = image.toString();
3859 break;
3860 case 110 :
3861 image.append(input_stream.GetSuffix(jjimageLen + (lengthOfMatch = jjmatchedPos + 1)));
3862 matchedToken.image = image.toString();
3863 break;
3864 case 111 :
3865 image.append(input_stream.GetSuffix(jjimageLen + (lengthOfMatch = jjmatchedPos + 1)));
3866 matchedToken.image = image.toString();
3867 break;
3868 case 112 :
3869 image.append(input_stream.GetSuffix(jjimageLen + (lengthOfMatch = jjmatchedPos + 1)));
3870 matchedToken.image = image.toString();
3871 break;
3872 case 113 :
3873 image.append(input_stream.GetSuffix(jjimageLen + (lengthOfMatch = jjmatchedPos + 1)));
3874 matchedToken.image = image.toString();
3875 break;
3876 case 114 :
3877 image.append(input_stream.GetSuffix(jjimageLen + (lengthOfMatch = jjmatchedPos + 1)));
3878 matchedToken.image = image.toString();
3879 break;
3880 case 115 :
3881 image.append(input_stream.GetSuffix(jjimageLen + (lengthOfMatch = jjmatchedPos + 1)));
3882 matchedToken.image = image.toString();
3883 break;
3884 default :
3885 break;
3886 }
3887 }
3888 private void jjCheckNAdd(int state)
3889 {
3890 if (jjrounds[state] != jjround)
3891 {
3892 jjstateSet[jjnewStateCnt++] = state;
3893 jjrounds[state] = jjround;
3894 }
3895 }
3896 private void jjAddStates(int start, int end)
3897 {
3898 do {
3899 jjstateSet[jjnewStateCnt++] = jjnextStates[start];
3900 } while (start++ != end);
3901 }
3902 private void jjCheckNAddTwoStates(int state1, int state2)
3903 {
3904 jjCheckNAdd(state1);
3905 jjCheckNAdd(state2);
3906 }
3907
3908 private void jjCheckNAddStates(int start, int end)
3909 {
3910 do {
3911 jjCheckNAdd(jjnextStates[start]);
3912 } while (start++ != end);
3913 }
3914
3915 }