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