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