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