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