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