1
2 package net.sourceforge.pmd.lang.vm.ast;
3 import java.io.IOException;
4 import java.io.Reader;
5 import java.util.ArrayList;
6 import java.util.List;
7 import java.util.HashMap;
8 import java.util.Map;
9 import net.sourceforge.pmd.lang.ast.CharStream;
10 import net.sourceforge.pmd.lang.vm.directive.Directive;
11 import net.sourceforge.pmd.lang.vm.util.VelocityCharStream;
12 import net.sourceforge.pmd.lang.vm.util.DirectiveMapper;
13
14
15 public class VmParserTokenManager extends net.sourceforge.pmd.lang.ast.AbstractTokenManager implements VmParserConstants
16 {
17 private int fileDepth = 0;
18
19 private int lparen = 0;
20 private int rparen = 0;
21
22 List stateStack = new ArrayList(50);
23
24 public boolean debugPrint = false;
25
26 private boolean inReference;
27 public boolean inDirective;
28 private boolean inComment;
29 public boolean inSet;
30
31
32
33
34
35
36
37
38
39 public boolean stateStackPop()
40 {
41 ParserState s;
42 try
43 {
44 s = (ParserState) stateStack.remove(stateStack.size() - 1);
45 }
46 catch(IndexOutOfBoundsException e)
47 {
48
49 lparen=0;
50 SwitchTo(DEFAULT);
51 return false;
52 }
53
54 if( debugPrint )
55 System.out.println(
56 " stack pop (" + stateStack.size() + ") : lparen=" +
57 s.lparen +
58 " newstate=" + s.lexstate );
59
60 lparen = s.lparen;
61 rparen = s.rparen;
62
63 SwitchTo(s.lexstate);
64
65 return true;
66 }
67
68
69
70
71
72
73 public boolean stateStackPush()
74 {
75 if( debugPrint )
76 System.out.println(" (" + stateStack.size() + ") pushing cur state : " +
77 curLexState );
78
79 ParserState s = new ParserState();
80 s.lparen = lparen;
81 s.rparen = rparen;
82 s.lexstate = curLexState;
83
84 lparen = 0;
85 stateStack.add(s);
86
87 return true;
88 }
89
90
91
92
93
94
95 public void clearStateVars()
96 {
97 stateStack.clear();
98
99 lparen = 0;
100 rparen = 0;
101 inReference = false;
102 inDirective = false;
103 inComment = false;
104 inSet = false;
105
106 return;
107 }
108
109
110
111
112 private static class ParserState
113 {
114 int lparen;
115 int rparen;
116 int lexstate;
117 }
118
119
120
121
122 private void RPARENHandler()
123 {
124
125
126
127
128
129
130 boolean closed = false;
131
132 if (inComment)
133 closed = true;
134
135 while( !closed )
136 {
137
138
139
140
141
142
143 if( lparen > 0)
144 {
145
146
147
148
149
150 if( lparen == rparen + 1)
151 {
152 stateStackPop();
153 }
154 else
155 {
156 rparen++;
157 }
158
159 closed = true;
160 }
161 else
162 {
163
164
165
166
167 if(!stateStackPop())
168 break;
169 }
170 }
171 }
172
173
174 public java.io.PrintStream debugStream = System.out;
175
176 public void setDebugStream(java.io.PrintStream ds) { debugStream = ds; }
177 private final int jjStopStringLiteralDfa_3(int pos, long active0)
178 {
179 switch (pos)
180 {
181 case 0:
182 if ((active0 & 0x2000000000L) != 0L)
183 return 105;
184 if ((active0 & 0x200L) != 0L)
185 return 69;
186 if ((active0 & 0xc00000080L) != 0L)
187 {
188 jjmatchedKind = 63;
189 return 67;
190 }
191 if ((active0 & 0x40L) != 0L)
192 return 62;
193 if ((active0 & 0x8000000000000L) != 0L)
194 return 54;
195 if ((active0 & 0x740000L) != 0L)
196 return 7;
197 return -1;
198 case 1:
199 if ((active0 & 0x80L) != 0L)
200 return 67;
201 if ((active0 & 0x100000L) != 0L)
202 return 5;
203 if ((active0 & 0xc00000000L) != 0L)
204 {
205 jjmatchedKind = 63;
206 jjmatchedPos = 1;
207 return 67;
208 }
209 return -1;
210 case 2:
211 if ((active0 & 0xc00000000L) != 0L)
212 {
213 jjmatchedKind = 63;
214 jjmatchedPos = 2;
215 return 67;
216 }
217 return -1;
218 case 3:
219 if ((active0 & 0x400000000L) != 0L)
220 return 67;
221 if ((active0 & 0x800000000L) != 0L)
222 {
223 jjmatchedKind = 63;
224 jjmatchedPos = 3;
225 return 67;
226 }
227 return -1;
228 default :
229 return -1;
230 }
231 }
232 private final int jjStartNfa_3(int pos, long active0)
233 {
234 return jjMoveNfa_3(jjStopStringLiteralDfa_3(pos, active0), pos + 1);
235 }
236 private int jjStopAtPos(int pos, int kind)
237 {
238 jjmatchedKind = kind;
239 jjmatchedPos = pos;
240 return pos + 1;
241 }
242 private int jjMoveStringLiteralDfa0_3()
243 {
244 switch(curChar)
245 {
246 case 35:
247 jjmatchedKind = 21;
248 return jjMoveStringLiteralDfa1_3(0x540000L);
249 case 37:
250 return jjStopAtPos(0, 41);
251 case 40:
252 return jjStopAtPos(0, 11);
253 case 42:
254 return jjStopAtPos(0, 39);
255 case 43:
256 return jjStopAtPos(0, 38);
257 case 44:
258 return jjStopAtPos(0, 5);
259 case 45:
260 return jjStartNfaWithStates_3(0, 37, 105);
261 case 46:
262 return jjMoveStringLiteralDfa1_3(0x40L);
263 case 47:
264 return jjStopAtPos(0, 40);
265 case 58:
266 return jjStopAtPos(0, 8);
267 case 61:
268 return jjStartNfaWithStates_3(0, 51, 54);
269 case 91:
270 return jjStopAtPos(0, 3);
271 case 93:
272 return jjStopAtPos(0, 4);
273 case 70:
274 case 102:
275 return jjMoveStringLiteralDfa1_3(0x800000000L);
276 case 73:
277 case 105:
278 return jjMoveStringLiteralDfa1_3(0x80L);
279 case 84:
280 case 116:
281 return jjMoveStringLiteralDfa1_3(0x400000000L);
282 case 123:
283 return jjStartNfaWithStates_3(0, 9, 69);
284 case 125:
285 return jjStopAtPos(0, 10);
286 default :
287 return jjMoveNfa_3(0, 0);
288 }
289 }
290 private int jjMoveStringLiteralDfa1_3(long active0)
291 {
292 try { curChar = input_stream.readChar(); }
293 catch(java.io.IOException e) {
294 jjStopStringLiteralDfa_3(0, active0);
295 return 1;
296 }
297 switch(curChar)
298 {
299 case 35:
300 if ((active0 & 0x400000L) != 0L)
301 return jjStopAtPos(1, 22);
302 break;
303 case 42:
304 if ((active0 & 0x100000L) != 0L)
305 return jjStartNfaWithStates_3(1, 20, 5);
306 break;
307 case 46:
308 if ((active0 & 0x40L) != 0L)
309 return jjStopAtPos(1, 6);
310 break;
311 case 91:
312 return jjMoveStringLiteralDfa2_3(active0, 0x40000L);
313 case 65:
314 case 97:
315 return jjMoveStringLiteralDfa2_3(active0, 0x800000000L);
316 case 78:
317 case 110:
318 if ((active0 & 0x80L) != 0L)
319 return jjStartNfaWithStates_3(1, 7, 67);
320 break;
321 case 82:
322 case 114:
323 return jjMoveStringLiteralDfa2_3(active0, 0x400000000L);
324 default :
325 break;
326 }
327 return jjStartNfa_3(0, active0);
328 }
329 private int jjMoveStringLiteralDfa2_3(long old0, long active0)
330 {
331 if (((active0 &= old0)) == 0L)
332 return jjStartNfa_3(0, old0);
333 try { curChar = input_stream.readChar(); }
334 catch(java.io.IOException e) {
335 jjStopStringLiteralDfa_3(1, active0);
336 return 2;
337 }
338 switch(curChar)
339 {
340 case 91:
341 if ((active0 & 0x40000L) != 0L)
342 return jjStopAtPos(2, 18);
343 break;
344 case 76:
345 case 108:
346 return jjMoveStringLiteralDfa3_3(active0, 0x800000000L);
347 case 85:
348 case 117:
349 return jjMoveStringLiteralDfa3_3(active0, 0x400000000L);
350 default :
351 break;
352 }
353 return jjStartNfa_3(1, active0);
354 }
355 private int jjMoveStringLiteralDfa3_3(long old0, long active0)
356 {
357 if (((active0 &= old0)) == 0L)
358 return jjStartNfa_3(1, old0);
359 try { curChar = input_stream.readChar(); }
360 catch(java.io.IOException e) {
361 jjStopStringLiteralDfa_3(2, active0);
362 return 3;
363 }
364 switch(curChar)
365 {
366 case 69:
367 case 101:
368 if ((active0 & 0x400000000L) != 0L)
369 return jjStartNfaWithStates_3(3, 34, 67);
370 break;
371 case 83:
372 case 115:
373 return jjMoveStringLiteralDfa4_3(active0, 0x800000000L);
374 default :
375 break;
376 }
377 return jjStartNfa_3(2, active0);
378 }
379 private int jjMoveStringLiteralDfa4_3(long old0, long active0)
380 {
381 if (((active0 &= old0)) == 0L)
382 return jjStartNfa_3(2, old0);
383 try { curChar = input_stream.readChar(); }
384 catch(java.io.IOException e) {
385 jjStopStringLiteralDfa_3(3, active0);
386 return 4;
387 }
388 switch(curChar)
389 {
390 case 69:
391 case 101:
392 if ((active0 & 0x800000000L) != 0L)
393 return jjStartNfaWithStates_3(4, 35, 67);
394 break;
395 default :
396 break;
397 }
398 return jjStartNfa_3(3, active0);
399 }
400 private int jjStartNfaWithStates_3(int pos, int kind, int state)
401 {
402 jjmatchedKind = kind;
403 jjmatchedPos = pos;
404 try { curChar = input_stream.readChar(); }
405 catch(java.io.IOException e) { return pos + 1; }
406 return jjMoveNfa_3(state, pos + 1);
407 }
408 static final long[] jjbitVec0 = {
409 0xfffffffffffffffeL, 0xffffffffffffffffL, 0xffffffffffffffffL, 0xffffffffffffffffL
410 };
411 static final long[] jjbitVec2 = {
412 0x0L, 0x0L, 0xffffffffffffffffL, 0xffffffffffffffffL
413 };
414 private int jjMoveNfa_3(int startState, int curPos)
415 {
416 int startsAt = 0;
417 jjnewStateCnt = 105;
418 int i = 1;
419 jjstateSet[0] = startState;
420 int kind = 0x7fffffff;
421 for (;;)
422 {
423 if (++jjround == 0x7fffffff)
424 ReInitRounds();
425 if (curChar < 64)
426 {
427 long l = 1L << curChar;
428 do
429 {
430 switch(jjstateSet[--i])
431 {
432 case 105:
433 if ((0x3ff000000000000L & l) != 0L)
434 jjCheckNAddTwoStates(100, 101);
435 else if (curChar == 46)
436 jjCheckNAdd(62);
437 if ((0x3ff000000000000L & l) != 0L)
438 jjCheckNAddTwoStates(94, 95);
439 if ((0x3ff000000000000L & l) != 0L)
440 {
441 if (kind > 58)
442 kind = 58;
443 jjCheckNAddTwoStates(91, 93);
444 }
445 break;
446 case 0:
447 if ((0x3ff000000000000L & l) != 0L)
448 {
449 if (kind > 58)
450 kind = 58;
451 jjCheckNAddStates(0, 5);
452 }
453 else if ((0x100002600L & l) != 0L)
454 {
455 if (kind > 32)
456 kind = 32;
457 jjCheckNAdd(9);
458 }
459 else if (curChar == 45)
460 jjCheckNAddStates(6, 9);
461 else if (curChar == 36)
462 {
463 if (kind > 16)
464 kind = 16;
465 jjCheckNAddTwoStates(77, 78);
466 }
467 else if (curChar == 46)
468 jjCheckNAdd(62);
469 else if (curChar == 33)
470 {
471 if (kind > 50)
472 kind = 50;
473 }
474 else if (curChar == 61)
475 jjstateSet[jjnewStateCnt++] = 54;
476 else if (curChar == 62)
477 jjstateSet[jjnewStateCnt++] = 52;
478 else if (curChar == 60)
479 jjstateSet[jjnewStateCnt++] = 49;
480 else if (curChar == 38)
481 jjstateSet[jjnewStateCnt++] = 39;
482 else if (curChar == 39)
483 jjCheckNAddStates(10, 13);
484 else if (curChar == 34)
485 jjCheckNAddStates(14, 17);
486 else if (curChar == 35)
487 jjstateSet[jjnewStateCnt++] = 7;
488 else if (curChar == 41)
489 {
490 if (kind > 12)
491 kind = 12;
492 jjCheckNAddStates(18, 20);
493 }
494 if ((0x2400L & l) != 0L)
495 {
496 if (kind > 36)
497 kind = 36;
498 }
499 else if (curChar == 33)
500 jjstateSet[jjnewStateCnt++] = 58;
501 else if (curChar == 62)
502 {
503 if (kind > 46)
504 kind = 46;
505 }
506 else if (curChar == 60)
507 {
508 if (kind > 44)
509 kind = 44;
510 }
511 if (curChar == 13)
512 jjstateSet[jjnewStateCnt++] = 37;
513 break;
514 case 1:
515 if ((0x100000200L & l) != 0L)
516 jjCheckNAddStates(18, 20);
517 break;
518 case 2:
519 if ((0x2400L & l) != 0L && kind > 12)
520 kind = 12;
521 break;
522 case 3:
523 if (curChar == 10 && kind > 12)
524 kind = 12;
525 break;
526 case 4:
527 if (curChar == 13)
528 jjstateSet[jjnewStateCnt++] = 3;
529 break;
530 case 5:
531 if (curChar == 42)
532 jjstateSet[jjnewStateCnt++] = 6;
533 break;
534 case 6:
535 if ((0xfffffff7ffffffffL & l) != 0L && kind > 19)
536 kind = 19;
537 break;
538 case 7:
539 if (curChar == 42)
540 jjstateSet[jjnewStateCnt++] = 5;
541 break;
542 case 8:
543 if (curChar == 35)
544 jjstateSet[jjnewStateCnt++] = 7;
545 break;
546 case 9:
547 if ((0x100002600L & l) == 0L)
548 break;
549 if (kind > 32)
550 kind = 32;
551 jjCheckNAdd(9);
552 break;
553 case 10:
554 case 12:
555 if (curChar == 34)
556 jjCheckNAddStates(14, 17);
557 break;
558 case 11:
559 if ((0xfffffffbffffffffL & l) != 0L)
560 jjCheckNAddStates(14, 17);
561 break;
562 case 13:
563 if (curChar == 34)
564 jjstateSet[jjnewStateCnt++] = 12;
565 break;
566 case 14:
567 if (curChar == 34 && kind > 33)
568 kind = 33;
569 break;
570 case 17:
571 if ((0xff000000000000L & l) != 0L)
572 jjCheckNAddStates(21, 25);
573 break;
574 case 18:
575 if ((0xff000000000000L & l) != 0L)
576 jjCheckNAddStates(14, 17);
577 break;
578 case 19:
579 if ((0xf000000000000L & l) != 0L)
580 jjstateSet[jjnewStateCnt++] = 20;
581 break;
582 case 20:
583 if ((0xff000000000000L & l) != 0L)
584 jjCheckNAdd(18);
585 break;
586 case 22:
587 if ((0x3ff000000000000L & l) != 0L)
588 jjstateSet[jjnewStateCnt++] = 23;
589 break;
590 case 23:
591 if ((0x3ff000000000000L & l) != 0L)
592 jjstateSet[jjnewStateCnt++] = 24;
593 break;
594 case 24:
595 if ((0x3ff000000000000L & l) != 0L)
596 jjstateSet[jjnewStateCnt++] = 25;
597 break;
598 case 25:
599 if ((0x3ff000000000000L & l) != 0L)
600 jjCheckNAddStates(14, 17);
601 break;
602 case 26:
603 if (curChar == 32)
604 jjAddStates(26, 27);
605 break;
606 case 27:
607 if (curChar == 10)
608 jjCheckNAddStates(14, 17);
609 break;
610 case 28:
611 case 30:
612 if (curChar == 39)
613 jjCheckNAddStates(10, 13);
614 break;
615 case 29:
616 if ((0xffffff7fffffffffL & l) != 0L)
617 jjCheckNAddStates(10, 13);
618 break;
619 case 31:
620 if (curChar == 39)
621 jjstateSet[jjnewStateCnt++] = 30;
622 break;
623 case 33:
624 if (curChar == 32)
625 jjAddStates(28, 29);
626 break;
627 case 34:
628 if (curChar == 10)
629 jjCheckNAddStates(10, 13);
630 break;
631 case 35:
632 if (curChar == 39 && kind > 33)
633 kind = 33;
634 break;
635 case 36:
636 if ((0x2400L & l) != 0L && kind > 36)
637 kind = 36;
638 break;
639 case 37:
640 if (curChar == 10 && kind > 36)
641 kind = 36;
642 break;
643 case 38:
644 if (curChar == 13)
645 jjstateSet[jjnewStateCnt++] = 37;
646 break;
647 case 39:
648 if (curChar == 38 && kind > 42)
649 kind = 42;
650 break;
651 case 40:
652 if (curChar == 38)
653 jjstateSet[jjnewStateCnt++] = 39;
654 break;
655 case 48:
656 if (curChar == 60 && kind > 44)
657 kind = 44;
658 break;
659 case 49:
660 if (curChar == 61 && kind > 45)
661 kind = 45;
662 break;
663 case 50:
664 if (curChar == 60)
665 jjstateSet[jjnewStateCnt++] = 49;
666 break;
667 case 51:
668 if (curChar == 62 && kind > 46)
669 kind = 46;
670 break;
671 case 52:
672 if (curChar == 61 && kind > 47)
673 kind = 47;
674 break;
675 case 53:
676 if (curChar == 62)
677 jjstateSet[jjnewStateCnt++] = 52;
678 break;
679 case 54:
680 if (curChar == 61 && kind > 48)
681 kind = 48;
682 break;
683 case 55:
684 if (curChar == 61)
685 jjstateSet[jjnewStateCnt++] = 54;
686 break;
687 case 58:
688 if (curChar == 61 && kind > 49)
689 kind = 49;
690 break;
691 case 59:
692 if (curChar == 33)
693 jjstateSet[jjnewStateCnt++] = 58;
694 break;
695 case 60:
696 if (curChar == 33 && kind > 50)
697 kind = 50;
698 break;
699 case 61:
700 if (curChar == 46)
701 jjCheckNAdd(62);
702 break;
703 case 62:
704 if ((0x3ff000000000000L & l) == 0L)
705 break;
706 if (kind > 59)
707 kind = 59;
708 jjCheckNAddTwoStates(62, 63);
709 break;
710 case 64:
711 if ((0x280000000000L & l) != 0L)
712 jjCheckNAdd(65);
713 break;
714 case 65:
715 if ((0x3ff000000000000L & l) == 0L)
716 break;
717 if (kind > 59)
718 kind = 59;
719 jjCheckNAdd(65);
720 break;
721 case 67:
722 if ((0x3ff000000000000L & l) == 0L)
723 break;
724 if (kind > 63)
725 kind = 63;
726 jjstateSet[jjnewStateCnt++] = 67;
727 break;
728 case 70:
729 if ((0x3ff000000000000L & l) != 0L)
730 jjAddStates(30, 31);
731 break;
732 case 74:
733 if (curChar == 36 && kind > 16)
734 kind = 16;
735 break;
736 case 76:
737 if (curChar == 36)
738 jjCheckNAddTwoStates(77, 78);
739 break;
740 case 78:
741 if (curChar == 33 && kind > 17)
742 kind = 17;
743 break;
744 case 79:
745 if (curChar != 36)
746 break;
747 if (kind > 16)
748 kind = 16;
749 jjCheckNAddTwoStates(77, 78);
750 break;
751 case 90:
752 if (curChar == 45)
753 jjCheckNAddStates(6, 9);
754 break;
755 case 91:
756 if ((0x3ff000000000000L & l) == 0L)
757 break;
758 if (kind > 58)
759 kind = 58;
760 jjCheckNAddTwoStates(91, 93);
761 break;
762 case 92:
763 if (curChar == 46 && kind > 58)
764 kind = 58;
765 break;
766 case 93:
767 if (curChar == 46)
768 jjstateSet[jjnewStateCnt++] = 92;
769 break;
770 case 94:
771 if ((0x3ff000000000000L & l) != 0L)
772 jjCheckNAddTwoStates(94, 95);
773 break;
774 case 95:
775 if (curChar != 46)
776 break;
777 if (kind > 59)
778 kind = 59;
779 jjCheckNAddTwoStates(96, 97);
780 break;
781 case 96:
782 if ((0x3ff000000000000L & l) == 0L)
783 break;
784 if (kind > 59)
785 kind = 59;
786 jjCheckNAddTwoStates(96, 97);
787 break;
788 case 98:
789 if ((0x280000000000L & l) != 0L)
790 jjCheckNAdd(99);
791 break;
792 case 99:
793 if ((0x3ff000000000000L & l) == 0L)
794 break;
795 if (kind > 59)
796 kind = 59;
797 jjCheckNAdd(99);
798 break;
799 case 100:
800 if ((0x3ff000000000000L & l) != 0L)
801 jjCheckNAddTwoStates(100, 101);
802 break;
803 case 102:
804 if ((0x280000000000L & l) != 0L)
805 jjCheckNAdd(103);
806 break;
807 case 103:
808 if ((0x3ff000000000000L & l) == 0L)
809 break;
810 if (kind > 59)
811 kind = 59;
812 jjCheckNAdd(103);
813 break;
814 case 104:
815 if ((0x3ff000000000000L & l) == 0L)
816 break;
817 if (kind > 58)
818 kind = 58;
819 jjCheckNAddStates(0, 5);
820 break;
821 default : break;
822 }
823 } while(i != startsAt);
824 }
825 else if (curChar < 128)
826 {
827 long l = 1L << (curChar & 077);
828 do
829 {
830 switch(jjstateSet[--i])
831 {
832 case 0:
833 if ((0x7fffffe87ffffffL & l) != 0L)
834 {
835 if (kind > 63)
836 kind = 63;
837 jjCheckNAdd(67);
838 }
839 else if (curChar == 92)
840 jjCheckNAddStates(32, 35);
841 else if (curChar == 123)
842 jjstateSet[jjnewStateCnt++] = 69;
843 else if (curChar == 124)
844 jjstateSet[jjnewStateCnt++] = 44;
845 if ((0x400000004000L & l) != 0L)
846 jjAddStates(36, 37);
847 else if ((0x8000000080L & l) != 0L)
848 jjAddStates(38, 39);
849 else if ((0x100000001000L & l) != 0L)
850 jjAddStates(40, 41);
851 else if ((0x2000000020L & l) != 0L)
852 jjstateSet[jjnewStateCnt++] = 56;
853 else if ((0x800000008000L & l) != 0L)
854 jjstateSet[jjnewStateCnt++] = 46;
855 else if ((0x200000002L & l) != 0L)
856 jjstateSet[jjnewStateCnt++] = 42;
857 break;
858 case 6:
859 if (kind > 19)
860 kind = 19;
861 break;
862 case 11:
863 jjCheckNAddStates(14, 17);
864 break;
865 case 15:
866 if (curChar == 92)
867 jjAddStates(42, 47);
868 break;
869 case 16:
870 if ((0x14404400144044L & l) != 0L)
871 jjCheckNAddStates(14, 17);
872 break;
873 case 21:
874 if ((0x20000000200000L & l) != 0L)
875 jjstateSet[jjnewStateCnt++] = 22;
876 break;
877 case 22:
878 if ((0x7e0000007eL & l) != 0L)
879 jjstateSet[jjnewStateCnt++] = 23;
880 break;
881 case 23:
882 if ((0x7e0000007eL & l) != 0L)
883 jjstateSet[jjnewStateCnt++] = 24;
884 break;
885 case 24:
886 if ((0x7e0000007eL & l) != 0L)
887 jjstateSet[jjnewStateCnt++] = 25;
888 break;
889 case 25:
890 if ((0x7e0000007eL & l) != 0L)
891 jjCheckNAddStates(14, 17);
892 break;
893 case 29:
894 jjAddStates(10, 13);
895 break;
896 case 32:
897 if (curChar == 92)
898 jjAddStates(28, 29);
899 break;
900 case 41:
901 if ((0x1000000010L & l) != 0L && kind > 42)
902 kind = 42;
903 break;
904 case 42:
905 if ((0x400000004000L & l) != 0L)
906 jjstateSet[jjnewStateCnt++] = 41;
907 break;
908 case 43:
909 if ((0x200000002L & l) != 0L)
910 jjstateSet[jjnewStateCnt++] = 42;
911 break;
912 case 44:
913 if (curChar == 124 && kind > 43)
914 kind = 43;
915 break;
916 case 45:
917 if (curChar == 124)
918 jjstateSet[jjnewStateCnt++] = 44;
919 break;
920 case 46:
921 if ((0x4000000040000L & l) != 0L && kind > 43)
922 kind = 43;
923 break;
924 case 47:
925 if ((0x800000008000L & l) != 0L)
926 jjstateSet[jjnewStateCnt++] = 46;
927 break;
928 case 56:
929 if ((0x2000000020000L & l) != 0L && kind > 48)
930 kind = 48;
931 break;
932 case 57:
933 if ((0x2000000020L & l) != 0L)
934 jjstateSet[jjnewStateCnt++] = 56;
935 break;
936 case 63:
937 if ((0x2000000020L & l) != 0L)
938 jjAddStates(48, 49);
939 break;
940 case 66:
941 case 67:
942 if ((0x7fffffe87ffffffL & l) == 0L)
943 break;
944 if (kind > 63)
945 kind = 63;
946 jjCheckNAdd(67);
947 break;
948 case 68:
949 if (curChar == 123)
950 jjstateSet[jjnewStateCnt++] = 69;
951 break;
952 case 69:
953 if ((0x7fffffe87fffffeL & l) != 0L)
954 jjCheckNAddTwoStates(70, 71);
955 break;
956 case 70:
957 if ((0x7fffffe87ffffffL & l) != 0L)
958 jjCheckNAddTwoStates(70, 71);
959 break;
960 case 71:
961 if (curChar == 125 && kind > 64)
962 kind = 64;
963 break;
964 case 72:
965 if (curChar == 92)
966 jjCheckNAddStates(32, 35);
967 break;
968 case 73:
969 if (curChar == 92)
970 jjCheckNAddTwoStates(73, 74);
971 break;
972 case 75:
973 if (curChar == 92)
974 jjCheckNAddTwoStates(75, 76);
975 break;
976 case 77:
977 if (curChar == 92)
978 jjAddStates(50, 51);
979 break;
980 case 80:
981 if ((0x100000001000L & l) != 0L)
982 jjAddStates(40, 41);
983 break;
984 case 81:
985 if ((0x10000000100000L & l) != 0L && kind > 44)
986 kind = 44;
987 break;
988 case 82:
989 if ((0x2000000020L & l) != 0L && kind > 45)
990 kind = 45;
991 break;
992 case 83:
993 if ((0x8000000080L & l) != 0L)
994 jjAddStates(38, 39);
995 break;
996 case 84:
997 if ((0x10000000100000L & l) != 0L && kind > 46)
998 kind = 46;
999 break;
1000 case 85:
1001 if ((0x2000000020L & l) != 0L && kind > 47)
1002 kind = 47;
1003 break;
1004 case 86:
1005 if ((0x400000004000L & l) != 0L)
1006 jjAddStates(36, 37);
1007 break;
1008 case 87:
1009 if ((0x2000000020L & l) != 0L && kind > 49)
1010 kind = 49;
1011 break;
1012 case 88:
1013 if ((0x10000000100000L & l) != 0L && kind > 50)
1014 kind = 50;
1015 break;
1016 case 89:
1017 if ((0x800000008000L & l) != 0L)
1018 jjstateSet[jjnewStateCnt++] = 88;
1019 break;
1020 case 97:
1021 if ((0x2000000020L & l) != 0L)
1022 jjAddStates(52, 53);
1023 break;
1024 case 101:
1025 if ((0x2000000020L & l) != 0L)
1026 jjAddStates(54, 55);
1027 break;
1028 default : break;
1029 }
1030 } while(i != startsAt);
1031 }
1032 else
1033 {
1034 int hiByte = (int)(curChar >> 8);
1035 int i1 = hiByte >> 6;
1036 long l1 = 1L << (hiByte & 077);
1037 int i2 = (curChar & 0xff) >> 6;
1038 long l2 = 1L << (curChar & 077);
1039 do
1040 {
1041 switch(jjstateSet[--i])
1042 {
1043 case 6:
1044 if (jjCanMove_0(hiByte, i1, i2, l1, l2) && kind > 19)
1045 kind = 19;
1046 break;
1047 case 11:
1048 if (jjCanMove_0(hiByte, i1, i2, l1, l2))
1049 jjAddStates(14, 17);
1050 break;
1051 case 29:
1052 if (jjCanMove_0(hiByte, i1, i2, l1, l2))
1053 jjAddStates(10, 13);
1054 break;
1055 default : break;
1056 }
1057 } while(i != startsAt);
1058 }
1059 if (kind != 0x7fffffff)
1060 {
1061 jjmatchedKind = kind;
1062 jjmatchedPos = curPos;
1063 kind = 0x7fffffff;
1064 }
1065 ++curPos;
1066 if ((i = jjnewStateCnt) == (startsAt = 105 - (jjnewStateCnt = startsAt)))
1067 return curPos;
1068 try { curChar = input_stream.readChar(); }
1069 catch(java.io.IOException e) { return curPos; }
1070 }
1071 }
1072 private final int jjStopStringLiteralDfa_11(int pos, long active0)
1073 {
1074 switch (pos)
1075 {
1076 case 0:
1077 if ((active0 & 0x740000L) != 0L)
1078 return 2;
1079 return -1;
1080 case 1:
1081 if ((active0 & 0x100000L) != 0L)
1082 return 0;
1083 return -1;
1084 default :
1085 return -1;
1086 }
1087 }
1088 private final int jjStartNfa_11(int pos, long active0)
1089 {
1090 return jjMoveNfa_11(jjStopStringLiteralDfa_11(pos, active0), pos + 1);
1091 }
1092 private int jjMoveStringLiteralDfa0_11()
1093 {
1094 switch(curChar)
1095 {
1096 case 35:
1097 jjmatchedKind = 21;
1098 return jjMoveStringLiteralDfa1_11(0x540000L);
1099 default :
1100 return jjMoveNfa_11(3, 0);
1101 }
1102 }
1103 private int jjMoveStringLiteralDfa1_11(long active0)
1104 {
1105 try { curChar = input_stream.readChar(); }
1106 catch(java.io.IOException e) {
1107 jjStopStringLiteralDfa_11(0, active0);
1108 return 1;
1109 }
1110 switch(curChar)
1111 {
1112 case 35:
1113 if ((active0 & 0x400000L) != 0L)
1114 return jjStopAtPos(1, 22);
1115 break;
1116 case 42:
1117 if ((active0 & 0x100000L) != 0L)
1118 return jjStartNfaWithStates_11(1, 20, 0);
1119 break;
1120 case 91:
1121 return jjMoveStringLiteralDfa2_11(active0, 0x40000L);
1122 default :
1123 break;
1124 }
1125 return jjStartNfa_11(0, active0);
1126 }
1127 private int jjMoveStringLiteralDfa2_11(long old0, long active0)
1128 {
1129 if (((active0 &= old0)) == 0L)
1130 return jjStartNfa_11(0, old0);
1131 try { curChar = input_stream.readChar(); }
1132 catch(java.io.IOException e) {
1133 jjStopStringLiteralDfa_11(1, active0);
1134 return 2;
1135 }
1136 switch(curChar)
1137 {
1138 case 91:
1139 if ((active0 & 0x40000L) != 0L)
1140 return jjStopAtPos(2, 18);
1141 break;
1142 default :
1143 break;
1144 }
1145 return jjStartNfa_11(1, active0);
1146 }
1147 private int jjStartNfaWithStates_11(int pos, int kind, int state)
1148 {
1149 jjmatchedKind = kind;
1150 jjmatchedPos = pos;
1151 try { curChar = input_stream.readChar(); }
1152 catch(java.io.IOException e) { return pos + 1; }
1153 return jjMoveNfa_11(state, pos + 1);
1154 }
1155 private int jjMoveNfa_11(int startState, int curPos)
1156 {
1157 int startsAt = 0;
1158 jjnewStateCnt = 98;
1159 int i = 1;
1160 jjstateSet[0] = startState;
1161 int kind = 0x7fffffff;
1162 for (;;)
1163 {
1164 if (++jjround == 0x7fffffff)
1165 ReInitRounds();
1166 if (curChar < 64)
1167 {
1168 long l = 1L << curChar;
1169 do
1170 {
1171 switch(jjstateSet[--i])
1172 {
1173 case 3:
1174 if ((0x3ff000000000000L & l) != 0L)
1175 {
1176 if (kind > 58)
1177 kind = 58;
1178 jjCheckNAddStates(56, 61);
1179 }
1180 else if (curChar == 45)
1181 jjCheckNAddStates(62, 65);
1182 else if (curChar == 36)
1183 {
1184 if (kind > 16)
1185 kind = 16;
1186 jjCheckNAddTwoStates(29, 30);
1187 }
1188 else if (curChar == 46)
1189 jjCheckNAdd(14);
1190 else if (curChar == 35)
1191 jjstateSet[jjnewStateCnt++] = 2;
1192 break;
1193 case 0:
1194 if (curChar == 42)
1195 jjstateSet[jjnewStateCnt++] = 1;
1196 break;
1197 case 1:
1198 if ((0xfffffff7ffffffffL & l) != 0L && kind > 19)
1199 kind = 19;
1200 break;
1201 case 2:
1202 if (curChar == 42)
1203 jjstateSet[jjnewStateCnt++] = 0;
1204 break;
1205 case 13:
1206 if (curChar == 46)
1207 jjCheckNAdd(14);
1208 break;
1209 case 14:
1210 if ((0x3ff000000000000L & l) == 0L)
1211 break;
1212 if (kind > 59)
1213 kind = 59;
1214 jjCheckNAddTwoStates(14, 15);
1215 break;
1216 case 16:
1217 if ((0x280000000000L & l) != 0L)
1218 jjCheckNAdd(17);
1219 break;
1220 case 17:
1221 if ((0x3ff000000000000L & l) == 0L)
1222 break;
1223 if (kind > 59)
1224 kind = 59;
1225 jjCheckNAdd(17);
1226 break;
1227 case 19:
1228 if ((0x3ff000000000000L & l) == 0L)
1229 break;
1230 if (kind > 63)
1231 kind = 63;
1232 jjstateSet[jjnewStateCnt++] = 19;
1233 break;
1234 case 22:
1235 if ((0x3ff000000000000L & l) != 0L)
1236 jjAddStates(66, 67);
1237 break;
1238 case 26:
1239 if (curChar == 36 && kind > 16)
1240 kind = 16;
1241 break;
1242 case 28:
1243 if (curChar == 36)
1244 jjCheckNAddTwoStates(29, 30);
1245 break;
1246 case 30:
1247 if (curChar == 33 && kind > 17)
1248 kind = 17;
1249 break;
1250 case 31:
1251 if (curChar != 36)
1252 break;
1253 if (kind > 16)
1254 kind = 16;
1255 jjCheckNAddTwoStates(29, 30);
1256 break;
1257 case 34:
1258 if ((0x100000200L & l) != 0L)
1259 jjCheckNAddStates(68, 70);
1260 break;
1261 case 35:
1262 if ((0x2400L & l) != 0L && kind > 52)
1263 kind = 52;
1264 break;
1265 case 36:
1266 if (curChar == 10 && kind > 52)
1267 kind = 52;
1268 break;
1269 case 37:
1270 case 54:
1271 if (curChar == 13)
1272 jjCheckNAdd(36);
1273 break;
1274 case 45:
1275 if ((0x100000200L & l) != 0L)
1276 jjCheckNAddStates(71, 73);
1277 break;
1278 case 46:
1279 if ((0x2400L & l) != 0L && kind > 56)
1280 kind = 56;
1281 break;
1282 case 47:
1283 if (curChar == 10 && kind > 56)
1284 kind = 56;
1285 break;
1286 case 48:
1287 case 78:
1288 if (curChar == 13)
1289 jjCheckNAdd(47);
1290 break;
1291 case 53:
1292 if ((0x100000200L & l) != 0L)
1293 jjCheckNAddStates(74, 76);
1294 break;
1295 case 77:
1296 if ((0x100000200L & l) != 0L)
1297 jjCheckNAddStates(77, 79);
1298 break;
1299 case 83:
1300 if (curChar == 45)
1301 jjCheckNAddStates(62, 65);
1302 break;
1303 case 84:
1304 if ((0x3ff000000000000L & l) == 0L)
1305 break;
1306 if (kind > 58)
1307 kind = 58;
1308 jjCheckNAddTwoStates(84, 86);
1309 break;
1310 case 85:
1311 if (curChar == 46 && kind > 58)
1312 kind = 58;
1313 break;
1314 case 86:
1315 if (curChar == 46)
1316 jjstateSet[jjnewStateCnt++] = 85;
1317 break;
1318 case 87:
1319 if ((0x3ff000000000000L & l) != 0L)
1320 jjCheckNAddTwoStates(87, 88);
1321 break;
1322 case 88:
1323 if (curChar != 46)
1324 break;
1325 if (kind > 59)
1326 kind = 59;
1327 jjCheckNAddTwoStates(89, 90);
1328 break;
1329 case 89:
1330 if ((0x3ff000000000000L & l) == 0L)
1331 break;
1332 if (kind > 59)
1333 kind = 59;
1334 jjCheckNAddTwoStates(89, 90);
1335 break;
1336 case 91:
1337 if ((0x280000000000L & l) != 0L)
1338 jjCheckNAdd(92);
1339 break;
1340 case 92:
1341 if ((0x3ff000000000000L & l) == 0L)
1342 break;
1343 if (kind > 59)
1344 kind = 59;
1345 jjCheckNAdd(92);
1346 break;
1347 case 93:
1348 if ((0x3ff000000000000L & l) != 0L)
1349 jjCheckNAddTwoStates(93, 94);
1350 break;
1351 case 95:
1352 if ((0x280000000000L & l) != 0L)
1353 jjCheckNAdd(96);
1354 break;
1355 case 96:
1356 if ((0x3ff000000000000L & l) == 0L)
1357 break;
1358 if (kind > 59)
1359 kind = 59;
1360 jjCheckNAdd(96);
1361 break;
1362 case 97:
1363 if ((0x3ff000000000000L & l) == 0L)
1364 break;
1365 if (kind > 58)
1366 kind = 58;
1367 jjCheckNAddStates(56, 61);
1368 break;
1369 default : break;
1370 }
1371 } while(i != startsAt);
1372 }
1373 else if (curChar < 128)
1374 {
1375 long l = 1L << (curChar & 077);
1376 do
1377 {
1378 switch(jjstateSet[--i])
1379 {
1380 case 3:
1381 if ((0x7fffffe87ffffffL & l) != 0L)
1382 {
1383 if (kind > 63)
1384 kind = 63;
1385 jjCheckNAdd(19);
1386 }
1387 else if (curChar == 123)
1388 jjAddStates(80, 84);
1389 else if (curChar == 92)
1390 jjCheckNAddStates(85, 88);
1391 if ((0x2000000020L & l) != 0L)
1392 jjAddStates(89, 91);
1393 else if ((0x20000000200L & l) != 0L)
1394 jjstateSet[jjnewStateCnt++] = 11;
1395 else if ((0x4000000040L & l) != 0L)
1396 jjstateSet[jjnewStateCnt++] = 9;
1397 else if (curChar == 123)
1398 jjstateSet[jjnewStateCnt++] = 21;
1399 break;
1400 case 1:
1401 if (kind > 19)
1402 kind = 19;
1403 break;
1404 case 4:
1405 if ((0x10000000100L & l) != 0L && kind > 53)
1406 kind = 53;
1407 break;
1408 case 5:
1409 if ((0x800000008L & l) != 0L)
1410 jjstateSet[jjnewStateCnt++] = 4;
1411 break;
1412 case 6:
1413 if ((0x200000002L & l) != 0L)
1414 jjstateSet[jjnewStateCnt++] = 5;
1415 break;
1416 case 7:
1417 if ((0x2000000020L & l) != 0L)
1418 jjstateSet[jjnewStateCnt++] = 6;
1419 break;
1420 case 8:
1421 if ((0x4000000040000L & l) != 0L)
1422 jjstateSet[jjnewStateCnt++] = 7;
1423 break;
1424 case 9:
1425 if ((0x800000008000L & l) != 0L)
1426 jjstateSet[jjnewStateCnt++] = 8;
1427 break;
1428 case 10:
1429 if ((0x4000000040L & l) != 0L)
1430 jjstateSet[jjnewStateCnt++] = 9;
1431 break;
1432 case 11:
1433 if ((0x4000000040L & l) != 0L && kind > 54)
1434 kind = 54;
1435 break;
1436 case 12:
1437 if ((0x20000000200L & l) != 0L)
1438 jjstateSet[jjnewStateCnt++] = 11;
1439 break;
1440 case 15:
1441 if ((0x2000000020L & l) != 0L)
1442 jjAddStates(92, 93);
1443 break;
1444 case 18:
1445 case 19:
1446 if ((0x7fffffe87ffffffL & l) == 0L)
1447 break;
1448 if (kind > 63)
1449 kind = 63;
1450 jjCheckNAdd(19);
1451 break;
1452 case 20:
1453 if (curChar == 123)
1454 jjstateSet[jjnewStateCnt++] = 21;
1455 break;
1456 case 21:
1457 if ((0x7fffffe87fffffeL & l) != 0L)
1458 jjCheckNAddTwoStates(22, 23);
1459 break;
1460 case 22:
1461 if ((0x7fffffe87ffffffL & l) != 0L)
1462 jjCheckNAddTwoStates(22, 23);
1463 break;
1464 case 23:
1465 if (curChar == 125 && kind > 64)
1466 kind = 64;
1467 break;
1468 case 24:
1469 if (curChar == 92)
1470 jjCheckNAddStates(85, 88);
1471 break;
1472 case 25:
1473 if (curChar == 92)
1474 jjCheckNAddTwoStates(25, 26);
1475 break;
1476 case 27:
1477 if (curChar == 92)
1478 jjCheckNAddTwoStates(27, 28);
1479 break;
1480 case 29:
1481 if (curChar == 92)
1482 jjAddStates(94, 95);
1483 break;
1484 case 32:
1485 if ((0x2000000020L & l) != 0L)
1486 jjAddStates(89, 91);
1487 break;
1488 case 33:
1489 if ((0x1000000010L & l) == 0L)
1490 break;
1491 if (kind > 52)
1492 kind = 52;
1493 jjCheckNAddStates(68, 70);
1494 break;
1495 case 38:
1496 if ((0x400000004000L & l) != 0L)
1497 jjstateSet[jjnewStateCnt++] = 33;
1498 break;
1499 case 39:
1500 if ((0x4000000040L & l) != 0L && kind > 55)
1501 kind = 55;
1502 break;
1503 case 40:
1504 if ((0x20000000200L & l) != 0L)
1505 jjstateSet[jjnewStateCnt++] = 39;
1506 break;
1507 case 41:
1508 if ((0x2000000020L & l) != 0L)
1509 jjstateSet[jjnewStateCnt++] = 40;
1510 break;
1511 case 42:
1512 if ((0x8000000080000L & l) != 0L)
1513 jjstateSet[jjnewStateCnt++] = 41;
1514 break;
1515 case 43:
1516 if ((0x100000001000L & l) != 0L)
1517 jjstateSet[jjnewStateCnt++] = 42;
1518 break;
1519 case 44:
1520 if ((0x2000000020L & l) == 0L)
1521 break;
1522 if (kind > 56)
1523 kind = 56;
1524 jjCheckNAddStates(71, 73);
1525 break;
1526 case 49:
1527 if ((0x8000000080000L & l) != 0L)
1528 jjstateSet[jjnewStateCnt++] = 44;
1529 break;
1530 case 50:
1531 if ((0x100000001000L & l) != 0L)
1532 jjstateSet[jjnewStateCnt++] = 49;
1533 break;
1534 case 51:
1535 if (curChar == 123)
1536 jjAddStates(80, 84);
1537 break;
1538 case 52:
1539 if (curChar != 125)
1540 break;
1541 if (kind > 52)
1542 kind = 52;
1543 jjCheckNAddStates(74, 76);
1544 break;
1545 case 55:
1546 if ((0x1000000010L & l) != 0L)
1547 jjstateSet[jjnewStateCnt++] = 52;
1548 break;
1549 case 56:
1550 if ((0x400000004000L & l) != 0L)
1551 jjstateSet[jjnewStateCnt++] = 55;
1552 break;
1553 case 57:
1554 if ((0x2000000020L & l) != 0L)
1555 jjstateSet[jjnewStateCnt++] = 56;
1556 break;
1557 case 58:
1558 if (curChar == 125 && kind > 53)
1559 kind = 53;
1560 break;
1561 case 59:
1562 if ((0x10000000100L & l) != 0L)
1563 jjstateSet[jjnewStateCnt++] = 58;
1564 break;
1565 case 60:
1566 if ((0x800000008L & l) != 0L)
1567 jjstateSet[jjnewStateCnt++] = 59;
1568 break;
1569 case 61:
1570 if ((0x200000002L & l) != 0L)
1571 jjstateSet[jjnewStateCnt++] = 60;
1572 break;
1573 case 62:
1574 if ((0x2000000020L & l) != 0L)
1575 jjstateSet[jjnewStateCnt++] = 61;
1576 break;
1577 case 63:
1578 if ((0x4000000040000L & l) != 0L)
1579 jjstateSet[jjnewStateCnt++] = 62;
1580 break;
1581 case 64:
1582 if ((0x800000008000L & l) != 0L)
1583 jjstateSet[jjnewStateCnt++] = 63;
1584 break;
1585 case 65:
1586 if ((0x4000000040L & l) != 0L)
1587 jjstateSet[jjnewStateCnt++] = 64;
1588 break;
1589 case 66:
1590 if (curChar == 125 && kind > 54)
1591 kind = 54;
1592 break;
1593 case 67:
1594 if ((0x4000000040L & l) != 0L)
1595 jjstateSet[jjnewStateCnt++] = 66;
1596 break;
1597 case 68:
1598 if ((0x20000000200L & l) != 0L)
1599 jjstateSet[jjnewStateCnt++] = 67;
1600 break;
1601 case 69:
1602 if (curChar == 125 && kind > 55)
1603 kind = 55;
1604 break;
1605 case 70:
1606 if ((0x4000000040L & l) != 0L)
1607 jjstateSet[jjnewStateCnt++] = 69;
1608 break;
1609 case 71:
1610 if ((0x20000000200L & l) != 0L)
1611 jjstateSet[jjnewStateCnt++] = 70;
1612 break;
1613 case 72:
1614 if ((0x2000000020L & l) != 0L)
1615 jjstateSet[jjnewStateCnt++] = 71;
1616 break;
1617 case 73:
1618 if ((0x8000000080000L & l) != 0L)
1619 jjstateSet[jjnewStateCnt++] = 72;
1620 break;
1621 case 74:
1622 if ((0x100000001000L & l) != 0L)
1623 jjstateSet[jjnewStateCnt++] = 73;
1624 break;
1625 case 75:
1626 if ((0x2000000020L & l) != 0L)
1627 jjstateSet[jjnewStateCnt++] = 74;
1628 break;
1629 case 76:
1630 if (curChar != 125)
1631 break;
1632 if (kind > 56)
1633 kind = 56;
1634 jjCheckNAddStates(77, 79);
1635 break;
1636 case 79:
1637 if ((0x2000000020L & l) != 0L)
1638 jjstateSet[jjnewStateCnt++] = 76;
1639 break;
1640 case 80:
1641 if ((0x8000000080000L & l) != 0L)
1642 jjstateSet[jjnewStateCnt++] = 79;
1643 break;
1644 case 81:
1645 if ((0x100000001000L & l) != 0L)
1646 jjstateSet[jjnewStateCnt++] = 80;
1647 break;
1648 case 82:
1649 if ((0x2000000020L & l) != 0L)
1650 jjstateSet[jjnewStateCnt++] = 81;
1651 break;
1652 case 90:
1653 if ((0x2000000020L & l) != 0L)
1654 jjAddStates(96, 97);
1655 break;
1656 case 94:
1657 if ((0x2000000020L & l) != 0L)
1658 jjAddStates(98, 99);
1659 break;
1660 default : break;
1661 }
1662 } while(i != startsAt);
1663 }
1664 else
1665 {
1666 int hiByte = (int)(curChar >> 8);
1667 int i1 = hiByte >> 6;
1668 long l1 = 1L << (hiByte & 077);
1669 int i2 = (curChar & 0xff) >> 6;
1670 long l2 = 1L << (curChar & 077);
1671 do
1672 {
1673 switch(jjstateSet[--i])
1674 {
1675 case 1:
1676 if (jjCanMove_0(hiByte, i1, i2, l1, l2) && kind > 19)
1677 kind = 19;
1678 break;
1679 default : break;
1680 }
1681 } while(i != startsAt);
1682 }
1683 if (kind != 0x7fffffff)
1684 {
1685 jjmatchedKind = kind;
1686 jjmatchedPos = curPos;
1687 kind = 0x7fffffff;
1688 }
1689 ++curPos;
1690 if ((i = jjnewStateCnt) == (startsAt = 98 - (jjnewStateCnt = startsAt)))
1691 return curPos;
1692 try { curChar = input_stream.readChar(); }
1693 catch(java.io.IOException e) { return curPos; }
1694 }
1695 }
1696 private final int jjStopStringLiteralDfa_8(int pos, long active0)
1697 {
1698 switch (pos)
1699 {
1700 case 0:
1701 if ((active0 & 0x340000L) != 0L)
1702 return 2;
1703 return -1;
1704 case 1:
1705 if ((active0 & 0x100000L) != 0L)
1706 return 0;
1707 return -1;
1708 default :
1709 return -1;
1710 }
1711 }
1712 private final int jjStartNfa_8(int pos, long active0)
1713 {
1714 return jjMoveNfa_8(jjStopStringLiteralDfa_8(pos, active0), pos + 1);
1715 }
1716 private int jjMoveStringLiteralDfa0_8()
1717 {
1718 switch(curChar)
1719 {
1720 case 35:
1721 jjmatchedKind = 21;
1722 return jjMoveStringLiteralDfa1_8(0x140000L);
1723 case 42:
1724 return jjMoveStringLiteralDfa1_8(0x10000000L);
1725 default :
1726 return jjMoveNfa_8(3, 0);
1727 }
1728 }
1729 private int jjMoveStringLiteralDfa1_8(long active0)
1730 {
1731 try { curChar = input_stream.readChar(); }
1732 catch(java.io.IOException e) {
1733 jjStopStringLiteralDfa_8(0, active0);
1734 return 1;
1735 }
1736 switch(curChar)
1737 {
1738 case 35:
1739 if ((active0 & 0x10000000L) != 0L)
1740 return jjStopAtPos(1, 28);
1741 break;
1742 case 42:
1743 if ((active0 & 0x100000L) != 0L)
1744 return jjStartNfaWithStates_8(1, 20, 0);
1745 break;
1746 case 91:
1747 return jjMoveStringLiteralDfa2_8(active0, 0x40000L);
1748 default :
1749 break;
1750 }
1751 return jjStartNfa_8(0, active0);
1752 }
1753 private int jjMoveStringLiteralDfa2_8(long old0, long active0)
1754 {
1755 if (((active0 &= old0)) == 0L)
1756 return jjStartNfa_8(0, old0);
1757 try { curChar = input_stream.readChar(); }
1758 catch(java.io.IOException e) {
1759 jjStopStringLiteralDfa_8(1, active0);
1760 return 2;
1761 }
1762 switch(curChar)
1763 {
1764 case 91:
1765 if ((active0 & 0x40000L) != 0L)
1766 return jjStopAtPos(2, 18);
1767 break;
1768 default :
1769 break;
1770 }
1771 return jjStartNfa_8(1, active0);
1772 }
1773 private int jjStartNfaWithStates_8(int pos, int kind, int state)
1774 {
1775 jjmatchedKind = kind;
1776 jjmatchedPos = pos;
1777 try { curChar = input_stream.readChar(); }
1778 catch(java.io.IOException e) { return pos + 1; }
1779 return jjMoveNfa_8(state, pos + 1);
1780 }
1781 private int jjMoveNfa_8(int startState, int curPos)
1782 {
1783 int startsAt = 0;
1784 jjnewStateCnt = 12;
1785 int i = 1;
1786 jjstateSet[0] = startState;
1787 int kind = 0x7fffffff;
1788 for (;;)
1789 {
1790 if (++jjround == 0x7fffffff)
1791 ReInitRounds();
1792 if (curChar < 64)
1793 {
1794 long l = 1L << curChar;
1795 do
1796 {
1797 switch(jjstateSet[--i])
1798 {
1799 case 3:
1800 if (curChar == 36)
1801 {
1802 if (kind > 16)
1803 kind = 16;
1804 jjCheckNAddTwoStates(9, 10);
1805 }
1806 else if (curChar == 35)
1807 jjstateSet[jjnewStateCnt++] = 2;
1808 break;
1809 case 0:
1810 if (curChar == 42)
1811 jjstateSet[jjnewStateCnt++] = 1;
1812 break;
1813 case 1:
1814 if ((0xfffffff7ffffffffL & l) != 0L && kind > 19)
1815 kind = 19;
1816 break;
1817 case 2:
1818 if (curChar == 42)
1819 jjstateSet[jjnewStateCnt++] = 0;
1820 break;
1821 case 6:
1822 if (curChar == 36 && kind > 16)
1823 kind = 16;
1824 break;
1825 case 8:
1826 if (curChar == 36)
1827 jjCheckNAddTwoStates(9, 10);
1828 break;
1829 case 10:
1830 if (curChar == 33 && kind > 17)
1831 kind = 17;
1832 break;
1833 case 11:
1834 if (curChar != 36)
1835 break;
1836 if (kind > 16)
1837 kind = 16;
1838 jjCheckNAddTwoStates(9, 10);
1839 break;
1840 default : break;
1841 }
1842 } while(i != startsAt);
1843 }
1844 else if (curChar < 128)
1845 {
1846 long l = 1L << (curChar & 077);
1847 do
1848 {
1849 switch(jjstateSet[--i])
1850 {
1851 case 3:
1852 if (curChar == 92)
1853 jjCheckNAddStates(100, 103);
1854 break;
1855 case 1:
1856 if (kind > 19)
1857 kind = 19;
1858 break;
1859 case 5:
1860 if (curChar == 92)
1861 jjCheckNAddTwoStates(5, 6);
1862 break;
1863 case 7:
1864 if (curChar == 92)
1865 jjCheckNAddTwoStates(7, 8);
1866 break;
1867 case 9:
1868 if (curChar == 92)
1869 jjAddStates(104, 105);
1870 break;
1871 default : break;
1872 }
1873 } while(i != startsAt);
1874 }
1875 else
1876 {
1877 int hiByte = (int)(curChar >> 8);
1878 int i1 = hiByte >> 6;
1879 long l1 = 1L << (hiByte & 077);
1880 int i2 = (curChar & 0xff) >> 6;
1881 long l2 = 1L << (curChar & 077);
1882 do
1883 {
1884 switch(jjstateSet[--i])
1885 {
1886 case 1:
1887 if (jjCanMove_0(hiByte, i1, i2, l1, l2) && kind > 19)
1888 kind = 19;
1889 break;
1890 default : break;
1891 }
1892 } while(i != startsAt);
1893 }
1894 if (kind != 0x7fffffff)
1895 {
1896 jjmatchedKind = kind;
1897 jjmatchedPos = curPos;
1898 kind = 0x7fffffff;
1899 }
1900 ++curPos;
1901 if ((i = jjnewStateCnt) == (startsAt = 12 - (jjnewStateCnt = startsAt)))
1902 return curPos;
1903 try { curChar = input_stream.readChar(); }
1904 catch(java.io.IOException e) { return curPos; }
1905 }
1906 }
1907 private final int jjStopStringLiteralDfa_6(int pos, long active0)
1908 {
1909 switch (pos)
1910 {
1911 case 0:
1912 if ((active0 & 0x340000L) != 0L)
1913 return 2;
1914 return -1;
1915 case 1:
1916 if ((active0 & 0x100000L) != 0L)
1917 return 0;
1918 return -1;
1919 default :
1920 return -1;
1921 }
1922 }
1923 private final int jjStartNfa_6(int pos, long active0)
1924 {
1925 return jjMoveNfa_6(jjStopStringLiteralDfa_6(pos, active0), pos + 1);
1926 }
1927 private int jjMoveStringLiteralDfa0_6()
1928 {
1929 switch(curChar)
1930 {
1931 case 35:
1932 jjmatchedKind = 21;
1933 return jjMoveStringLiteralDfa1_6(0x140000L);
1934 default :
1935 return jjMoveNfa_6(3, 0);
1936 }
1937 }
1938 private int jjMoveStringLiteralDfa1_6(long active0)
1939 {
1940 try { curChar = input_stream.readChar(); }
1941 catch(java.io.IOException e) {
1942 jjStopStringLiteralDfa_6(0, active0);
1943 return 1;
1944 }
1945 switch(curChar)
1946 {
1947 case 42:
1948 if ((active0 & 0x100000L) != 0L)
1949 return jjStartNfaWithStates_6(1, 20, 0);
1950 break;
1951 case 91:
1952 return jjMoveStringLiteralDfa2_6(active0, 0x40000L);
1953 default :
1954 break;
1955 }
1956 return jjStartNfa_6(0, active0);
1957 }
1958 private int jjMoveStringLiteralDfa2_6(long old0, long active0)
1959 {
1960 if (((active0 &= old0)) == 0L)
1961 return jjStartNfa_6(0, old0);
1962 try { curChar = input_stream.readChar(); }
1963 catch(java.io.IOException e) {
1964 jjStopStringLiteralDfa_6(1, active0);
1965 return 2;
1966 }
1967 switch(curChar)
1968 {
1969 case 91:
1970 if ((active0 & 0x40000L) != 0L)
1971 return jjStopAtPos(2, 18);
1972 break;
1973 default :
1974 break;
1975 }
1976 return jjStartNfa_6(1, active0);
1977 }
1978 private int jjStartNfaWithStates_6(int pos, int kind, int state)
1979 {
1980 jjmatchedKind = kind;
1981 jjmatchedPos = pos;
1982 try { curChar = input_stream.readChar(); }
1983 catch(java.io.IOException e) { return pos + 1; }
1984 return jjMoveNfa_6(state, pos + 1);
1985 }
1986 private int jjMoveNfa_6(int startState, int curPos)
1987 {
1988 int startsAt = 0;
1989 jjnewStateCnt = 12;
1990 int i = 1;
1991 jjstateSet[0] = startState;
1992 int kind = 0x7fffffff;
1993 for (;;)
1994 {
1995 if (++jjround == 0x7fffffff)
1996 ReInitRounds();
1997 if (curChar < 64)
1998 {
1999 long l = 1L << curChar;
2000 do
2001 {
2002 switch(jjstateSet[--i])
2003 {
2004 case 3:
2005 if (curChar == 36)
2006 {
2007 if (kind > 16)
2008 kind = 16;
2009 jjCheckNAddTwoStates(9, 10);
2010 }
2011 else if (curChar == 35)
2012 jjstateSet[jjnewStateCnt++] = 2;
2013 break;
2014 case 0:
2015 if (curChar == 42)
2016 jjstateSet[jjnewStateCnt++] = 1;
2017 break;
2018 case 1:
2019 if ((0xfffffff7ffffffffL & l) != 0L && kind > 19)
2020 kind = 19;
2021 break;
2022 case 2:
2023 if (curChar == 42)
2024 jjstateSet[jjnewStateCnt++] = 0;
2025 break;
2026 case 6:
2027 if (curChar == 36 && kind > 16)
2028 kind = 16;
2029 break;
2030 case 8:
2031 if (curChar == 36)
2032 jjCheckNAddTwoStates(9, 10);
2033 break;
2034 case 10:
2035 if (curChar == 33 && kind > 17)
2036 kind = 17;
2037 break;
2038 case 11:
2039 if (curChar != 36)
2040 break;
2041 if (kind > 16)
2042 kind = 16;
2043 jjCheckNAddTwoStates(9, 10);
2044 break;
2045 default : break;
2046 }
2047 } while(i != startsAt);
2048 }
2049 else if (curChar < 128)
2050 {
2051 long l = 1L << (curChar & 077);
2052 do
2053 {
2054 switch(jjstateSet[--i])
2055 {
2056 case 3:
2057 if (curChar == 92)
2058 jjCheckNAddStates(100, 103);
2059 break;
2060 case 1:
2061 if (kind > 19)
2062 kind = 19;
2063 break;
2064 case 5:
2065 if (curChar == 92)
2066 jjCheckNAddTwoStates(5, 6);
2067 break;
2068 case 7:
2069 if (curChar == 92)
2070 jjCheckNAddTwoStates(7, 8);
2071 break;
2072 case 9:
2073 if (curChar == 92)
2074 jjAddStates(104, 105);
2075 break;
2076 default : break;
2077 }
2078 } while(i != startsAt);
2079 }
2080 else
2081 {
2082 int hiByte = (int)(curChar >> 8);
2083 int i1 = hiByte >> 6;
2084 long l1 = 1L << (hiByte & 077);
2085 int i2 = (curChar & 0xff) >> 6;
2086 long l2 = 1L << (curChar & 077);
2087 do
2088 {
2089 switch(jjstateSet[--i])
2090 {
2091 case 1:
2092 if (jjCanMove_0(hiByte, i1, i2, l1, l2) && kind > 19)
2093 kind = 19;
2094 break;
2095 default : break;
2096 }
2097 } while(i != startsAt);
2098 }
2099 if (kind != 0x7fffffff)
2100 {
2101 jjmatchedKind = kind;
2102 jjmatchedPos = curPos;
2103 kind = 0x7fffffff;
2104 }
2105 ++curPos;
2106 if ((i = jjnewStateCnt) == (startsAt = 12 - (jjnewStateCnt = startsAt)))
2107 return curPos;
2108 try { curChar = input_stream.readChar(); }
2109 catch(java.io.IOException e) { return curPos; }
2110 }
2111 }
2112 private final int jjStopStringLiteralDfa_5(int pos, long active0)
2113 {
2114 switch (pos)
2115 {
2116 case 0:
2117 if ((active0 & 0x1800000L) != 0L)
2118 return 20;
2119 if ((active0 & 0x740000L) != 0L)
2120 return 39;
2121 return -1;
2122 case 1:
2123 if ((active0 & 0x800000L) != 0L)
2124 return 40;
2125 if ((active0 & 0x100000L) != 0L)
2126 return 37;
2127 return -1;
2128 default :
2129 return -1;
2130 }
2131 }
2132 private final int jjStartNfa_5(int pos, long active0)
2133 {
2134 return jjMoveNfa_5(jjStopStringLiteralDfa_5(pos, active0), pos + 1);
2135 }
2136 private int jjMoveStringLiteralDfa0_5()
2137 {
2138 switch(curChar)
2139 {
2140 case 35:
2141 jjmatchedKind = 21;
2142 return jjMoveStringLiteralDfa1_5(0x540000L);
2143 case 92:
2144 jjmatchedKind = 24;
2145 return jjMoveStringLiteralDfa1_5(0x800000L);
2146 default :
2147 return jjMoveNfa_5(13, 0);
2148 }
2149 }
2150 private int jjMoveStringLiteralDfa1_5(long active0)
2151 {
2152 try { curChar = input_stream.readChar(); }
2153 catch(java.io.IOException e) {
2154 jjStopStringLiteralDfa_5(0, active0);
2155 return 1;
2156 }
2157 switch(curChar)
2158 {
2159 case 35:
2160 if ((active0 & 0x400000L) != 0L)
2161 return jjStopAtPos(1, 22);
2162 break;
2163 case 42:
2164 if ((active0 & 0x100000L) != 0L)
2165 return jjStartNfaWithStates_5(1, 20, 37);
2166 break;
2167 case 91:
2168 return jjMoveStringLiteralDfa2_5(active0, 0x40000L);
2169 case 92:
2170 if ((active0 & 0x800000L) != 0L)
2171 return jjStartNfaWithStates_5(1, 23, 40);
2172 break;
2173 default :
2174 break;
2175 }
2176 return jjStartNfa_5(0, active0);
2177 }
2178 private int jjMoveStringLiteralDfa2_5(long old0, long active0)
2179 {
2180 if (((active0 &= old0)) == 0L)
2181 return jjStartNfa_5(0, old0);
2182 try { curChar = input_stream.readChar(); }
2183 catch(java.io.IOException e) {
2184 jjStopStringLiteralDfa_5(1, active0);
2185 return 2;
2186 }
2187 switch(curChar)
2188 {
2189 case 91:
2190 if ((active0 & 0x40000L) != 0L)
2191 return jjStopAtPos(2, 18);
2192 break;
2193 default :
2194 break;
2195 }
2196 return jjStartNfa_5(1, active0);
2197 }
2198 private int jjStartNfaWithStates_5(int pos, int kind, int state)
2199 {
2200 jjmatchedKind = kind;
2201 jjmatchedPos = pos;
2202 try { curChar = input_stream.readChar(); }
2203 catch(java.io.IOException e) { return pos + 1; }
2204 return jjMoveNfa_5(state, pos + 1);
2205 }
2206 private int jjMoveNfa_5(int startState, int curPos)
2207 {
2208 int startsAt = 0;
2209 jjnewStateCnt = 40;
2210 int i = 1;
2211 jjstateSet[0] = startState;
2212 int kind = 0x7fffffff;
2213 for (;;)
2214 {
2215 if (++jjround == 0x7fffffff)
2216 ReInitRounds();
2217 if (curChar < 64)
2218 {
2219 long l = 1L << curChar;
2220 do
2221 {
2222 switch(jjstateSet[--i])
2223 {
2224 case 39:
2225 if (curChar == 42)
2226 jjstateSet[jjnewStateCnt++] = 37;
2227 break;
2228 case 40:
2229 if (curChar == 36)
2230 jjCheckNAddTwoStates(33, 34);
2231 if (curChar == 36)
2232 {
2233 if (kind > 16)
2234 kind = 16;
2235 }
2236 break;
2237 case 13:
2238 if ((0xffffffe7ffffffffL & l) != 0L)
2239 {
2240 if (kind > 25)
2241 kind = 25;
2242 jjCheckNAdd(12);
2243 }
2244 else if (curChar == 35)
2245 jjCheckNAddStates(106, 108);
2246 else if (curChar == 36)
2247 {
2248 if (kind > 16)
2249 kind = 16;
2250 jjCheckNAddTwoStates(33, 34);
2251 }
2252 if ((0x100000200L & l) != 0L)
2253 jjCheckNAddTwoStates(0, 1);
2254 else if (curChar == 36)
2255 jjCheckNAddStates(109, 112);
2256 break;
2257 case 20:
2258 if (curChar == 36)
2259 jjCheckNAddTwoStates(33, 34);
2260 else if (curChar == 35)
2261 jjAddStates(113, 114);
2262 if (curChar == 36)
2263 {
2264 if (kind > 16)
2265 kind = 16;
2266 }
2267 break;
2268 case 0:
2269 if ((0x100000200L & l) != 0L)
2270 jjCheckNAddTwoStates(0, 1);
2271 break;
2272 case 1:
2273 if (curChar == 35)
2274 jjCheckNAddTwoStates(6, 11);
2275 break;
2276 case 3:
2277 if (curChar == 32)
2278 jjAddStates(115, 116);
2279 break;
2280 case 4:
2281 if (curChar == 40 && kind > 15)
2282 kind = 15;
2283 break;
2284 case 12:
2285 if ((0xffffffe7ffffffffL & l) == 0L)
2286 break;
2287 if (kind > 25)
2288 kind = 25;
2289 jjCheckNAdd(12);
2290 break;
2291 case 15:
2292 case 16:
2293 if (curChar == 33)
2294 jjCheckNAdd(14);
2295 break;
2296 case 18:
2297 if (curChar == 46 && kind > 74)
2298 kind = 74;
2299 break;
2300 case 21:
2301 if (curChar == 35)
2302 jjAddStates(113, 114);
2303 break;
2304 case 23:
2305 if ((0x3ff000000000000L & l) == 0L)
2306 break;
2307 if (kind > 14)
2308 kind = 14;
2309 jjstateSet[jjnewStateCnt++] = 23;
2310 break;
2311 case 26:
2312 if ((0x3ff000000000000L & l) != 0L)
2313 jjAddStates(26, 27);
2314 break;
2315 case 30:
2316 if (curChar == 36 && kind > 16)
2317 kind = 16;
2318 break;
2319 case 32:
2320 if (curChar == 36)
2321 jjCheckNAddTwoStates(33, 34);
2322 break;
2323 case 34:
2324 if (curChar == 33 && kind > 17)
2325 kind = 17;
2326 break;
2327 case 35:
2328 if (curChar != 36)
2329 break;
2330 if (kind > 16)
2331 kind = 16;
2332 jjCheckNAddTwoStates(33, 34);
2333 break;
2334 case 36:
2335 if (curChar == 35)
2336 jjCheckNAddStates(106, 108);
2337 break;
2338 case 37:
2339 if (curChar == 42)
2340 jjstateSet[jjnewStateCnt++] = 38;
2341 break;
2342 case 38:
2343 if ((0xfffffff7ffffffffL & l) != 0L && kind > 19)
2344 kind = 19;
2345 break;
2346 default : break;
2347 }
2348 } while(i != startsAt);
2349 }
2350 else if (curChar < 128)
2351 {
2352 long l = 1L << (curChar & 077);
2353 do
2354 {
2355 switch(jjstateSet[--i])
2356 {
2357 case 39:
2358 if ((0x8000000080000L & l) != 0L)
2359 jjstateSet[jjnewStateCnt++] = 5;
2360 else if (curChar == 123)
2361 jjstateSet[jjnewStateCnt++] = 10;
2362 break;
2363 case 40:
2364 if (curChar == 92)
2365 jjAddStates(117, 118);
2366 if (curChar == 92)
2367 jjCheckNAddTwoStates(31, 32);
2368 if (curChar == 92)
2369 jjCheckNAddTwoStates(29, 30);
2370 break;
2371 case 13:
2372 if ((0xffffffffefffffffL & l) != 0L)
2373 {
2374 if (kind > 25)
2375 kind = 25;
2376 jjCheckNAdd(12);
2377 }
2378 else if (curChar == 92)
2379 jjCheckNAddStates(119, 122);
2380 if (curChar == 92)
2381 jjAddStates(117, 118);
2382 break;
2383 case 20:
2384 if (curChar == 92)
2385 jjCheckNAddTwoStates(31, 32);
2386 if (curChar == 92)
2387 jjCheckNAddTwoStates(29, 30);
2388 if (curChar == 92)
2389 jjstateSet[jjnewStateCnt++] = 19;
2390 break;
2391 case 2:
2392 if ((0x10000000100000L & l) != 0L)
2393 jjCheckNAddTwoStates(3, 4);
2394 break;
2395 case 5:
2396 if ((0x2000000020L & l) != 0L)
2397 jjstateSet[jjnewStateCnt++] = 2;
2398 break;
2399 case 6:
2400 if ((0x8000000080000L & l) != 0L)
2401 jjstateSet[jjnewStateCnt++] = 5;
2402 break;
2403 case 7:
2404 if (curChar == 125)
2405 jjCheckNAddTwoStates(3, 4);
2406 break;
2407 case 8:
2408 if ((0x10000000100000L & l) != 0L)
2409 jjstateSet[jjnewStateCnt++] = 7;
2410 break;
2411 case 9:
2412 if ((0x2000000020L & l) != 0L)
2413 jjstateSet[jjnewStateCnt++] = 8;
2414 break;
2415 case 10:
2416 if ((0x8000000080000L & l) != 0L)
2417 jjstateSet[jjnewStateCnt++] = 9;
2418 break;
2419 case 11:
2420 if (curChar == 123)
2421 jjstateSet[jjnewStateCnt++] = 10;
2422 break;
2423 case 12:
2424 if ((0xffffffffefffffffL & l) == 0L)
2425 break;
2426 if (kind > 25)
2427 kind = 25;
2428 jjCheckNAdd(12);
2429 break;
2430 case 14:
2431 if (curChar == 91 && kind > 74)
2432 kind = 74;
2433 break;
2434 case 17:
2435 if (curChar == 92)
2436 jjstateSet[jjnewStateCnt++] = 16;
2437 break;
2438 case 19:
2439 if (curChar == 92)
2440 jjAddStates(117, 118);
2441 break;
2442 case 22:
2443 case 23:
2444 if ((0x7fffffe87ffffffL & l) == 0L)
2445 break;
2446 if (kind > 14)
2447 kind = 14;
2448 jjCheckNAdd(23);
2449 break;
2450 case 24:
2451 if (curChar == 123)
2452 jjstateSet[jjnewStateCnt++] = 25;
2453 break;
2454 case 25:
2455 if ((0x7fffffe87fffffeL & l) != 0L)
2456 jjCheckNAddTwoStates(26, 27);
2457 break;
2458 case 26:
2459 if ((0x7fffffe87ffffffL & l) != 0L)
2460 jjCheckNAddTwoStates(26, 27);
2461 break;
2462 case 27:
2463 if (curChar == 125 && kind > 14)
2464 kind = 14;
2465 break;
2466 case 28:
2467 if (curChar == 92)
2468 jjCheckNAddStates(119, 122);
2469 break;
2470 case 29:
2471 if (curChar == 92)
2472 jjCheckNAddTwoStates(29, 30);
2473 break;
2474 case 31:
2475 if (curChar == 92)
2476 jjCheckNAddTwoStates(31, 32);
2477 break;
2478 case 33:
2479 if (curChar == 92)
2480 jjAddStates(28, 29);
2481 break;
2482 case 38:
2483 if (kind > 19)
2484 kind = 19;
2485 break;
2486 default : break;
2487 }
2488 } while(i != startsAt);
2489 }
2490 else
2491 {
2492 int hiByte = (int)(curChar >> 8);
2493 int i1 = hiByte >> 6;
2494 long l1 = 1L << (hiByte & 077);
2495 int i2 = (curChar & 0xff) >> 6;
2496 long l2 = 1L << (curChar & 077);
2497 do
2498 {
2499 switch(jjstateSet[--i])
2500 {
2501 case 13:
2502 case 12:
2503 if (!jjCanMove_0(hiByte, i1, i2, l1, l2))
2504 break;
2505 if (kind > 25)
2506 kind = 25;
2507 jjCheckNAdd(12);
2508 break;
2509 case 38:
2510 if (jjCanMove_0(hiByte, i1, i2, l1, l2) && kind > 19)
2511 kind = 19;
2512 break;
2513 default : break;
2514 }
2515 } while(i != startsAt);
2516 }
2517 if (kind != 0x7fffffff)
2518 {
2519 jjmatchedKind = kind;
2520 jjmatchedPos = curPos;
2521 kind = 0x7fffffff;
2522 }
2523 ++curPos;
2524 if ((i = jjnewStateCnt) == (startsAt = 40 - (jjnewStateCnt = startsAt)))
2525 return curPos;
2526 try { curChar = input_stream.readChar(); }
2527 catch(java.io.IOException e) { return curPos; }
2528 }
2529 }
2530 private final int jjStopStringLiteralDfa_9(int pos, long active0)
2531 {
2532 switch (pos)
2533 {
2534 case 0:
2535 if ((active0 & 0x340000L) != 0L)
2536 return 2;
2537 return -1;
2538 case 1:
2539 if ((active0 & 0x100000L) != 0L)
2540 return 0;
2541 return -1;
2542 default :
2543 return -1;
2544 }
2545 }
2546 private final int jjStartNfa_9(int pos, long active0)
2547 {
2548 return jjMoveNfa_9(jjStopStringLiteralDfa_9(pos, active0), pos + 1);
2549 }
2550 private int jjMoveStringLiteralDfa0_9()
2551 {
2552 switch(curChar)
2553 {
2554 case 35:
2555 jjmatchedKind = 21;
2556 return jjMoveStringLiteralDfa1_9(0x140000L);
2557 case 42:
2558 return jjMoveStringLiteralDfa1_9(0x8000000L);
2559 default :
2560 return jjMoveNfa_9(3, 0);
2561 }
2562 }
2563 private int jjMoveStringLiteralDfa1_9(long active0)
2564 {
2565 try { curChar = input_stream.readChar(); }
2566 catch(java.io.IOException e) {
2567 jjStopStringLiteralDfa_9(0, active0);
2568 return 1;
2569 }
2570 switch(curChar)
2571 {
2572 case 35:
2573 if ((active0 & 0x8000000L) != 0L)
2574 return jjStopAtPos(1, 27);
2575 break;
2576 case 42:
2577 if ((active0 & 0x100000L) != 0L)
2578 return jjStartNfaWithStates_9(1, 20, 0);
2579 break;
2580 case 91:
2581 return jjMoveStringLiteralDfa2_9(active0, 0x40000L);
2582 default :
2583 break;
2584 }
2585 return jjStartNfa_9(0, active0);
2586 }
2587 private int jjMoveStringLiteralDfa2_9(long old0, long active0)
2588 {
2589 if (((active0 &= old0)) == 0L)
2590 return jjStartNfa_9(0, old0);
2591 try { curChar = input_stream.readChar(); }
2592 catch(java.io.IOException e) {
2593 jjStopStringLiteralDfa_9(1, active0);
2594 return 2;
2595 }
2596 switch(curChar)
2597 {
2598 case 91:
2599 if ((active0 & 0x40000L) != 0L)
2600 return jjStopAtPos(2, 18);
2601 break;
2602 default :
2603 break;
2604 }
2605 return jjStartNfa_9(1, active0);
2606 }
2607 private int jjStartNfaWithStates_9(int pos, int kind, int state)
2608 {
2609 jjmatchedKind = kind;
2610 jjmatchedPos = pos;
2611 try { curChar = input_stream.readChar(); }
2612 catch(java.io.IOException e) { return pos + 1; }
2613 return jjMoveNfa_9(state, pos + 1);
2614 }
2615 private int jjMoveNfa_9(int startState, int curPos)
2616 {
2617 int startsAt = 0;
2618 jjnewStateCnt = 12;
2619 int i = 1;
2620 jjstateSet[0] = startState;
2621 int kind = 0x7fffffff;
2622 for (;;)
2623 {
2624 if (++jjround == 0x7fffffff)
2625 ReInitRounds();
2626 if (curChar < 64)
2627 {
2628 long l = 1L << curChar;
2629 do
2630 {
2631 switch(jjstateSet[--i])
2632 {
2633 case 3:
2634 if (curChar == 36)
2635 {
2636 if (kind > 16)
2637 kind = 16;
2638 jjCheckNAddTwoStates(9, 10);
2639 }
2640 else if (curChar == 35)
2641 jjstateSet[jjnewStateCnt++] = 2;
2642 break;
2643 case 0:
2644 if (curChar == 42)
2645 jjstateSet[jjnewStateCnt++] = 1;
2646 break;
2647 case 1:
2648 if ((0xfffffff7ffffffffL & l) != 0L && kind > 19)
2649 kind = 19;
2650 break;
2651 case 2:
2652 if (curChar == 42)
2653 jjstateSet[jjnewStateCnt++] = 0;
2654 break;
2655 case 6:
2656 if (curChar == 36 && kind > 16)
2657 kind = 16;
2658 break;
2659 case 8:
2660 if (curChar == 36)
2661 jjCheckNAddTwoStates(9, 10);
2662 break;
2663 case 10:
2664 if (curChar == 33 && kind > 17)
2665 kind = 17;
2666 break;
2667 case 11:
2668 if (curChar != 36)
2669 break;
2670 if (kind > 16)
2671 kind = 16;
2672 jjCheckNAddTwoStates(9, 10);
2673 break;
2674 default : break;
2675 }
2676 } while(i != startsAt);
2677 }
2678 else if (curChar < 128)
2679 {
2680 long l = 1L << (curChar & 077);
2681 do
2682 {
2683 switch(jjstateSet[--i])
2684 {
2685 case 3:
2686 if (curChar == 92)
2687 jjCheckNAddStates(100, 103);
2688 break;
2689 case 1:
2690 if (kind > 19)
2691 kind = 19;
2692 break;
2693 case 5:
2694 if (curChar == 92)
2695 jjCheckNAddTwoStates(5, 6);
2696 break;
2697 case 7:
2698 if (curChar == 92)
2699 jjCheckNAddTwoStates(7, 8);
2700 break;
2701 case 9:
2702 if (curChar == 92)
2703 jjAddStates(104, 105);
2704 break;
2705 default : break;
2706 }
2707 } while(i != startsAt);
2708 }
2709 else
2710 {
2711 int hiByte = (int)(curChar >> 8);
2712 int i1 = hiByte >> 6;
2713 long l1 = 1L << (hiByte & 077);
2714 int i2 = (curChar & 0xff) >> 6;
2715 long l2 = 1L << (curChar & 077);
2716 do
2717 {
2718 switch(jjstateSet[--i])
2719 {
2720 case 1:
2721 if (jjCanMove_0(hiByte, i1, i2, l1, l2) && kind > 19)
2722 kind = 19;
2723 break;
2724 default : break;
2725 }
2726 } while(i != startsAt);
2727 }
2728 if (kind != 0x7fffffff)
2729 {
2730 jjmatchedKind = kind;
2731 jjmatchedPos = curPos;
2732 kind = 0x7fffffff;
2733 }
2734 ++curPos;
2735 if ((i = jjnewStateCnt) == (startsAt = 12 - (jjnewStateCnt = startsAt)))
2736 return curPos;
2737 try { curChar = input_stream.readChar(); }
2738 catch(java.io.IOException e) { return curPos; }
2739 }
2740 }
2741 private final int jjStopStringLiteralDfa_2(int pos, long active0)
2742 {
2743 switch (pos)
2744 {
2745 case 0:
2746 if ((active0 & 0x340000L) != 0L)
2747 return 2;
2748 return -1;
2749 case 1:
2750 if ((active0 & 0x100000L) != 0L)
2751 return 0;
2752 return -1;
2753 default :
2754 return -1;
2755 }
2756 }
2757 private final int jjStartNfa_2(int pos, long active0)
2758 {
2759 return jjMoveNfa_2(jjStopStringLiteralDfa_2(pos, active0), pos + 1);
2760 }
2761 private int jjMoveStringLiteralDfa0_2()
2762 {
2763 switch(curChar)
2764 {
2765 case 35:
2766 jjmatchedKind = 21;
2767 return jjMoveStringLiteralDfa1_2(0x140000L);
2768 case 93:
2769 return jjStopAtPos(0, 2);
2770 case 70:
2771 case 102:
2772 return jjMoveStringLiteralDfa1_2(0x800000000L);
2773 case 84:
2774 case 116:
2775 return jjMoveStringLiteralDfa1_2(0x400000000L);
2776 default :
2777 return jjMoveNfa_2(3, 0);
2778 }
2779 }
2780 private int jjMoveStringLiteralDfa1_2(long active0)
2781 {
2782 try { curChar = input_stream.readChar(); }
2783 catch(java.io.IOException e) {
2784 jjStopStringLiteralDfa_2(0, active0);
2785 return 1;
2786 }
2787 switch(curChar)
2788 {
2789 case 42:
2790 if ((active0 & 0x100000L) != 0L)
2791 return jjStartNfaWithStates_2(1, 20, 0);
2792 break;
2793 case 91:
2794 return jjMoveStringLiteralDfa2_2(active0, 0x40000L);
2795 case 65:
2796 case 97:
2797 return jjMoveStringLiteralDfa2_2(active0, 0x800000000L);
2798 case 82:
2799 case 114:
2800 return jjMoveStringLiteralDfa2_2(active0, 0x400000000L);
2801 default :
2802 break;
2803 }
2804 return jjStartNfa_2(0, active0);
2805 }
2806 private int jjMoveStringLiteralDfa2_2(long old0, long active0)
2807 {
2808 if (((active0 &= old0)) == 0L)
2809 return jjStartNfa_2(0, old0);
2810 try { curChar = input_stream.readChar(); }
2811 catch(java.io.IOException e) {
2812 jjStopStringLiteralDfa_2(1, active0);
2813 return 2;
2814 }
2815 switch(curChar)
2816 {
2817 case 91:
2818 if ((active0 & 0x40000L) != 0L)
2819 return jjStopAtPos(2, 18);
2820 break;
2821 case 76:
2822 case 108:
2823 return jjMoveStringLiteralDfa3_2(active0, 0x800000000L);
2824 case 85:
2825 case 117:
2826 return jjMoveStringLiteralDfa3_2(active0, 0x400000000L);
2827 default :
2828 break;
2829 }
2830 return jjStartNfa_2(1, active0);
2831 }
2832 private int jjMoveStringLiteralDfa3_2(long old0, long active0)
2833 {
2834 if (((active0 &= old0)) == 0L)
2835 return jjStartNfa_2(1, old0);
2836 try { curChar = input_stream.readChar(); }
2837 catch(java.io.IOException e) {
2838 jjStopStringLiteralDfa_2(2, active0);
2839 return 3;
2840 }
2841 switch(curChar)
2842 {
2843 case 69:
2844 case 101:
2845 if ((active0 & 0x400000000L) != 0L)
2846 return jjStopAtPos(3, 34);
2847 break;
2848 case 83:
2849 case 115:
2850 return jjMoveStringLiteralDfa4_2(active0, 0x800000000L);
2851 default :
2852 break;
2853 }
2854 return jjStartNfa_2(2, active0);
2855 }
2856 private int jjMoveStringLiteralDfa4_2(long old0, long active0)
2857 {
2858 if (((active0 &= old0)) == 0L)
2859 return jjStartNfa_2(2, old0);
2860 try { curChar = input_stream.readChar(); }
2861 catch(java.io.IOException e) {
2862 jjStopStringLiteralDfa_2(3, active0);
2863 return 4;
2864 }
2865 switch(curChar)
2866 {
2867 case 69:
2868 case 101:
2869 if ((active0 & 0x800000000L) != 0L)
2870 return jjStopAtPos(4, 35);
2871 break;
2872 default :
2873 break;
2874 }
2875 return jjStartNfa_2(3, active0);
2876 }
2877 private int jjStartNfaWithStates_2(int pos, int kind, int state)
2878 {
2879 jjmatchedKind = kind;
2880 jjmatchedPos = pos;
2881 try { curChar = input_stream.readChar(); }
2882 catch(java.io.IOException e) { return pos + 1; }
2883 return jjMoveNfa_2(state, pos + 1);
2884 }
2885 private int jjMoveNfa_2(int startState, int curPos)
2886 {
2887 int startsAt = 0;
2888 jjnewStateCnt = 59;
2889 int i = 1;
2890 jjstateSet[0] = startState;
2891 int kind = 0x7fffffff;
2892 for (;;)
2893 {
2894 if (++jjround == 0x7fffffff)
2895 ReInitRounds();
2896 if (curChar < 64)
2897 {
2898 long l = 1L << curChar;
2899 do
2900 {
2901 switch(jjstateSet[--i])
2902 {
2903 case 3:
2904 if ((0x3ff000000000000L & l) != 0L)
2905 {
2906 if (kind > 58)
2907 kind = 58;
2908 jjCheckNAddStates(123, 128);
2909 }
2910 else if ((0x100002600L & l) != 0L)
2911 {
2912 if (kind > 32)
2913 kind = 32;
2914 jjCheckNAdd(4);
2915 }
2916 else if (curChar == 45)
2917 jjCheckNAddStates(129, 132);
2918 else if (curChar == 36)
2919 {
2920 if (kind > 16)
2921 kind = 16;
2922 jjCheckNAddTwoStates(41, 42);
2923 }
2924 else if (curChar == 46)
2925 jjCheckNAdd(32);
2926 else if (curChar == 39)
2927 jjCheckNAddStates(133, 136);
2928 else if (curChar == 34)
2929 jjCheckNAddStates(137, 140);
2930 else if (curChar == 35)
2931 jjstateSet[jjnewStateCnt++] = 2;
2932 break;
2933 case 0:
2934 if (curChar == 42)
2935 jjstateSet[jjnewStateCnt++] = 1;
2936 break;
2937 case 1:
2938 if ((0xfffffff7ffffffffL & l) != 0L && kind > 19)
2939 kind = 19;
2940 break;
2941 case 2:
2942 if (curChar == 42)
2943 jjstateSet[jjnewStateCnt++] = 0;
2944 break;
2945 case 4:
2946 if ((0x100002600L & l) == 0L)
2947 break;
2948 if (kind > 32)
2949 kind = 32;
2950 jjCheckNAdd(4);
2951 break;
2952 case 5:
2953 case 7:
2954 if (curChar == 34)
2955 jjCheckNAddStates(137, 140);
2956 break;
2957 case 6:
2958 if ((0xfffffffbffffffffL & l) != 0L)
2959 jjCheckNAddStates(137, 140);
2960 break;
2961 case 8:
2962 if (curChar == 34)
2963 jjstateSet[jjnewStateCnt++] = 7;
2964 break;
2965 case 9:
2966 if (curChar == 34 && kind > 33)
2967 kind = 33;
2968 break;
2969 case 12:
2970 if ((0xff000000000000L & l) != 0L)
2971 jjCheckNAddStates(141, 145);
2972 break;
2973 case 13:
2974 if ((0xff000000000000L & l) != 0L)
2975 jjCheckNAddStates(137, 140);
2976 break;
2977 case 14:
2978 if ((0xf000000000000L & l) != 0L)
2979 jjstateSet[jjnewStateCnt++] = 15;
2980 break;
2981 case 15:
2982 if ((0xff000000000000L & l) != 0L)
2983 jjCheckNAdd(13);
2984 break;
2985 case 17:
2986 if ((0x3ff000000000000L & l) != 0L)
2987 jjstateSet[jjnewStateCnt++] = 18;
2988 break;
2989 case 18:
2990 if ((0x3ff000000000000L & l) != 0L)
2991 jjstateSet[jjnewStateCnt++] = 19;
2992 break;
2993 case 19:
2994 if ((0x3ff000000000000L & l) != 0L)
2995 jjstateSet[jjnewStateCnt++] = 20;
2996 break;
2997 case 20:
2998 if ((0x3ff000000000000L & l) != 0L)
2999 jjCheckNAddStates(137, 140);
3000 break;
3001 case 21:
3002 if (curChar == 32)
3003 jjAddStates(146, 147);
3004 break;
3005 case 22:
3006 if (curChar == 10)
3007 jjCheckNAddStates(137, 140);
3008 break;
3009 case 23:
3010 case 25:
3011 if (curChar == 39)
3012 jjCheckNAddStates(133, 136);
3013 break;
3014 case 24:
3015 if ((0xffffff7fffffffffL & l) != 0L)
3016 jjCheckNAddStates(133, 136);
3017 break;
3018 case 26:
3019 if (curChar == 39)
3020 jjstateSet[jjnewStateCnt++] = 25;
3021 break;
3022 case 28:
3023 if (curChar == 32)
3024 jjAddStates(148, 149);
3025 break;
3026 case 29:
3027 if (curChar == 10)
3028 jjCheckNAddStates(133, 136);
3029 break;
3030 case 30:
3031 if (curChar == 39 && kind > 33)
3032 kind = 33;
3033 break;
3034 case 31:
3035 if (curChar == 46)
3036 jjCheckNAdd(32);
3037 break;
3038 case 32:
3039 if ((0x3ff000000000000L & l) == 0L)
3040 break;
3041 if (kind > 59)
3042 kind = 59;
3043 jjCheckNAddTwoStates(32, 33);
3044 break;
3045 case 34:
3046 if ((0x280000000000L & l) != 0L)
3047 jjCheckNAdd(35);
3048 break;
3049 case 35:
3050 if ((0x3ff000000000000L & l) == 0L)
3051 break;
3052 if (kind > 59)
3053 kind = 59;
3054 jjCheckNAdd(35);
3055 break;
3056 case 38:
3057 if (curChar == 36 && kind > 16)
3058 kind = 16;
3059 break;
3060 case 40:
3061 if (curChar == 36)
3062 jjCheckNAddTwoStates(41, 42);
3063 break;
3064 case 42:
3065 if (curChar == 33 && kind > 17)
3066 kind = 17;
3067 break;
3068 case 43:
3069 if (curChar != 36)
3070 break;
3071 if (kind > 16)
3072 kind = 16;
3073 jjCheckNAddTwoStates(41, 42);
3074 break;
3075 case 44:
3076 if (curChar == 45)
3077 jjCheckNAddStates(129, 132);
3078 break;
3079 case 45:
3080 if ((0x3ff000000000000L & l) == 0L)
3081 break;
3082 if (kind > 58)
3083 kind = 58;
3084 jjCheckNAddTwoStates(45, 47);
3085 break;
3086 case 46:
3087 if (curChar == 46 && kind > 58)
3088 kind = 58;
3089 break;
3090 case 47:
3091 if (curChar == 46)
3092 jjstateSet[jjnewStateCnt++] = 46;
3093 break;
3094 case 48:
3095 if ((0x3ff000000000000L & l) != 0L)
3096 jjCheckNAddTwoStates(48, 49);
3097 break;
3098 case 49:
3099 if (curChar != 46)
3100 break;
3101 if (kind > 59)
3102 kind = 59;
3103 jjCheckNAddTwoStates(50, 51);
3104 break;
3105 case 50:
3106 if ((0x3ff000000000000L & l) == 0L)
3107 break;
3108 if (kind > 59)
3109 kind = 59;
3110 jjCheckNAddTwoStates(50, 51);
3111 break;
3112 case 52:
3113 if ((0x280000000000L & l) != 0L)
3114 jjCheckNAdd(53);
3115 break;
3116 case 53:
3117 if ((0x3ff000000000000L & l) == 0L)
3118 break;
3119 if (kind > 59)
3120 kind = 59;
3121 jjCheckNAdd(53);
3122 break;
3123 case 54:
3124 if ((0x3ff000000000000L & l) != 0L)
3125 jjCheckNAddTwoStates(54, 55);
3126 break;
3127 case 56:
3128 if ((0x280000000000L & l) != 0L)
3129 jjCheckNAdd(57);
3130 break;
3131 case 57:
3132 if ((0x3ff000000000000L & l) == 0L)
3133 break;
3134 if (kind > 59)
3135 kind = 59;
3136 jjCheckNAdd(57);
3137 break;
3138 case 58:
3139 if ((0x3ff000000000000L & l) == 0L)
3140 break;
3141 if (kind > 58)
3142 kind = 58;
3143 jjCheckNAddStates(123, 128);
3144 break;
3145 default : break;
3146 }
3147 } while(i != startsAt);
3148 }
3149 else if (curChar < 128)
3150 {
3151 long l = 1L << (curChar & 077);
3152 do
3153 {
3154 switch(jjstateSet[--i])
3155 {
3156 case 3:
3157 if (curChar == 92)
3158 jjCheckNAddStates(150, 153);
3159 break;
3160 case 1:
3161 if (kind > 19)
3162 kind = 19;
3163 break;
3164 case 6:
3165 jjCheckNAddStates(137, 140);
3166 break;
3167 case 10:
3168 if (curChar == 92)
3169 jjAddStates(154, 159);
3170 break;
3171 case 11:
3172 if ((0x14404400144044L & l) != 0L)
3173 jjCheckNAddStates(137, 140);
3174 break;
3175 case 16:
3176 if ((0x20000000200000L & l) != 0L)
3177 jjstateSet[jjnewStateCnt++] = 17;
3178 break;
3179 case 17:
3180 if ((0x7e0000007eL & l) != 0L)
3181 jjstateSet[jjnewStateCnt++] = 18;
3182 break;
3183 case 18:
3184 if ((0x7e0000007eL & l) != 0L)
3185 jjstateSet[jjnewStateCnt++] = 19;
3186 break;
3187 case 19:
3188 if ((0x7e0000007eL & l) != 0L)
3189 jjstateSet[jjnewStateCnt++] = 20;
3190 break;
3191 case 20:
3192 if ((0x7e0000007eL & l) != 0L)
3193 jjCheckNAddStates(137, 140);
3194 break;
3195 case 24:
3196 jjAddStates(133, 136);
3197 break;
3198 case 27:
3199 if (curChar == 92)
3200 jjAddStates(148, 149);
3201 break;
3202 case 33:
3203 if ((0x2000000020L & l) != 0L)
3204 jjAddStates(160, 161);
3205 break;
3206 case 37:
3207 if (curChar == 92)
3208 jjCheckNAddTwoStates(37, 38);
3209 break;
3210 case 39:
3211 if (curChar == 92)
3212 jjCheckNAddTwoStates(39, 40);
3213 break;
3214 case 41:
3215 if (curChar == 92)
3216 jjAddStates(162, 163);
3217 break;
3218 case 51:
3219 if ((0x2000000020L & l) != 0L)
3220 jjAddStates(164, 165);
3221 break;
3222 case 55:
3223 if ((0x2000000020L & l) != 0L)
3224 jjAddStates(166, 167);
3225 break;
3226 default : break;
3227 }
3228 } while(i != startsAt);
3229 }
3230 else
3231 {
3232 int hiByte = (int)(curChar >> 8);
3233 int i1 = hiByte >> 6;
3234 long l1 = 1L << (hiByte & 077);
3235 int i2 = (curChar & 0xff) >> 6;
3236 long l2 = 1L << (curChar & 077);
3237 do
3238 {
3239 switch(jjstateSet[--i])
3240 {
3241 case 1:
3242 if (jjCanMove_0(hiByte, i1, i2, l1, l2) && kind > 19)
3243 kind = 19;
3244 break;
3245 case 6:
3246 if (jjCanMove_0(hiByte, i1, i2, l1, l2))
3247 jjAddStates(137, 140);
3248 break;
3249 case 24:
3250 if (jjCanMove_0(hiByte, i1, i2, l1, l2))
3251 jjAddStates(133, 136);
3252 break;
3253 default : break;
3254 }
3255 } while(i != startsAt);
3256 }
3257 if (kind != 0x7fffffff)
3258 {
3259 jjmatchedKind = kind;
3260 jjmatchedPos = curPos;
3261 kind = 0x7fffffff;
3262 }
3263 ++curPos;
3264 if ((i = jjnewStateCnt) == (startsAt = 59 - (jjnewStateCnt = startsAt)))
3265 return curPos;
3266 try { curChar = input_stream.readChar(); }
3267 catch(java.io.IOException e) { return curPos; }
3268 }
3269 }
3270 private final int jjStopStringLiteralDfa_10(int pos, long active0)
3271 {
3272 switch (pos)
3273 {
3274 case 0:
3275 if ((active0 & 0x340000L) != 0L)
3276 return 2;
3277 return -1;
3278 case 1:
3279 if ((active0 & 0x100000L) != 0L)
3280 return 0;
3281 return -1;
3282 default :
3283 return -1;
3284 }
3285 }
3286 private final int jjStartNfa_10(int pos, long active0)
3287 {
3288 return jjMoveNfa_10(jjStopStringLiteralDfa_10(pos, active0), pos + 1);
3289 }
3290 private int jjMoveStringLiteralDfa0_10()
3291 {
3292 switch(curChar)
3293 {
3294 case 35:
3295 jjmatchedKind = 21;
3296 return jjMoveStringLiteralDfa1_10(0x140000L);
3297 default :
3298 return jjMoveNfa_10(3, 0);
3299 }
3300 }
3301 private int jjMoveStringLiteralDfa1_10(long active0)
3302 {
3303 try { curChar = input_stream.readChar(); }
3304 catch(java.io.IOException e) {
3305 jjStopStringLiteralDfa_10(0, active0);
3306 return 1;
3307 }
3308 switch(curChar)
3309 {
3310 case 42:
3311 if ((active0 & 0x100000L) != 0L)
3312 return jjStartNfaWithStates_10(1, 20, 0);
3313 break;
3314 case 91:
3315 return jjMoveStringLiteralDfa2_10(active0, 0x40000L);
3316 default :
3317 break;
3318 }
3319 return jjStartNfa_10(0, active0);
3320 }
3321 private int jjMoveStringLiteralDfa2_10(long old0, long active0)
3322 {
3323 if (((active0 &= old0)) == 0L)
3324 return jjStartNfa_10(0, old0);
3325 try { curChar = input_stream.readChar(); }
3326 catch(java.io.IOException e) {
3327 jjStopStringLiteralDfa_10(1, active0);
3328 return 2;
3329 }
3330 switch(curChar)
3331 {
3332 case 91:
3333 if ((active0 & 0x40000L) != 0L)
3334 return jjStopAtPos(2, 18);
3335 break;
3336 default :
3337 break;
3338 }
3339 return jjStartNfa_10(1, active0);
3340 }
3341 private int jjStartNfaWithStates_10(int pos, int kind, int state)
3342 {
3343 jjmatchedKind = kind;
3344 jjmatchedPos = pos;
3345 try { curChar = input_stream.readChar(); }
3346 catch(java.io.IOException e) { return pos + 1; }
3347 return jjMoveNfa_10(state, pos + 1);
3348 }
3349 private int jjMoveNfa_10(int startState, int curPos)
3350 {
3351 int startsAt = 0;
3352 jjnewStateCnt = 15;
3353 int i = 1;
3354 jjstateSet[0] = startState;
3355 int kind = 0x7fffffff;
3356 for (;;)
3357 {
3358 if (++jjround == 0x7fffffff)
3359 ReInitRounds();
3360 if (curChar < 64)
3361 {
3362 long l = 1L << curChar;
3363 do
3364 {
3365 switch(jjstateSet[--i])
3366 {
3367 case 3:
3368 if ((0x2400L & l) != 0L)
3369 {
3370 if (kind > 26)
3371 kind = 26;
3372 }
3373 else if (curChar == 36)
3374 {
3375 if (kind > 16)
3376 kind = 16;
3377 jjCheckNAddTwoStates(12, 13);
3378 }
3379 else if (curChar == 35)
3380 jjstateSet[jjnewStateCnt++] = 2;
3381 if (curChar == 13)
3382 jjstateSet[jjnewStateCnt++] = 5;
3383 break;
3384 case 0:
3385 if (curChar == 42)
3386 jjstateSet[jjnewStateCnt++] = 1;
3387 break;
3388 case 1:
3389 if ((0xfffffff7ffffffffL & l) != 0L && kind > 19)
3390 kind = 19;
3391 break;
3392 case 2:
3393 if (curChar == 42)
3394 jjstateSet[jjnewStateCnt++] = 0;
3395 break;
3396 case 4:
3397 if ((0x2400L & l) != 0L && kind > 26)
3398 kind = 26;
3399 break;
3400 case 5:
3401 if (curChar == 10 && kind > 26)
3402 kind = 26;
3403 break;
3404 case 6:
3405 if (curChar == 13)
3406 jjstateSet[jjnewStateCnt++] = 5;
3407 break;
3408 case 9:
3409 if (curChar == 36 && kind > 16)
3410 kind = 16;
3411 break;
3412 case 11:
3413 if (curChar == 36)
3414 jjCheckNAddTwoStates(12, 13);
3415 break;
3416 case 13:
3417 if (curChar == 33 && kind > 17)
3418 kind = 17;
3419 break;
3420 case 14:
3421 if (curChar != 36)
3422 break;
3423 if (kind > 16)
3424 kind = 16;
3425 jjCheckNAddTwoStates(12, 13);
3426 break;
3427 default : break;
3428 }
3429 } while(i != startsAt);
3430 }
3431 else if (curChar < 128)
3432 {
3433 long l = 1L << (curChar & 077);
3434 do
3435 {
3436 switch(jjstateSet[--i])
3437 {
3438 case 3:
3439 if (curChar == 92)
3440 jjCheckNAddStates(168, 171);
3441 break;
3442 case 1:
3443 if (kind > 19)
3444 kind = 19;
3445 break;
3446 case 8:
3447 if (curChar == 92)
3448 jjCheckNAddTwoStates(8, 9);
3449 break;
3450 case 10:
3451 if (curChar == 92)
3452 jjCheckNAddTwoStates(10, 11);
3453 break;
3454 case 12:
3455 if (curChar == 92)
3456 jjAddStates(172, 173);
3457 break;
3458 default : break;
3459 }
3460 } while(i != startsAt);
3461 }
3462 else
3463 {
3464 int hiByte = (int)(curChar >> 8);
3465 int i1 = hiByte >> 6;
3466 long l1 = 1L << (hiByte & 077);
3467 int i2 = (curChar & 0xff) >> 6;
3468 long l2 = 1L << (curChar & 077);
3469 do
3470 {
3471 switch(jjstateSet[--i])
3472 {
3473 case 1:
3474 if (jjCanMove_0(hiByte, i1, i2, l1, l2) && kind > 19)
3475 kind = 19;
3476 break;
3477 default : break;
3478 }
3479 } while(i != startsAt);
3480 }
3481 if (kind != 0x7fffffff)
3482 {
3483 jjmatchedKind = kind;
3484 jjmatchedPos = curPos;
3485 kind = 0x7fffffff;
3486 }
3487 ++curPos;
3488 if ((i = jjnewStateCnt) == (startsAt = 15 - (jjnewStateCnt = startsAt)))
3489 return curPos;
3490 try { curChar = input_stream.readChar(); }
3491 catch(java.io.IOException e) { return curPos; }
3492 }
3493 }
3494 private final int jjStopStringLiteralDfa_0(int pos, long active0, long active1)
3495 {
3496 switch (pos)
3497 {
3498 case 0:
3499 if ((active0 & 0x740000L) != 0L)
3500 return 33;
3501 if ((active0 & 0xc00000000L) != 0L)
3502 {
3503 jjmatchedKind = 68;
3504 return 13;
3505 }
3506 return -1;
3507 case 1:
3508 if ((active0 & 0xc00000000L) != 0L)
3509 {
3510 jjmatchedKind = 68;
3511 jjmatchedPos = 1;
3512 return 13;
3513 }
3514 if ((active0 & 0x100000L) != 0L)
3515 return 31;
3516 return -1;
3517 case 2:
3518 if ((active0 & 0xc00000000L) != 0L)
3519 {
3520 jjmatchedKind = 68;
3521 jjmatchedPos = 2;
3522 return 13;
3523 }
3524 return -1;
3525 case 3:
3526 if ((active0 & 0x800000000L) != 0L)
3527 {
3528 jjmatchedKind = 68;
3529 jjmatchedPos = 3;
3530 return 13;
3531 }
3532 if ((active0 & 0x400000000L) != 0L)
3533 return 13;
3534 return -1;
3535 default :
3536 return -1;
3537 }
3538 }
3539 private final int jjStartNfa_0(int pos, long active0, long active1)
3540 {
3541 return jjMoveNfa_0(jjStopStringLiteralDfa_0(pos, active0, active1), pos + 1);
3542 }
3543 private int jjMoveStringLiteralDfa0_0()
3544 {
3545 switch(curChar)
3546 {
3547 case 35:
3548 jjmatchedKind = 21;
3549 return jjMoveStringLiteralDfa1_0(0x540000L);
3550 case 91:
3551 return jjStopAtPos(0, 1);
3552 case 70:
3553 case 102:
3554 return jjMoveStringLiteralDfa1_0(0x800000000L);
3555 case 84:
3556 case 116:
3557 return jjMoveStringLiteralDfa1_0(0x400000000L);
3558 case 123:
3559 return jjStopAtPos(0, 70);
3560 case 125:
3561 return jjStopAtPos(0, 71);
3562 default :
3563 return jjMoveNfa_0(12, 0);
3564 }
3565 }
3566 private int jjMoveStringLiteralDfa1_0(long active0)
3567 {
3568 try { curChar = input_stream.readChar(); }
3569 catch(java.io.IOException e) {
3570 jjStopStringLiteralDfa_0(0, active0, 0L);
3571 return 1;
3572 }
3573 switch(curChar)
3574 {
3575 case 35:
3576 if ((active0 & 0x400000L) != 0L)
3577 return jjStopAtPos(1, 22);
3578 break;
3579 case 42:
3580 if ((active0 & 0x100000L) != 0L)
3581 return jjStartNfaWithStates_0(1, 20, 31);
3582 break;
3583 case 91:
3584 return jjMoveStringLiteralDfa2_0(active0, 0x40000L);
3585 case 65:
3586 case 97:
3587 return jjMoveStringLiteralDfa2_0(active0, 0x800000000L);
3588 case 82:
3589 case 114:
3590 return jjMoveStringLiteralDfa2_0(active0, 0x400000000L);
3591 default :
3592 break;
3593 }
3594 return jjStartNfa_0(0, active0, 0L);
3595 }
3596 private int jjMoveStringLiteralDfa2_0(long old0, long active0)
3597 {
3598 if (((active0 &= old0)) == 0L)
3599 return jjStartNfa_0(0, old0, 0L);
3600 try { curChar = input_stream.readChar(); }
3601 catch(java.io.IOException e) {
3602 jjStopStringLiteralDfa_0(1, active0, 0L);
3603 return 2;
3604 }
3605 switch(curChar)
3606 {
3607 case 91:
3608 if ((active0 & 0x40000L) != 0L)
3609 return jjStopAtPos(2, 18);
3610 break;
3611 case 76:
3612 case 108:
3613 return jjMoveStringLiteralDfa3_0(active0, 0x800000000L);
3614 case 85:
3615 case 117:
3616 return jjMoveStringLiteralDfa3_0(active0, 0x400000000L);
3617 default :
3618 break;
3619 }
3620 return jjStartNfa_0(1, active0, 0L);
3621 }
3622 private int jjMoveStringLiteralDfa3_0(long old0, long active0)
3623 {
3624 if (((active0 &= old0)) == 0L)
3625 return jjStartNfa_0(1, old0, 0L);
3626 try { curChar = input_stream.readChar(); }
3627 catch(java.io.IOException e) {
3628 jjStopStringLiteralDfa_0(2, active0, 0L);
3629 return 3;
3630 }
3631 switch(curChar)
3632 {
3633 case 69:
3634 case 101:
3635 if ((active0 & 0x400000000L) != 0L)
3636 return jjStartNfaWithStates_0(3, 34, 13);
3637 break;
3638 case 83:
3639 case 115:
3640 return jjMoveStringLiteralDfa4_0(active0, 0x800000000L);
3641 default :
3642 break;
3643 }
3644 return jjStartNfa_0(2, active0, 0L);
3645 }
3646 private int jjMoveStringLiteralDfa4_0(long old0, long active0)
3647 {
3648 if (((active0 &= old0)) == 0L)
3649 return jjStartNfa_0(2, old0, 0L);
3650 try { curChar = input_stream.readChar(); }
3651 catch(java.io.IOException e) {
3652 jjStopStringLiteralDfa_0(3, active0, 0L);
3653 return 4;
3654 }
3655 switch(curChar)
3656 {
3657 case 69:
3658 case 101:
3659 if ((active0 & 0x800000000L) != 0L)
3660 return jjStartNfaWithStates_0(4, 35, 13);
3661 break;
3662 default :
3663 break;
3664 }
3665 return jjStartNfa_0(3, active0, 0L);
3666 }
3667 private int jjStartNfaWithStates_0(int pos, int kind, int state)
3668 {
3669 jjmatchedKind = kind;
3670 jjmatchedPos = pos;
3671 try { curChar = input_stream.readChar(); }
3672 catch(java.io.IOException e) { return pos + 1; }
3673 return jjMoveNfa_0(state, pos + 1);
3674 }
3675 private int jjMoveNfa_0(int startState, int curPos)
3676 {
3677 int startsAt = 0;
3678 jjnewStateCnt = 34;
3679 int i = 1;
3680 jjstateSet[0] = startState;
3681 int kind = 0x7fffffff;
3682 for (;;)
3683 {
3684 if (++jjround == 0x7fffffff)
3685 ReInitRounds();
3686 if (curChar < 64)
3687 {
3688 long l = 1L << curChar;
3689 do
3690 {
3691 switch(jjstateSet[--i])
3692 {
3693 case 12:
3694 if ((0x100000200L & l) != 0L)
3695 jjCheckNAddTwoStates(0, 1);
3696 else if (curChar == 35)
3697 jjCheckNAddStates(174, 176);
3698 else if (curChar == 36)
3699 {
3700 if (kind > 16)
3701 kind = 16;
3702 jjCheckNAddTwoStates(27, 28);
3703 }
3704 else if (curChar == 46)
3705 jjstateSet[jjnewStateCnt++] = 15;
3706 if (curChar == 36)
3707 jjCheckNAddStates(177, 180);
3708 break;
3709 case 33:
3710 if (curChar == 42)
3711 jjstateSet[jjnewStateCnt++] = 31;
3712 break;
3713 case 0:
3714 if ((0x100000200L & l) != 0L)
3715 jjCheckNAddTwoStates(0, 1);
3716 break;
3717 case 1:
3718 if (curChar == 35)
3719 jjCheckNAddTwoStates(6, 11);
3720 break;
3721 case 3:
3722 if (curChar == 32)
3723 jjAddStates(115, 116);
3724 break;
3725 case 4:
3726 if (curChar == 40 && kind > 15)
3727 kind = 15;
3728 break;
3729 case 13:
3730 if ((0x3ff200000000000L & l) == 0L)
3731 break;
3732 if (kind > 68)
3733 kind = 68;
3734 jjstateSet[jjnewStateCnt++] = 13;
3735 break;
3736 case 14:
3737 if (curChar == 46)
3738 jjstateSet[jjnewStateCnt++] = 15;
3739 break;
3740 case 16:
3741 if (curChar == 36)
3742 jjCheckNAddStates(177, 180);
3743 break;
3744 case 18:
3745 case 19:
3746 if (curChar == 33)
3747 jjCheckNAdd(17);
3748 break;
3749 case 21:
3750 if (curChar == 46 && kind > 74)
3751 kind = 74;
3752 break;
3753 case 24:
3754 if (curChar == 36 && kind > 16)
3755 kind = 16;
3756 break;
3757 case 26:
3758 if (curChar == 36)
3759 jjCheckNAddTwoStates(27, 28);
3760 break;
3761 case 28:
3762 if (curChar == 33 && kind > 17)
3763 kind = 17;
3764 break;
3765 case 29:
3766 if (curChar != 36)
3767 break;
3768 if (kind > 16)
3769 kind = 16;
3770 jjCheckNAddTwoStates(27, 28);
3771 break;
3772 case 30:
3773 if (curChar == 35)
3774 jjCheckNAddStates(174, 176);
3775 break;
3776 case 31:
3777 if (curChar == 42)
3778 jjstateSet[jjnewStateCnt++] = 32;
3779 break;
3780 case 32:
3781 if ((0xfffffff7ffffffffL & l) != 0L && kind > 19)
3782 kind = 19;
3783 break;
3784 default : break;
3785 }
3786 } while(i != startsAt);
3787 }
3788 else if (curChar < 128)
3789 {
3790 long l = 1L << (curChar & 077);
3791 do
3792 {
3793 switch(jjstateSet[--i])
3794 {
3795 case 12:
3796 if ((0x7fffffe87fffffeL & l) != 0L)
3797 {
3798 if (kind > 68)
3799 kind = 68;
3800 jjCheckNAdd(13);
3801 }
3802 else if (curChar == 92)
3803 jjCheckNAddStates(181, 184);
3804 break;
3805 case 33:
3806 if ((0x8000000080000L & l) != 0L)
3807 jjstateSet[jjnewStateCnt++] = 5;
3808 else if (curChar == 123)
3809 jjstateSet[jjnewStateCnt++] = 10;
3810 break;
3811 case 2:
3812 if ((0x10000000100000L & l) != 0L)
3813 jjCheckNAddTwoStates(3, 4);
3814 break;
3815 case 5:
3816 if ((0x2000000020L & l) != 0L)
3817 jjstateSet[jjnewStateCnt++] = 2;
3818 break;
3819 case 6:
3820 if ((0x8000000080000L & l) != 0L)
3821 jjstateSet[jjnewStateCnt++] = 5;
3822 break;
3823 case 7:
3824 if (curChar == 125)
3825 jjCheckNAddTwoStates(3, 4);
3826 break;
3827 case 8:
3828 if ((0x10000000100000L & l) != 0L)
3829 jjstateSet[jjnewStateCnt++] = 7;
3830 break;
3831 case 9:
3832 if ((0x2000000020L & l) != 0L)
3833 jjstateSet[jjnewStateCnt++] = 8;
3834 break;
3835 case 10:
3836 if ((0x8000000080000L & l) != 0L)
3837 jjstateSet[jjnewStateCnt++] = 9;
3838 break;
3839 case 11:
3840 if (curChar == 123)
3841 jjstateSet[jjnewStateCnt++] = 10;
3842 break;
3843 case 13:
3844 if ((0x7fffffe87fffffeL & l) == 0L)
3845 break;
3846 if (kind > 68)
3847 kind = 68;
3848 jjCheckNAdd(13);
3849 break;
3850 case 15:
3851 if ((0x7fffffe07fffffeL & l) != 0L && kind > 69)
3852 kind = 69;
3853 break;
3854 case 17:
3855 if (curChar == 91 && kind > 74)
3856 kind = 74;
3857 break;
3858 case 20:
3859 if (curChar == 92)
3860 jjstateSet[jjnewStateCnt++] = 19;
3861 break;
3862 case 22:
3863 if (curChar == 92)
3864 jjCheckNAddStates(181, 184);
3865 break;
3866 case 23:
3867 if (curChar == 92)
3868 jjCheckNAddTwoStates(23, 24);
3869 break;
3870 case 25:
3871 if (curChar == 92)
3872 jjCheckNAddTwoStates(25, 26);
3873 break;
3874 case 27:
3875 if (curChar == 92)
3876 jjAddStates(185, 186);
3877 break;
3878 case 32:
3879 if (kind > 19)
3880 kind = 19;
3881 break;
3882 default : break;
3883 }
3884 } while(i != startsAt);
3885 }
3886 else
3887 {
3888 int hiByte = (int)(curChar >> 8);
3889 int i1 = hiByte >> 6;
3890 long l1 = 1L << (hiByte & 077);
3891 int i2 = (curChar & 0xff) >> 6;
3892 long l2 = 1L << (curChar & 077);
3893 do
3894 {
3895 switch(jjstateSet[--i])
3896 {
3897 case 32:
3898 if (jjCanMove_0(hiByte, i1, i2, l1, l2) && kind > 19)
3899 kind = 19;
3900 break;
3901 default : break;
3902 }
3903 } while(i != startsAt);
3904 }
3905 if (kind != 0x7fffffff)
3906 {
3907 jjmatchedKind = kind;
3908 jjmatchedPos = curPos;
3909 kind = 0x7fffffff;
3910 }
3911 ++curPos;
3912 if ((i = jjnewStateCnt) == (startsAt = 34 - (jjnewStateCnt = startsAt)))
3913 return curPos;
3914 try { curChar = input_stream.readChar(); }
3915 catch(java.io.IOException e) { return curPos; }
3916 }
3917 }
3918 private final int jjStopStringLiteralDfa_4(int pos, long active0)
3919 {
3920 switch (pos)
3921 {
3922 case 0:
3923 if ((active0 & 0x340000L) != 0L)
3924 return 52;
3925 if ((active0 & 0x40L) != 0L)
3926 return 74;
3927 if ((active0 & 0xc00000080L) != 0L)
3928 {
3929 jjmatchedKind = 68;
3930 return 40;
3931 }
3932 return -1;
3933 case 1:
3934 if ((active0 & 0xc00000000L) != 0L)
3935 {
3936 jjmatchedKind = 68;
3937 jjmatchedPos = 1;
3938 return 40;
3939 }
3940 if ((active0 & 0x100000L) != 0L)
3941 return 50;
3942 if ((active0 & 0x80L) != 0L)
3943 return 40;
3944 return -1;
3945 case 2:
3946 if ((active0 & 0xc00000000L) != 0L)
3947 {
3948 jjmatchedKind = 68;
3949 jjmatchedPos = 2;
3950 return 40;
3951 }
3952 return -1;
3953 case 3:
3954 if ((active0 & 0x800000000L) != 0L)
3955 {
3956 jjmatchedKind = 68;
3957 jjmatchedPos = 3;
3958 return 40;
3959 }
3960 if ((active0 & 0x400000000L) != 0L)
3961 return 40;
3962 return -1;
3963 default :
3964 return -1;
3965 }
3966 }
3967 private final int jjStartNfa_4(int pos, long active0)
3968 {
3969 return jjMoveNfa_4(jjStopStringLiteralDfa_4(pos, active0), pos + 1);
3970 }
3971 private int jjMoveStringLiteralDfa0_4()
3972 {
3973 switch(curChar)
3974 {
3975 case 35:
3976 jjmatchedKind = 21;
3977 return jjMoveStringLiteralDfa1_4(0x140000L);
3978 case 41:
3979 return jjStopAtPos(0, 13);
3980 case 44:
3981 return jjStopAtPos(0, 5);
3982 case 46:
3983 return jjMoveStringLiteralDfa1_4(0x40L);
3984 case 58:
3985 return jjStopAtPos(0, 8);
3986 case 91:
3987 return jjStopAtPos(0, 3);
3988 case 93:
3989 return jjStopAtPos(0, 4);
3990 case 70:
3991 case 102:
3992 return jjMoveStringLiteralDfa1_4(0x800000000L);
3993 case 73:
3994 case 105:
3995 return jjMoveStringLiteralDfa1_4(0x80L);
3996 case 84:
3997 case 116:
3998 return jjMoveStringLiteralDfa1_4(0x400000000L);
3999 case 123:
4000 return jjStopAtPos(0, 9);
4001 case 125:
4002 return jjStopAtPos(0, 10);
4003 default :
4004 return jjMoveNfa_4(13, 0);
4005 }
4006 }
4007 private int jjMoveStringLiteralDfa1_4(long active0)
4008 {
4009 try { curChar = input_stream.readChar(); }
4010 catch(java.io.IOException e) {
4011 jjStopStringLiteralDfa_4(0, active0);
4012 return 1;
4013 }
4014 switch(curChar)
4015 {
4016 case 42:
4017 if ((active0 & 0x100000L) != 0L)
4018 return jjStartNfaWithStates_4(1, 20, 50);
4019 break;
4020 case 46:
4021 if ((active0 & 0x40L) != 0L)
4022 return jjStopAtPos(1, 6);
4023 break;
4024 case 91:
4025 return jjMoveStringLiteralDfa2_4(active0, 0x40000L);
4026 case 65:
4027 case 97:
4028 return jjMoveStringLiteralDfa2_4(active0, 0x800000000L);
4029 case 78:
4030 case 110:
4031 if ((active0 & 0x80L) != 0L)
4032 return jjStartNfaWithStates_4(1, 7, 40);
4033 break;
4034 case 82:
4035 case 114:
4036 return jjMoveStringLiteralDfa2_4(active0, 0x400000000L);
4037 default :
4038 break;
4039 }
4040 return jjStartNfa_4(0, active0);
4041 }
4042 private int jjMoveStringLiteralDfa2_4(long old0, long active0)
4043 {
4044 if (((active0 &= old0)) == 0L)
4045 return jjStartNfa_4(0, old0);
4046 try { curChar = input_stream.readChar(); }
4047 catch(java.io.IOException e) {
4048 jjStopStringLiteralDfa_4(1, active0);
4049 return 2;
4050 }
4051 switch(curChar)
4052 {
4053 case 91:
4054 if ((active0 & 0x40000L) != 0L)
4055 return jjStopAtPos(2, 18);
4056 break;
4057 case 76:
4058 case 108:
4059 return jjMoveStringLiteralDfa3_4(active0, 0x800000000L);
4060 case 85:
4061 case 117:
4062 return jjMoveStringLiteralDfa3_4(active0, 0x400000000L);
4063 default :
4064 break;
4065 }
4066 return jjStartNfa_4(1, active0);
4067 }
4068 private int jjMoveStringLiteralDfa3_4(long old0, long active0)
4069 {
4070 if (((active0 &= old0)) == 0L)
4071 return jjStartNfa_4(1, old0);
4072 try { curChar = input_stream.readChar(); }
4073 catch(java.io.IOException e) {
4074 jjStopStringLiteralDfa_4(2, active0);
4075 return 3;
4076 }
4077 switch(curChar)
4078 {
4079 case 69:
4080 case 101:
4081 if ((active0 & 0x400000000L) != 0L)
4082 return jjStartNfaWithStates_4(3, 34, 40);
4083 break;
4084 case 83:
4085 case 115:
4086 return jjMoveStringLiteralDfa4_4(active0, 0x800000000L);
4087 default :
4088 break;
4089 }
4090 return jjStartNfa_4(2, active0);
4091 }
4092 private int jjMoveStringLiteralDfa4_4(long old0, long active0)
4093 {
4094 if (((active0 &= old0)) == 0L)
4095 return jjStartNfa_4(2, old0);
4096 try { curChar = input_stream.readChar(); }
4097 catch(java.io.IOException e) {
4098 jjStopStringLiteralDfa_4(3, active0);
4099 return 4;
4100 }
4101 switch(curChar)
4102 {
4103 case 69:
4104 case 101:
4105 if ((active0 & 0x800000000L) != 0L)
4106 return jjStartNfaWithStates_4(4, 35, 40);
4107 break;
4108 default :
4109 break;
4110 }
4111 return jjStartNfa_4(3, active0);
4112 }
4113 private int jjStartNfaWithStates_4(int pos, int kind, int state)
4114 {
4115 jjmatchedKind = kind;
4116 jjmatchedPos = pos;
4117 try { curChar = input_stream.readChar(); }
4118 catch(java.io.IOException e) { return pos + 1; }
4119 return jjMoveNfa_4(state, pos + 1);
4120 }
4121 private int jjMoveNfa_4(int startState, int curPos)
4122 {
4123 int startsAt = 0;
4124 jjnewStateCnt = 75;
4125 int i = 1;
4126 jjstateSet[0] = startState;
4127 int kind = 0x7fffffff;
4128 for (;;)
4129 {
4130 if (++jjround == 0x7fffffff)
4131 ReInitRounds();
4132 if (curChar < 64)
4133 {
4134 long l = 1L << curChar;
4135 do
4136 {
4137 switch(jjstateSet[--i])
4138 {
4139 case 52:
4140 if (curChar == 42)
4141 jjstateSet[jjnewStateCnt++] = 50;
4142 break;
4143 case 74:
4144 case 64:
4145 if ((0x3ff000000000000L & l) == 0L)
4146 break;
4147 if (kind > 59)
4148 kind = 59;
4149 jjCheckNAddTwoStates(64, 65);
4150 break;
4151 case 13:
4152 if ((0x3ff000000000000L & l) != 0L)
4153 {
4154 if (kind > 58)
4155 kind = 58;
4156 jjCheckNAddStates(187, 192);
4157 }
4158 else if ((0x100002600L & l) != 0L)
4159 {
4160 if (kind > 32)
4161 kind = 32;
4162 jjCheckNAdd(12);
4163 }
4164 else if (curChar == 46)
4165 jjCheckNAddTwoStates(64, 74);
4166 else if (curChar == 45)
4167 jjCheckNAddStates(193, 196);
4168 else if (curChar == 35)
4169 jjCheckNAddStates(197, 199);
4170 else if (curChar == 36)
4171 {
4172 if (kind > 16)
4173 kind = 16;
4174 jjCheckNAddTwoStates(46, 47);
4175 }
4176 else if (curChar == 39)
4177 jjCheckNAddStates(200, 203);
4178 else if (curChar == 34)
4179 jjCheckNAddStates(204, 207);
4180 if ((0x100000200L & l) != 0L)
4181 jjCheckNAddTwoStates(0, 1);
4182 break;
4183 case 0:
4184 if ((0x100000200L & l) != 0L)
4185 jjCheckNAddTwoStates(0, 1);
4186 break;
4187 case 1:
4188 if (curChar == 35)
4189 jjCheckNAddTwoStates(6, 11);
4190 break;
4191 case 3:
4192 if (curChar == 32)
4193 jjAddStates(115, 116);
4194 break;
4195 case 4:
4196 if (curChar == 40 && kind > 15)
4197 kind = 15;
4198 break;
4199 case 12:
4200 if ((0x100002600L & l) == 0L)
4201 break;
4202 if (kind > 32)
4203 kind = 32;
4204 jjCheckNAdd(12);
4205 break;
4206 case 14:
4207 if ((0xfffffffbffffffffL & l) != 0L)
4208 jjCheckNAddStates(204, 207);
4209 break;
4210 case 15:
4211 if (curChar == 34)
4212 jjCheckNAddStates(204, 207);
4213 break;
4214 case 16:
4215 if (curChar == 34)
4216 jjstateSet[jjnewStateCnt++] = 15;
4217 break;
4218 case 17:
4219 if (curChar == 34 && kind > 33)
4220 kind = 33;
4221 break;
4222 case 20:
4223 if ((0xff000000000000L & l) != 0L)
4224 jjCheckNAddStates(208, 212);
4225 break;
4226 case 21:
4227 if ((0xff000000000000L & l) != 0L)
4228 jjCheckNAddStates(204, 207);
4229 break;
4230 case 22:
4231 if ((0xf000000000000L & l) != 0L)
4232 jjstateSet[jjnewStateCnt++] = 23;
4233 break;
4234 case 23:
4235 if ((0xff000000000000L & l) != 0L)
4236 jjCheckNAdd(21);
4237 break;
4238 case 25:
4239 if ((0x3ff000000000000L & l) != 0L)
4240 jjstateSet[jjnewStateCnt++] = 26;
4241 break;
4242 case 26:
4243 if ((0x3ff000000000000L & l) != 0L)
4244 jjstateSet[jjnewStateCnt++] = 27;
4245 break;
4246 case 27:
4247 if ((0x3ff000000000000L & l) != 0L)
4248 jjstateSet[jjnewStateCnt++] = 28;
4249 break;
4250 case 28:
4251 if ((0x3ff000000000000L & l) != 0L)
4252 jjCheckNAddStates(204, 207);
4253 break;
4254 case 29:
4255 if (curChar == 32)
4256 jjAddStates(94, 95);
4257 break;
4258 case 30:
4259 if (curChar == 10)
4260 jjCheckNAddStates(204, 207);
4261 break;
4262 case 31:
4263 case 33:
4264 if (curChar == 39)
4265 jjCheckNAddStates(200, 203);
4266 break;
4267 case 32:
4268 if ((0xffffff7fffffffffL & l) != 0L)
4269 jjCheckNAddStates(200, 203);
4270 break;
4271 case 34:
4272 if (curChar == 39)
4273 jjstateSet[jjnewStateCnt++] = 33;
4274 break;
4275 case 36:
4276 if (curChar == 32)
4277 jjAddStates(213, 214);
4278 break;
4279 case 37:
4280 if (curChar == 10)
4281 jjCheckNAddStates(200, 203);
4282 break;
4283 case 38:
4284 if (curChar == 39 && kind > 33)
4285 kind = 33;
4286 break;
4287 case 40:
4288 if ((0x3ff200000000000L & l) == 0L)
4289 break;
4290 if (kind > 68)
4291 kind = 68;
4292 jjstateSet[jjnewStateCnt++] = 40;
4293 break;
4294 case 43:
4295 if (curChar == 36 && kind > 16)
4296 kind = 16;
4297 break;
4298 case 45:
4299 if (curChar == 36)
4300 jjCheckNAddTwoStates(46, 47);
4301 break;
4302 case 47:
4303 if (curChar == 33 && kind > 17)
4304 kind = 17;
4305 break;
4306 case 48:
4307 if (curChar != 36)
4308 break;
4309 if (kind > 16)
4310 kind = 16;
4311 jjCheckNAddTwoStates(46, 47);
4312 break;
4313 case 49:
4314 if (curChar == 35)
4315 jjCheckNAddStates(197, 199);
4316 break;
4317 case 50:
4318 if (curChar == 42)
4319 jjstateSet[jjnewStateCnt++] = 51;
4320 break;
4321 case 51:
4322 if ((0xfffffff7ffffffffL & l) != 0L && kind > 19)
4323 kind = 19;
4324 break;
4325 case 53:
4326 if (curChar == 45)
4327 jjCheckNAddStates(193, 196);
4328 break;
4329 case 54:
4330 if ((0x3ff000000000000L & l) == 0L)
4331 break;
4332 if (kind > 58)
4333 kind = 58;
4334 jjCheckNAddTwoStates(54, 56);
4335 break;
4336 case 55:
4337 if (curChar == 46 && kind > 58)
4338 kind = 58;
4339 break;
4340 case 56:
4341 if (curChar == 46)
4342 jjstateSet[jjnewStateCnt++] = 55;
4343 break;
4344 case 57:
4345 if ((0x3ff000000000000L & l) != 0L)
4346 jjCheckNAddTwoStates(57, 58);
4347 break;
4348 case 58:
4349 if (curChar != 46)
4350 break;
4351 if (kind > 59)
4352 kind = 59;
4353 jjCheckNAddTwoStates(59, 60);
4354 break;
4355 case 59:
4356 if ((0x3ff000000000000L & l) == 0L)
4357 break;
4358 if (kind > 59)
4359 kind = 59;
4360 jjCheckNAddTwoStates(59, 60);
4361 break;
4362 case 61:
4363 if ((0x280000000000L & l) != 0L)
4364 jjCheckNAdd(62);
4365 break;
4366 case 62:
4367 if ((0x3ff000000000000L & l) == 0L)
4368 break;
4369 if (kind > 59)
4370 kind = 59;
4371 jjCheckNAdd(62);
4372 break;
4373 case 63:
4374 if (curChar == 46)
4375 jjCheckNAdd(64);
4376 break;
4377 case 66:
4378 if ((0x280000000000L & l) != 0L)
4379 jjCheckNAdd(67);
4380 break;
4381 case 67:
4382 if ((0x3ff000000000000L & l) == 0L)
4383 break;
4384 if (kind > 59)
4385 kind = 59;
4386 jjCheckNAdd(67);
4387 break;
4388 case 68:
4389 if ((0x3ff000000000000L & l) != 0L)
4390 jjCheckNAddTwoStates(68, 69);
4391 break;
4392 case 70:
4393 if ((0x280000000000L & l) != 0L)
4394 jjCheckNAdd(71);
4395 break;
4396 case 71:
4397 if ((0x3ff000000000000L & l) == 0L)
4398 break;
4399 if (kind > 59)
4400 kind = 59;
4401 jjCheckNAdd(71);
4402 break;
4403 case 72:
4404 if ((0x3ff000000000000L & l) == 0L)
4405 break;
4406 if (kind > 58)
4407 kind = 58;
4408 jjCheckNAddStates(187, 192);
4409 break;
4410 case 73:
4411 if (curChar == 46)
4412 jjCheckNAddTwoStates(64, 74);
4413 break;
4414 default : break;
4415 }
4416 } while(i != startsAt);
4417 }
4418 else if (curChar < 128)
4419 {
4420 long l = 1L << (curChar & 077);
4421 do
4422 {
4423 switch(jjstateSet[--i])
4424 {
4425 case 52:
4426 if ((0x8000000080000L & l) != 0L)
4427 jjstateSet[jjnewStateCnt++] = 5;
4428 else if (curChar == 123)
4429 jjstateSet[jjnewStateCnt++] = 10;
4430 break;
4431 case 74:
4432 if ((0x7fffffe07fffffeL & l) != 0L && kind > 69)
4433 kind = 69;
4434 break;
4435 case 13:
4436 if ((0x7fffffe87fffffeL & l) != 0L)
4437 {
4438 if (kind > 68)
4439 kind = 68;
4440 jjCheckNAdd(40);
4441 }
4442 else if (curChar == 92)
4443 jjCheckNAddStates(215, 218);
4444 break;
4445 case 2:
4446 if ((0x10000000100000L & l) != 0L)
4447 jjCheckNAddTwoStates(3, 4);
4448 break;
4449 case 5:
4450 if ((0x2000000020L & l) != 0L)
4451 jjstateSet[jjnewStateCnt++] = 2;
4452 break;
4453 case 6:
4454 if ((0x8000000080000L & l) != 0L)
4455 jjstateSet[jjnewStateCnt++] = 5;
4456 break;
4457 case 7:
4458 if (curChar == 125)
4459 jjCheckNAddTwoStates(3, 4);
4460 break;
4461 case 8:
4462 if ((0x10000000100000L & l) != 0L)
4463 jjstateSet[jjnewStateCnt++] = 7;
4464 break;
4465 case 9:
4466 if ((0x2000000020L & l) != 0L)
4467 jjstateSet[jjnewStateCnt++] = 8;
4468 break;
4469 case 10:
4470 if ((0x8000000080000L & l) != 0L)
4471 jjstateSet[jjnewStateCnt++] = 9;
4472 break;
4473 case 11:
4474 if (curChar == 123)
4475 jjstateSet[jjnewStateCnt++] = 10;
4476 break;
4477 case 14:
4478 jjCheckNAddStates(204, 207);
4479 break;
4480 case 18:
4481 if (curChar == 92)
4482 jjAddStates(219, 224);
4483 break;
4484 case 19:
4485 if ((0x14404400144044L & l) != 0L)
4486 jjCheckNAddStates(204, 207);
4487 break;
4488 case 24:
4489 if ((0x20000000200000L & l) != 0L)
4490 jjstateSet[jjnewStateCnt++] = 25;
4491 break;
4492 case 25:
4493 if ((0x7e0000007eL & l) != 0L)
4494 jjstateSet[jjnewStateCnt++] = 26;
4495 break;
4496 case 26:
4497 if ((0x7e0000007eL & l) != 0L)
4498 jjstateSet[jjnewStateCnt++] = 27;
4499 break;
4500 case 27:
4501 if ((0x7e0000007eL & l) != 0L)
4502 jjstateSet[jjnewStateCnt++] = 28;
4503 break;
4504 case 28:
4505 if ((0x7e0000007eL & l) != 0L)
4506 jjCheckNAddStates(204, 207);
4507 break;
4508 case 32:
4509 jjAddStates(200, 203);
4510 break;
4511 case 35:
4512 if (curChar == 92)
4513 jjAddStates(213, 214);
4514 break;
4515 case 39:
4516 case 40:
4517 if ((0x7fffffe87fffffeL & l) == 0L)
4518 break;
4519 if (kind > 68)
4520 kind = 68;
4521 jjCheckNAdd(40);
4522 break;
4523 case 41:
4524 if (curChar == 92)
4525 jjCheckNAddStates(215, 218);
4526 break;
4527 case 42:
4528 if (curChar == 92)
4529 jjCheckNAddTwoStates(42, 43);
4530 break;
4531 case 44:
4532 if (curChar == 92)
4533 jjCheckNAddTwoStates(44, 45);
4534 break;
4535 case 46:
4536 if (curChar == 92)
4537 jjAddStates(225, 226);
4538 break;
4539 case 51:
4540 if (kind > 19)
4541 kind = 19;
4542 break;
4543 case 60:
4544 if ((0x2000000020L & l) != 0L)
4545 jjAddStates(227, 228);
4546 break;
4547 case 65:
4548 if ((0x2000000020L & l) != 0L)
4549 jjAddStates(229, 230);
4550 break;
4551 case 69:
4552 if ((0x2000000020L & l) != 0L)
4553 jjAddStates(30, 31);
4554 break;
4555 default : break;
4556 }
4557 } while(i != startsAt);
4558 }
4559 else
4560 {
4561 int hiByte = (int)(curChar >> 8);
4562 int i1 = hiByte >> 6;
4563 long l1 = 1L << (hiByte & 077);
4564 int i2 = (curChar & 0xff) >> 6;
4565 long l2 = 1L << (curChar & 077);
4566 do
4567 {
4568 switch(jjstateSet[--i])
4569 {
4570 case 14:
4571 if (jjCanMove_0(hiByte, i1, i2, l1, l2))
4572 jjAddStates(204, 207);
4573 break;
4574 case 32:
4575 if (jjCanMove_0(hiByte, i1, i2, l1, l2))
4576 jjAddStates(200, 203);
4577 break;
4578 case 51:
4579 if (jjCanMove_0(hiByte, i1, i2, l1, l2) && kind > 19)
4580 kind = 19;
4581 break;
4582 default : break;
4583 }
4584 } while(i != startsAt);
4585 }
4586 if (kind != 0x7fffffff)
4587 {
4588 jjmatchedKind = kind;
4589 jjmatchedPos = curPos;
4590 kind = 0x7fffffff;
4591 }
4592 ++curPos;
4593 if ((i = jjnewStateCnt) == (startsAt = 75 - (jjnewStateCnt = startsAt)))
4594 return curPos;
4595 try { curChar = input_stream.readChar(); }
4596 catch(java.io.IOException e) { return curPos; }
4597 }
4598 }
4599 private final int jjStopStringLiteralDfa_1(int pos, long active0, long active1)
4600 {
4601 switch (pos)
4602 {
4603 case 0:
4604 if ((active0 & 0xc00000000L) != 0L)
4605 {
4606 jjmatchedKind = 68;
4607 return 13;
4608 }
4609 if ((active0 & 0x340000L) != 0L)
4610 return 27;
4611 return -1;
4612 case 1:
4613 if ((active0 & 0xc00000000L) != 0L)
4614 {
4615 jjmatchedKind = 68;
4616 jjmatchedPos = 1;
4617 return 13;
4618 }
4619 if ((active0 & 0x100000L) != 0L)
4620 return 25;
4621 return -1;
4622 case 2:
4623 if ((active0 & 0xc00000000L) != 0L)
4624 {
4625 jjmatchedKind = 68;
4626 jjmatchedPos = 2;
4627 return 13;
4628 }
4629 return -1;
4630 case 3:
4631 if ((active0 & 0x800000000L) != 0L)
4632 {
4633 jjmatchedKind = 68;
4634 jjmatchedPos = 3;
4635 return 13;
4636 }
4637 if ((active0 & 0x400000000L) != 0L)
4638 return 13;
4639 return -1;
4640 default :
4641 return -1;
4642 }
4643 }
4644 private final int jjStartNfa_1(int pos, long active0, long active1)
4645 {
4646 return jjMoveNfa_1(jjStopStringLiteralDfa_1(pos, active0, active1), pos + 1);
4647 }
4648 private int jjMoveStringLiteralDfa0_1()
4649 {
4650 switch(curChar)
4651 {
4652 case 35:
4653 jjmatchedKind = 21;
4654 return jjMoveStringLiteralDfa1_1(0x140000L);
4655 case 40:
4656 return jjStopAtPos(0, 11);
4657 case 91:
4658 return jjStopAtPos(0, 1);
4659 case 70:
4660 case 102:
4661 return jjMoveStringLiteralDfa1_1(0x800000000L);
4662 case 84:
4663 case 116:
4664 return jjMoveStringLiteralDfa1_1(0x400000000L);
4665 case 123:
4666 return jjStopAtPos(0, 70);
4667 case 125:
4668 return jjStopAtPos(0, 71);
4669 default :
4670 return jjMoveNfa_1(12, 0);
4671 }
4672 }
4673 private int jjMoveStringLiteralDfa1_1(long active0)
4674 {
4675 try { curChar = input_stream.readChar(); }
4676 catch(java.io.IOException e) {
4677 jjStopStringLiteralDfa_1(0, active0, 0L);
4678 return 1;
4679 }
4680 switch(curChar)
4681 {
4682 case 42:
4683 if ((active0 & 0x100000L) != 0L)
4684 return jjStartNfaWithStates_1(1, 20, 25);
4685 break;
4686 case 91:
4687 return jjMoveStringLiteralDfa2_1(active0, 0x40000L);
4688 case 65:
4689 case 97:
4690 return jjMoveStringLiteralDfa2_1(active0, 0x800000000L);
4691 case 82:
4692 case 114:
4693 return jjMoveStringLiteralDfa2_1(active0, 0x400000000L);
4694 default :
4695 break;
4696 }
4697 return jjStartNfa_1(0, active0, 0L);
4698 }
4699 private int jjMoveStringLiteralDfa2_1(long old0, long active0)
4700 {
4701 if (((active0 &= old0)) == 0L)
4702 return jjStartNfa_1(0, old0, 0L);
4703 try { curChar = input_stream.readChar(); }
4704 catch(java.io.IOException e) {
4705 jjStopStringLiteralDfa_1(1, active0, 0L);
4706 return 2;
4707 }
4708 switch(curChar)
4709 {
4710 case 91:
4711 if ((active0 & 0x40000L) != 0L)
4712 return jjStopAtPos(2, 18);
4713 break;
4714 case 76:
4715 case 108:
4716 return jjMoveStringLiteralDfa3_1(active0, 0x800000000L);
4717 case 85:
4718 case 117:
4719 return jjMoveStringLiteralDfa3_1(active0, 0x400000000L);
4720 default :
4721 break;
4722 }
4723 return jjStartNfa_1(1, active0, 0L);
4724 }
4725 private int jjMoveStringLiteralDfa3_1(long old0, long active0)
4726 {
4727 if (((active0 &= old0)) == 0L)
4728 return jjStartNfa_1(1, old0, 0L);
4729 try { curChar = input_stream.readChar(); }
4730 catch(java.io.IOException e) {
4731 jjStopStringLiteralDfa_1(2, active0, 0L);
4732 return 3;
4733 }
4734 switch(curChar)
4735 {
4736 case 69:
4737 case 101:
4738 if ((active0 & 0x400000000L) != 0L)
4739 return jjStartNfaWithStates_1(3, 34, 13);
4740 break;
4741 case 83:
4742 case 115:
4743 return jjMoveStringLiteralDfa4_1(active0, 0x800000000L);
4744 default :
4745 break;
4746 }
4747 return jjStartNfa_1(2, active0, 0L);
4748 }
4749 private int jjMoveStringLiteralDfa4_1(long old0, long active0)
4750 {
4751 if (((active0 &= old0)) == 0L)
4752 return jjStartNfa_1(2, old0, 0L);
4753 try { curChar = input_stream.readChar(); }
4754 catch(java.io.IOException e) {
4755 jjStopStringLiteralDfa_1(3, active0, 0L);
4756 return 4;
4757 }
4758 switch(curChar)
4759 {
4760 case 69:
4761 case 101:
4762 if ((active0 & 0x800000000L) != 0L)
4763 return jjStartNfaWithStates_1(4, 35, 13);
4764 break;
4765 default :
4766 break;
4767 }
4768 return jjStartNfa_1(3, active0, 0L);
4769 }
4770 private int jjStartNfaWithStates_1(int pos, int kind, int state)
4771 {
4772 jjmatchedKind = kind;
4773 jjmatchedPos = pos;
4774 try { curChar = input_stream.readChar(); }
4775 catch(java.io.IOException e) { return pos + 1; }
4776 return jjMoveNfa_1(state, pos + 1);
4777 }
4778 private int jjMoveNfa_1(int startState, int curPos)
4779 {
4780 int startsAt = 0;
4781 jjnewStateCnt = 28;
4782 int i = 1;
4783 jjstateSet[0] = startState;
4784 int kind = 0x7fffffff;
4785 for (;;)
4786 {
4787 if (++jjround == 0x7fffffff)
4788 ReInitRounds();
4789 if (curChar < 64)
4790 {
4791 long l = 1L << curChar;
4792 do
4793 {
4794 switch(jjstateSet[--i])
4795 {
4796 case 12:
4797 if ((0x100000200L & l) != 0L)
4798 jjCheckNAddTwoStates(0, 1);
4799 else if (curChar == 35)
4800 jjCheckNAddStates(231, 233);
4801 else if (curChar == 36)
4802 {
4803 if (kind > 16)
4804 kind = 16;
4805 jjCheckNAddTwoStates(21, 22);
4806 }
4807 else if (curChar == 46)
4808 jjstateSet[jjnewStateCnt++] = 15;
4809 break;
4810 case 27:
4811 if (curChar == 42)
4812 jjstateSet[jjnewStateCnt++] = 25;
4813 break;
4814 case 0:
4815 if ((0x100000200L & l) != 0L)
4816 jjCheckNAddTwoStates(0, 1);
4817 break;
4818 case 1:
4819 if (curChar == 35)
4820 jjCheckNAddTwoStates(6, 11);
4821 break;
4822 case 3:
4823 if (curChar == 32)
4824 jjAddStates(115, 116);
4825 break;
4826 case 4:
4827 if (curChar == 40 && kind > 15)
4828 kind = 15;
4829 break;
4830 case 13:
4831 if ((0x3ff200000000000L & l) == 0L)
4832 break;
4833 if (kind > 68)
4834 kind = 68;
4835 jjstateSet[jjnewStateCnt++] = 13;
4836 break;
4837 case 14:
4838 if (curChar == 46)
4839 jjstateSet[jjnewStateCnt++] = 15;
4840 break;
4841 case 18:
4842 if (curChar == 36 && kind > 16)
4843 kind = 16;
4844 break;
4845 case 20:
4846 if (curChar == 36)
4847 jjCheckNAddTwoStates(21, 22);
4848 break;
4849 case 22:
4850 if (curChar == 33 && kind > 17)
4851 kind = 17;
4852 break;
4853 case 23:
4854 if (curChar != 36)
4855 break;
4856 if (kind > 16)
4857 kind = 16;
4858 jjCheckNAddTwoStates(21, 22);
4859 break;
4860 case 24:
4861 if (curChar == 35)
4862 jjCheckNAddStates(231, 233);
4863 break;
4864 case 25:
4865 if (curChar == 42)
4866 jjstateSet[jjnewStateCnt++] = 26;
4867 break;
4868 case 26:
4869 if ((0xfffffff7ffffffffL & l) != 0L && kind > 19)
4870 kind = 19;
4871 break;
4872 default : break;
4873 }
4874 } while(i != startsAt);
4875 }
4876 else if (curChar < 128)
4877 {
4878 long l = 1L << (curChar & 077);
4879 do
4880 {
4881 switch(jjstateSet[--i])
4882 {
4883 case 12:
4884 if ((0x7fffffe87fffffeL & l) != 0L)
4885 {
4886 if (kind > 68)
4887 kind = 68;
4888 jjCheckNAdd(13);
4889 }
4890 else if (curChar == 92)
4891 jjCheckNAddStates(234, 237);
4892 break;
4893 case 27:
4894 if ((0x8000000080000L & l) != 0L)
4895 jjstateSet[jjnewStateCnt++] = 5;
4896 else if (curChar == 123)
4897 jjstateSet[jjnewStateCnt++] = 10;
4898 break;
4899 case 2:
4900 if ((0x10000000100000L & l) != 0L)
4901 jjCheckNAddTwoStates(3, 4);
4902 break;
4903 case 5:
4904 if ((0x2000000020L & l) != 0L)
4905 jjstateSet[jjnewStateCnt++] = 2;
4906 break;
4907 case 6:
4908 if ((0x8000000080000L & l) != 0L)
4909 jjstateSet[jjnewStateCnt++] = 5;
4910 break;
4911 case 7:
4912 if (curChar == 125)
4913 jjCheckNAddTwoStates(3, 4);
4914 break;
4915 case 8:
4916 if ((0x10000000100000L & l) != 0L)
4917 jjstateSet[jjnewStateCnt++] = 7;
4918 break;
4919 case 9:
4920 if ((0x2000000020L & l) != 0L)
4921 jjstateSet[jjnewStateCnt++] = 8;
4922 break;
4923 case 10:
4924 if ((0x8000000080000L & l) != 0L)
4925 jjstateSet[jjnewStateCnt++] = 9;
4926 break;
4927 case 11:
4928 if (curChar == 123)
4929 jjstateSet[jjnewStateCnt++] = 10;
4930 break;
4931 case 13:
4932 if ((0x7fffffe87fffffeL & l) == 0L)
4933 break;
4934 if (kind > 68)
4935 kind = 68;
4936 jjCheckNAdd(13);
4937 break;
4938 case 15:
4939 if ((0x7fffffe07fffffeL & l) != 0L && kind > 69)
4940 kind = 69;
4941 break;
4942 case 16:
4943 if (curChar == 92)
4944 jjCheckNAddStates(234, 237);
4945 break;
4946 case 17:
4947 if (curChar == 92)
4948 jjCheckNAddTwoStates(17, 18);
4949 break;
4950 case 19:
4951 if (curChar == 92)
4952 jjCheckNAddTwoStates(19, 20);
4953 break;
4954 case 21:
4955 if (curChar == 92)
4956 jjAddStates(146, 147);
4957 break;
4958 case 26:
4959 if (kind > 19)
4960 kind = 19;
4961 break;
4962 default : break;
4963 }
4964 } while(i != startsAt);
4965 }
4966 else
4967 {
4968 int hiByte = (int)(curChar >> 8);
4969 int i1 = hiByte >> 6;
4970 long l1 = 1L << (hiByte & 077);
4971 int i2 = (curChar & 0xff) >> 6;
4972 long l2 = 1L << (curChar & 077);
4973 do
4974 {
4975 switch(jjstateSet[--i])
4976 {
4977 case 26:
4978 if (jjCanMove_0(hiByte, i1, i2, l1, l2) && kind > 19)
4979 kind = 19;
4980 break;
4981 default : break;
4982 }
4983 } while(i != startsAt);
4984 }
4985 if (kind != 0x7fffffff)
4986 {
4987 jjmatchedKind = kind;
4988 jjmatchedPos = curPos;
4989 kind = 0x7fffffff;
4990 }
4991 ++curPos;
4992 if ((i = jjnewStateCnt) == (startsAt = 28 - (jjnewStateCnt = startsAt)))
4993 return curPos;
4994 try { curChar = input_stream.readChar(); }
4995 catch(java.io.IOException e) { return curPos; }
4996 }
4997 }
4998 private final int jjStopStringLiteralDfa_7(int pos, long active0)
4999 {
5000 switch (pos)
5001 {
5002 case 0:
5003 if ((active0 & 0x340000L) != 0L)
5004 return 2;
5005 return -1;
5006 case 1:
5007 if ((active0 & 0x100000L) != 0L)
5008 return 0;
5009 return -1;
5010 default :
5011 return -1;
5012 }
5013 }
5014 private final int jjStartNfa_7(int pos, long active0)
5015 {
5016 return jjMoveNfa_7(jjStopStringLiteralDfa_7(pos, active0), pos + 1);
5017 }
5018 private int jjMoveStringLiteralDfa0_7()
5019 {
5020 switch(curChar)
5021 {
5022 case 35:
5023 jjmatchedKind = 21;
5024 return jjMoveStringLiteralDfa1_7(0x140000L);
5025 case 93:
5026 return jjMoveStringLiteralDfa1_7(0x20000000L);
5027 default :
5028 return jjMoveNfa_7(3, 0);
5029 }
5030 }
5031 private int jjMoveStringLiteralDfa1_7(long active0)
5032 {
5033 try { curChar = input_stream.readChar(); }
5034 catch(java.io.IOException e) {
5035 jjStopStringLiteralDfa_7(0, active0);
5036 return 1;
5037 }
5038 switch(curChar)
5039 {
5040 case 42:
5041 if ((active0 & 0x100000L) != 0L)
5042 return jjStartNfaWithStates_7(1, 20, 0);
5043 break;
5044 case 91:
5045 return jjMoveStringLiteralDfa2_7(active0, 0x40000L);
5046 case 93:
5047 return jjMoveStringLiteralDfa2_7(active0, 0x20000000L);
5048 default :
5049 break;
5050 }
5051 return jjStartNfa_7(0, active0);
5052 }
5053 private int jjMoveStringLiteralDfa2_7(long old0, long active0)
5054 {
5055 if (((active0 &= old0)) == 0L)
5056 return jjStartNfa_7(0, old0);
5057 try { curChar = input_stream.readChar(); }
5058 catch(java.io.IOException e) {
5059 jjStopStringLiteralDfa_7(1, active0);
5060 return 2;
5061 }
5062 switch(curChar)
5063 {
5064 case 35:
5065 if ((active0 & 0x20000000L) != 0L)
5066 return jjStopAtPos(2, 29);
5067 break;
5068 case 91:
5069 if ((active0 & 0x40000L) != 0L)
5070 return jjStopAtPos(2, 18);
5071 break;
5072 default :
5073 break;
5074 }
5075 return jjStartNfa_7(1, active0);
5076 }
5077 private int jjStartNfaWithStates_7(int pos, int kind, int state)
5078 {
5079 jjmatchedKind = kind;
5080 jjmatchedPos = pos;
5081 try { curChar = input_stream.readChar(); }
5082 catch(java.io.IOException e) { return pos + 1; }
5083 return jjMoveNfa_7(state, pos + 1);
5084 }
5085 private int jjMoveNfa_7(int startState, int curPos)
5086 {
5087 int startsAt = 0;
5088 jjnewStateCnt = 12;
5089 int i = 1;
5090 jjstateSet[0] = startState;
5091 int kind = 0x7fffffff;
5092 for (;;)
5093 {
5094 if (++jjround == 0x7fffffff)
5095 ReInitRounds();
5096 if (curChar < 64)
5097 {
5098 long l = 1L << curChar;
5099 do
5100 {
5101 switch(jjstateSet[--i])
5102 {
5103 case 3:
5104 if (curChar == 36)
5105 {
5106 if (kind > 16)
5107 kind = 16;
5108 jjCheckNAddTwoStates(9, 10);
5109 }
5110 else if (curChar == 35)
5111 jjstateSet[jjnewStateCnt++] = 2;
5112 break;
5113 case 0:
5114 if (curChar == 42)
5115 jjstateSet[jjnewStateCnt++] = 1;
5116 break;
5117 case 1:
5118 if ((0xfffffff7ffffffffL & l) != 0L && kind > 19)
5119 kind = 19;
5120 break;
5121 case 2:
5122 if (curChar == 42)
5123 jjstateSet[jjnewStateCnt++] = 0;
5124 break;
5125 case 6:
5126 if (curChar == 36 && kind > 16)
5127 kind = 16;
5128 break;
5129 case 8:
5130 if (curChar == 36)
5131 jjCheckNAddTwoStates(9, 10);
5132 break;
5133 case 10:
5134 if (curChar == 33 && kind > 17)
5135 kind = 17;
5136 break;
5137 case 11:
5138 if (curChar != 36)
5139 break;
5140 if (kind > 16)
5141 kind = 16;
5142 jjCheckNAddTwoStates(9, 10);
5143 break;
5144 default : break;
5145 }
5146 } while(i != startsAt);
5147 }
5148 else if (curChar < 128)
5149 {
5150 long l = 1L << (curChar & 077);
5151 do
5152 {
5153 switch(jjstateSet[--i])
5154 {
5155 case 3:
5156 if (curChar == 92)
5157 jjCheckNAddStates(100, 103);
5158 break;
5159 case 1:
5160 if (kind > 19)
5161 kind = 19;
5162 break;
5163 case 5:
5164 if (curChar == 92)
5165 jjCheckNAddTwoStates(5, 6);
5166 break;
5167 case 7:
5168 if (curChar == 92)
5169 jjCheckNAddTwoStates(7, 8);
5170 break;
5171 case 9:
5172 if (curChar == 92)
5173 jjAddStates(104, 105);
5174 break;
5175 default : break;
5176 }
5177 } while(i != startsAt);
5178 }
5179 else
5180 {
5181 int hiByte = (int)(curChar >> 8);
5182 int i1 = hiByte >> 6;
5183 long l1 = 1L << (hiByte & 077);
5184 int i2 = (curChar & 0xff) >> 6;
5185 long l2 = 1L << (curChar & 077);
5186 do
5187 {
5188 switch(jjstateSet[--i])
5189 {
5190 case 1:
5191 if (jjCanMove_0(hiByte, i1, i2, l1, l2) && kind > 19)
5192 kind = 19;
5193 break;
5194 default : break;
5195 }
5196 } while(i != startsAt);
5197 }
5198 if (kind != 0x7fffffff)
5199 {
5200 jjmatchedKind = kind;
5201 jjmatchedPos = curPos;
5202 kind = 0x7fffffff;
5203 }
5204 ++curPos;
5205 if ((i = jjnewStateCnt) == (startsAt = 12 - (jjnewStateCnt = startsAt)))
5206 return curPos;
5207 try { curChar = input_stream.readChar(); }
5208 catch(java.io.IOException e) { return curPos; }
5209 }
5210 }
5211 static final int[] jjnextStates = {
5212 91, 93, 94, 95, 100, 101, 91, 94, 61, 100, 29, 31, 32, 35, 11, 13,
5213 14, 15, 1, 2, 4, 11, 18, 13, 14, 15, 26, 27, 33, 34, 70, 71,
5214 73, 74, 75, 76, 87, 89, 84, 85, 81, 82, 16, 17, 19, 21, 26, 27,
5215 64, 65, 77, 78, 98, 99, 102, 103, 84, 86, 87, 88, 93, 94, 84, 87,
5216 13, 93, 22, 23, 34, 35, 37, 45, 46, 48, 53, 35, 54, 77, 46, 78,
5217 57, 65, 68, 75, 82, 25, 26, 27, 28, 38, 43, 50, 16, 17, 29, 30,
5218 91, 92, 95, 96, 5, 6, 7, 8, 9, 10, 6, 11, 39, 14, 15, 17,
5219 18, 22, 24, 3, 4, 20, 21, 29, 30, 31, 32, 45, 47, 48, 49, 54,
5220 55, 45, 48, 31, 54, 24, 26, 27, 30, 6, 8, 9, 10, 6, 13, 8,
5221 9, 10, 21, 22, 28, 29, 37, 38, 39, 40, 11, 12, 14, 16, 21, 22,
5222 34, 35, 41, 42, 52, 53, 56, 57, 8, 9, 10, 11, 12, 13, 6, 11,
5223 33, 17, 18, 20, 21, 23, 24, 25, 26, 27, 28, 54, 56, 57, 58, 68,
5224 69, 54, 57, 63, 68, 6, 11, 52, 32, 34, 35, 38, 14, 16, 17, 18,
5225 14, 21, 16, 17, 18, 36, 37, 42, 43, 44, 45, 19, 20, 22, 24, 29,
5226 30, 46, 47, 61, 62, 66, 67, 6, 11, 27, 17, 18, 19, 20,
5227 };
5228 private static final boolean jjCanMove_0(int hiByte, int i1, int i2, long l1, long l2)
5229 {
5230 switch(hiByte)
5231 {
5232 case 0:
5233 return ((jjbitVec2[i2] & l2) != 0L);
5234 default :
5235 if ((jjbitVec0[i1] & l1) != 0L)
5236 return true;
5237 return false;
5238 }
5239 }
5240
5241
5242 public static final String[] jjstrLiteralImages = {
5243 null, null, null, null, null, null, null, null, null, null, null, null, null,
5244 null, null, null, null, null, null, null, null, null, null, null, null, null, null,
5245 null, null, null, null, null, null, null, null, null, null, null, null, null, null,
5246 null, null, null, null, null, null, null, null, null, null, null, null, null, null,
5247 null, null, null, null, null, null, null, null, null, null, null, null, null, null,
5248 null, null, null, null, null, null, };
5249
5250
5251 public static final String[] lexStateNames = {
5252 "REFERENCE",
5253 "REFMODIFIER",
5254 "REFINDEX",
5255 "DIRECTIVE",
5256 "REFMOD2",
5257 "DEFAULT",
5258 "REFMOD",
5259 "IN_TEXTBLOCK",
5260 "IN_MULTI_LINE_COMMENT",
5261 "IN_FORMAL_COMMENT",
5262 "IN_SINGLE_LINE_COMMENT",
5263 "PRE_DIRECTIVE",
5264 };
5265
5266
5267 public static final int[] jjnewLexState = {
5268 -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,
5269 -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,
5270 -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,
5271 };
5272 static final long[] jjtoToken = {
5273 0x8dffffff3fc0ffffL, 0x4f1L,
5274 };
5275 static final long[] jjtoSkip = {
5276 0x40000000L, 0x300L,
5277 };
5278 static final long[] jjtoSpecial = {
5279 0x0L, 0x300L,
5280 };
5281 static final long[] jjtoMore = {
5282 0x803f0000L, 0x0L,
5283 };
5284 protected CharStream input_stream;
5285 private final int[] jjrounds = new int[105];
5286 private final int[] jjstateSet = new int[210];
5287 private final StringBuilder jjimage = new StringBuilder();
5288 private StringBuilder image = jjimage;
5289 private int jjimageLen;
5290 private int lengthOfMatch;
5291 protected char curChar;
5292
5293 public VmParserTokenManager(CharStream stream){
5294 input_stream = stream;
5295 }
5296
5297
5298 public VmParserTokenManager(CharStream stream, int lexState){
5299 this(stream);
5300 SwitchTo(lexState);
5301 }
5302
5303
5304 public void ReInit(CharStream stream)
5305 {
5306 jjmatchedPos = jjnewStateCnt = 0;
5307 curLexState = defaultLexState;
5308 input_stream = stream;
5309 ReInitRounds();
5310 }
5311 private void ReInitRounds()
5312 {
5313 int i;
5314 jjround = 0x80000001;
5315 for (i = 105; i-- > 0;)
5316 jjrounds[i] = 0x80000000;
5317 }
5318
5319
5320 public void ReInit(CharStream stream, int lexState)
5321 {
5322 ReInit(stream);
5323 SwitchTo(lexState);
5324 }
5325
5326
5327 public void SwitchTo(int lexState)
5328 {
5329 if (lexState >= 12 || lexState < 0)
5330 throw new TokenMgrError("Error: Ignoring invalid lexical state : " + lexState + ". State unchanged.", TokenMgrError.INVALID_LEXICAL_STATE);
5331 else
5332 curLexState = lexState;
5333 }
5334
5335 protected Token jjFillToken()
5336 {
5337 final Token t;
5338 final String curTokenImage;
5339 final int beginLine;
5340 final int endLine;
5341 final int beginColumn;
5342 final int endColumn;
5343 String im = jjstrLiteralImages[jjmatchedKind];
5344 curTokenImage = (im == null) ? input_stream.GetImage() : im;
5345 beginLine = input_stream.getBeginLine();
5346 beginColumn = input_stream.getBeginColumn();
5347 endLine = input_stream.getEndLine();
5348 endColumn = input_stream.getEndColumn();
5349 t = Token.newToken(jjmatchedKind, curTokenImage);
5350
5351 t.beginLine = beginLine;
5352 t.endLine = endLine;
5353 t.beginColumn = beginColumn;
5354 t.endColumn = endColumn;
5355
5356 return t;
5357 }
5358
5359 int curLexState = 5;
5360 int defaultLexState = 5;
5361 int jjnewStateCnt;
5362 int jjround;
5363 int jjmatchedPos;
5364 int jjmatchedKind;
5365
5366
5367 public Token getNextToken()
5368 {
5369 Token specialToken = null;
5370 Token matchedToken;
5371 int curPos = 0;
5372
5373 EOFLoop :
5374 for (;;)
5375 {
5376 try
5377 {
5378 curChar = input_stream.BeginToken();
5379 }
5380 catch(java.io.IOException e)
5381 {
5382 jjmatchedKind = 0;
5383 matchedToken = jjFillToken();
5384 matchedToken.specialToken = specialToken;
5385 return matchedToken;
5386 }
5387 image = jjimage;
5388 image.setLength(0);
5389 jjimageLen = 0;
5390
5391 for (;;)
5392 {
5393 switch(curLexState)
5394 {
5395 case 0:
5396 jjmatchedKind = 0x7fffffff;
5397 jjmatchedPos = 0;
5398 curPos = jjMoveStringLiteralDfa0_0();
5399 if (jjmatchedPos == 0 && jjmatchedKind > 72)
5400 {
5401 jjmatchedKind = 72;
5402 }
5403 break;
5404 case 1:
5405 jjmatchedKind = 0x7fffffff;
5406 jjmatchedPos = 0;
5407 curPos = jjMoveStringLiteralDfa0_1();
5408 if (jjmatchedPos == 0 && jjmatchedKind > 72)
5409 {
5410 jjmatchedKind = 72;
5411 }
5412 break;
5413 case 2:
5414 jjmatchedKind = 0x7fffffff;
5415 jjmatchedPos = 0;
5416 curPos = jjMoveStringLiteralDfa0_2();
5417 break;
5418 case 3:
5419 jjmatchedKind = 0x7fffffff;
5420 jjmatchedPos = 0;
5421 curPos = jjMoveStringLiteralDfa0_3();
5422 break;
5423 case 4:
5424 jjmatchedKind = 0x7fffffff;
5425 jjmatchedPos = 0;
5426 curPos = jjMoveStringLiteralDfa0_4();
5427 break;
5428 case 5:
5429 jjmatchedKind = 0x7fffffff;
5430 jjmatchedPos = 0;
5431 curPos = jjMoveStringLiteralDfa0_5();
5432 break;
5433 case 6:
5434 jjmatchedKind = 0x7fffffff;
5435 jjmatchedPos = 0;
5436 curPos = jjMoveStringLiteralDfa0_6();
5437 if (jjmatchedPos == 0 && jjmatchedKind > 72)
5438 {
5439 jjmatchedKind = 72;
5440 }
5441 break;
5442 case 7:
5443 jjmatchedKind = 0x7fffffff;
5444 jjmatchedPos = 0;
5445 curPos = jjMoveStringLiteralDfa0_7();
5446 if (jjmatchedPos == 0 && jjmatchedKind > 31)
5447 {
5448 jjmatchedKind = 31;
5449 }
5450 break;
5451 case 8:
5452 jjmatchedKind = 0x7fffffff;
5453 jjmatchedPos = 0;
5454 curPos = jjMoveStringLiteralDfa0_8();
5455 if (jjmatchedPos == 0 && jjmatchedKind > 30)
5456 {
5457 jjmatchedKind = 30;
5458 }
5459 break;
5460 case 9:
5461 jjmatchedKind = 0x7fffffff;
5462 jjmatchedPos = 0;
5463 curPos = jjMoveStringLiteralDfa0_9();
5464 if (jjmatchedPos == 0 && jjmatchedKind > 30)
5465 {
5466 jjmatchedKind = 30;
5467 }
5468 break;
5469 case 10:
5470 jjmatchedKind = 0x7fffffff;
5471 jjmatchedPos = 0;
5472 curPos = jjMoveStringLiteralDfa0_10();
5473 if (jjmatchedPos == 0 && jjmatchedKind > 30)
5474 {
5475 jjmatchedKind = 30;
5476 }
5477 break;
5478 case 11:
5479 jjmatchedKind = 0x7fffffff;
5480 jjmatchedPos = 0;
5481 curPos = jjMoveStringLiteralDfa0_11();
5482 if (jjmatchedPos == 0 && jjmatchedKind > 73)
5483 {
5484 jjmatchedKind = 73;
5485 }
5486 break;
5487 }
5488 if (jjmatchedKind != 0x7fffffff)
5489 {
5490 if (jjmatchedPos + 1 < curPos)
5491 input_stream.backup(curPos - jjmatchedPos - 1);
5492 if ((jjtoToken[jjmatchedKind >> 6] & (1L << (jjmatchedKind & 077))) != 0L)
5493 {
5494 matchedToken = jjFillToken();
5495 matchedToken.specialToken = specialToken;
5496 TokenLexicalActions(matchedToken);
5497 if (jjnewLexState[jjmatchedKind] != -1)
5498 curLexState = jjnewLexState[jjmatchedKind];
5499 return matchedToken;
5500 }
5501 else if ((jjtoSkip[jjmatchedKind >> 6] & (1L << (jjmatchedKind & 077))) != 0L)
5502 {
5503 if ((jjtoSpecial[jjmatchedKind >> 6] & (1L << (jjmatchedKind & 077))) != 0L)
5504 {
5505 matchedToken = jjFillToken();
5506 if (specialToken == null)
5507 specialToken = matchedToken;
5508 else
5509 {
5510 matchedToken.specialToken = specialToken;
5511 specialToken = (specialToken.next = matchedToken);
5512 }
5513 SkipLexicalActions(matchedToken);
5514 }
5515 else
5516 SkipLexicalActions(null);
5517 if (jjnewLexState[jjmatchedKind] != -1)
5518 curLexState = jjnewLexState[jjmatchedKind];
5519 continue EOFLoop;
5520 }
5521 MoreLexicalActions();
5522 if (jjnewLexState[jjmatchedKind] != -1)
5523 curLexState = jjnewLexState[jjmatchedKind];
5524 curPos = 0;
5525 jjmatchedKind = 0x7fffffff;
5526 try {
5527 curChar = input_stream.readChar();
5528 continue;
5529 }
5530 catch (java.io.IOException e1) { }
5531 }
5532 int error_line = input_stream.getEndLine();
5533 int error_column = input_stream.getEndColumn();
5534 String error_after = null;
5535 boolean EOFSeen = false;
5536 try { input_stream.readChar(); input_stream.backup(1); }
5537 catch (java.io.IOException e1) {
5538 EOFSeen = true;
5539 error_after = curPos <= 1 ? "" : input_stream.GetImage();
5540 if (curChar == '\n' || curChar == '\r') {
5541 error_line++;
5542 error_column = 0;
5543 }
5544 else
5545 error_column++;
5546 }
5547 if (!EOFSeen) {
5548 input_stream.backup(1);
5549 error_after = curPos <= 1 ? "" : input_stream.GetImage();
5550 }
5551 throw new TokenMgrError(EOFSeen, curLexState, error_line, error_column, error_after, curChar, TokenMgrError.LEXICAL_ERROR);
5552 }
5553 }
5554 }
5555
5556 void SkipLexicalActions(Token matchedToken)
5557 {
5558 switch(jjmatchedKind)
5559 {
5560 case 72 :
5561 image.append(input_stream.GetSuffix(jjimageLen + (lengthOfMatch = jjmatchedPos + 1)));
5562
5563
5564
5565
5566 input_stream.backup(1);
5567
5568 inReference = false;
5569
5570 if ( debugPrint )
5571 System.out.print("REF_TERM :");
5572
5573 stateStackPop();
5574 break;
5575 case 73 :
5576 image.append(input_stream.GetSuffix(jjimageLen + (lengthOfMatch = jjmatchedPos + 1)));
5577 if ( debugPrint )
5578 System.out.print("DIRECTIVE_TERM :");
5579
5580 input_stream.backup(1);
5581 inDirective = false;
5582 stateStackPop();
5583 break;
5584 default :
5585 break;
5586 }
5587 }
5588 void MoreLexicalActions()
5589 {
5590 jjimageLen += (lengthOfMatch = jjmatchedPos + 1);
5591 switch(jjmatchedKind)
5592 {
5593 case 16 :
5594 image.append(input_stream.GetSuffix(jjimageLen));
5595 jjimageLen = 0;
5596 if (! inComment)
5597 {
5598
5599
5600
5601
5602
5603 if (curLexState == REFERENCE)
5604 {
5605 inReference = false;
5606 stateStackPop();
5607 }
5608
5609 inReference = true;
5610
5611 if ( debugPrint )
5612 System.out.print( "$ : going to " + REFERENCE );
5613
5614 stateStackPush();
5615 SwitchTo(REFERENCE);
5616 }
5617 break;
5618 case 17 :
5619 image.append(input_stream.GetSuffix(jjimageLen));
5620 jjimageLen = 0;
5621 if (! inComment)
5622 {
5623
5624
5625
5626
5627
5628 if (curLexState == REFERENCE)
5629 {
5630 inReference = false;
5631 stateStackPop();
5632 }
5633
5634 inReference = true;
5635
5636 if ( debugPrint )
5637 System.out.print( "$! : going to " + REFERENCE );
5638
5639 stateStackPush();
5640 SwitchTo(REFERENCE);
5641 }
5642 break;
5643 case 18 :
5644 image.append(input_stream.GetSuffix(jjimageLen));
5645 jjimageLen = 0;
5646 if (!inComment)
5647 {
5648 inComment = true;
5649 stateStackPush();
5650 SwitchTo( IN_TEXTBLOCK );
5651 }
5652 break;
5653 case 19 :
5654 image.append(input_stream.GetSuffix(jjimageLen));
5655 jjimageLen = 0;
5656 if (!inComment)
5657 {
5658 input_stream.backup(1);
5659 inComment = true;
5660 stateStackPush();
5661 SwitchTo( IN_FORMAL_COMMENT);
5662 }
5663 break;
5664 case 20 :
5665 image.append(input_stream.GetSuffix(jjimageLen));
5666 jjimageLen = 0;
5667 if (!inComment)
5668 {
5669 inComment=true;
5670 stateStackPush();
5671 SwitchTo( IN_MULTI_LINE_COMMENT );
5672 }
5673 break;
5674 case 21 :
5675 image.append(input_stream.GetSuffix(jjimageLen));
5676 jjimageLen = 0;
5677 if (! inComment)
5678 {
5679
5680
5681
5682
5683
5684
5685
5686 if (curLexState == REFERENCE || curLexState == REFMODIFIER )
5687 {
5688 inReference = false;
5689 stateStackPop();
5690 }
5691
5692 inDirective = true;
5693
5694 if ( debugPrint )
5695 System.out.print("# : going to " + DIRECTIVE );
5696
5697 stateStackPush();
5698 SwitchTo(PRE_DIRECTIVE);
5699 }
5700 break;
5701 default :
5702 break;
5703 }
5704 }
5705 void TokenLexicalActions(Token matchedToken)
5706 {
5707 switch(jjmatchedKind)
5708 {
5709 case 1 :
5710 image.append(input_stream.GetSuffix(jjimageLen + (lengthOfMatch = jjmatchedPos + 1)));
5711 stateStackPush();
5712 SwitchTo(REFINDEX);
5713 break;
5714 case 2 :
5715 image.append(input_stream.GetSuffix(jjimageLen + (lengthOfMatch = jjmatchedPos + 1)));
5716 stateStackPop();
5717 break;
5718 case 11 :
5719 image.append(input_stream.GetSuffix(jjimageLen + (lengthOfMatch = jjmatchedPos + 1)));
5720 if (!inComment)
5721 lparen++;
5722
5723
5724
5725
5726
5727
5728 if (curLexState == REFMODIFIER )
5729 SwitchTo( REFMOD2 );
5730 break;
5731 case 12 :
5732 image.append(input_stream.GetSuffix(jjimageLen + (lengthOfMatch = jjmatchedPos + 1)));
5733 RPARENHandler();
5734 break;
5735 case 13 :
5736 image.append(input_stream.GetSuffix(jjimageLen + (lengthOfMatch = jjmatchedPos + 1)));
5737
5738
5739
5740
5741
5742
5743 SwitchTo( REFERENCE );
5744 break;
5745 case 15 :
5746 image.append(input_stream.GetSuffix(jjimageLen + (lengthOfMatch = jjmatchedPos + 1)));
5747 if (! inComment)
5748 {
5749 inDirective = true;
5750
5751 if ( debugPrint )
5752 System.out.print("#set : going to " + DIRECTIVE );
5753
5754 stateStackPush();
5755 inSet = true;
5756 SwitchTo(DIRECTIVE);
5757 }
5758
5759
5760
5761
5762
5763 if (!inComment)
5764 {
5765 lparen++;
5766
5767
5768
5769
5770
5771
5772 if (curLexState == REFMODIFIER )
5773 SwitchTo( REFMOD2 );
5774 }
5775 break;
5776 case 22 :
5777 image.append(input_stream.GetSuffix(jjimageLen + (lengthOfMatch = jjmatchedPos + 1)));
5778 if (!inComment)
5779 {
5780 if (curLexState == REFERENCE)
5781 {
5782 inReference = false;
5783 stateStackPop();
5784 }
5785
5786 inComment = true;
5787 stateStackPush();
5788 SwitchTo(IN_SINGLE_LINE_COMMENT);
5789 }
5790 break;
5791 case 26 :
5792 image.append(input_stream.GetSuffix(jjimageLen + (lengthOfMatch = jjmatchedPos + 1)));
5793 inComment = false;
5794 stateStackPop();
5795 break;
5796 case 27 :
5797 image.append(input_stream.GetSuffix(jjimageLen + (lengthOfMatch = jjmatchedPos + 1)));
5798 inComment = false;
5799 stateStackPop();
5800 break;
5801 case 28 :
5802 image.append(input_stream.GetSuffix(jjimageLen + (lengthOfMatch = jjmatchedPos + 1)));
5803 inComment = false;
5804 stateStackPop();
5805 break;
5806 case 29 :
5807 image.append(input_stream.GetSuffix(jjimageLen + (lengthOfMatch = jjmatchedPos + 1)));
5808 inComment = false;
5809 stateStackPop();
5810 break;
5811 case 33 :
5812 image.append(input_stream.GetSuffix(jjimageLen + (lengthOfMatch = jjmatchedPos + 1)));
5813
5814
5815
5816
5817
5818
5819 if( curLexState == DIRECTIVE && !inSet && lparen == 0)
5820 stateStackPop();
5821 break;
5822 case 36 :
5823 image.append(input_stream.GetSuffix(jjimageLen + (lengthOfMatch = jjmatchedPos + 1)));
5824 if ( debugPrint )
5825 System.out.println(" NEWLINE :");
5826
5827 stateStackPop();
5828
5829 if (inSet)
5830 inSet = false;
5831
5832 if (inDirective)
5833 inDirective = false;
5834 break;
5835 case 52 :
5836 image.append(input_stream.GetSuffix(jjimageLen + (lengthOfMatch = jjmatchedPos + 1)));
5837 inDirective = false;
5838 stateStackPop();
5839 break;
5840 case 53 :
5841 image.append(input_stream.GetSuffix(jjimageLen + (lengthOfMatch = jjmatchedPos + 1)));
5842 SwitchTo(DIRECTIVE);
5843 break;
5844 case 54 :
5845 image.append(input_stream.GetSuffix(jjimageLen + (lengthOfMatch = jjmatchedPos + 1)));
5846 SwitchTo(DIRECTIVE);
5847 break;
5848 case 55 :
5849 image.append(input_stream.GetSuffix(jjimageLen + (lengthOfMatch = jjmatchedPos + 1)));
5850 SwitchTo(DIRECTIVE);
5851 break;
5852 case 56 :
5853 image.append(input_stream.GetSuffix(jjimageLen + (lengthOfMatch = jjmatchedPos + 1)));
5854 inDirective = false;
5855 stateStackPop();
5856 break;
5857 case 58 :
5858 image.append(input_stream.GetSuffix(jjimageLen + (lengthOfMatch = jjmatchedPos + 1)));
5859
5860
5861
5862 if (matchedToken.image.endsWith("..")) {
5863 input_stream.backup(2);
5864 matchedToken.image = matchedToken.image.substring(0,matchedToken.image.length()-2);
5865 }
5866
5867
5868
5869
5870
5871
5872
5873 if ( lparen == 0 && !inSet && curLexState != REFMOD2 && curLexState != REFINDEX)
5874 {
5875 stateStackPop();
5876 }
5877 break;
5878 case 59 :
5879 image.append(input_stream.GetSuffix(jjimageLen + (lengthOfMatch = jjmatchedPos + 1)));
5880
5881
5882
5883
5884
5885
5886 if ( lparen == 0 && !inSet && curLexState != REFMOD2)
5887 {
5888 stateStackPop();
5889 }
5890 break;
5891 case 69 :
5892 image.append(input_stream.GetSuffix(jjimageLen + (lengthOfMatch = jjmatchedPos + 1)));
5893
5894
5895
5896
5897
5898 input_stream.backup(1);
5899
5900
5901
5902
5903
5904
5905 matchedToken.image = ".";
5906
5907 if ( debugPrint )
5908 System.out.print("DOT : switching to " + REFMODIFIER);
5909 SwitchTo(REFMODIFIER);
5910 break;
5911 case 71 :
5912 image.append(input_stream.GetSuffix(jjimageLen + (lengthOfMatch = jjmatchedPos + 1)));
5913 stateStackPop();
5914 break;
5915 default :
5916 break;
5917 }
5918 }
5919 private void jjCheckNAdd(int state)
5920 {
5921 if (jjrounds[state] != jjround)
5922 {
5923 jjstateSet[jjnewStateCnt++] = state;
5924 jjrounds[state] = jjround;
5925 }
5926 }
5927 private void jjAddStates(int start, int end)
5928 {
5929 do {
5930 jjstateSet[jjnewStateCnt++] = jjnextStates[start];
5931 } while (start++ != end);
5932 }
5933 private void jjCheckNAddTwoStates(int state1, int state2)
5934 {
5935 jjCheckNAdd(state1);
5936 jjCheckNAdd(state2);
5937 }
5938
5939 private void jjCheckNAddStates(int start, int end)
5940 {
5941 do {
5942 jjCheckNAdd(jjnextStates[start]);
5943 } while (start++ != end);
5944 }
5945
5946 }