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