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