1 /* Generated By:JJTree&JavaCC: Do not edit this line. StandardParserTokenManager.java */
2 package org.apache.velocity.runtime.parser;
3 import org.apache.velocity.runtime.parser.node.*;
4 import java.io.*;
5 import java.util.*;
6 import org.apache.velocity.Template;
7 import org.apache.velocity.exception.VelocityException;
8 import org.apache.velocity.runtime.RuntimeServices;
9 import org.apache.velocity.runtime.parser.*;
10 import org.apache.velocity.runtime.parser.node.*;
11 import org.apache.velocity.runtime.directive.*;
12 import org.apache.velocity.runtime.directive.MacroParseException;
13 import org.apache.velocity.runtime.RuntimeConstants;
14 import static org.apache.velocity.runtime.RuntimeConstants.SpaceGobbling;
15 import org.slf4j.Logger;
16
17 /** Token Manager. */
18 public class StandardParserTokenManager implements StandardParserConstants
19 {
20 private int fileDepth = 0;
21
22 private int lparen = 0;
23 private int rparen = 0;
24 private int curlyLevel = 0;
25 List stateStack = new ArrayList(50);
26
27 private boolean inComment;
28 private boolean inSet;
29
30 /**
31 * Our own trace method. Use sparsingly in production, since each
32 * and every call will introduce an execution branch and slow down parsing.
33 */
trace(String message)34 public static void trace(String message)
35 {
36 StandardParser.trace(message);
37 }
38
39 /**
40 * Switches to a new state (add some log to the default method)
41 */
switchTo(int lexState)42 public void switchTo(int lexState)
43 {
44 trace(" switch to " + lexStateNames[lexState]);
45 SwitchTo(lexState);
46 }
47
getCurrentLexicalState()48 public int getCurrentLexicalState()
49 {
50 return curLexState;
51 }
52
53 /**
54 * pops a state off the stack, and restores paren counts
55 *
56 * @return boolean : success of operation
57 */
stateStackPop()58 public boolean stateStackPop()
59 {
60 ParserState s;
61 try
62 {
63 s = (ParserState) stateStack.remove(stateStack.size() - 1); // stack.pop
64 }
65 catch(IndexOutOfBoundsException e)
66 {
67 // empty stack
68 lparen=0;
69 switchTo(DEFAULT);
70 return false;
71 }
72
73 trace(" stack pop (" + stateStack.size() + ")");
74 lparen = s.lparen;
75 rparen = s.rparen;
76 curlyLevel = s.curlyLevel;
77
78 switchTo(s.lexstate);
79
80 return true;
81 }
82
83 /**
84 * pushes the current state onto the 'state stack',
85 * and maintains the parens counts
86 * public because we need it in PD & VM handling
87 *
88 * @return boolean : success. It can fail if the state machine
89 * gets messed up (do don't mess it up :)
90 */
stateStackPush()91 public boolean stateStackPush()
92 {
93 trace(" (" + stateStack.size() + ") pushing cur state : " + lexStateNames[curLexState] );
94
95 ParserState s = new ParserState();
96 s.lparen = lparen;
97 s.rparen = rparen;
98 s.curlyLevel = curlyLevel;
99 s.lexstate = curLexState;
100
101 stateStack.add(s); // stack.push
102
103 lparen = 0;
104 curlyLevel = 0;
105
106 return true;
107 }
108
109 /**
110 * Clears all state variables, resets to
111 * start values, clears stateStack. Call
112 * before parsing.
113 */
clearStateVars()114 public void clearStateVars()
115 {
116 stateStack.clear();
117
118 lparen = 0;
119 rparen = 0;
120 curlyLevel = 0;
121 inComment = false;
122 inSet = false;
123
124 return;
125 }
126
setInSet(boolean value)127 public void setInSet(boolean value)
128 {
129 inSet = value;
130 }
131
isInSet()132 public boolean isInSet()
133 {
134 return inSet;
135 }
136
137 /**
138 * Holds the state of the parsing process.
139 */
140 private static class ParserState
141 {
142 int lparen;
143 int rparen;
144 int curlyLevel;
145 int lexstate;
146 }
147
148 /**
149 * handles the dropdown logic when encountering a RPAREN
150 */
RPARENHandler()151 private void RPARENHandler()
152 {
153 /*
154 * Ultimately, we want to drop down to the state below
155 * the one that has an open (if we hit bottom (DEFAULT),
156 * that's fine. It's just text schmoo.
157 */
158
159 boolean closed = false;
160
161 if (inComment)
162 closed = true;
163
164 while( !closed )
165 {
166 /*
167 * look at current state. If we haven't seen a lparen
168 * in this state then we drop a state, because this
169 * lparen clearly closes our state
170 */
171
172 if( lparen > 0)
173 {
174 /*
175 * if rparen + 1 == lparen, then this state is closed.
176 * Otherwise, increment and keep parsing
177 */
178
179 if( lparen == rparen + 1)
180 {
181 stateStackPop();
182 }
183 else
184 {
185 rparen++;
186 }
187
188 closed = true;
189 }
190 else
191 {
192 /*
193 * now, drop a state
194 */
195
196 if(!stateStackPop())
197 break;
198 }
199 }
200 }
201
202 /** Debug output. */
203 public java.io.PrintStream debugStream = System.out;
204 /** Set debug output. */
setDebugStream(java.io.PrintStream ds)205 public void setDebugStream(java.io.PrintStream ds) { debugStream = ds; }
206
207 /** The parser. */
208 public StandardParser parser = null;
jjStopStringLiteralDfa_3(int pos, long active0, long active1)209 private final int jjStopStringLiteralDfa_3(int pos, long active0, long active1)
210 {
211 switch (pos)
212 {
213 case 0:
214 if ((active0 & 0x3a00000L) != 0L)
215 return 15;
216 return -1;
217 case 1:
218 if ((active0 & 0x800000L) != 0L)
219 return 21;
220 return -1;
221 default :
222 return -1;
223 }
224 }
jjStartNfa_3(int pos, long active0, long active1)225 private final int jjStartNfa_3(int pos, long active0, long active1)
226 {
227 return jjMoveNfa_3(jjStopStringLiteralDfa_3(pos, active0, active1), pos + 1);
228 }
jjStopAtPos(int pos, int kind)229 private int jjStopAtPos(int pos, int kind)
230 {
231 jjmatchedKind = kind;
232 jjmatchedPos = pos;
233 return pos + 1;
234 }
jjMoveStringLiteralDfa0_3()235 private int jjMoveStringLiteralDfa0_3()
236 {
237 switch(curChar)
238 {
239 case 28:
240 return jjStopAtPos(0, 2);
241 case 35:
242 jjmatchedKind = 24;
243 return jjMoveStringLiteralDfa1_3(0x2a00000L);
244 case 91:
245 return jjStopAtPos(0, 3);
246 case 102:
247 return jjMoveStringLiteralDfa1_3(0x2000000000L);
248 case 116:
249 return jjMoveStringLiteralDfa1_3(0x1000000000L);
250 case 123:
251 return jjStopAtPos(0, 72);
252 case 124:
253 jjmatchedKind = 5;
254 return jjMoveStringLiteralDfa1_3(0x10L);
255 case 125:
256 return jjStopAtPos(0, 73);
257 default :
258 return jjMoveNfa_3(0, 0);
259 }
260 }
jjMoveStringLiteralDfa1_3(long active0)261 private int jjMoveStringLiteralDfa1_3(long active0)
262 {
263 try { curChar = input_stream.readChar(); }
264 catch(java.io.IOException e) {
265 jjStopStringLiteralDfa_3(0, active0, 0L);
266 return 1;
267 }
268 switch(curChar)
269 {
270 case 35:
271 if ((active0 & 0x2000000L) != 0L)
272 return jjStopAtPos(1, 25);
273 break;
274 case 42:
275 if ((active0 & 0x800000L) != 0L)
276 return jjStartNfaWithStates_3(1, 23, 21);
277 break;
278 case 91:
279 return jjMoveStringLiteralDfa2_3(active0, 0x200000L);
280 case 97:
281 return jjMoveStringLiteralDfa2_3(active0, 0x2000000000L);
282 case 114:
283 return jjMoveStringLiteralDfa2_3(active0, 0x1000000000L);
284 case 124:
285 if ((active0 & 0x10L) != 0L)
286 return jjStopAtPos(1, 4);
287 break;
288 default :
289 break;
290 }
291 return jjStartNfa_3(0, active0, 0L);
292 }
jjMoveStringLiteralDfa2_3(long old0, long active0)293 private int jjMoveStringLiteralDfa2_3(long old0, long active0)
294 {
295 if (((active0 &= old0)) == 0L)
296 return jjStartNfa_3(0, old0, 0L);
297 try { curChar = input_stream.readChar(); }
298 catch(java.io.IOException e) {
299 jjStopStringLiteralDfa_3(1, active0, 0L);
300 return 2;
301 }
302 switch(curChar)
303 {
304 case 91:
305 if ((active0 & 0x200000L) != 0L)
306 return jjStopAtPos(2, 21);
307 break;
308 case 108:
309 return jjMoveStringLiteralDfa3_3(active0, 0x2000000000L);
310 case 117:
311 return jjMoveStringLiteralDfa3_3(active0, 0x1000000000L);
312 default :
313 break;
314 }
315 return jjStartNfa_3(1, active0, 0L);
316 }
jjMoveStringLiteralDfa3_3(long old0, long active0)317 private int jjMoveStringLiteralDfa3_3(long old0, long active0)
318 {
319 if (((active0 &= old0)) == 0L)
320 return jjStartNfa_3(1, old0, 0L);
321 try { curChar = input_stream.readChar(); }
322 catch(java.io.IOException e) {
323 jjStopStringLiteralDfa_3(2, active0, 0L);
324 return 3;
325 }
326 switch(curChar)
327 {
328 case 101:
329 if ((active0 & 0x1000000000L) != 0L)
330 return jjStopAtPos(3, 36);
331 break;
332 case 115:
333 return jjMoveStringLiteralDfa4_3(active0, 0x2000000000L);
334 default :
335 break;
336 }
337 return jjStartNfa_3(2, active0, 0L);
338 }
jjMoveStringLiteralDfa4_3(long old0, long active0)339 private int jjMoveStringLiteralDfa4_3(long old0, long active0)
340 {
341 if (((active0 &= old0)) == 0L)
342 return jjStartNfa_3(2, old0, 0L);
343 try { curChar = input_stream.readChar(); }
344 catch(java.io.IOException e) {
345 jjStopStringLiteralDfa_3(3, active0, 0L);
346 return 4;
347 }
348 switch(curChar)
349 {
350 case 101:
351 if ((active0 & 0x2000000000L) != 0L)
352 return jjStopAtPos(4, 37);
353 break;
354 default :
355 break;
356 }
357 return jjStartNfa_3(3, active0, 0L);
358 }
jjStartNfaWithStates_3(int pos, int kind, int state)359 private int jjStartNfaWithStates_3(int pos, int kind, int state)
360 {
361 jjmatchedKind = kind;
362 jjmatchedPos = pos;
363 try { curChar = input_stream.readChar(); }
364 catch(java.io.IOException e) { return pos + 1; }
365 return jjMoveNfa_3(state, pos + 1);
366 }
367 static final long[] jjbitVec0 = {
368 0xfffffffffffffffeL, 0xffffffffffffffffL, 0xffffffffffffffffL, 0xffffffffffffffffL
369 };
370 static final long[] jjbitVec2 = {
371 0x0L, 0x0L, 0xffffffffffffffffL, 0xffffffffffffffffL
372 };
jjMoveNfa_3(int startState, int curPos)373 private int jjMoveNfa_3(int startState, int curPos)
374 {
375 int startsAt = 0;
376 jjnewStateCnt = 24;
377 int i = 1;
378 jjstateSet[0] = startState;
379 int kind = 0x7fffffff;
380 for (;;)
381 {
382 if (++jjround == 0x7fffffff)
383 ReInitRounds();
384 if (curChar < 64)
385 {
386 long l = 1L << curChar;
387 do
388 {
389 switch(jjstateSet[--i])
390 {
391 case 0:
392 if (curChar == 35)
393 jjAddStates(0, 2);
394 else if (curChar == 36)
395 {
396 if (kind > 19)
397 kind = 19;
398 jjCheckNAddTwoStates(7, 8);
399 }
400 else if (curChar == 46)
401 jjstateSet[jjnewStateCnt++] = 1;
402 break;
403 case 15:
404 if (curChar == 42)
405 jjstateSet[jjnewStateCnt++] = 21;
406 break;
407 case 4:
408 if (curChar == 36 && kind > 19)
409 kind = 19;
410 break;
411 case 6:
412 if (curChar == 36)
413 jjCheckNAddTwoStates(7, 8);
414 break;
415 case 8:
416 if (curChar == 33 && kind > 20)
417 kind = 20;
418 break;
419 case 9:
420 if (curChar != 36)
421 break;
422 if (kind > 19)
423 kind = 19;
424 jjCheckNAddTwoStates(7, 8);
425 break;
426 case 10:
427 if (curChar == 35)
428 jjAddStates(0, 2);
429 break;
430 case 12:
431 if ((0x100000200L & l) != 0L)
432 jjAddStates(3, 4);
433 break;
434 case 13:
435 if (curChar == 40 && kind > 18)
436 kind = 18;
437 break;
438 case 21:
439 if (curChar == 42)
440 jjstateSet[jjnewStateCnt++] = 22;
441 break;
442 case 22:
443 if ((0xfffffff7efffffffL & l) != 0L && kind > 22)
444 kind = 22;
445 break;
446 default : break;
447 }
448 } while(i != startsAt);
449 }
450 else if (curChar < 128)
451 {
452 long l = 1L << (curChar & 077);
453 do
454 {
455 switch(jjstateSet[--i])
456 {
457 case 0:
458 if (curChar == 92)
459 jjCheckNAddStates(5, 8);
460 break;
461 case 15:
462 if (curChar == 123)
463 jjstateSet[jjnewStateCnt++] = 19;
464 else if (curChar == 115)
465 jjstateSet[jjnewStateCnt++] = 14;
466 break;
467 case 1:
468 if ((0x7fffffe87fffffeL & l) != 0L && kind > 71)
469 kind = 71;
470 break;
471 case 3:
472 if (curChar == 92)
473 jjCheckNAddTwoStates(3, 4);
474 break;
475 case 5:
476 if (curChar == 92)
477 jjCheckNAddTwoStates(5, 6);
478 break;
479 case 7:
480 if (curChar == 92)
481 jjAddStates(9, 10);
482 break;
483 case 11:
484 if (curChar == 116)
485 jjCheckNAddTwoStates(12, 13);
486 break;
487 case 14:
488 if (curChar == 101)
489 jjstateSet[jjnewStateCnt++] = 11;
490 break;
491 case 16:
492 if (curChar == 125)
493 jjCheckNAddTwoStates(12, 13);
494 break;
495 case 17:
496 if (curChar == 116)
497 jjstateSet[jjnewStateCnt++] = 16;
498 break;
499 case 18:
500 if (curChar == 101)
501 jjstateSet[jjnewStateCnt++] = 17;
502 break;
503 case 19:
504 if (curChar == 115)
505 jjstateSet[jjnewStateCnt++] = 18;
506 break;
507 case 20:
508 if (curChar == 123)
509 jjstateSet[jjnewStateCnt++] = 19;
510 break;
511 case 22:
512 if (kind > 22)
513 kind = 22;
514 break;
515 default : break;
516 }
517 } while(i != startsAt);
518 }
519 else
520 {
521 int hiByte = (int)(curChar >> 8);
522 int i1 = hiByte >> 6;
523 long l1 = 1L << (hiByte & 077);
524 int i2 = (curChar & 0xff) >> 6;
525 long l2 = 1L << (curChar & 077);
526 do
527 {
528 switch(jjstateSet[--i])
529 {
530 case 22:
531 if (jjCanMove_0(hiByte, i1, i2, l1, l2) && kind > 22)
532 kind = 22;
533 break;
534 default : break;
535 }
536 } while(i != startsAt);
537 }
538 if (kind != 0x7fffffff)
539 {
540 jjmatchedKind = kind;
541 jjmatchedPos = curPos;
542 kind = 0x7fffffff;
543 }
544 ++curPos;
545 if ((i = jjnewStateCnt) == (startsAt = 24 - (jjnewStateCnt = startsAt)))
546 return curPos;
547 try { curChar = input_stream.readChar(); }
548 catch(java.io.IOException e) { return curPos; }
549 }
550 }
jjStopStringLiteralDfa_0(int pos, long active0)551 private final int jjStopStringLiteralDfa_0(int pos, long active0)
552 {
553 switch (pos)
554 {
555 case 0:
556 if ((active0 & 0x3a00000L) != 0L)
557 return 2;
558 return -1;
559 case 1:
560 if ((active0 & 0x800000L) != 0L)
561 return 0;
562 return -1;
563 default :
564 return -1;
565 }
566 }
jjStartNfa_0(int pos, long active0)567 private final int jjStartNfa_0(int pos, long active0)
568 {
569 return jjMoveNfa_0(jjStopStringLiteralDfa_0(pos, active0), pos + 1);
570 }
jjMoveStringLiteralDfa0_0()571 private int jjMoveStringLiteralDfa0_0()
572 {
573 switch(curChar)
574 {
575 case 28:
576 return jjStopAtPos(0, 1);
577 case 35:
578 jjmatchedKind = 24;
579 return jjMoveStringLiteralDfa1_0(0x2a00000L);
580 default :
581 return jjMoveNfa_0(3, 0);
582 }
583 }
jjMoveStringLiteralDfa1_0(long active0)584 private int jjMoveStringLiteralDfa1_0(long active0)
585 {
586 try { curChar = input_stream.readChar(); }
587 catch(java.io.IOException e) {
588 jjStopStringLiteralDfa_0(0, active0);
589 return 1;
590 }
591 switch(curChar)
592 {
593 case 35:
594 if ((active0 & 0x2000000L) != 0L)
595 return jjStopAtPos(1, 25);
596 break;
597 case 42:
598 if ((active0 & 0x800000L) != 0L)
599 return jjStartNfaWithStates_0(1, 23, 0);
600 break;
601 case 91:
602 return jjMoveStringLiteralDfa2_0(active0, 0x200000L);
603 default :
604 break;
605 }
606 return jjStartNfa_0(0, active0);
607 }
jjMoveStringLiteralDfa2_0(long old0, long active0)608 private int jjMoveStringLiteralDfa2_0(long old0, long active0)
609 {
610 if (((active0 &= old0)) == 0L)
611 return jjStartNfa_0(0, old0);
612 try { curChar = input_stream.readChar(); }
613 catch(java.io.IOException e) {
614 jjStopStringLiteralDfa_0(1, active0);
615 return 2;
616 }
617 switch(curChar)
618 {
619 case 91:
620 if ((active0 & 0x200000L) != 0L)
621 return jjStopAtPos(2, 21);
622 break;
623 default :
624 break;
625 }
626 return jjStartNfa_0(1, active0);
627 }
jjStartNfaWithStates_0(int pos, int kind, int state)628 private int jjStartNfaWithStates_0(int pos, int kind, int state)
629 {
630 jjmatchedKind = kind;
631 jjmatchedPos = pos;
632 try { curChar = input_stream.readChar(); }
633 catch(java.io.IOException e) { return pos + 1; }
634 return jjMoveNfa_0(state, pos + 1);
635 }
jjMoveNfa_0(int startState, int curPos)636 private int jjMoveNfa_0(int startState, int curPos)
637 {
638 int startsAt = 0;
639 jjnewStateCnt = 75;
640 int i = 1;
641 jjstateSet[0] = startState;
642 int kind = 0x7fffffff;
643 for (;;)
644 {
645 if (++jjround == 0x7fffffff)
646 ReInitRounds();
647 if (curChar < 64)
648 {
649 long l = 1L << curChar;
650 do
651 {
652 switch(jjstateSet[--i])
653 {
654 case 3:
655 if ((0x3ff000000000000L & l) != 0L)
656 {
657 if (kind > 58)
658 kind = 58;
659 jjCheckNAddStates(11, 16);
660 }
661 else if ((0x2400L & l) != 0L)
662 {
663 if (kind > 34)
664 kind = 34;
665 }
666 else if ((0x100000200L & l) != 0L)
667 jjCheckNAddStates(17, 19);
668 else if (curChar == 45)
669 jjCheckNAddStates(20, 23);
670 else if (curChar == 36)
671 {
672 if (kind > 19)
673 kind = 19;
674 jjCheckNAddTwoStates(26, 27);
675 }
676 else if (curChar == 46)
677 jjCheckNAdd(11);
678 else if (curChar == 35)
679 jjstateSet[jjnewStateCnt++] = 2;
680 if (curChar == 13)
681 jjstateSet[jjnewStateCnt++] = 6;
682 break;
683 case 0:
684 if (curChar == 42)
685 jjstateSet[jjnewStateCnt++] = 1;
686 break;
687 case 1:
688 if ((0xfffffff7efffffffL & l) != 0L && kind > 22)
689 kind = 22;
690 break;
691 case 2:
692 if (curChar == 42)
693 jjstateSet[jjnewStateCnt++] = 0;
694 break;
695 case 4:
696 if ((0x100000200L & l) != 0L)
697 jjCheckNAddStates(17, 19);
698 break;
699 case 5:
700 if ((0x2400L & l) != 0L && kind > 34)
701 kind = 34;
702 break;
703 case 6:
704 if (curChar == 10 && kind > 34)
705 kind = 34;
706 break;
707 case 7:
708 if (curChar == 13)
709 jjstateSet[jjnewStateCnt++] = 6;
710 break;
711 case 10:
712 if (curChar == 46)
713 jjCheckNAdd(11);
714 break;
715 case 11:
716 if ((0x3ff000000000000L & l) == 0L)
717 break;
718 if (kind > 59)
719 kind = 59;
720 jjCheckNAddTwoStates(11, 12);
721 break;
722 case 13:
723 if ((0x280000000000L & l) != 0L)
724 jjCheckNAdd(14);
725 break;
726 case 14:
727 if ((0x3ff000000000000L & l) == 0L)
728 break;
729 if (kind > 59)
730 kind = 59;
731 jjCheckNAdd(14);
732 break;
733 case 16:
734 if ((0x3ff000000000000L & l) == 0L)
735 break;
736 if (kind > 63)
737 kind = 63;
738 jjstateSet[jjnewStateCnt++] = 16;
739 break;
740 case 19:
741 if ((0x3ff000000000000L & l) != 0L)
742 jjAddStates(24, 25);
743 break;
744 case 23:
745 if (curChar == 36 && kind > 19)
746 kind = 19;
747 break;
748 case 25:
749 if (curChar == 36)
750 jjCheckNAddTwoStates(26, 27);
751 break;
752 case 27:
753 if (curChar == 33 && kind > 20)
754 kind = 20;
755 break;
756 case 28:
757 if (curChar != 36)
758 break;
759 if (kind > 19)
760 kind = 19;
761 jjCheckNAddTwoStates(26, 27);
762 break;
763 case 60:
764 if (curChar == 45)
765 jjCheckNAddStates(20, 23);
766 break;
767 case 61:
768 if ((0x3ff000000000000L & l) == 0L)
769 break;
770 if (kind > 58)
771 kind = 58;
772 jjCheckNAddTwoStates(61, 63);
773 break;
774 case 62:
775 if (curChar == 46 && kind > 58)
776 kind = 58;
777 break;
778 case 63:
779 if (curChar == 46)
780 jjstateSet[jjnewStateCnt++] = 62;
781 break;
782 case 64:
783 if ((0x3ff000000000000L & l) != 0L)
784 jjCheckNAddTwoStates(64, 65);
785 break;
786 case 65:
787 if (curChar != 46)
788 break;
789 if (kind > 59)
790 kind = 59;
791 jjCheckNAddTwoStates(66, 67);
792 break;
793 case 66:
794 if ((0x3ff000000000000L & l) == 0L)
795 break;
796 if (kind > 59)
797 kind = 59;
798 jjCheckNAddTwoStates(66, 67);
799 break;
800 case 68:
801 if ((0x280000000000L & l) != 0L)
802 jjCheckNAdd(69);
803 break;
804 case 69:
805 if ((0x3ff000000000000L & l) == 0L)
806 break;
807 if (kind > 59)
808 kind = 59;
809 jjCheckNAdd(69);
810 break;
811 case 70:
812 if ((0x3ff000000000000L & l) != 0L)
813 jjCheckNAddTwoStates(70, 71);
814 break;
815 case 72:
816 if ((0x280000000000L & l) != 0L)
817 jjCheckNAdd(73);
818 break;
819 case 73:
820 if ((0x3ff000000000000L & l) == 0L)
821 break;
822 if (kind > 59)
823 kind = 59;
824 jjCheckNAdd(73);
825 break;
826 case 74:
827 if ((0x3ff000000000000L & l) == 0L)
828 break;
829 if (kind > 58)
830 kind = 58;
831 jjCheckNAddStates(11, 16);
832 break;
833 default : break;
834 }
835 } while(i != startsAt);
836 }
837 else if (curChar < 128)
838 {
839 long l = 1L << (curChar & 077);
840 do
841 {
842 switch(jjstateSet[--i])
843 {
844 case 3:
845 if ((0x7fffffe87ffffffL & l) != 0L)
846 {
847 if (kind > 63)
848 kind = 63;
849 jjCheckNAdd(16);
850 }
851 else if (curChar == 123)
852 jjAddStates(26, 29);
853 else if (curChar == 92)
854 jjCheckNAddStates(30, 33);
855 if (curChar == 101)
856 jjAddStates(34, 36);
857 else if (curChar == 123)
858 jjstateSet[jjnewStateCnt++] = 18;
859 else if (curChar == 105)
860 jjstateSet[jjnewStateCnt++] = 8;
861 break;
862 case 1:
863 if (kind > 22)
864 kind = 22;
865 break;
866 case 8:
867 if (curChar == 102 && kind > 54)
868 kind = 54;
869 break;
870 case 9:
871 if (curChar == 105)
872 jjstateSet[jjnewStateCnt++] = 8;
873 break;
874 case 12:
875 if ((0x2000000020L & l) != 0L)
876 jjAddStates(37, 38);
877 break;
878 case 15:
879 if ((0x7fffffe87ffffffL & l) == 0L)
880 break;
881 if (kind > 63)
882 kind = 63;
883 jjCheckNAdd(16);
884 break;
885 case 16:
886 if ((0x7fffffe87fffffeL & l) == 0L)
887 break;
888 if (kind > 63)
889 kind = 63;
890 jjCheckNAdd(16);
891 break;
892 case 17:
893 if (curChar == 123)
894 jjstateSet[jjnewStateCnt++] = 18;
895 break;
896 case 18:
897 if ((0x7fffffe87ffffffL & l) != 0L)
898 jjCheckNAddTwoStates(19, 20);
899 break;
900 case 19:
901 if ((0x7fffffe87fffffeL & l) != 0L)
902 jjCheckNAddTwoStates(19, 20);
903 break;
904 case 20:
905 if (curChar == 125 && kind > 64)
906 kind = 64;
907 break;
908 case 21:
909 if (curChar == 92)
910 jjCheckNAddStates(30, 33);
911 break;
912 case 22:
913 if (curChar == 92)
914 jjCheckNAddTwoStates(22, 23);
915 break;
916 case 24:
917 if (curChar == 92)
918 jjCheckNAddTwoStates(24, 25);
919 break;
920 case 26:
921 if (curChar == 92)
922 jjAddStates(39, 40);
923 break;
924 case 29:
925 if (curChar == 101)
926 jjAddStates(34, 36);
927 break;
928 case 30:
929 if (curChar == 100 && kind > 53)
930 kind = 53;
931 break;
932 case 31:
933 if (curChar == 110)
934 jjstateSet[jjnewStateCnt++] = 30;
935 break;
936 case 32:
937 if (curChar == 102 && kind > 55)
938 kind = 55;
939 break;
940 case 33:
941 if (curChar == 105)
942 jjstateSet[jjnewStateCnt++] = 32;
943 break;
944 case 34:
945 if (curChar == 101)
946 jjstateSet[jjnewStateCnt++] = 33;
947 break;
948 case 35:
949 if (curChar == 115)
950 jjstateSet[jjnewStateCnt++] = 34;
951 break;
952 case 36:
953 if (curChar == 108)
954 jjstateSet[jjnewStateCnt++] = 35;
955 break;
956 case 37:
957 if (curChar == 101 && kind > 56)
958 kind = 56;
959 break;
960 case 38:
961 if (curChar == 115)
962 jjstateSet[jjnewStateCnt++] = 37;
963 break;
964 case 39:
965 if (curChar == 108)
966 jjstateSet[jjnewStateCnt++] = 38;
967 break;
968 case 40:
969 if (curChar == 123)
970 jjAddStates(26, 29);
971 break;
972 case 41:
973 if (curChar == 125 && kind > 53)
974 kind = 53;
975 break;
976 case 42:
977 if (curChar == 100)
978 jjstateSet[jjnewStateCnt++] = 41;
979 break;
980 case 43:
981 if (curChar == 110)
982 jjstateSet[jjnewStateCnt++] = 42;
983 break;
984 case 44:
985 if (curChar == 101)
986 jjstateSet[jjnewStateCnt++] = 43;
987 break;
988 case 45:
989 if (curChar == 125 && kind > 54)
990 kind = 54;
991 break;
992 case 46:
993 if (curChar == 102)
994 jjstateSet[jjnewStateCnt++] = 45;
995 break;
996 case 47:
997 if (curChar == 105)
998 jjstateSet[jjnewStateCnt++] = 46;
999 break;
1000 case 48:
1001 if (curChar == 125 && kind > 55)
1002 kind = 55;
1003 break;
1004 case 49:
1005 if (curChar == 102)
1006 jjstateSet[jjnewStateCnt++] = 48;
1007 break;
1008 case 50:
1009 if (curChar == 105)
1010 jjstateSet[jjnewStateCnt++] = 49;
1011 break;
1012 case 51:
1013 if (curChar == 101)
1014 jjstateSet[jjnewStateCnt++] = 50;
1015 break;
1016 case 52:
1017 if (curChar == 115)
1018 jjstateSet[jjnewStateCnt++] = 51;
1019 break;
1020 case 53:
1021 if (curChar == 108)
1022 jjstateSet[jjnewStateCnt++] = 52;
1023 break;
1024 case 54:
1025 if (curChar == 101)
1026 jjstateSet[jjnewStateCnt++] = 53;
1027 break;
1028 case 55:
1029 if (curChar == 125 && kind > 56)
1030 kind = 56;
1031 break;
1032 case 56:
1033 if (curChar == 101)
1034 jjstateSet[jjnewStateCnt++] = 55;
1035 break;
1036 case 57:
1037 if (curChar == 115)
1038 jjstateSet[jjnewStateCnt++] = 56;
1039 break;
1040 case 58:
1041 if (curChar == 108)
1042 jjstateSet[jjnewStateCnt++] = 57;
1043 break;
1044 case 59:
1045 if (curChar == 101)
1046 jjstateSet[jjnewStateCnt++] = 58;
1047 break;
1048 case 67:
1049 if ((0x2000000020L & l) != 0L)
1050 jjAddStates(41, 42);
1051 break;
1052 case 71:
1053 if ((0x2000000020L & l) != 0L)
1054 jjAddStates(43, 44);
1055 break;
1056 default : break;
1057 }
1058 } while(i != startsAt);
1059 }
1060 else
1061 {
1062 int hiByte = (int)(curChar >> 8);
1063 int i1 = hiByte >> 6;
1064 long l1 = 1L << (hiByte & 077);
1065 int i2 = (curChar & 0xff) >> 6;
1066 long l2 = 1L << (curChar & 077);
1067 do
1068 {
1069 switch(jjstateSet[--i])
1070 {
1071 case 1:
1072 if (jjCanMove_0(hiByte, i1, i2, l1, l2) && kind > 22)
1073 kind = 22;
1074 break;
1075 default : break;
1076 }
1077 } while(i != startsAt);
1078 }
1079 if (kind != 0x7fffffff)
1080 {
1081 jjmatchedKind = kind;
1082 jjmatchedPos = curPos;
1083 kind = 0x7fffffff;
1084 }
1085 ++curPos;
1086 if ((i = jjnewStateCnt) == (startsAt = 75 - (jjnewStateCnt = startsAt)))
1087 return curPos;
1088 try { curChar = input_stream.readChar(); }
1089 catch(java.io.IOException e) { return curPos; }
1090 }
1091 }
jjStopStringLiteralDfa_16(int pos, long active0)1092 private final int jjStopStringLiteralDfa_16(int pos, long active0)
1093 {
1094 switch (pos)
1095 {
1096 case 0:
1097 if ((active0 & 0x4000000000L) != 0L)
1098 return 94;
1099 if ((active0 & 0x1a00000L) != 0L)
1100 return 2;
1101 if ((active0 & 0x400L) != 0L)
1102 return 57;
1103 if ((active0 & 0x10000000000000L) != 0L)
1104 return 49;
1105 return -1;
1106 case 1:
1107 if ((active0 & 0x800000L) != 0L)
1108 return 0;
1109 return -1;
1110 default :
1111 return -1;
1112 }
1113 }
jjStartNfa_16(int pos, long active0)1114 private final int jjStartNfa_16(int pos, long active0)
1115 {
1116 return jjMoveNfa_16(jjStopStringLiteralDfa_16(pos, active0), pos + 1);
1117 }
jjMoveStringLiteralDfa0_16()1118 private int jjMoveStringLiteralDfa0_16()
1119 {
1120 switch(curChar)
1121 {
1122 case 35:
1123 jjmatchedKind = 24;
1124 return jjMoveStringLiteralDfa1_16(0xa00000L);
1125 case 37:
1126 return jjStopAtPos(0, 42);
1127 case 42:
1128 return jjStopAtPos(0, 40);
1129 case 43:
1130 return jjStopAtPos(0, 39);
1131 case 44:
1132 return jjStopAtPos(0, 9);
1133 case 45:
1134 return jjStartNfaWithStates_16(0, 38, 94);
1135 case 46:
1136 return jjMoveStringLiteralDfa1_16(0x400L);
1137 case 47:
1138 return jjStopAtPos(0, 41);
1139 case 58:
1140 return jjStopAtPos(0, 11);
1141 case 61:
1142 return jjStartNfaWithStates_16(0, 52, 49);
1143 case 91:
1144 return jjStopAtPos(0, 7);
1145 case 93:
1146 return jjStopAtPos(0, 8);
1147 case 102:
1148 return jjMoveStringLiteralDfa1_16(0x2000000000L);
1149 case 116:
1150 return jjMoveStringLiteralDfa1_16(0x1000000000L);
1151 case 123:
1152 return jjStopAtPos(0, 12);
1153 case 125:
1154 return jjStopAtPos(0, 13);
1155 default :
1156 return jjMoveNfa_16(3, 0);
1157 }
1158 }
jjMoveStringLiteralDfa1_16(long active0)1159 private int jjMoveStringLiteralDfa1_16(long active0)
1160 {
1161 try { curChar = input_stream.readChar(); }
1162 catch(java.io.IOException e) {
1163 jjStopStringLiteralDfa_16(0, active0);
1164 return 1;
1165 }
1166 switch(curChar)
1167 {
1168 case 42:
1169 if ((active0 & 0x800000L) != 0L)
1170 return jjStartNfaWithStates_16(1, 23, 0);
1171 break;
1172 case 46:
1173 if ((active0 & 0x400L) != 0L)
1174 return jjStopAtPos(1, 10);
1175 break;
1176 case 91:
1177 return jjMoveStringLiteralDfa2_16(active0, 0x200000L);
1178 case 97:
1179 return jjMoveStringLiteralDfa2_16(active0, 0x2000000000L);
1180 case 114:
1181 return jjMoveStringLiteralDfa2_16(active0, 0x1000000000L);
1182 default :
1183 break;
1184 }
1185 return jjStartNfa_16(0, active0);
1186 }
jjMoveStringLiteralDfa2_16(long old0, long active0)1187 private int jjMoveStringLiteralDfa2_16(long old0, long active0)
1188 {
1189 if (((active0 &= old0)) == 0L)
1190 return jjStartNfa_16(0, old0);
1191 try { curChar = input_stream.readChar(); }
1192 catch(java.io.IOException e) {
1193 jjStopStringLiteralDfa_16(1, active0);
1194 return 2;
1195 }
1196 switch(curChar)
1197 {
1198 case 91:
1199 if ((active0 & 0x200000L) != 0L)
1200 return jjStopAtPos(2, 21);
1201 break;
1202 case 108:
1203 return jjMoveStringLiteralDfa3_16(active0, 0x2000000000L);
1204 case 117:
1205 return jjMoveStringLiteralDfa3_16(active0, 0x1000000000L);
1206 default :
1207 break;
1208 }
1209 return jjStartNfa_16(1, active0);
1210 }
jjMoveStringLiteralDfa3_16(long old0, long active0)1211 private int jjMoveStringLiteralDfa3_16(long old0, long active0)
1212 {
1213 if (((active0 &= old0)) == 0L)
1214 return jjStartNfa_16(1, old0);
1215 try { curChar = input_stream.readChar(); }
1216 catch(java.io.IOException e) {
1217 jjStopStringLiteralDfa_16(2, active0);
1218 return 3;
1219 }
1220 switch(curChar)
1221 {
1222 case 101:
1223 if ((active0 & 0x1000000000L) != 0L)
1224 return jjStopAtPos(3, 36);
1225 break;
1226 case 115:
1227 return jjMoveStringLiteralDfa4_16(active0, 0x2000000000L);
1228 default :
1229 break;
1230 }
1231 return jjStartNfa_16(2, active0);
1232 }
jjMoveStringLiteralDfa4_16(long old0, long active0)1233 private int jjMoveStringLiteralDfa4_16(long old0, long active0)
1234 {
1235 if (((active0 &= old0)) == 0L)
1236 return jjStartNfa_16(2, old0);
1237 try { curChar = input_stream.readChar(); }
1238 catch(java.io.IOException e) {
1239 jjStopStringLiteralDfa_16(3, active0);
1240 return 4;
1241 }
1242 switch(curChar)
1243 {
1244 case 101:
1245 if ((active0 & 0x2000000000L) != 0L)
1246 return jjStopAtPos(4, 37);
1247 break;
1248 default :
1249 break;
1250 }
1251 return jjStartNfa_16(3, active0);
1252 }
jjStartNfaWithStates_16(int pos, int kind, int state)1253 private int jjStartNfaWithStates_16(int pos, int kind, int state)
1254 {
1255 jjmatchedKind = kind;
1256 jjmatchedPos = pos;
1257 try { curChar = input_stream.readChar(); }
1258 catch(java.io.IOException e) { return pos + 1; }
1259 return jjMoveNfa_16(state, pos + 1);
1260 }
jjMoveNfa_16(int startState, int curPos)1261 private int jjMoveNfa_16(int startState, int curPos)
1262 {
1263 int startsAt = 0;
1264 jjnewStateCnt = 94;
1265 int i = 1;
1266 jjstateSet[0] = startState;
1267 int kind = 0x7fffffff;
1268 for (;;)
1269 {
1270 if (++jjround == 0x7fffffff)
1271 ReInitRounds();
1272 if (curChar < 64)
1273 {
1274 long l = 1L << curChar;
1275 do
1276 {
1277 switch(jjstateSet[--i])
1278 {
1279 case 94:
1280 if ((0x3ff000000000000L & l) != 0L)
1281 jjCheckNAddTwoStates(89, 90);
1282 else if (curChar == 46)
1283 jjCheckNAdd(57);
1284 if ((0x3ff000000000000L & l) != 0L)
1285 jjCheckNAddTwoStates(83, 84);
1286 if ((0x3ff000000000000L & l) != 0L)
1287 {
1288 if (kind > 58)
1289 kind = 58;
1290 jjCheckNAddTwoStates(80, 82);
1291 }
1292 break;
1293 case 3:
1294 if ((0x3ff000000000000L & l) != 0L)
1295 {
1296 if (kind > 58)
1297 kind = 58;
1298 jjCheckNAddStates(45, 50);
1299 }
1300 else if ((0x2400L & l) != 0L)
1301 {
1302 if (kind > 33)
1303 kind = 33;
1304 }
1305 else if ((0x100000200L & l) != 0L)
1306 {
1307 if (kind > 32)
1308 kind = 32;
1309 jjCheckNAdd(4);
1310 }
1311 else if (curChar == 45)
1312 jjCheckNAddStates(51, 54);
1313 else if (curChar == 36)
1314 {
1315 if (kind > 19)
1316 kind = 19;
1317 jjCheckNAddTwoStates(66, 67);
1318 }
1319 else if (curChar == 46)
1320 jjCheckNAdd(57);
1321 else if (curChar == 33)
1322 {
1323 if (kind > 51)
1324 kind = 51;
1325 }
1326 else if (curChar == 61)
1327 jjstateSet[jjnewStateCnt++] = 49;
1328 else if (curChar == 62)
1329 jjstateSet[jjnewStateCnt++] = 47;
1330 else if (curChar == 60)
1331 jjstateSet[jjnewStateCnt++] = 44;
1332 else if (curChar == 38)
1333 jjstateSet[jjnewStateCnt++] = 34;
1334 else if (curChar == 39)
1335 jjCheckNAddStates(55, 58);
1336 else if (curChar == 34)
1337 jjCheckNAddStates(59, 62);
1338 else if (curChar == 35)
1339 jjstateSet[jjnewStateCnt++] = 2;
1340 if (curChar == 33)
1341 jjstateSet[jjnewStateCnt++] = 53;
1342 else if (curChar == 62)
1343 {
1344 if (kind > 47)
1345 kind = 47;
1346 }
1347 else if (curChar == 60)
1348 {
1349 if (kind > 45)
1350 kind = 45;
1351 }
1352 else if (curChar == 13)
1353 jjstateSet[jjnewStateCnt++] = 6;
1354 break;
1355 case 0:
1356 if (curChar == 42)
1357 jjstateSet[jjnewStateCnt++] = 1;
1358 break;
1359 case 1:
1360 if ((0xfffffff7efffffffL & l) != 0L && kind > 22)
1361 kind = 22;
1362 break;
1363 case 2:
1364 if (curChar == 42)
1365 jjstateSet[jjnewStateCnt++] = 0;
1366 break;
1367 case 4:
1368 if ((0x100000200L & l) == 0L)
1369 break;
1370 if (kind > 32)
1371 kind = 32;
1372 jjCheckNAdd(4);
1373 break;
1374 case 5:
1375 if ((0x2400L & l) != 0L && kind > 33)
1376 kind = 33;
1377 break;
1378 case 6:
1379 if (curChar == 10 && kind > 33)
1380 kind = 33;
1381 break;
1382 case 7:
1383 if (curChar == 13)
1384 jjstateSet[jjnewStateCnt++] = 6;
1385 break;
1386 case 8:
1387 case 10:
1388 if (curChar == 34)
1389 jjCheckNAddStates(59, 62);
1390 break;
1391 case 9:
1392 if ((0xfffffffbefffffffL & l) != 0L)
1393 jjCheckNAddStates(59, 62);
1394 break;
1395 case 11:
1396 if (curChar == 34)
1397 jjstateSet[jjnewStateCnt++] = 10;
1398 break;
1399 case 12:
1400 if (curChar == 34 && kind > 35)
1401 kind = 35;
1402 break;
1403 case 15:
1404 if ((0xff000000000000L & l) != 0L)
1405 jjCheckNAddStates(63, 67);
1406 break;
1407 case 16:
1408 if ((0xff000000000000L & l) != 0L)
1409 jjCheckNAddStates(59, 62);
1410 break;
1411 case 17:
1412 if ((0xf000000000000L & l) != 0L)
1413 jjstateSet[jjnewStateCnt++] = 18;
1414 break;
1415 case 18:
1416 if ((0xff000000000000L & l) != 0L)
1417 jjCheckNAdd(16);
1418 break;
1419 case 20:
1420 if ((0x3ff000000000000L & l) != 0L)
1421 jjstateSet[jjnewStateCnt++] = 21;
1422 break;
1423 case 21:
1424 if ((0x3ff000000000000L & l) != 0L)
1425 jjstateSet[jjnewStateCnt++] = 22;
1426 break;
1427 case 22:
1428 if ((0x3ff000000000000L & l) != 0L)
1429 jjstateSet[jjnewStateCnt++] = 23;
1430 break;
1431 case 23:
1432 if ((0x3ff000000000000L & l) != 0L)
1433 jjCheckNAddStates(59, 62);
1434 break;
1435 case 24:
1436 if (curChar == 32)
1437 jjAddStates(68, 69);
1438 break;
1439 case 25:
1440 if (curChar == 10)
1441 jjCheckNAddStates(59, 62);
1442 break;
1443 case 26:
1444 case 28:
1445 if (curChar == 39)
1446 jjCheckNAddStates(55, 58);
1447 break;
1448 case 27:
1449 if ((0xffffff7fefffffffL & l) != 0L)
1450 jjCheckNAddStates(55, 58);
1451 break;
1452 case 29:
1453 if (curChar == 39)
1454 jjstateSet[jjnewStateCnt++] = 28;
1455 break;
1456 case 31:
1457 if (curChar == 32)
1458 jjAddStates(70, 71);
1459 break;
1460 case 32:
1461 if (curChar == 10)
1462 jjCheckNAddStates(55, 58);
1463 break;
1464 case 33:
1465 if (curChar == 39 && kind > 35)
1466 kind = 35;
1467 break;
1468 case 34:
1469 if (curChar == 38 && kind > 43)
1470 kind = 43;
1471 break;
1472 case 35:
1473 if (curChar == 38)
1474 jjstateSet[jjnewStateCnt++] = 34;
1475 break;
1476 case 43:
1477 if (curChar == 60 && kind > 45)
1478 kind = 45;
1479 break;
1480 case 44:
1481 if (curChar == 61 && kind > 46)
1482 kind = 46;
1483 break;
1484 case 45:
1485 if (curChar == 60)
1486 jjstateSet[jjnewStateCnt++] = 44;
1487 break;
1488 case 46:
1489 if (curChar == 62 && kind > 47)
1490 kind = 47;
1491 break;
1492 case 47:
1493 if (curChar == 61 && kind > 48)
1494 kind = 48;
1495 break;
1496 case 48:
1497 if (curChar == 62)
1498 jjstateSet[jjnewStateCnt++] = 47;
1499 break;
1500 case 49:
1501 if (curChar == 61 && kind > 49)
1502 kind = 49;
1503 break;
1504 case 50:
1505 if (curChar == 61)
1506 jjstateSet[jjnewStateCnt++] = 49;
1507 break;
1508 case 53:
1509 if (curChar == 61 && kind > 50)
1510 kind = 50;
1511 break;
1512 case 54:
1513 if (curChar == 33)
1514 jjstateSet[jjnewStateCnt++] = 53;
1515 break;
1516 case 55:
1517 if (curChar == 33 && kind > 51)
1518 kind = 51;
1519 break;
1520 case 56:
1521 if (curChar == 46)
1522 jjCheckNAdd(57);
1523 break;
1524 case 57:
1525 if ((0x3ff000000000000L & l) == 0L)
1526 break;
1527 if (kind > 59)
1528 kind = 59;
1529 jjCheckNAddTwoStates(57, 58);
1530 break;
1531 case 59:
1532 if ((0x280000000000L & l) != 0L)
1533 jjCheckNAdd(60);
1534 break;
1535 case 60:
1536 if ((0x3ff000000000000L & l) == 0L)
1537 break;
1538 if (kind > 59)
1539 kind = 59;
1540 jjCheckNAdd(60);
1541 break;
1542 case 63:
1543 if (curChar == 36 && kind > 19)
1544 kind = 19;
1545 break;
1546 case 65:
1547 if (curChar == 36)
1548 jjCheckNAddTwoStates(66, 67);
1549 break;
1550 case 67:
1551 if (curChar == 33 && kind > 20)
1552 kind = 20;
1553 break;
1554 case 68:
1555 if (curChar != 36)
1556 break;
1557 if (kind > 19)
1558 kind = 19;
1559 jjCheckNAddTwoStates(66, 67);
1560 break;
1561 case 79:
1562 if (curChar == 45)
1563 jjCheckNAddStates(51, 54);
1564 break;
1565 case 80:
1566 if ((0x3ff000000000000L & l) == 0L)
1567 break;
1568 if (kind > 58)
1569 kind = 58;
1570 jjCheckNAddTwoStates(80, 82);
1571 break;
1572 case 81:
1573 if (curChar == 46 && kind > 58)
1574 kind = 58;
1575 break;
1576 case 82:
1577 if (curChar == 46)
1578 jjstateSet[jjnewStateCnt++] = 81;
1579 break;
1580 case 83:
1581 if ((0x3ff000000000000L & l) != 0L)
1582 jjCheckNAddTwoStates(83, 84);
1583 break;
1584 case 84:
1585 if (curChar != 46)
1586 break;
1587 if (kind > 59)
1588 kind = 59;
1589 jjCheckNAddTwoStates(85, 86);
1590 break;
1591 case 85:
1592 if ((0x3ff000000000000L & l) == 0L)
1593 break;
1594 if (kind > 59)
1595 kind = 59;
1596 jjCheckNAddTwoStates(85, 86);
1597 break;
1598 case 87:
1599 if ((0x280000000000L & l) != 0L)
1600 jjCheckNAdd(88);
1601 break;
1602 case 88:
1603 if ((0x3ff000000000000L & l) == 0L)
1604 break;
1605 if (kind > 59)
1606 kind = 59;
1607 jjCheckNAdd(88);
1608 break;
1609 case 89:
1610 if ((0x3ff000000000000L & l) != 0L)
1611 jjCheckNAddTwoStates(89, 90);
1612 break;
1613 case 91:
1614 if ((0x280000000000L & l) != 0L)
1615 jjCheckNAdd(92);
1616 break;
1617 case 92:
1618 if ((0x3ff000000000000L & l) == 0L)
1619 break;
1620 if (kind > 59)
1621 kind = 59;
1622 jjCheckNAdd(92);
1623 break;
1624 case 93:
1625 if ((0x3ff000000000000L & l) == 0L)
1626 break;
1627 if (kind > 58)
1628 kind = 58;
1629 jjCheckNAddStates(45, 50);
1630 break;
1631 default : break;
1632 }
1633 } while(i != startsAt);
1634 }
1635 else if (curChar < 128)
1636 {
1637 long l = 1L << (curChar & 077);
1638 do
1639 {
1640 switch(jjstateSet[--i])
1641 {
1642 case 3:
1643 if (curChar == 110)
1644 jjAddStates(72, 73);
1645 else if (curChar == 103)
1646 jjAddStates(74, 75);
1647 else if (curChar == 108)
1648 jjAddStates(76, 77);
1649 else if (curChar == 92)
1650 jjCheckNAddStates(78, 81);
1651 else if (curChar == 101)
1652 jjstateSet[jjnewStateCnt++] = 51;
1653 else if (curChar == 111)
1654 jjstateSet[jjnewStateCnt++] = 41;
1655 else if (curChar == 124)
1656 jjstateSet[jjnewStateCnt++] = 39;
1657 else if (curChar == 97)
1658 jjstateSet[jjnewStateCnt++] = 37;
1659 break;
1660 case 1:
1661 if (kind > 22)
1662 kind = 22;
1663 break;
1664 case 9:
1665 jjCheckNAddStates(59, 62);
1666 break;
1667 case 13:
1668 if (curChar == 92)
1669 jjAddStates(82, 87);
1670 break;
1671 case 14:
1672 if ((0x14404400000000L & l) != 0L)
1673 jjCheckNAddStates(59, 62);
1674 break;
1675 case 19:
1676 if (curChar == 117)
1677 jjstateSet[jjnewStateCnt++] = 20;
1678 break;
1679 case 20:
1680 if ((0x7e0000007eL & l) != 0L)
1681 jjstateSet[jjnewStateCnt++] = 21;
1682 break;
1683 case 21:
1684 if ((0x7e0000007eL & l) != 0L)
1685 jjstateSet[jjnewStateCnt++] = 22;
1686 break;
1687 case 22:
1688 if ((0x7e0000007eL & l) != 0L)
1689 jjstateSet[jjnewStateCnt++] = 23;
1690 break;
1691 case 23:
1692 if ((0x7e0000007eL & l) != 0L)
1693 jjCheckNAddStates(59, 62);
1694 break;
1695 case 27:
1696 jjAddStates(55, 58);
1697 break;
1698 case 30:
1699 if (curChar == 92)
1700 jjAddStates(70, 71);
1701 break;
1702 case 36:
1703 if (curChar == 100 && kind > 43)
1704 kind = 43;
1705 break;
1706 case 37:
1707 if (curChar == 110)
1708 jjstateSet[jjnewStateCnt++] = 36;
1709 break;
1710 case 38:
1711 if (curChar == 97)
1712 jjstateSet[jjnewStateCnt++] = 37;
1713 break;
1714 case 39:
1715 if (curChar == 124 && kind > 44)
1716 kind = 44;
1717 break;
1718 case 40:
1719 if (curChar == 124)
1720 jjstateSet[jjnewStateCnt++] = 39;
1721 break;
1722 case 41:
1723 if (curChar == 114 && kind > 44)
1724 kind = 44;
1725 break;
1726 case 42:
1727 if (curChar == 111)
1728 jjstateSet[jjnewStateCnt++] = 41;
1729 break;
1730 case 51:
1731 if (curChar == 113 && kind > 49)
1732 kind = 49;
1733 break;
1734 case 52:
1735 if (curChar == 101)
1736 jjstateSet[jjnewStateCnt++] = 51;
1737 break;
1738 case 58:
1739 if ((0x2000000020L & l) != 0L)
1740 jjAddStates(88, 89);
1741 break;
1742 case 61:
1743 if (curChar == 92)
1744 jjCheckNAddStates(78, 81);
1745 break;
1746 case 62:
1747 if (curChar == 92)
1748 jjCheckNAddTwoStates(62, 63);
1749 break;
1750 case 64:
1751 if (curChar == 92)
1752 jjCheckNAddTwoStates(64, 65);
1753 break;
1754 case 66:
1755 if (curChar == 92)
1756 jjAddStates(90, 91);
1757 break;
1758 case 69:
1759 if (curChar == 108)
1760 jjAddStates(76, 77);
1761 break;
1762 case 70:
1763 if (curChar == 116 && kind > 45)
1764 kind = 45;
1765 break;
1766 case 71:
1767 if (curChar == 101 && kind > 46)
1768 kind = 46;
1769 break;
1770 case 72:
1771 if (curChar == 103)
1772 jjAddStates(74, 75);
1773 break;
1774 case 73:
1775 if (curChar == 116 && kind > 47)
1776 kind = 47;
1777 break;
1778 case 74:
1779 if (curChar == 101 && kind > 48)
1780 kind = 48;
1781 break;
1782 case 75:
1783 if (curChar == 110)
1784 jjAddStates(72, 73);
1785 break;
1786 case 76:
1787 if (curChar == 101 && kind > 50)
1788 kind = 50;
1789 break;
1790 case 77:
1791 if (curChar == 116 && kind > 51)
1792 kind = 51;
1793 break;
1794 case 78:
1795 if (curChar == 111)
1796 jjstateSet[jjnewStateCnt++] = 77;
1797 break;
1798 case 86:
1799 if ((0x2000000020L & l) != 0L)
1800 jjAddStates(92, 93);
1801 break;
1802 case 90:
1803 if ((0x2000000020L & l) != 0L)
1804 jjAddStates(94, 95);
1805 break;
1806 default : break;
1807 }
1808 } while(i != startsAt);
1809 }
1810 else
1811 {
1812 int hiByte = (int)(curChar >> 8);
1813 int i1 = hiByte >> 6;
1814 long l1 = 1L << (hiByte & 077);
1815 int i2 = (curChar & 0xff) >> 6;
1816 long l2 = 1L << (curChar & 077);
1817 do
1818 {
1819 switch(jjstateSet[--i])
1820 {
1821 case 1:
1822 if (jjCanMove_0(hiByte, i1, i2, l1, l2) && kind > 22)
1823 kind = 22;
1824 break;
1825 case 9:
1826 if (jjCanMove_0(hiByte, i1, i2, l1, l2))
1827 jjAddStates(59, 62);
1828 break;
1829 case 27:
1830 if (jjCanMove_0(hiByte, i1, i2, l1, l2))
1831 jjAddStates(55, 58);
1832 break;
1833 default : break;
1834 }
1835 } while(i != startsAt);
1836 }
1837 if (kind != 0x7fffffff)
1838 {
1839 jjmatchedKind = kind;
1840 jjmatchedPos = curPos;
1841 kind = 0x7fffffff;
1842 }
1843 ++curPos;
1844 if ((i = jjnewStateCnt) == (startsAt = 94 - (jjnewStateCnt = startsAt)))
1845 return curPos;
1846 try { curChar = input_stream.readChar(); }
1847 catch(java.io.IOException e) { return curPos; }
1848 }
1849 }
jjStopStringLiteralDfa_12(int pos, long active0)1850 private final int jjStopStringLiteralDfa_12(int pos, long active0)
1851 {
1852 switch (pos)
1853 {
1854 case 0:
1855 if ((active0 & 0x1a00000L) != 0L)
1856 return 2;
1857 if ((active0 & 0x20000000L) != 0L)
1858 {
1859 jjmatchedKind = 31;
1860 return -1;
1861 }
1862 return -1;
1863 case 1:
1864 if ((active0 & 0x800000L) != 0L)
1865 return 0;
1866 if ((active0 & 0x20000000L) != 0L)
1867 {
1868 if (jjmatchedPos == 0)
1869 {
1870 jjmatchedKind = 31;
1871 jjmatchedPos = 0;
1872 }
1873 return -1;
1874 }
1875 return -1;
1876 default :
1877 return -1;
1878 }
1879 }
jjStartNfa_12(int pos, long active0)1880 private final int jjStartNfa_12(int pos, long active0)
1881 {
1882 return jjMoveNfa_12(jjStopStringLiteralDfa_12(pos, active0), pos + 1);
1883 }
jjMoveStringLiteralDfa0_12()1884 private int jjMoveStringLiteralDfa0_12()
1885 {
1886 switch(curChar)
1887 {
1888 case 28:
1889 return jjStopAtPos(0, 2);
1890 case 35:
1891 jjmatchedKind = 24;
1892 return jjMoveStringLiteralDfa1_12(0xa00000L);
1893 case 93:
1894 return jjMoveStringLiteralDfa1_12(0x20000000L);
1895 default :
1896 return jjMoveNfa_12(3, 0);
1897 }
1898 }
jjMoveStringLiteralDfa1_12(long active0)1899 private int jjMoveStringLiteralDfa1_12(long active0)
1900 {
1901 try { curChar = input_stream.readChar(); }
1902 catch(java.io.IOException e) {
1903 jjStopStringLiteralDfa_12(0, active0);
1904 return 1;
1905 }
1906 switch(curChar)
1907 {
1908 case 42:
1909 if ((active0 & 0x800000L) != 0L)
1910 return jjStartNfaWithStates_12(1, 23, 0);
1911 break;
1912 case 91:
1913 return jjMoveStringLiteralDfa2_12(active0, 0x200000L);
1914 case 93:
1915 return jjMoveStringLiteralDfa2_12(active0, 0x20000000L);
1916 default :
1917 break;
1918 }
1919 return jjStartNfa_12(0, active0);
1920 }
jjMoveStringLiteralDfa2_12(long old0, long active0)1921 private int jjMoveStringLiteralDfa2_12(long old0, long active0)
1922 {
1923 if (((active0 &= old0)) == 0L)
1924 return jjStartNfa_12(0, old0);
1925 try { curChar = input_stream.readChar(); }
1926 catch(java.io.IOException e) {
1927 jjStopStringLiteralDfa_12(1, active0);
1928 return 2;
1929 }
1930 switch(curChar)
1931 {
1932 case 35:
1933 if ((active0 & 0x20000000L) != 0L)
1934 return jjStopAtPos(2, 29);
1935 break;
1936 case 91:
1937 if ((active0 & 0x200000L) != 0L)
1938 return jjStopAtPos(2, 21);
1939 break;
1940 default :
1941 break;
1942 }
1943 return jjStartNfa_12(1, active0);
1944 }
jjStartNfaWithStates_12(int pos, int kind, int state)1945 private int jjStartNfaWithStates_12(int pos, int kind, int state)
1946 {
1947 jjmatchedKind = kind;
1948 jjmatchedPos = pos;
1949 try { curChar = input_stream.readChar(); }
1950 catch(java.io.IOException e) { return pos + 1; }
1951 return jjMoveNfa_12(state, pos + 1);
1952 }
jjMoveNfa_12(int startState, int curPos)1953 private int jjMoveNfa_12(int startState, int curPos)
1954 {
1955 int startsAt = 0;
1956 jjnewStateCnt = 13;
1957 int i = 1;
1958 jjstateSet[0] = startState;
1959 int kind = 0x7fffffff;
1960 for (;;)
1961 {
1962 if (++jjround == 0x7fffffff)
1963 ReInitRounds();
1964 if (curChar < 64)
1965 {
1966 long l = 1L << curChar;
1967 do
1968 {
1969 switch(jjstateSet[--i])
1970 {
1971 case 3:
1972 if ((0xffffffffefffffffL & l) != 0L)
1973 {
1974 if (kind > 31)
1975 kind = 31;
1976 }
1977 if (curChar == 36)
1978 {
1979 if (kind > 19)
1980 kind = 19;
1981 jjCheckNAddTwoStates(10, 11);
1982 }
1983 else if (curChar == 35)
1984 jjstateSet[jjnewStateCnt++] = 2;
1985 break;
1986 case 0:
1987 if (curChar == 42)
1988 jjstateSet[jjnewStateCnt++] = 1;
1989 break;
1990 case 1:
1991 if ((0xfffffff7efffffffL & l) != 0L && kind > 22)
1992 kind = 22;
1993 break;
1994 case 2:
1995 if (curChar == 42)
1996 jjstateSet[jjnewStateCnt++] = 0;
1997 break;
1998 case 4:
1999 if ((0xffffffffefffffffL & l) != 0L && kind > 31)
2000 kind = 31;
2001 break;
2002 case 7:
2003 if (curChar == 36 && kind > 19)
2004 kind = 19;
2005 break;
2006 case 9:
2007 if (curChar == 36)
2008 jjCheckNAddTwoStates(10, 11);
2009 break;
2010 case 11:
2011 if (curChar == 33 && kind > 20)
2012 kind = 20;
2013 break;
2014 case 12:
2015 if (curChar != 36)
2016 break;
2017 if (kind > 19)
2018 kind = 19;
2019 jjCheckNAddTwoStates(10, 11);
2020 break;
2021 default : break;
2022 }
2023 } while(i != startsAt);
2024 }
2025 else if (curChar < 128)
2026 {
2027 long l = 1L << (curChar & 077);
2028 do
2029 {
2030 switch(jjstateSet[--i])
2031 {
2032 case 3:
2033 if (kind > 31)
2034 kind = 31;
2035 if (curChar == 92)
2036 jjCheckNAddStates(96, 99);
2037 break;
2038 case 1:
2039 if (kind > 22)
2040 kind = 22;
2041 break;
2042 case 4:
2043 if (kind > 31)
2044 kind = 31;
2045 break;
2046 case 5:
2047 if (curChar == 92)
2048 jjCheckNAddStates(96, 99);
2049 break;
2050 case 6:
2051 if (curChar == 92)
2052 jjCheckNAddTwoStates(6, 7);
2053 break;
2054 case 8:
2055 if (curChar == 92)
2056 jjCheckNAddTwoStates(8, 9);
2057 break;
2058 case 10:
2059 if (curChar == 92)
2060 jjAddStates(100, 101);
2061 break;
2062 default : break;
2063 }
2064 } while(i != startsAt);
2065 }
2066 else
2067 {
2068 int hiByte = (int)(curChar >> 8);
2069 int i1 = hiByte >> 6;
2070 long l1 = 1L << (hiByte & 077);
2071 int i2 = (curChar & 0xff) >> 6;
2072 long l2 = 1L << (curChar & 077);
2073 do
2074 {
2075 switch(jjstateSet[--i])
2076 {
2077 case 3:
2078 if (jjCanMove_0(hiByte, i1, i2, l1, l2) && kind > 31)
2079 kind = 31;
2080 break;
2081 case 1:
2082 if (jjCanMove_0(hiByte, i1, i2, l1, l2) && kind > 22)
2083 kind = 22;
2084 break;
2085 default : break;
2086 }
2087 } while(i != startsAt);
2088 }
2089 if (kind != 0x7fffffff)
2090 {
2091 jjmatchedKind = kind;
2092 jjmatchedPos = curPos;
2093 kind = 0x7fffffff;
2094 }
2095 ++curPos;
2096 if ((i = jjnewStateCnt) == (startsAt = 13 - (jjnewStateCnt = startsAt)))
2097 return curPos;
2098 try { curChar = input_stream.readChar(); }
2099 catch(java.io.IOException e) { return curPos; }
2100 }
2101 }
jjStopStringLiteralDfa_15(int pos, long active0)2102 private final int jjStopStringLiteralDfa_15(int pos, long active0)
2103 {
2104 switch (pos)
2105 {
2106 case 0:
2107 if ((active0 & 0x1a00000L) != 0L)
2108 return 2;
2109 return -1;
2110 case 1:
2111 if ((active0 & 0x800000L) != 0L)
2112 return 0;
2113 return -1;
2114 default :
2115 return -1;
2116 }
2117 }
jjStartNfa_15(int pos, long active0)2118 private final int jjStartNfa_15(int pos, long active0)
2119 {
2120 return jjMoveNfa_15(jjStopStringLiteralDfa_15(pos, active0), pos + 1);
2121 }
jjMoveStringLiteralDfa0_15()2122 private int jjMoveStringLiteralDfa0_15()
2123 {
2124 switch(curChar)
2125 {
2126 case 28:
2127 return jjStopAtPos(0, 2);
2128 case 35:
2129 jjmatchedKind = 24;
2130 return jjMoveStringLiteralDfa1_15(0xa00000L);
2131 default :
2132 return jjMoveNfa_15(3, 0);
2133 }
2134 }
jjMoveStringLiteralDfa1_15(long active0)2135 private int jjMoveStringLiteralDfa1_15(long active0)
2136 {
2137 try { curChar = input_stream.readChar(); }
2138 catch(java.io.IOException e) {
2139 jjStopStringLiteralDfa_15(0, active0);
2140 return 1;
2141 }
2142 switch(curChar)
2143 {
2144 case 42:
2145 if ((active0 & 0x800000L) != 0L)
2146 return jjStartNfaWithStates_15(1, 23, 0);
2147 break;
2148 case 91:
2149 return jjMoveStringLiteralDfa2_15(active0, 0x200000L);
2150 default :
2151 break;
2152 }
2153 return jjStartNfa_15(0, active0);
2154 }
jjMoveStringLiteralDfa2_15(long old0, long active0)2155 private int jjMoveStringLiteralDfa2_15(long old0, long active0)
2156 {
2157 if (((active0 &= old0)) == 0L)
2158 return jjStartNfa_15(0, old0);
2159 try { curChar = input_stream.readChar(); }
2160 catch(java.io.IOException e) {
2161 jjStopStringLiteralDfa_15(1, active0);
2162 return 2;
2163 }
2164 switch(curChar)
2165 {
2166 case 91:
2167 if ((active0 & 0x200000L) != 0L)
2168 return jjStopAtPos(2, 21);
2169 break;
2170 default :
2171 break;
2172 }
2173 return jjStartNfa_15(1, active0);
2174 }
jjStartNfaWithStates_15(int pos, int kind, int state)2175 private int jjStartNfaWithStates_15(int pos, int kind, int state)
2176 {
2177 jjmatchedKind = kind;
2178 jjmatchedPos = pos;
2179 try { curChar = input_stream.readChar(); }
2180 catch(java.io.IOException e) { return pos + 1; }
2181 return jjMoveNfa_15(state, pos + 1);
2182 }
jjMoveNfa_15(int startState, int curPos)2183 private int jjMoveNfa_15(int startState, int curPos)
2184 {
2185 int startsAt = 0;
2186 jjnewStateCnt = 15;
2187 int i = 1;
2188 jjstateSet[0] = startState;
2189 int kind = 0x7fffffff;
2190 for (;;)
2191 {
2192 if (++jjround == 0x7fffffff)
2193 ReInitRounds();
2194 if (curChar < 64)
2195 {
2196 long l = 1L << curChar;
2197 do
2198 {
2199 switch(jjstateSet[--i])
2200 {
2201 case 3:
2202 if ((0x2400L & l) != 0L)
2203 {
2204 if (kind > 26)
2205 kind = 26;
2206 }
2207 else if (curChar == 36)
2208 {
2209 if (kind > 19)
2210 kind = 19;
2211 jjCheckNAddTwoStates(12, 13);
2212 }
2213 else if (curChar == 35)
2214 jjstateSet[jjnewStateCnt++] = 2;
2215 if (curChar == 13)
2216 jjstateSet[jjnewStateCnt++] = 5;
2217 break;
2218 case 0:
2219 if (curChar == 42)
2220 jjstateSet[jjnewStateCnt++] = 1;
2221 break;
2222 case 1:
2223 if ((0xfffffff7efffffffL & l) != 0L && kind > 22)
2224 kind = 22;
2225 break;
2226 case 2:
2227 if (curChar == 42)
2228 jjstateSet[jjnewStateCnt++] = 0;
2229 break;
2230 case 4:
2231 if ((0x2400L & l) != 0L && kind > 26)
2232 kind = 26;
2233 break;
2234 case 5:
2235 if (curChar == 10 && kind > 26)
2236 kind = 26;
2237 break;
2238 case 6:
2239 if (curChar == 13)
2240 jjstateSet[jjnewStateCnt++] = 5;
2241 break;
2242 case 9:
2243 if (curChar == 36 && kind > 19)
2244 kind = 19;
2245 break;
2246 case 11:
2247 if (curChar == 36)
2248 jjCheckNAddTwoStates(12, 13);
2249 break;
2250 case 13:
2251 if (curChar == 33 && kind > 20)
2252 kind = 20;
2253 break;
2254 case 14:
2255 if (curChar != 36)
2256 break;
2257 if (kind > 19)
2258 kind = 19;
2259 jjCheckNAddTwoStates(12, 13);
2260 break;
2261 default : break;
2262 }
2263 } while(i != startsAt);
2264 }
2265 else if (curChar < 128)
2266 {
2267 long l = 1L << (curChar & 077);
2268 do
2269 {
2270 switch(jjstateSet[--i])
2271 {
2272 case 3:
2273 if (curChar == 92)
2274 jjCheckNAddStates(102, 105);
2275 break;
2276 case 1:
2277 if (kind > 22)
2278 kind = 22;
2279 break;
2280 case 8:
2281 if (curChar == 92)
2282 jjCheckNAddTwoStates(8, 9);
2283 break;
2284 case 10:
2285 if (curChar == 92)
2286 jjCheckNAddTwoStates(10, 11);
2287 break;
2288 case 12:
2289 if (curChar == 92)
2290 jjAddStates(3, 4);
2291 break;
2292 default : break;
2293 }
2294 } while(i != startsAt);
2295 }
2296 else
2297 {
2298 int hiByte = (int)(curChar >> 8);
2299 int i1 = hiByte >> 6;
2300 long l1 = 1L << (hiByte & 077);
2301 int i2 = (curChar & 0xff) >> 6;
2302 long l2 = 1L << (curChar & 077);
2303 do
2304 {
2305 switch(jjstateSet[--i])
2306 {
2307 case 1:
2308 if (jjCanMove_0(hiByte, i1, i2, l1, l2) && kind > 22)
2309 kind = 22;
2310 break;
2311 default : break;
2312 }
2313 } while(i != startsAt);
2314 }
2315 if (kind != 0x7fffffff)
2316 {
2317 jjmatchedKind = kind;
2318 jjmatchedPos = curPos;
2319 kind = 0x7fffffff;
2320 }
2321 ++curPos;
2322 if ((i = jjnewStateCnt) == (startsAt = 15 - (jjnewStateCnt = startsAt)))
2323 return curPos;
2324 try { curChar = input_stream.readChar(); }
2325 catch(java.io.IOException e) { return curPos; }
2326 }
2327 }
jjStopStringLiteralDfa_5(int pos, long active0, long active1)2328 private final int jjStopStringLiteralDfa_5(int pos, long active0, long active1)
2329 {
2330 switch (pos)
2331 {
2332 case 0:
2333 if ((active0 & 0x3000000000L) != 0L)
2334 {
2335 jjmatchedKind = 70;
2336 return 1;
2337 }
2338 if ((active0 & 0x3a00000L) != 0L)
2339 return 17;
2340 return -1;
2341 case 1:
2342 if ((active0 & 0x3000000000L) != 0L)
2343 {
2344 jjmatchedKind = 70;
2345 jjmatchedPos = 1;
2346 return 1;
2347 }
2348 if ((active0 & 0x800000L) != 0L)
2349 return 23;
2350 return -1;
2351 case 2:
2352 if ((active0 & 0x3000000000L) != 0L)
2353 {
2354 jjmatchedKind = 70;
2355 jjmatchedPos = 2;
2356 return 1;
2357 }
2358 return -1;
2359 case 3:
2360 if ((active0 & 0x2000000000L) != 0L)
2361 {
2362 jjmatchedKind = 70;
2363 jjmatchedPos = 3;
2364 return 1;
2365 }
2366 if ((active0 & 0x1000000000L) != 0L)
2367 return 1;
2368 return -1;
2369 default :
2370 return -1;
2371 }
2372 }
jjStartNfa_5(int pos, long active0, long active1)2373 private final int jjStartNfa_5(int pos, long active0, long active1)
2374 {
2375 return jjMoveNfa_5(jjStopStringLiteralDfa_5(pos, active0, active1), pos + 1);
2376 }
jjMoveStringLiteralDfa0_5()2377 private int jjMoveStringLiteralDfa0_5()
2378 {
2379 switch(curChar)
2380 {
2381 case 28:
2382 return jjStopAtPos(0, 2);
2383 case 35:
2384 jjmatchedKind = 24;
2385 return jjMoveStringLiteralDfa1_5(0x2a00000L);
2386 case 40:
2387 return jjStopAtPos(0, 14);
2388 case 91:
2389 return jjStopAtPos(0, 3);
2390 case 102:
2391 return jjMoveStringLiteralDfa1_5(0x2000000000L);
2392 case 116:
2393 return jjMoveStringLiteralDfa1_5(0x1000000000L);
2394 case 123:
2395 return jjStopAtPos(0, 72);
2396 case 124:
2397 jjmatchedKind = 5;
2398 return jjMoveStringLiteralDfa1_5(0x10L);
2399 case 125:
2400 return jjStopAtPos(0, 73);
2401 default :
2402 return jjMoveNfa_5(0, 0);
2403 }
2404 }
jjMoveStringLiteralDfa1_5(long active0)2405 private int jjMoveStringLiteralDfa1_5(long active0)
2406 {
2407 try { curChar = input_stream.readChar(); }
2408 catch(java.io.IOException e) {
2409 jjStopStringLiteralDfa_5(0, active0, 0L);
2410 return 1;
2411 }
2412 switch(curChar)
2413 {
2414 case 35:
2415 if ((active0 & 0x2000000L) != 0L)
2416 return jjStopAtPos(1, 25);
2417 break;
2418 case 42:
2419 if ((active0 & 0x800000L) != 0L)
2420 return jjStartNfaWithStates_5(1, 23, 23);
2421 break;
2422 case 91:
2423 return jjMoveStringLiteralDfa2_5(active0, 0x200000L);
2424 case 97:
2425 return jjMoveStringLiteralDfa2_5(active0, 0x2000000000L);
2426 case 114:
2427 return jjMoveStringLiteralDfa2_5(active0, 0x1000000000L);
2428 case 124:
2429 if ((active0 & 0x10L) != 0L)
2430 return jjStopAtPos(1, 4);
2431 break;
2432 default :
2433 break;
2434 }
2435 return jjStartNfa_5(0, active0, 0L);
2436 }
jjMoveStringLiteralDfa2_5(long old0, long active0)2437 private int jjMoveStringLiteralDfa2_5(long old0, long active0)
2438 {
2439 if (((active0 &= old0)) == 0L)
2440 return jjStartNfa_5(0, old0, 0L);
2441 try { curChar = input_stream.readChar(); }
2442 catch(java.io.IOException e) {
2443 jjStopStringLiteralDfa_5(1, active0, 0L);
2444 return 2;
2445 }
2446 switch(curChar)
2447 {
2448 case 91:
2449 if ((active0 & 0x200000L) != 0L)
2450 return jjStopAtPos(2, 21);
2451 break;
2452 case 108:
2453 return jjMoveStringLiteralDfa3_5(active0, 0x2000000000L);
2454 case 117:
2455 return jjMoveStringLiteralDfa3_5(active0, 0x1000000000L);
2456 default :
2457 break;
2458 }
2459 return jjStartNfa_5(1, active0, 0L);
2460 }
jjMoveStringLiteralDfa3_5(long old0, long active0)2461 private int jjMoveStringLiteralDfa3_5(long old0, long active0)
2462 {
2463 if (((active0 &= old0)) == 0L)
2464 return jjStartNfa_5(1, old0, 0L);
2465 try { curChar = input_stream.readChar(); }
2466 catch(java.io.IOException e) {
2467 jjStopStringLiteralDfa_5(2, active0, 0L);
2468 return 3;
2469 }
2470 switch(curChar)
2471 {
2472 case 101:
2473 if ((active0 & 0x1000000000L) != 0L)
2474 return jjStartNfaWithStates_5(3, 36, 1);
2475 break;
2476 case 115:
2477 return jjMoveStringLiteralDfa4_5(active0, 0x2000000000L);
2478 default :
2479 break;
2480 }
2481 return jjStartNfa_5(2, active0, 0L);
2482 }
jjMoveStringLiteralDfa4_5(long old0, long active0)2483 private int jjMoveStringLiteralDfa4_5(long old0, long active0)
2484 {
2485 if (((active0 &= old0)) == 0L)
2486 return jjStartNfa_5(2, old0, 0L);
2487 try { curChar = input_stream.readChar(); }
2488 catch(java.io.IOException e) {
2489 jjStopStringLiteralDfa_5(3, active0, 0L);
2490 return 4;
2491 }
2492 switch(curChar)
2493 {
2494 case 101:
2495 if ((active0 & 0x2000000000L) != 0L)
2496 return jjStartNfaWithStates_5(4, 37, 1);
2497 break;
2498 default :
2499 break;
2500 }
2501 return jjStartNfa_5(3, active0, 0L);
2502 }
jjStartNfaWithStates_5(int pos, int kind, int state)2503 private int jjStartNfaWithStates_5(int pos, int kind, int state)
2504 {
2505 jjmatchedKind = kind;
2506 jjmatchedPos = pos;
2507 try { curChar = input_stream.readChar(); }
2508 catch(java.io.IOException e) { return pos + 1; }
2509 return jjMoveNfa_5(state, pos + 1);
2510 }
jjMoveNfa_5(int startState, int curPos)2511 private int jjMoveNfa_5(int startState, int curPos)
2512 {
2513 int startsAt = 0;
2514 jjnewStateCnt = 26;
2515 int i = 1;
2516 jjstateSet[0] = startState;
2517 int kind = 0x7fffffff;
2518 for (;;)
2519 {
2520 if (++jjround == 0x7fffffff)
2521 ReInitRounds();
2522 if (curChar < 64)
2523 {
2524 long l = 1L << curChar;
2525 do
2526 {
2527 switch(jjstateSet[--i])
2528 {
2529 case 0:
2530 if (curChar == 35)
2531 jjAddStates(106, 108);
2532 else if (curChar == 36)
2533 {
2534 if (kind > 19)
2535 kind = 19;
2536 jjCheckNAddTwoStates(9, 10);
2537 }
2538 else if (curChar == 46)
2539 jjstateSet[jjnewStateCnt++] = 3;
2540 break;
2541 case 17:
2542 if (curChar == 42)
2543 jjstateSet[jjnewStateCnt++] = 23;
2544 break;
2545 case 1:
2546 if ((0x3ff200000000000L & l) == 0L)
2547 break;
2548 if (kind > 70)
2549 kind = 70;
2550 jjstateSet[jjnewStateCnt++] = 1;
2551 break;
2552 case 2:
2553 if (curChar == 46)
2554 jjstateSet[jjnewStateCnt++] = 3;
2555 break;
2556 case 6:
2557 if (curChar == 36 && kind > 19)
2558 kind = 19;
2559 break;
2560 case 8:
2561 if (curChar == 36)
2562 jjCheckNAddTwoStates(9, 10);
2563 break;
2564 case 10:
2565 if (curChar == 33 && kind > 20)
2566 kind = 20;
2567 break;
2568 case 11:
2569 if (curChar != 36)
2570 break;
2571 if (kind > 19)
2572 kind = 19;
2573 jjCheckNAddTwoStates(9, 10);
2574 break;
2575 case 12:
2576 if (curChar == 35)
2577 jjAddStates(106, 108);
2578 break;
2579 case 14:
2580 if ((0x100000200L & l) != 0L)
2581 jjAddStates(109, 110);
2582 break;
2583 case 15:
2584 if (curChar == 40 && kind > 18)
2585 kind = 18;
2586 break;
2587 case 23:
2588 if (curChar == 42)
2589 jjstateSet[jjnewStateCnt++] = 24;
2590 break;
2591 case 24:
2592 if ((0xfffffff7efffffffL & l) != 0L && kind > 22)
2593 kind = 22;
2594 break;
2595 default : break;
2596 }
2597 } while(i != startsAt);
2598 }
2599 else if (curChar < 128)
2600 {
2601 long l = 1L << (curChar & 077);
2602 do
2603 {
2604 switch(jjstateSet[--i])
2605 {
2606 case 0:
2607 if ((0x7fffffe87fffffeL & l) != 0L)
2608 {
2609 if (kind > 70)
2610 kind = 70;
2611 jjCheckNAdd(1);
2612 }
2613 else if (curChar == 92)
2614 jjCheckNAddStates(111, 114);
2615 break;
2616 case 17:
2617 if (curChar == 123)
2618 jjstateSet[jjnewStateCnt++] = 21;
2619 else if (curChar == 115)
2620 jjstateSet[jjnewStateCnt++] = 16;
2621 break;
2622 case 1:
2623 if ((0x7fffffe87fffffeL & l) == 0L)
2624 break;
2625 if (kind > 70)
2626 kind = 70;
2627 jjCheckNAdd(1);
2628 break;
2629 case 3:
2630 if ((0x7fffffe87fffffeL & l) != 0L && kind > 71)
2631 kind = 71;
2632 break;
2633 case 4:
2634 if (curChar == 92)
2635 jjCheckNAddStates(111, 114);
2636 break;
2637 case 5:
2638 if (curChar == 92)
2639 jjCheckNAddTwoStates(5, 6);
2640 break;
2641 case 7:
2642 if (curChar == 92)
2643 jjCheckNAddTwoStates(7, 8);
2644 break;
2645 case 9:
2646 if (curChar == 92)
2647 jjAddStates(115, 116);
2648 break;
2649 case 13:
2650 if (curChar == 116)
2651 jjCheckNAddTwoStates(14, 15);
2652 break;
2653 case 16:
2654 if (curChar == 101)
2655 jjstateSet[jjnewStateCnt++] = 13;
2656 break;
2657 case 18:
2658 if (curChar == 125)
2659 jjCheckNAddTwoStates(14, 15);
2660 break;
2661 case 19:
2662 if (curChar == 116)
2663 jjstateSet[jjnewStateCnt++] = 18;
2664 break;
2665 case 20:
2666 if (curChar == 101)
2667 jjstateSet[jjnewStateCnt++] = 19;
2668 break;
2669 case 21:
2670 if (curChar == 115)
2671 jjstateSet[jjnewStateCnt++] = 20;
2672 break;
2673 case 22:
2674 if (curChar == 123)
2675 jjstateSet[jjnewStateCnt++] = 21;
2676 break;
2677 case 24:
2678 if (kind > 22)
2679 kind = 22;
2680 break;
2681 default : break;
2682 }
2683 } while(i != startsAt);
2684 }
2685 else
2686 {
2687 int hiByte = (int)(curChar >> 8);
2688 int i1 = hiByte >> 6;
2689 long l1 = 1L << (hiByte & 077);
2690 int i2 = (curChar & 0xff) >> 6;
2691 long l2 = 1L << (curChar & 077);
2692 do
2693 {
2694 switch(jjstateSet[--i])
2695 {
2696 case 24:
2697 if (jjCanMove_0(hiByte, i1, i2, l1, l2) && kind > 22)
2698 kind = 22;
2699 break;
2700 default : break;
2701 }
2702 } while(i != startsAt);
2703 }
2704 if (kind != 0x7fffffff)
2705 {
2706 jjmatchedKind = kind;
2707 jjmatchedPos = curPos;
2708 kind = 0x7fffffff;
2709 }
2710 ++curPos;
2711 if ((i = jjnewStateCnt) == (startsAt = 26 - (jjnewStateCnt = startsAt)))
2712 return curPos;
2713 try { curChar = input_stream.readChar(); }
2714 catch(java.io.IOException e) { return curPos; }
2715 }
2716 }
jjStopStringLiteralDfa_8(int pos, long active0)2717 private final int jjStopStringLiteralDfa_8(int pos, long active0)
2718 {
2719 switch (pos)
2720 {
2721 case 0:
2722 if ((active0 & 0x3a00000L) != 0L)
2723 return 2;
2724 if ((active0 & 0x400L) != 0L)
2725 return 57;
2726 if ((active0 & 0x4000000000L) != 0L)
2727 return 100;
2728 if ((active0 & 0x10000000000000L) != 0L)
2729 return 49;
2730 if ((active0 & 0x1000L) != 0L)
2731 return 64;
2732 if ((active0 & 0x3000000000L) != 0L)
2733 {
2734 jjmatchedKind = 63;
2735 return 62;
2736 }
2737 return -1;
2738 case 1:
2739 if ((active0 & 0x800000L) != 0L)
2740 return 0;
2741 if ((active0 & 0x3000000000L) != 0L)
2742 {
2743 jjmatchedKind = 63;
2744 jjmatchedPos = 1;
2745 return 62;
2746 }
2747 return -1;
2748 case 2:
2749 if ((active0 & 0x3000000000L) != 0L)
2750 {
2751 jjmatchedKind = 63;
2752 jjmatchedPos = 2;
2753 return 62;
2754 }
2755 return -1;
2756 case 3:
2757 if ((active0 & 0x1000000000L) != 0L)
2758 return 62;
2759 if ((active0 & 0x2000000000L) != 0L)
2760 {
2761 jjmatchedKind = 63;
2762 jjmatchedPos = 3;
2763 return 62;
2764 }
2765 return -1;
2766 default :
2767 return -1;
2768 }
2769 }
jjStartNfa_8(int pos, long active0)2770 private final int jjStartNfa_8(int pos, long active0)
2771 {
2772 return jjMoveNfa_8(jjStopStringLiteralDfa_8(pos, active0), pos + 1);
2773 }
jjMoveStringLiteralDfa0_8()2774 private int jjMoveStringLiteralDfa0_8()
2775 {
2776 switch(curChar)
2777 {
2778 case 28:
2779 return jjStopAtPos(0, 2);
2780 case 35:
2781 jjmatchedKind = 24;
2782 return jjMoveStringLiteralDfa1_8(0x2a00000L);
2783 case 37:
2784 return jjStopAtPos(0, 42);
2785 case 40:
2786 return jjStopAtPos(0, 14);
2787 case 41:
2788 return jjStopAtPos(0, 15);
2789 case 42:
2790 return jjStopAtPos(0, 40);
2791 case 43:
2792 return jjStopAtPos(0, 39);
2793 case 44:
2794 return jjStopAtPos(0, 9);
2795 case 45:
2796 return jjStartNfaWithStates_8(0, 38, 100);
2797 case 46:
2798 return jjMoveStringLiteralDfa1_8(0x400L);
2799 case 47:
2800 return jjStopAtPos(0, 41);
2801 case 58:
2802 return jjStopAtPos(0, 11);
2803 case 61:
2804 return jjStartNfaWithStates_8(0, 52, 49);
2805 case 91:
2806 return jjStopAtPos(0, 7);
2807 case 93:
2808 return jjStopAtPos(0, 8);
2809 case 102:
2810 return jjMoveStringLiteralDfa1_8(0x2000000000L);
2811 case 116:
2812 return jjMoveStringLiteralDfa1_8(0x1000000000L);
2813 case 123:
2814 return jjStartNfaWithStates_8(0, 12, 64);
2815 case 125:
2816 return jjStopAtPos(0, 13);
2817 default :
2818 return jjMoveNfa_8(3, 0);
2819 }
2820 }
jjMoveStringLiteralDfa1_8(long active0)2821 private int jjMoveStringLiteralDfa1_8(long active0)
2822 {
2823 try { curChar = input_stream.readChar(); }
2824 catch(java.io.IOException e) {
2825 jjStopStringLiteralDfa_8(0, active0);
2826 return 1;
2827 }
2828 switch(curChar)
2829 {
2830 case 35:
2831 if ((active0 & 0x2000000L) != 0L)
2832 return jjStopAtPos(1, 25);
2833 break;
2834 case 42:
2835 if ((active0 & 0x800000L) != 0L)
2836 return jjStartNfaWithStates_8(1, 23, 0);
2837 break;
2838 case 46:
2839 if ((active0 & 0x400L) != 0L)
2840 return jjStopAtPos(1, 10);
2841 break;
2842 case 91:
2843 return jjMoveStringLiteralDfa2_8(active0, 0x200000L);
2844 case 97:
2845 return jjMoveStringLiteralDfa2_8(active0, 0x2000000000L);
2846 case 114:
2847 return jjMoveStringLiteralDfa2_8(active0, 0x1000000000L);
2848 default :
2849 break;
2850 }
2851 return jjStartNfa_8(0, active0);
2852 }
jjMoveStringLiteralDfa2_8(long old0, long active0)2853 private int jjMoveStringLiteralDfa2_8(long old0, long active0)
2854 {
2855 if (((active0 &= old0)) == 0L)
2856 return jjStartNfa_8(0, old0);
2857 try { curChar = input_stream.readChar(); }
2858 catch(java.io.IOException e) {
2859 jjStopStringLiteralDfa_8(1, active0);
2860 return 2;
2861 }
2862 switch(curChar)
2863 {
2864 case 91:
2865 if ((active0 & 0x200000L) != 0L)
2866 return jjStopAtPos(2, 21);
2867 break;
2868 case 108:
2869 return jjMoveStringLiteralDfa3_8(active0, 0x2000000000L);
2870 case 117:
2871 return jjMoveStringLiteralDfa3_8(active0, 0x1000000000L);
2872 default :
2873 break;
2874 }
2875 return jjStartNfa_8(1, active0);
2876 }
jjMoveStringLiteralDfa3_8(long old0, long active0)2877 private int jjMoveStringLiteralDfa3_8(long old0, long active0)
2878 {
2879 if (((active0 &= old0)) == 0L)
2880 return jjStartNfa_8(1, old0);
2881 try { curChar = input_stream.readChar(); }
2882 catch(java.io.IOException e) {
2883 jjStopStringLiteralDfa_8(2, active0);
2884 return 3;
2885 }
2886 switch(curChar)
2887 {
2888 case 101:
2889 if ((active0 & 0x1000000000L) != 0L)
2890 return jjStartNfaWithStates_8(3, 36, 62);
2891 break;
2892 case 115:
2893 return jjMoveStringLiteralDfa4_8(active0, 0x2000000000L);
2894 default :
2895 break;
2896 }
2897 return jjStartNfa_8(2, active0);
2898 }
jjMoveStringLiteralDfa4_8(long old0, long active0)2899 private int jjMoveStringLiteralDfa4_8(long old0, long active0)
2900 {
2901 if (((active0 &= old0)) == 0L)
2902 return jjStartNfa_8(2, old0);
2903 try { curChar = input_stream.readChar(); }
2904 catch(java.io.IOException e) {
2905 jjStopStringLiteralDfa_8(3, active0);
2906 return 4;
2907 }
2908 switch(curChar)
2909 {
2910 case 101:
2911 if ((active0 & 0x2000000000L) != 0L)
2912 return jjStartNfaWithStates_8(4, 37, 62);
2913 break;
2914 default :
2915 break;
2916 }
2917 return jjStartNfa_8(3, active0);
2918 }
jjStartNfaWithStates_8(int pos, int kind, int state)2919 private int jjStartNfaWithStates_8(int pos, int kind, int state)
2920 {
2921 jjmatchedKind = kind;
2922 jjmatchedPos = pos;
2923 try { curChar = input_stream.readChar(); }
2924 catch(java.io.IOException e) { return pos + 1; }
2925 return jjMoveNfa_8(state, pos + 1);
2926 }
jjMoveNfa_8(int startState, int curPos)2927 private int jjMoveNfa_8(int startState, int curPos)
2928 {
2929 int startsAt = 0;
2930 jjnewStateCnt = 100;
2931 int i = 1;
2932 jjstateSet[0] = startState;
2933 int kind = 0x7fffffff;
2934 for (;;)
2935 {
2936 if (++jjround == 0x7fffffff)
2937 ReInitRounds();
2938 if (curChar < 64)
2939 {
2940 long l = 1L << curChar;
2941 do
2942 {
2943 switch(jjstateSet[--i])
2944 {
2945 case 3:
2946 if ((0x3ff000000000000L & l) != 0L)
2947 {
2948 if (kind > 58)
2949 kind = 58;
2950 jjCheckNAddStates(117, 122);
2951 }
2952 else if ((0x2400L & l) != 0L)
2953 {
2954 if (kind > 33)
2955 kind = 33;
2956 }
2957 else if ((0x100000200L & l) != 0L)
2958 {
2959 if (kind > 32)
2960 kind = 32;
2961 jjCheckNAdd(4);
2962 }
2963 else if (curChar == 45)
2964 jjCheckNAddStates(123, 126);
2965 else if (curChar == 36)
2966 {
2967 if (kind > 19)
2968 kind = 19;
2969 jjCheckNAddTwoStates(72, 73);
2970 }
2971 else if (curChar == 46)
2972 jjCheckNAdd(57);
2973 else if (curChar == 33)
2974 {
2975 if (kind > 51)
2976 kind = 51;
2977 }
2978 else if (curChar == 61)
2979 jjstateSet[jjnewStateCnt++] = 49;
2980 else if (curChar == 62)
2981 jjstateSet[jjnewStateCnt++] = 47;
2982 else if (curChar == 60)
2983 jjstateSet[jjnewStateCnt++] = 44;
2984 else if (curChar == 38)
2985 jjstateSet[jjnewStateCnt++] = 34;
2986 else if (curChar == 39)
2987 jjCheckNAddStates(55, 58);
2988 else if (curChar == 34)
2989 jjCheckNAddStates(59, 62);
2990 else if (curChar == 35)
2991 jjstateSet[jjnewStateCnt++] = 2;
2992 if (curChar == 33)
2993 jjstateSet[jjnewStateCnt++] = 53;
2994 else if (curChar == 62)
2995 {
2996 if (kind > 47)
2997 kind = 47;
2998 }
2999 else if (curChar == 60)
3000 {
3001 if (kind > 45)
3002 kind = 45;
3003 }
3004 else if (curChar == 13)
3005 jjstateSet[jjnewStateCnt++] = 6;
3006 break;
3007 case 100:
3008 if ((0x3ff000000000000L & l) != 0L)
3009 jjCheckNAddTwoStates(95, 96);
3010 else if (curChar == 46)
3011 jjCheckNAdd(57);
3012 if ((0x3ff000000000000L & l) != 0L)
3013 jjCheckNAddTwoStates(89, 90);
3014 if ((0x3ff000000000000L & l) != 0L)
3015 {
3016 if (kind > 58)
3017 kind = 58;
3018 jjCheckNAddTwoStates(86, 88);
3019 }
3020 break;
3021 case 0:
3022 if (curChar == 42)
3023 jjstateSet[jjnewStateCnt++] = 1;
3024 break;
3025 case 1:
3026 if ((0xfffffff7efffffffL & l) != 0L && kind > 22)
3027 kind = 22;
3028 break;
3029 case 2:
3030 if (curChar == 42)
3031 jjstateSet[jjnewStateCnt++] = 0;
3032 break;
3033 case 4:
3034 if ((0x100000200L & l) == 0L)
3035 break;
3036 if (kind > 32)
3037 kind = 32;
3038 jjCheckNAdd(4);
3039 break;
3040 case 5:
3041 if ((0x2400L & l) != 0L && kind > 33)
3042 kind = 33;
3043 break;
3044 case 6:
3045 if (curChar == 10 && kind > 33)
3046 kind = 33;
3047 break;
3048 case 7:
3049 if (curChar == 13)
3050 jjstateSet[jjnewStateCnt++] = 6;
3051 break;
3052 case 8:
3053 case 10:
3054 if (curChar == 34)
3055 jjCheckNAddStates(59, 62);
3056 break;
3057 case 9:
3058 if ((0xfffffffbefffffffL & l) != 0L)
3059 jjCheckNAddStates(59, 62);
3060 break;
3061 case 11:
3062 if (curChar == 34)
3063 jjstateSet[jjnewStateCnt++] = 10;
3064 break;
3065 case 12:
3066 if (curChar == 34 && kind > 35)
3067 kind = 35;
3068 break;
3069 case 15:
3070 if ((0xff000000000000L & l) != 0L)
3071 jjCheckNAddStates(63, 67);
3072 break;
3073 case 16:
3074 if ((0xff000000000000L & l) != 0L)
3075 jjCheckNAddStates(59, 62);
3076 break;
3077 case 17:
3078 if ((0xf000000000000L & l) != 0L)
3079 jjstateSet[jjnewStateCnt++] = 18;
3080 break;
3081 case 18:
3082 if ((0xff000000000000L & l) != 0L)
3083 jjCheckNAdd(16);
3084 break;
3085 case 20:
3086 if ((0x3ff000000000000L & l) != 0L)
3087 jjstateSet[jjnewStateCnt++] = 21;
3088 break;
3089 case 21:
3090 if ((0x3ff000000000000L & l) != 0L)
3091 jjstateSet[jjnewStateCnt++] = 22;
3092 break;
3093 case 22:
3094 if ((0x3ff000000000000L & l) != 0L)
3095 jjstateSet[jjnewStateCnt++] = 23;
3096 break;
3097 case 23:
3098 if ((0x3ff000000000000L & l) != 0L)
3099 jjCheckNAddStates(59, 62);
3100 break;
3101 case 24:
3102 if (curChar == 32)
3103 jjAddStates(68, 69);
3104 break;
3105 case 25:
3106 if (curChar == 10)
3107 jjCheckNAddStates(59, 62);
3108 break;
3109 case 26:
3110 case 28:
3111 if (curChar == 39)
3112 jjCheckNAddStates(55, 58);
3113 break;
3114 case 27:
3115 if ((0xffffff7fefffffffL & l) != 0L)
3116 jjCheckNAddStates(55, 58);
3117 break;
3118 case 29:
3119 if (curChar == 39)
3120 jjstateSet[jjnewStateCnt++] = 28;
3121 break;
3122 case 31:
3123 if (curChar == 32)
3124 jjAddStates(70, 71);
3125 break;
3126 case 32:
3127 if (curChar == 10)
3128 jjCheckNAddStates(55, 58);
3129 break;
3130 case 33:
3131 if (curChar == 39 && kind > 35)
3132 kind = 35;
3133 break;
3134 case 34:
3135 if (curChar == 38 && kind > 43)
3136 kind = 43;
3137 break;
3138 case 35:
3139 if (curChar == 38)
3140 jjstateSet[jjnewStateCnt++] = 34;
3141 break;
3142 case 43:
3143 if (curChar == 60 && kind > 45)
3144 kind = 45;
3145 break;
3146 case 44:
3147 if (curChar == 61 && kind > 46)
3148 kind = 46;
3149 break;
3150 case 45:
3151 if (curChar == 60)
3152 jjstateSet[jjnewStateCnt++] = 44;
3153 break;
3154 case 46:
3155 if (curChar == 62 && kind > 47)
3156 kind = 47;
3157 break;
3158 case 47:
3159 if (curChar == 61 && kind > 48)
3160 kind = 48;
3161 break;
3162 case 48:
3163 if (curChar == 62)
3164 jjstateSet[jjnewStateCnt++] = 47;
3165 break;
3166 case 49:
3167 if (curChar == 61 && kind > 49)
3168 kind = 49;
3169 break;
3170 case 50:
3171 if (curChar == 61)
3172 jjstateSet[jjnewStateCnt++] = 49;
3173 break;
3174 case 53:
3175 if (curChar == 61 && kind > 50)
3176 kind = 50;
3177 break;
3178 case 54:
3179 if (curChar == 33)
3180 jjstateSet[jjnewStateCnt++] = 53;
3181 break;
3182 case 55:
3183 if (curChar == 33 && kind > 51)
3184 kind = 51;
3185 break;
3186 case 56:
3187 if (curChar == 46)
3188 jjCheckNAdd(57);
3189 break;
3190 case 57:
3191 if ((0x3ff000000000000L & l) == 0L)
3192 break;
3193 if (kind > 59)
3194 kind = 59;
3195 jjCheckNAddTwoStates(57, 58);
3196 break;
3197 case 59:
3198 if ((0x280000000000L & l) != 0L)
3199 jjCheckNAdd(60);
3200 break;
3201 case 60:
3202 if ((0x3ff000000000000L & l) == 0L)
3203 break;
3204 if (kind > 59)
3205 kind = 59;
3206 jjCheckNAdd(60);
3207 break;
3208 case 62:
3209 if ((0x3ff000000000000L & l) == 0L)
3210 break;
3211 if (kind > 63)
3212 kind = 63;
3213 jjstateSet[jjnewStateCnt++] = 62;
3214 break;
3215 case 65:
3216 if ((0x3ff000000000000L & l) != 0L)
3217 jjAddStates(127, 128);
3218 break;
3219 case 69:
3220 if (curChar == 36 && kind > 19)
3221 kind = 19;
3222 break;
3223 case 71:
3224 if (curChar == 36)
3225 jjCheckNAddTwoStates(72, 73);
3226 break;
3227 case 73:
3228 if (curChar == 33 && kind > 20)
3229 kind = 20;
3230 break;
3231 case 74:
3232 if (curChar != 36)
3233 break;
3234 if (kind > 19)
3235 kind = 19;
3236 jjCheckNAddTwoStates(72, 73);
3237 break;
3238 case 85:
3239 if (curChar == 45)
3240 jjCheckNAddStates(123, 126);
3241 break;
3242 case 86:
3243 if ((0x3ff000000000000L & l) == 0L)
3244 break;
3245 if (kind > 58)
3246 kind = 58;
3247 jjCheckNAddTwoStates(86, 88);
3248 break;
3249 case 87:
3250 if (curChar == 46 && kind > 58)
3251 kind = 58;
3252 break;
3253 case 88:
3254 if (curChar == 46)
3255 jjstateSet[jjnewStateCnt++] = 87;
3256 break;
3257 case 89:
3258 if ((0x3ff000000000000L & l) != 0L)
3259 jjCheckNAddTwoStates(89, 90);
3260 break;
3261 case 90:
3262 if (curChar != 46)
3263 break;
3264 if (kind > 59)
3265 kind = 59;
3266 jjCheckNAddTwoStates(91, 92);
3267 break;
3268 case 91:
3269 if ((0x3ff000000000000L & l) == 0L)
3270 break;
3271 if (kind > 59)
3272 kind = 59;
3273 jjCheckNAddTwoStates(91, 92);
3274 break;
3275 case 93:
3276 if ((0x280000000000L & l) != 0L)
3277 jjCheckNAdd(94);
3278 break;
3279 case 94:
3280 if ((0x3ff000000000000L & l) == 0L)
3281 break;
3282 if (kind > 59)
3283 kind = 59;
3284 jjCheckNAdd(94);
3285 break;
3286 case 95:
3287 if ((0x3ff000000000000L & l) != 0L)
3288 jjCheckNAddTwoStates(95, 96);
3289 break;
3290 case 97:
3291 if ((0x280000000000L & l) != 0L)
3292 jjCheckNAdd(98);
3293 break;
3294 case 98:
3295 if ((0x3ff000000000000L & l) == 0L)
3296 break;
3297 if (kind > 59)
3298 kind = 59;
3299 jjCheckNAdd(98);
3300 break;
3301 case 99:
3302 if ((0x3ff000000000000L & l) == 0L)
3303 break;
3304 if (kind > 58)
3305 kind = 58;
3306 jjCheckNAddStates(117, 122);
3307 break;
3308 default : break;
3309 }
3310 } while(i != startsAt);
3311 }
3312 else if (curChar < 128)
3313 {
3314 long l = 1L << (curChar & 077);
3315 do
3316 {
3317 switch(jjstateSet[--i])
3318 {
3319 case 3:
3320 if ((0x7fffffe87ffffffL & l) != 0L)
3321 {
3322 if (kind > 63)
3323 kind = 63;
3324 jjCheckNAdd(62);
3325 }
3326 else if (curChar == 92)
3327 jjCheckNAddStates(129, 132);
3328 else if (curChar == 123)
3329 jjstateSet[jjnewStateCnt++] = 64;
3330 else if (curChar == 124)
3331 jjstateSet[jjnewStateCnt++] = 39;
3332 if (curChar == 110)
3333 jjAddStates(133, 134);
3334 else if (curChar == 103)
3335 jjAddStates(135, 136);
3336 else if (curChar == 108)
3337 jjAddStates(137, 138);
3338 else if (curChar == 101)
3339 jjstateSet[jjnewStateCnt++] = 51;
3340 else if (curChar == 111)
3341 jjstateSet[jjnewStateCnt++] = 41;
3342 else if (curChar == 97)
3343 jjstateSet[jjnewStateCnt++] = 37;
3344 break;
3345 case 1:
3346 if (kind > 22)
3347 kind = 22;
3348 break;
3349 case 9:
3350 jjCheckNAddStates(59, 62);
3351 break;
3352 case 13:
3353 if (curChar == 92)
3354 jjAddStates(82, 87);
3355 break;
3356 case 14:
3357 if ((0x14404400000000L & l) != 0L)
3358 jjCheckNAddStates(59, 62);
3359 break;
3360 case 19:
3361 if (curChar == 117)
3362 jjstateSet[jjnewStateCnt++] = 20;
3363 break;
3364 case 20:
3365 if ((0x7e0000007eL & l) != 0L)
3366 jjstateSet[jjnewStateCnt++] = 21;
3367 break;
3368 case 21:
3369 if ((0x7e0000007eL & l) != 0L)
3370 jjstateSet[jjnewStateCnt++] = 22;
3371 break;
3372 case 22:
3373 if ((0x7e0000007eL & l) != 0L)
3374 jjstateSet[jjnewStateCnt++] = 23;
3375 break;
3376 case 23:
3377 if ((0x7e0000007eL & l) != 0L)
3378 jjCheckNAddStates(59, 62);
3379 break;
3380 case 27:
3381 jjAddStates(55, 58);
3382 break;
3383 case 30:
3384 if (curChar == 92)
3385 jjAddStates(70, 71);
3386 break;
3387 case 36:
3388 if (curChar == 100 && kind > 43)
3389 kind = 43;
3390 break;
3391 case 37:
3392 if (curChar == 110)
3393 jjstateSet[jjnewStateCnt++] = 36;
3394 break;
3395 case 38:
3396 if (curChar == 97)
3397 jjstateSet[jjnewStateCnt++] = 37;
3398 break;
3399 case 39:
3400 if (curChar == 124 && kind > 44)
3401 kind = 44;
3402 break;
3403 case 40:
3404 if (curChar == 124)
3405 jjstateSet[jjnewStateCnt++] = 39;
3406 break;
3407 case 41:
3408 if (curChar == 114 && kind > 44)
3409 kind = 44;
3410 break;
3411 case 42:
3412 if (curChar == 111)
3413 jjstateSet[jjnewStateCnt++] = 41;
3414 break;
3415 case 51:
3416 if (curChar == 113 && kind > 49)
3417 kind = 49;
3418 break;
3419 case 52:
3420 if (curChar == 101)
3421 jjstateSet[jjnewStateCnt++] = 51;
3422 break;
3423 case 58:
3424 if ((0x2000000020L & l) != 0L)
3425 jjAddStates(88, 89);
3426 break;
3427 case 61:
3428 if ((0x7fffffe87ffffffL & l) == 0L)
3429 break;
3430 if (kind > 63)
3431 kind = 63;
3432 jjCheckNAdd(62);
3433 break;
3434 case 62:
3435 if ((0x7fffffe87fffffeL & l) == 0L)
3436 break;
3437 if (kind > 63)
3438 kind = 63;
3439 jjCheckNAdd(62);
3440 break;
3441 case 63:
3442 if (curChar == 123)
3443 jjstateSet[jjnewStateCnt++] = 64;
3444 break;
3445 case 64:
3446 if ((0x7fffffe87ffffffL & l) != 0L)
3447 jjCheckNAddTwoStates(65, 66);
3448 break;
3449 case 65:
3450 if ((0x7fffffe87fffffeL & l) != 0L)
3451 jjCheckNAddTwoStates(65, 66);
3452 break;
3453 case 66:
3454 if (curChar == 125 && kind > 64)
3455 kind = 64;
3456 break;
3457 case 67:
3458 if (curChar == 92)
3459 jjCheckNAddStates(129, 132);
3460 break;
3461 case 68:
3462 if (curChar == 92)
3463 jjCheckNAddTwoStates(68, 69);
3464 break;
3465 case 70:
3466 if (curChar == 92)
3467 jjCheckNAddTwoStates(70, 71);
3468 break;
3469 case 72:
3470 if (curChar == 92)
3471 jjAddStates(43, 44);
3472 break;
3473 case 75:
3474 if (curChar == 108)
3475 jjAddStates(137, 138);
3476 break;
3477 case 76:
3478 if (curChar == 116 && kind > 45)
3479 kind = 45;
3480 break;
3481 case 77:
3482 if (curChar == 101 && kind > 46)
3483 kind = 46;
3484 break;
3485 case 78:
3486 if (curChar == 103)
3487 jjAddStates(135, 136);
3488 break;
3489 case 79:
3490 if (curChar == 116 && kind > 47)
3491 kind = 47;
3492 break;
3493 case 80:
3494 if (curChar == 101 && kind > 48)
3495 kind = 48;
3496 break;
3497 case 81:
3498 if (curChar == 110)
3499 jjAddStates(133, 134);
3500 break;
3501 case 82:
3502 if (curChar == 101 && kind > 50)
3503 kind = 50;
3504 break;
3505 case 83:
3506 if (curChar == 116 && kind > 51)
3507 kind = 51;
3508 break;
3509 case 84:
3510 if (curChar == 111)
3511 jjstateSet[jjnewStateCnt++] = 83;
3512 break;
3513 case 92:
3514 if ((0x2000000020L & l) != 0L)
3515 jjAddStates(139, 140);
3516 break;
3517 case 96:
3518 if ((0x2000000020L & l) != 0L)
3519 jjAddStates(141, 142);
3520 break;
3521 default : break;
3522 }
3523 } while(i != startsAt);
3524 }
3525 else
3526 {
3527 int hiByte = (int)(curChar >> 8);
3528 int i1 = hiByte >> 6;
3529 long l1 = 1L << (hiByte & 077);
3530 int i2 = (curChar & 0xff) >> 6;
3531 long l2 = 1L << (curChar & 077);
3532 do
3533 {
3534 switch(jjstateSet[--i])
3535 {
3536 case 1:
3537 if (jjCanMove_0(hiByte, i1, i2, l1, l2) && kind > 22)
3538 kind = 22;
3539 break;
3540 case 9:
3541 if (jjCanMove_0(hiByte, i1, i2, l1, l2))
3542 jjAddStates(59, 62);
3543 break;
3544 case 27:
3545 if (jjCanMove_0(hiByte, i1, i2, l1, l2))
3546 jjAddStates(55, 58);
3547 break;
3548 default : break;
3549 }
3550 } while(i != startsAt);
3551 }
3552 if (kind != 0x7fffffff)
3553 {
3554 jjmatchedKind = kind;
3555 jjmatchedPos = curPos;
3556 kind = 0x7fffffff;
3557 }
3558 ++curPos;
3559 if ((i = jjnewStateCnt) == (startsAt = 100 - (jjnewStateCnt = startsAt)))
3560 return curPos;
3561 try { curChar = input_stream.readChar(); }
3562 catch(java.io.IOException e) { return curPos; }
3563 }
3564 }
jjStopStringLiteralDfa_17(int pos, long active0)3565 private final int jjStopStringLiteralDfa_17(int pos, long active0)
3566 {
3567 switch (pos)
3568 {
3569 case 0:
3570 if ((active0 & 0x1a00000L) != 0L)
3571 return 2;
3572 return -1;
3573 case 1:
3574 if ((active0 & 0x800000L) != 0L)
3575 return 0;
3576 return -1;
3577 default :
3578 return -1;
3579 }
3580 }
jjStartNfa_17(int pos, long active0)3581 private final int jjStartNfa_17(int pos, long active0)
3582 {
3583 return jjMoveNfa_17(jjStopStringLiteralDfa_17(pos, active0), pos + 1);
3584 }
jjMoveStringLiteralDfa0_17()3585 private int jjMoveStringLiteralDfa0_17()
3586 {
3587 switch(curChar)
3588 {
3589 case 35:
3590 jjmatchedKind = 24;
3591 return jjMoveStringLiteralDfa1_17(0xa00000L);
3592 case 42:
3593 return jjMoveStringLiteralDfa1_17(0x10000000L);
3594 default :
3595 return jjMoveNfa_17(3, 0);
3596 }
3597 }
jjMoveStringLiteralDfa1_17(long active0)3598 private int jjMoveStringLiteralDfa1_17(long active0)
3599 {
3600 try { curChar = input_stream.readChar(); }
3601 catch(java.io.IOException e) {
3602 jjStopStringLiteralDfa_17(0, active0);
3603 return 1;
3604 }
3605 switch(curChar)
3606 {
3607 case 35:
3608 if ((active0 & 0x10000000L) != 0L)
3609 return jjStopAtPos(1, 28);
3610 break;
3611 case 42:
3612 if ((active0 & 0x800000L) != 0L)
3613 return jjStartNfaWithStates_17(1, 23, 0);
3614 break;
3615 case 91:
3616 return jjMoveStringLiteralDfa2_17(active0, 0x200000L);
3617 default :
3618 break;
3619 }
3620 return jjStartNfa_17(0, active0);
3621 }
jjMoveStringLiteralDfa2_17(long old0, long active0)3622 private int jjMoveStringLiteralDfa2_17(long old0, long active0)
3623 {
3624 if (((active0 &= old0)) == 0L)
3625 return jjStartNfa_17(0, old0);
3626 try { curChar = input_stream.readChar(); }
3627 catch(java.io.IOException e) {
3628 jjStopStringLiteralDfa_17(1, active0);
3629 return 2;
3630 }
3631 switch(curChar)
3632 {
3633 case 91:
3634 if ((active0 & 0x200000L) != 0L)
3635 return jjStopAtPos(2, 21);
3636 break;
3637 default :
3638 break;
3639 }
3640 return jjStartNfa_17(1, active0);
3641 }
jjStartNfaWithStates_17(int pos, int kind, int state)3642 private int jjStartNfaWithStates_17(int pos, int kind, int state)
3643 {
3644 jjmatchedKind = kind;
3645 jjmatchedPos = pos;
3646 try { curChar = input_stream.readChar(); }
3647 catch(java.io.IOException e) { return pos + 1; }
3648 return jjMoveNfa_17(state, pos + 1);
3649 }
jjMoveNfa_17(int startState, int curPos)3650 private int jjMoveNfa_17(int startState, int curPos)
3651 {
3652 int startsAt = 0;
3653 jjnewStateCnt = 12;
3654 int i = 1;
3655 jjstateSet[0] = startState;
3656 int kind = 0x7fffffff;
3657 for (;;)
3658 {
3659 if (++jjround == 0x7fffffff)
3660 ReInitRounds();
3661 if (curChar < 64)
3662 {
3663 long l = 1L << curChar;
3664 do
3665 {
3666 switch(jjstateSet[--i])
3667 {
3668 case 3:
3669 if (curChar == 36)
3670 {
3671 if (kind > 19)
3672 kind = 19;
3673 jjCheckNAddTwoStates(9, 10);
3674 }
3675 else if (curChar == 35)
3676 jjstateSet[jjnewStateCnt++] = 2;
3677 break;
3678 case 0:
3679 if (curChar == 42)
3680 jjstateSet[jjnewStateCnt++] = 1;
3681 break;
3682 case 1:
3683 if ((0xfffffff7efffffffL & l) != 0L && kind > 22)
3684 kind = 22;
3685 break;
3686 case 2:
3687 if (curChar == 42)
3688 jjstateSet[jjnewStateCnt++] = 0;
3689 break;
3690 case 6:
3691 if (curChar == 36 && kind > 19)
3692 kind = 19;
3693 break;
3694 case 8:
3695 if (curChar == 36)
3696 jjCheckNAddTwoStates(9, 10);
3697 break;
3698 case 10:
3699 if (curChar == 33 && kind > 20)
3700 kind = 20;
3701 break;
3702 case 11:
3703 if (curChar != 36)
3704 break;
3705 if (kind > 19)
3706 kind = 19;
3707 jjCheckNAddTwoStates(9, 10);
3708 break;
3709 default : break;
3710 }
3711 } while(i != startsAt);
3712 }
3713 else if (curChar < 128)
3714 {
3715 long l = 1L << (curChar & 077);
3716 do
3717 {
3718 switch(jjstateSet[--i])
3719 {
3720 case 3:
3721 if (curChar == 92)
3722 jjCheckNAddStates(111, 114);
3723 break;
3724 case 1:
3725 if (kind > 22)
3726 kind = 22;
3727 break;
3728 case 5:
3729 if (curChar == 92)
3730 jjCheckNAddTwoStates(5, 6);
3731 break;
3732 case 7:
3733 if (curChar == 92)
3734 jjCheckNAddTwoStates(7, 8);
3735 break;
3736 case 9:
3737 if (curChar == 92)
3738 jjAddStates(115, 116);
3739 break;
3740 default : break;
3741 }
3742 } while(i != startsAt);
3743 }
3744 else
3745 {
3746 int hiByte = (int)(curChar >> 8);
3747 int i1 = hiByte >> 6;
3748 long l1 = 1L << (hiByte & 077);
3749 int i2 = (curChar & 0xff) >> 6;
3750 long l2 = 1L << (curChar & 077);
3751 do
3752 {
3753 switch(jjstateSet[--i])
3754 {
3755 case 1:
3756 if (jjCanMove_0(hiByte, i1, i2, l1, l2) && kind > 22)
3757 kind = 22;
3758 break;
3759 default : break;
3760 }
3761 } while(i != startsAt);
3762 }
3763 if (kind != 0x7fffffff)
3764 {
3765 jjmatchedKind = kind;
3766 jjmatchedPos = curPos;
3767 kind = 0x7fffffff;
3768 }
3769 ++curPos;
3770 if ((i = jjnewStateCnt) == (startsAt = 12 - (jjnewStateCnt = startsAt)))
3771 return curPos;
3772 try { curChar = input_stream.readChar(); }
3773 catch(java.io.IOException e) { return curPos; }
3774 }
3775 }
jjStopStringLiteralDfa_7(int pos, long active0)3776 private final int jjStopStringLiteralDfa_7(int pos, long active0)
3777 {
3778 switch (pos)
3779 {
3780 case 0:
3781 if ((active0 & 0x4000000000L) != 0L)
3782 return 94;
3783 if ((active0 & 0x1a00000L) != 0L)
3784 return 2;
3785 if ((active0 & 0x10000000000000L) != 0L)
3786 return 49;
3787 return -1;
3788 case 1:
3789 if ((active0 & 0x800000L) != 0L)
3790 return 0;
3791 return -1;
3792 default :
3793 return -1;
3794 }
3795 }
jjStartNfa_7(int pos, long active0)3796 private final int jjStartNfa_7(int pos, long active0)
3797 {
3798 return jjMoveNfa_7(jjStopStringLiteralDfa_7(pos, active0), pos + 1);
3799 }
jjMoveStringLiteralDfa0_7()3800 private int jjMoveStringLiteralDfa0_7()
3801 {
3802 switch(curChar)
3803 {
3804 case 28:
3805 return jjStopAtPos(0, 2);
3806 case 35:
3807 jjmatchedKind = 24;
3808 return jjMoveStringLiteralDfa1_7(0xa00000L);
3809 case 37:
3810 return jjStopAtPos(0, 42);
3811 case 42:
3812 return jjStopAtPos(0, 40);
3813 case 43:
3814 return jjStopAtPos(0, 39);
3815 case 45:
3816 return jjStartNfaWithStates_7(0, 38, 94);
3817 case 47:
3818 return jjStopAtPos(0, 41);
3819 case 61:
3820 return jjStartNfaWithStates_7(0, 52, 49);
3821 case 93:
3822 return jjStopAtPos(0, 6);
3823 case 102:
3824 return jjMoveStringLiteralDfa1_7(0x2000000000L);
3825 case 116:
3826 return jjMoveStringLiteralDfa1_7(0x1000000000L);
3827 default :
3828 return jjMoveNfa_7(3, 0);
3829 }
3830 }
jjMoveStringLiteralDfa1_7(long active0)3831 private int jjMoveStringLiteralDfa1_7(long active0)
3832 {
3833 try { curChar = input_stream.readChar(); }
3834 catch(java.io.IOException e) {
3835 jjStopStringLiteralDfa_7(0, active0);
3836 return 1;
3837 }
3838 switch(curChar)
3839 {
3840 case 42:
3841 if ((active0 & 0x800000L) != 0L)
3842 return jjStartNfaWithStates_7(1, 23, 0);
3843 break;
3844 case 91:
3845 return jjMoveStringLiteralDfa2_7(active0, 0x200000L);
3846 case 97:
3847 return jjMoveStringLiteralDfa2_7(active0, 0x2000000000L);
3848 case 114:
3849 return jjMoveStringLiteralDfa2_7(active0, 0x1000000000L);
3850 default :
3851 break;
3852 }
3853 return jjStartNfa_7(0, active0);
3854 }
jjMoveStringLiteralDfa2_7(long old0, long active0)3855 private int jjMoveStringLiteralDfa2_7(long old0, long active0)
3856 {
3857 if (((active0 &= old0)) == 0L)
3858 return jjStartNfa_7(0, old0);
3859 try { curChar = input_stream.readChar(); }
3860 catch(java.io.IOException e) {
3861 jjStopStringLiteralDfa_7(1, active0);
3862 return 2;
3863 }
3864 switch(curChar)
3865 {
3866 case 91:
3867 if ((active0 & 0x200000L) != 0L)
3868 return jjStopAtPos(2, 21);
3869 break;
3870 case 108:
3871 return jjMoveStringLiteralDfa3_7(active0, 0x2000000000L);
3872 case 117:
3873 return jjMoveStringLiteralDfa3_7(active0, 0x1000000000L);
3874 default :
3875 break;
3876 }
3877 return jjStartNfa_7(1, active0);
3878 }
jjMoveStringLiteralDfa3_7(long old0, long active0)3879 private int jjMoveStringLiteralDfa3_7(long old0, long active0)
3880 {
3881 if (((active0 &= old0)) == 0L)
3882 return jjStartNfa_7(1, old0);
3883 try { curChar = input_stream.readChar(); }
3884 catch(java.io.IOException e) {
3885 jjStopStringLiteralDfa_7(2, active0);
3886 return 3;
3887 }
3888 switch(curChar)
3889 {
3890 case 101:
3891 if ((active0 & 0x1000000000L) != 0L)
3892 return jjStopAtPos(3, 36);
3893 break;
3894 case 115:
3895 return jjMoveStringLiteralDfa4_7(active0, 0x2000000000L);
3896 default :
3897 break;
3898 }
3899 return jjStartNfa_7(2, active0);
3900 }
jjMoveStringLiteralDfa4_7(long old0, long active0)3901 private int jjMoveStringLiteralDfa4_7(long old0, long active0)
3902 {
3903 if (((active0 &= old0)) == 0L)
3904 return jjStartNfa_7(2, old0);
3905 try { curChar = input_stream.readChar(); }
3906 catch(java.io.IOException e) {
3907 jjStopStringLiteralDfa_7(3, active0);
3908 return 4;
3909 }
3910 switch(curChar)
3911 {
3912 case 101:
3913 if ((active0 & 0x2000000000L) != 0L)
3914 return jjStopAtPos(4, 37);
3915 break;
3916 default :
3917 break;
3918 }
3919 return jjStartNfa_7(3, active0);
3920 }
jjStartNfaWithStates_7(int pos, int kind, int state)3921 private int jjStartNfaWithStates_7(int pos, int kind, int state)
3922 {
3923 jjmatchedKind = kind;
3924 jjmatchedPos = pos;
3925 try { curChar = input_stream.readChar(); }
3926 catch(java.io.IOException e) { return pos + 1; }
3927 return jjMoveNfa_7(state, pos + 1);
3928 }
jjMoveNfa_7(int startState, int curPos)3929 private int jjMoveNfa_7(int startState, int curPos)
3930 {
3931 int startsAt = 0;
3932 jjnewStateCnt = 94;
3933 int i = 1;
3934 jjstateSet[0] = startState;
3935 int kind = 0x7fffffff;
3936 for (;;)
3937 {
3938 if (++jjround == 0x7fffffff)
3939 ReInitRounds();
3940 if (curChar < 64)
3941 {
3942 long l = 1L << curChar;
3943 do
3944 {
3945 switch(jjstateSet[--i])
3946 {
3947 case 94:
3948 if ((0x3ff000000000000L & l) != 0L)
3949 jjCheckNAddTwoStates(89, 90);
3950 else if (curChar == 46)
3951 jjCheckNAdd(57);
3952 if ((0x3ff000000000000L & l) != 0L)
3953 jjCheckNAddTwoStates(83, 84);
3954 if ((0x3ff000000000000L & l) != 0L)
3955 {
3956 if (kind > 58)
3957 kind = 58;
3958 jjCheckNAddTwoStates(80, 82);
3959 }
3960 break;
3961 case 3:
3962 if ((0x3ff000000000000L & l) != 0L)
3963 {
3964 if (kind > 58)
3965 kind = 58;
3966 jjCheckNAddStates(45, 50);
3967 }
3968 else if ((0x2400L & l) != 0L)
3969 {
3970 if (kind > 33)
3971 kind = 33;
3972 }
3973 else if ((0x100000200L & l) != 0L)
3974 {
3975 if (kind > 32)
3976 kind = 32;
3977 jjCheckNAdd(4);
3978 }
3979 else if (curChar == 45)
3980 jjCheckNAddStates(51, 54);
3981 else if (curChar == 36)
3982 {
3983 if (kind > 19)
3984 kind = 19;
3985 jjCheckNAddTwoStates(66, 67);
3986 }
3987 else if (curChar == 46)
3988 jjCheckNAdd(57);
3989 else if (curChar == 33)
3990 {
3991 if (kind > 51)
3992 kind = 51;
3993 }
3994 else if (curChar == 61)
3995 jjstateSet[jjnewStateCnt++] = 49;
3996 else if (curChar == 62)
3997 jjstateSet[jjnewStateCnt++] = 47;
3998 else if (curChar == 60)
3999 jjstateSet[jjnewStateCnt++] = 44;
4000 else if (curChar == 38)
4001 jjstateSet[jjnewStateCnt++] = 34;
4002 else if (curChar == 39)
4003 jjCheckNAddStates(55, 58);
4004 else if (curChar == 34)
4005 jjCheckNAddStates(59, 62);
4006 else if (curChar == 35)
4007 jjstateSet[jjnewStateCnt++] = 2;
4008 if (curChar == 33)
4009 jjstateSet[jjnewStateCnt++] = 53;
4010 else if (curChar == 62)
4011 {
4012 if (kind > 47)
4013 kind = 47;
4014 }
4015 else if (curChar == 60)
4016 {
4017 if (kind > 45)
4018 kind = 45;
4019 }
4020 else if (curChar == 13)
4021 jjstateSet[jjnewStateCnt++] = 6;
4022 break;
4023 case 0:
4024 if (curChar == 42)
4025 jjstateSet[jjnewStateCnt++] = 1;
4026 break;
4027 case 1:
4028 if ((0xfffffff7efffffffL & l) != 0L && kind > 22)
4029 kind = 22;
4030 break;
4031 case 2:
4032 if (curChar == 42)
4033 jjstateSet[jjnewStateCnt++] = 0;
4034 break;
4035 case 4:
4036 if ((0x100000200L & l) == 0L)
4037 break;
4038 if (kind > 32)
4039 kind = 32;
4040 jjCheckNAdd(4);
4041 break;
4042 case 5:
4043 if ((0x2400L & l) != 0L && kind > 33)
4044 kind = 33;
4045 break;
4046 case 6:
4047 if (curChar == 10 && kind > 33)
4048 kind = 33;
4049 break;
4050 case 7:
4051 if (curChar == 13)
4052 jjstateSet[jjnewStateCnt++] = 6;
4053 break;
4054 case 8:
4055 case 10:
4056 if (curChar == 34)
4057 jjCheckNAddStates(59, 62);
4058 break;
4059 case 9:
4060 if ((0xfffffffbefffffffL & l) != 0L)
4061 jjCheckNAddStates(59, 62);
4062 break;
4063 case 11:
4064 if (curChar == 34)
4065 jjstateSet[jjnewStateCnt++] = 10;
4066 break;
4067 case 12:
4068 if (curChar == 34 && kind > 35)
4069 kind = 35;
4070 break;
4071 case 15:
4072 if ((0xff000000000000L & l) != 0L)
4073 jjCheckNAddStates(63, 67);
4074 break;
4075 case 16:
4076 if ((0xff000000000000L & l) != 0L)
4077 jjCheckNAddStates(59, 62);
4078 break;
4079 case 17:
4080 if ((0xf000000000000L & l) != 0L)
4081 jjstateSet[jjnewStateCnt++] = 18;
4082 break;
4083 case 18:
4084 if ((0xff000000000000L & l) != 0L)
4085 jjCheckNAdd(16);
4086 break;
4087 case 20:
4088 if ((0x3ff000000000000L & l) != 0L)
4089 jjstateSet[jjnewStateCnt++] = 21;
4090 break;
4091 case 21:
4092 if ((0x3ff000000000000L & l) != 0L)
4093 jjstateSet[jjnewStateCnt++] = 22;
4094 break;
4095 case 22:
4096 if ((0x3ff000000000000L & l) != 0L)
4097 jjstateSet[jjnewStateCnt++] = 23;
4098 break;
4099 case 23:
4100 if ((0x3ff000000000000L & l) != 0L)
4101 jjCheckNAddStates(59, 62);
4102 break;
4103 case 24:
4104 if (curChar == 32)
4105 jjAddStates(68, 69);
4106 break;
4107 case 25:
4108 if (curChar == 10)
4109 jjCheckNAddStates(59, 62);
4110 break;
4111 case 26:
4112 case 28:
4113 if (curChar == 39)
4114 jjCheckNAddStates(55, 58);
4115 break;
4116 case 27:
4117 if ((0xffffff7fefffffffL & l) != 0L)
4118 jjCheckNAddStates(55, 58);
4119 break;
4120 case 29:
4121 if (curChar == 39)
4122 jjstateSet[jjnewStateCnt++] = 28;
4123 break;
4124 case 31:
4125 if (curChar == 32)
4126 jjAddStates(70, 71);
4127 break;
4128 case 32:
4129 if (curChar == 10)
4130 jjCheckNAddStates(55, 58);
4131 break;
4132 case 33:
4133 if (curChar == 39 && kind > 35)
4134 kind = 35;
4135 break;
4136 case 34:
4137 if (curChar == 38 && kind > 43)
4138 kind = 43;
4139 break;
4140 case 35:
4141 if (curChar == 38)
4142 jjstateSet[jjnewStateCnt++] = 34;
4143 break;
4144 case 43:
4145 if (curChar == 60 && kind > 45)
4146 kind = 45;
4147 break;
4148 case 44:
4149 if (curChar == 61 && kind > 46)
4150 kind = 46;
4151 break;
4152 case 45:
4153 if (curChar == 60)
4154 jjstateSet[jjnewStateCnt++] = 44;
4155 break;
4156 case 46:
4157 if (curChar == 62 && kind > 47)
4158 kind = 47;
4159 break;
4160 case 47:
4161 if (curChar == 61 && kind > 48)
4162 kind = 48;
4163 break;
4164 case 48:
4165 if (curChar == 62)
4166 jjstateSet[jjnewStateCnt++] = 47;
4167 break;
4168 case 49:
4169 if (curChar == 61 && kind > 49)
4170 kind = 49;
4171 break;
4172 case 50:
4173 if (curChar == 61)
4174 jjstateSet[jjnewStateCnt++] = 49;
4175 break;
4176 case 53:
4177 if (curChar == 61 && kind > 50)
4178 kind = 50;
4179 break;
4180 case 54:
4181 if (curChar == 33)
4182 jjstateSet[jjnewStateCnt++] = 53;
4183 break;
4184 case 55:
4185 if (curChar == 33 && kind > 51)
4186 kind = 51;
4187 break;
4188 case 56:
4189 if (curChar == 46)
4190 jjCheckNAdd(57);
4191 break;
4192 case 57:
4193 if ((0x3ff000000000000L & l) == 0L)
4194 break;
4195 if (kind > 59)
4196 kind = 59;
4197 jjCheckNAddTwoStates(57, 58);
4198 break;
4199 case 59:
4200 if ((0x280000000000L & l) != 0L)
4201 jjCheckNAdd(60);
4202 break;
4203 case 60:
4204 if ((0x3ff000000000000L & l) == 0L)
4205 break;
4206 if (kind > 59)
4207 kind = 59;
4208 jjCheckNAdd(60);
4209 break;
4210 case 63:
4211 if (curChar == 36 && kind > 19)
4212 kind = 19;
4213 break;
4214 case 65:
4215 if (curChar == 36)
4216 jjCheckNAddTwoStates(66, 67);
4217 break;
4218 case 67:
4219 if (curChar == 33 && kind > 20)
4220 kind = 20;
4221 break;
4222 case 68:
4223 if (curChar != 36)
4224 break;
4225 if (kind > 19)
4226 kind = 19;
4227 jjCheckNAddTwoStates(66, 67);
4228 break;
4229 case 79:
4230 if (curChar == 45)
4231 jjCheckNAddStates(51, 54);
4232 break;
4233 case 80:
4234 if ((0x3ff000000000000L & l) == 0L)
4235 break;
4236 if (kind > 58)
4237 kind = 58;
4238 jjCheckNAddTwoStates(80, 82);
4239 break;
4240 case 81:
4241 if (curChar == 46 && kind > 58)
4242 kind = 58;
4243 break;
4244 case 82:
4245 if (curChar == 46)
4246 jjstateSet[jjnewStateCnt++] = 81;
4247 break;
4248 case 83:
4249 if ((0x3ff000000000000L & l) != 0L)
4250 jjCheckNAddTwoStates(83, 84);
4251 break;
4252 case 84:
4253 if (curChar != 46)
4254 break;
4255 if (kind > 59)
4256 kind = 59;
4257 jjCheckNAddTwoStates(85, 86);
4258 break;
4259 case 85:
4260 if ((0x3ff000000000000L & l) == 0L)
4261 break;
4262 if (kind > 59)
4263 kind = 59;
4264 jjCheckNAddTwoStates(85, 86);
4265 break;
4266 case 87:
4267 if ((0x280000000000L & l) != 0L)
4268 jjCheckNAdd(88);
4269 break;
4270 case 88:
4271 if ((0x3ff000000000000L & l) == 0L)
4272 break;
4273 if (kind > 59)
4274 kind = 59;
4275 jjCheckNAdd(88);
4276 break;
4277 case 89:
4278 if ((0x3ff000000000000L & l) != 0L)
4279 jjCheckNAddTwoStates(89, 90);
4280 break;
4281 case 91:
4282 if ((0x280000000000L & l) != 0L)
4283 jjCheckNAdd(92);
4284 break;
4285 case 92:
4286 if ((0x3ff000000000000L & l) == 0L)
4287 break;
4288 if (kind > 59)
4289 kind = 59;
4290 jjCheckNAdd(92);
4291 break;
4292 case 93:
4293 if ((0x3ff000000000000L & l) == 0L)
4294 break;
4295 if (kind > 58)
4296 kind = 58;
4297 jjCheckNAddStates(45, 50);
4298 break;
4299 default : break;
4300 }
4301 } while(i != startsAt);
4302 }
4303 else if (curChar < 128)
4304 {
4305 long l = 1L << (curChar & 077);
4306 do
4307 {
4308 switch(jjstateSet[--i])
4309 {
4310 case 3:
4311 if (curChar == 110)
4312 jjAddStates(72, 73);
4313 else if (curChar == 103)
4314 jjAddStates(74, 75);
4315 else if (curChar == 108)
4316 jjAddStates(76, 77);
4317 else if (curChar == 92)
4318 jjCheckNAddStates(78, 81);
4319 else if (curChar == 101)
4320 jjstateSet[jjnewStateCnt++] = 51;
4321 else if (curChar == 111)
4322 jjstateSet[jjnewStateCnt++] = 41;
4323 else if (curChar == 124)
4324 jjstateSet[jjnewStateCnt++] = 39;
4325 else if (curChar == 97)
4326 jjstateSet[jjnewStateCnt++] = 37;
4327 break;
4328 case 1:
4329 if (kind > 22)
4330 kind = 22;
4331 break;
4332 case 9:
4333 jjCheckNAddStates(59, 62);
4334 break;
4335 case 13:
4336 if (curChar == 92)
4337 jjAddStates(82, 87);
4338 break;
4339 case 14:
4340 if ((0x14404400000000L & l) != 0L)
4341 jjCheckNAddStates(59, 62);
4342 break;
4343 case 19:
4344 if (curChar == 117)
4345 jjstateSet[jjnewStateCnt++] = 20;
4346 break;
4347 case 20:
4348 if ((0x7e0000007eL & l) != 0L)
4349 jjstateSet[jjnewStateCnt++] = 21;
4350 break;
4351 case 21:
4352 if ((0x7e0000007eL & l) != 0L)
4353 jjstateSet[jjnewStateCnt++] = 22;
4354 break;
4355 case 22:
4356 if ((0x7e0000007eL & l) != 0L)
4357 jjstateSet[jjnewStateCnt++] = 23;
4358 break;
4359 case 23:
4360 if ((0x7e0000007eL & l) != 0L)
4361 jjCheckNAddStates(59, 62);
4362 break;
4363 case 27:
4364 jjAddStates(55, 58);
4365 break;
4366 case 30:
4367 if (curChar == 92)
4368 jjAddStates(70, 71);
4369 break;
4370 case 36:
4371 if (curChar == 100 && kind > 43)
4372 kind = 43;
4373 break;
4374 case 37:
4375 if (curChar == 110)
4376 jjstateSet[jjnewStateCnt++] = 36;
4377 break;
4378 case 38:
4379 if (curChar == 97)
4380 jjstateSet[jjnewStateCnt++] = 37;
4381 break;
4382 case 39:
4383 if (curChar == 124 && kind > 44)
4384 kind = 44;
4385 break;
4386 case 40:
4387 if (curChar == 124)
4388 jjstateSet[jjnewStateCnt++] = 39;
4389 break;
4390 case 41:
4391 if (curChar == 114 && kind > 44)
4392 kind = 44;
4393 break;
4394 case 42:
4395 if (curChar == 111)
4396 jjstateSet[jjnewStateCnt++] = 41;
4397 break;
4398 case 51:
4399 if (curChar == 113 && kind > 49)
4400 kind = 49;
4401 break;
4402 case 52:
4403 if (curChar == 101)
4404 jjstateSet[jjnewStateCnt++] = 51;
4405 break;
4406 case 58:
4407 if ((0x2000000020L & l) != 0L)
4408 jjAddStates(88, 89);
4409 break;
4410 case 61:
4411 if (curChar == 92)
4412 jjCheckNAddStates(78, 81);
4413 break;
4414 case 62:
4415 if (curChar == 92)
4416 jjCheckNAddTwoStates(62, 63);
4417 break;
4418 case 64:
4419 if (curChar == 92)
4420 jjCheckNAddTwoStates(64, 65);
4421 break;
4422 case 66:
4423 if (curChar == 92)
4424 jjAddStates(90, 91);
4425 break;
4426 case 69:
4427 if (curChar == 108)
4428 jjAddStates(76, 77);
4429 break;
4430 case 70:
4431 if (curChar == 116 && kind > 45)
4432 kind = 45;
4433 break;
4434 case 71:
4435 if (curChar == 101 && kind > 46)
4436 kind = 46;
4437 break;
4438 case 72:
4439 if (curChar == 103)
4440 jjAddStates(74, 75);
4441 break;
4442 case 73:
4443 if (curChar == 116 && kind > 47)
4444 kind = 47;
4445 break;
4446 case 74:
4447 if (curChar == 101 && kind > 48)
4448 kind = 48;
4449 break;
4450 case 75:
4451 if (curChar == 110)
4452 jjAddStates(72, 73);
4453 break;
4454 case 76:
4455 if (curChar == 101 && kind > 50)
4456 kind = 50;
4457 break;
4458 case 77:
4459 if (curChar == 116 && kind > 51)
4460 kind = 51;
4461 break;
4462 case 78:
4463 if (curChar == 111)
4464 jjstateSet[jjnewStateCnt++] = 77;
4465 break;
4466 case 86:
4467 if ((0x2000000020L & l) != 0L)
4468 jjAddStates(92, 93);
4469 break;
4470 case 90:
4471 if ((0x2000000020L & l) != 0L)
4472 jjAddStates(94, 95);
4473 break;
4474 default : break;
4475 }
4476 } while(i != startsAt);
4477 }
4478 else
4479 {
4480 int hiByte = (int)(curChar >> 8);
4481 int i1 = hiByte >> 6;
4482 long l1 = 1L << (hiByte & 077);
4483 int i2 = (curChar & 0xff) >> 6;
4484 long l2 = 1L << (curChar & 077);
4485 do
4486 {
4487 switch(jjstateSet[--i])
4488 {
4489 case 1:
4490 if (jjCanMove_0(hiByte, i1, i2, l1, l2) && kind > 22)
4491 kind = 22;
4492 break;
4493 case 9:
4494 if (jjCanMove_0(hiByte, i1, i2, l1, l2))
4495 jjAddStates(59, 62);
4496 break;
4497 case 27:
4498 if (jjCanMove_0(hiByte, i1, i2, l1, l2))
4499 jjAddStates(55, 58);
4500 break;
4501 default : break;
4502 }
4503 } while(i != startsAt);
4504 }
4505 if (kind != 0x7fffffff)
4506 {
4507 jjmatchedKind = kind;
4508 jjmatchedPos = curPos;
4509 kind = 0x7fffffff;
4510 }
4511 ++curPos;
4512 if ((i = jjnewStateCnt) == (startsAt = 94 - (jjnewStateCnt = startsAt)))
4513 return curPos;
4514 try { curChar = input_stream.readChar(); }
4515 catch(java.io.IOException e) { return curPos; }
4516 }
4517 }
jjStopStringLiteralDfa_13(int pos, long active0)4518 private final int jjStopStringLiteralDfa_13(int pos, long active0)
4519 {
4520 switch (pos)
4521 {
4522 case 0:
4523 if ((active0 & 0x1a00000L) != 0L)
4524 return 2;
4525 return -1;
4526 case 1:
4527 if ((active0 & 0x800000L) != 0L)
4528 return 0;
4529 return -1;
4530 default :
4531 return -1;
4532 }
4533 }
jjStartNfa_13(int pos, long active0)4534 private final int jjStartNfa_13(int pos, long active0)
4535 {
4536 return jjMoveNfa_13(jjStopStringLiteralDfa_13(pos, active0), pos + 1);
4537 }
jjMoveStringLiteralDfa0_13()4538 private int jjMoveStringLiteralDfa0_13()
4539 {
4540 switch(curChar)
4541 {
4542 case 28:
4543 return jjStopAtPos(0, 2);
4544 case 35:
4545 jjmatchedKind = 24;
4546 return jjMoveStringLiteralDfa1_13(0xa00000L);
4547 default :
4548 return jjMoveNfa_13(3, 0);
4549 }
4550 }
jjMoveStringLiteralDfa1_13(long active0)4551 private int jjMoveStringLiteralDfa1_13(long active0)
4552 {
4553 try { curChar = input_stream.readChar(); }
4554 catch(java.io.IOException e) {
4555 jjStopStringLiteralDfa_13(0, active0);
4556 return 1;
4557 }
4558 switch(curChar)
4559 {
4560 case 42:
4561 if ((active0 & 0x800000L) != 0L)
4562 return jjStartNfaWithStates_13(1, 23, 0);
4563 break;
4564 case 91:
4565 return jjMoveStringLiteralDfa2_13(active0, 0x200000L);
4566 default :
4567 break;
4568 }
4569 return jjStartNfa_13(0, active0);
4570 }
jjMoveStringLiteralDfa2_13(long old0, long active0)4571 private int jjMoveStringLiteralDfa2_13(long old0, long active0)
4572 {
4573 if (((active0 &= old0)) == 0L)
4574 return jjStartNfa_13(0, old0);
4575 try { curChar = input_stream.readChar(); }
4576 catch(java.io.IOException e) {
4577 jjStopStringLiteralDfa_13(1, active0);
4578 return 2;
4579 }
4580 switch(curChar)
4581 {
4582 case 91:
4583 if ((active0 & 0x200000L) != 0L)
4584 return jjStopAtPos(2, 21);
4585 break;
4586 default :
4587 break;
4588 }
4589 return jjStartNfa_13(1, active0);
4590 }
jjStartNfaWithStates_13(int pos, int kind, int state)4591 private int jjStartNfaWithStates_13(int pos, int kind, int state)
4592 {
4593 jjmatchedKind = kind;
4594 jjmatchedPos = pos;
4595 try { curChar = input_stream.readChar(); }
4596 catch(java.io.IOException e) { return pos + 1; }
4597 return jjMoveNfa_13(state, pos + 1);
4598 }
jjMoveNfa_13(int startState, int curPos)4599 private int jjMoveNfa_13(int startState, int curPos)
4600 {
4601 int startsAt = 0;
4602 jjnewStateCnt = 12;
4603 int i = 1;
4604 jjstateSet[0] = startState;
4605 int kind = 0x7fffffff;
4606 for (;;)
4607 {
4608 if (++jjround == 0x7fffffff)
4609 ReInitRounds();
4610 if (curChar < 64)
4611 {
4612 long l = 1L << curChar;
4613 do
4614 {
4615 switch(jjstateSet[--i])
4616 {
4617 case 3:
4618 if (curChar == 36)
4619 {
4620 if (kind > 19)
4621 kind = 19;
4622 jjCheckNAddTwoStates(9, 10);
4623 }
4624 else if (curChar == 35)
4625 jjstateSet[jjnewStateCnt++] = 2;
4626 break;
4627 case 0:
4628 if (curChar == 42)
4629 jjstateSet[jjnewStateCnt++] = 1;
4630 break;
4631 case 1:
4632 if ((0xfffffff7efffffffL & l) != 0L && kind > 22)
4633 kind = 22;
4634 break;
4635 case 2:
4636 if (curChar == 42)
4637 jjstateSet[jjnewStateCnt++] = 0;
4638 break;
4639 case 6:
4640 if (curChar == 36 && kind > 19)
4641 kind = 19;
4642 break;
4643 case 8:
4644 if (curChar == 36)
4645 jjCheckNAddTwoStates(9, 10);
4646 break;
4647 case 10:
4648 if (curChar == 33 && kind > 20)
4649 kind = 20;
4650 break;
4651 case 11:
4652 if (curChar != 36)
4653 break;
4654 if (kind > 19)
4655 kind = 19;
4656 jjCheckNAddTwoStates(9, 10);
4657 break;
4658 default : break;
4659 }
4660 } while(i != startsAt);
4661 }
4662 else if (curChar < 128)
4663 {
4664 long l = 1L << (curChar & 077);
4665 do
4666 {
4667 switch(jjstateSet[--i])
4668 {
4669 case 3:
4670 if (curChar == 92)
4671 jjCheckNAddStates(111, 114);
4672 break;
4673 case 1:
4674 if (kind > 22)
4675 kind = 22;
4676 break;
4677 case 5:
4678 if (curChar == 92)
4679 jjCheckNAddTwoStates(5, 6);
4680 break;
4681 case 7:
4682 if (curChar == 92)
4683 jjCheckNAddTwoStates(7, 8);
4684 break;
4685 case 9:
4686 if (curChar == 92)
4687 jjAddStates(115, 116);
4688 break;
4689 default : break;
4690 }
4691 } while(i != startsAt);
4692 }
4693 else
4694 {
4695 int hiByte = (int)(curChar >> 8);
4696 int i1 = hiByte >> 6;
4697 long l1 = 1L << (hiByte & 077);
4698 int i2 = (curChar & 0xff) >> 6;
4699 long l2 = 1L << (curChar & 077);
4700 do
4701 {
4702 switch(jjstateSet[--i])
4703 {
4704 case 1:
4705 if (jjCanMove_0(hiByte, i1, i2, l1, l2) && kind > 22)
4706 kind = 22;
4707 break;
4708 default : break;
4709 }
4710 } while(i != startsAt);
4711 }
4712 if (kind != 0x7fffffff)
4713 {
4714 jjmatchedKind = kind;
4715 jjmatchedPos = curPos;
4716 kind = 0x7fffffff;
4717 }
4718 ++curPos;
4719 if ((i = jjnewStateCnt) == (startsAt = 12 - (jjnewStateCnt = startsAt)))
4720 return curPos;
4721 try { curChar = input_stream.readChar(); }
4722 catch(java.io.IOException e) { return curPos; }
4723 }
4724 }
jjStopStringLiteralDfa_14(int pos, long active0)4725 private final int jjStopStringLiteralDfa_14(int pos, long active0)
4726 {
4727 switch (pos)
4728 {
4729 case 0:
4730 if ((active0 & 0x1a00000L) != 0L)
4731 return 2;
4732 return -1;
4733 case 1:
4734 if ((active0 & 0x800000L) != 0L)
4735 return 0;
4736 return -1;
4737 default :
4738 return -1;
4739 }
4740 }
jjStartNfa_14(int pos, long active0)4741 private final int jjStartNfa_14(int pos, long active0)
4742 {
4743 return jjMoveNfa_14(jjStopStringLiteralDfa_14(pos, active0), pos + 1);
4744 }
jjMoveStringLiteralDfa0_14()4745 private int jjMoveStringLiteralDfa0_14()
4746 {
4747 switch(curChar)
4748 {
4749 case 28:
4750 return jjStopAtPos(0, 2);
4751 case 35:
4752 jjmatchedKind = 24;
4753 return jjMoveStringLiteralDfa1_14(0xa00000L);
4754 case 42:
4755 return jjMoveStringLiteralDfa1_14(0x8000000L);
4756 default :
4757 return jjMoveNfa_14(3, 0);
4758 }
4759 }
jjMoveStringLiteralDfa1_14(long active0)4760 private int jjMoveStringLiteralDfa1_14(long active0)
4761 {
4762 try { curChar = input_stream.readChar(); }
4763 catch(java.io.IOException e) {
4764 jjStopStringLiteralDfa_14(0, active0);
4765 return 1;
4766 }
4767 switch(curChar)
4768 {
4769 case 35:
4770 if ((active0 & 0x8000000L) != 0L)
4771 return jjStopAtPos(1, 27);
4772 break;
4773 case 42:
4774 if ((active0 & 0x800000L) != 0L)
4775 return jjStartNfaWithStates_14(1, 23, 0);
4776 break;
4777 case 91:
4778 return jjMoveStringLiteralDfa2_14(active0, 0x200000L);
4779 default :
4780 break;
4781 }
4782 return jjStartNfa_14(0, active0);
4783 }
jjMoveStringLiteralDfa2_14(long old0, long active0)4784 private int jjMoveStringLiteralDfa2_14(long old0, long active0)
4785 {
4786 if (((active0 &= old0)) == 0L)
4787 return jjStartNfa_14(0, old0);
4788 try { curChar = input_stream.readChar(); }
4789 catch(java.io.IOException e) {
4790 jjStopStringLiteralDfa_14(1, active0);
4791 return 2;
4792 }
4793 switch(curChar)
4794 {
4795 case 91:
4796 if ((active0 & 0x200000L) != 0L)
4797 return jjStopAtPos(2, 21);
4798 break;
4799 default :
4800 break;
4801 }
4802 return jjStartNfa_14(1, active0);
4803 }
jjStartNfaWithStates_14(int pos, int kind, int state)4804 private int jjStartNfaWithStates_14(int pos, int kind, int state)
4805 {
4806 jjmatchedKind = kind;
4807 jjmatchedPos = pos;
4808 try { curChar = input_stream.readChar(); }
4809 catch(java.io.IOException e) { return pos + 1; }
4810 return jjMoveNfa_14(state, pos + 1);
4811 }
jjMoveNfa_14(int startState, int curPos)4812 private int jjMoveNfa_14(int startState, int curPos)
4813 {
4814 int startsAt = 0;
4815 jjnewStateCnt = 12;
4816 int i = 1;
4817 jjstateSet[0] = startState;
4818 int kind = 0x7fffffff;
4819 for (;;)
4820 {
4821 if (++jjround == 0x7fffffff)
4822 ReInitRounds();
4823 if (curChar < 64)
4824 {
4825 long l = 1L << curChar;
4826 do
4827 {
4828 switch(jjstateSet[--i])
4829 {
4830 case 3:
4831 if (curChar == 36)
4832 {
4833 if (kind > 19)
4834 kind = 19;
4835 jjCheckNAddTwoStates(9, 10);
4836 }
4837 else if (curChar == 35)
4838 jjstateSet[jjnewStateCnt++] = 2;
4839 break;
4840 case 0:
4841 if (curChar == 42)
4842 jjstateSet[jjnewStateCnt++] = 1;
4843 break;
4844 case 1:
4845 if ((0xfffffff7efffffffL & l) != 0L && kind > 22)
4846 kind = 22;
4847 break;
4848 case 2:
4849 if (curChar == 42)
4850 jjstateSet[jjnewStateCnt++] = 0;
4851 break;
4852 case 6:
4853 if (curChar == 36 && kind > 19)
4854 kind = 19;
4855 break;
4856 case 8:
4857 if (curChar == 36)
4858 jjCheckNAddTwoStates(9, 10);
4859 break;
4860 case 10:
4861 if (curChar == 33 && kind > 20)
4862 kind = 20;
4863 break;
4864 case 11:
4865 if (curChar != 36)
4866 break;
4867 if (kind > 19)
4868 kind = 19;
4869 jjCheckNAddTwoStates(9, 10);
4870 break;
4871 default : break;
4872 }
4873 } while(i != startsAt);
4874 }
4875 else if (curChar < 128)
4876 {
4877 long l = 1L << (curChar & 077);
4878 do
4879 {
4880 switch(jjstateSet[--i])
4881 {
4882 case 3:
4883 if (curChar == 92)
4884 jjCheckNAddStates(111, 114);
4885 break;
4886 case 1:
4887 if (kind > 22)
4888 kind = 22;
4889 break;
4890 case 5:
4891 if (curChar == 92)
4892 jjCheckNAddTwoStates(5, 6);
4893 break;
4894 case 7:
4895 if (curChar == 92)
4896 jjCheckNAddTwoStates(7, 8);
4897 break;
4898 case 9:
4899 if (curChar == 92)
4900 jjAddStates(115, 116);
4901 break;
4902 default : break;
4903 }
4904 } while(i != startsAt);
4905 }
4906 else
4907 {
4908 int hiByte = (int)(curChar >> 8);
4909 int i1 = hiByte >> 6;
4910 long l1 = 1L << (hiByte & 077);
4911 int i2 = (curChar & 0xff) >> 6;
4912 long l2 = 1L << (curChar & 077);
4913 do
4914 {
4915 switch(jjstateSet[--i])
4916 {
4917 case 1:
4918 if (jjCanMove_0(hiByte, i1, i2, l1, l2) && kind > 22)
4919 kind = 22;
4920 break;
4921 default : break;
4922 }
4923 } while(i != startsAt);
4924 }
4925 if (kind != 0x7fffffff)
4926 {
4927 jjmatchedKind = kind;
4928 jjmatchedPos = curPos;
4929 kind = 0x7fffffff;
4930 }
4931 ++curPos;
4932 if ((i = jjnewStateCnt) == (startsAt = 12 - (jjnewStateCnt = startsAt)))
4933 return curPos;
4934 try { curChar = input_stream.readChar(); }
4935 catch(java.io.IOException e) { return curPos; }
4936 }
4937 }
jjStopStringLiteralDfa_2(int pos, long active0, long active1)4938 private final int jjStopStringLiteralDfa_2(int pos, long active0, long active1)
4939 {
4940 switch (pos)
4941 {
4942 case 0:
4943 if ((active0 & 0x3a00000L) != 0L)
4944 return 25;
4945 return -1;
4946 case 1:
4947 if ((active0 & 0x800000L) != 0L)
4948 return 31;
4949 return -1;
4950 default :
4951 return -1;
4952 }
4953 }
jjStartNfa_2(int pos, long active0, long active1)4954 private final int jjStartNfa_2(int pos, long active0, long active1)
4955 {
4956 return jjMoveNfa_2(jjStopStringLiteralDfa_2(pos, active0, active1), pos + 1);
4957 }
jjMoveStringLiteralDfa0_2()4958 private int jjMoveStringLiteralDfa0_2()
4959 {
4960 switch(curChar)
4961 {
4962 case 28:
4963 return jjStopAtPos(0, 1);
4964 case 35:
4965 jjmatchedKind = 24;
4966 return jjMoveStringLiteralDfa1_2(0x2a00000L);
4967 case 123:
4968 return jjStopAtPos(0, 72);
4969 case 125:
4970 return jjStopAtPos(0, 73);
4971 default :
4972 return jjMoveNfa_2(4, 0);
4973 }
4974 }
jjMoveStringLiteralDfa1_2(long active0)4975 private int jjMoveStringLiteralDfa1_2(long active0)
4976 {
4977 try { curChar = input_stream.readChar(); }
4978 catch(java.io.IOException e) {
4979 jjStopStringLiteralDfa_2(0, active0, 0L);
4980 return 1;
4981 }
4982 switch(curChar)
4983 {
4984 case 35:
4985 if ((active0 & 0x2000000L) != 0L)
4986 return jjStopAtPos(1, 25);
4987 break;
4988 case 42:
4989 if ((active0 & 0x800000L) != 0L)
4990 return jjStartNfaWithStates_2(1, 23, 31);
4991 break;
4992 case 91:
4993 return jjMoveStringLiteralDfa2_2(active0, 0x200000L);
4994 default :
4995 break;
4996 }
4997 return jjStartNfa_2(0, active0, 0L);
4998 }
jjMoveStringLiteralDfa2_2(long old0, long active0)4999 private int jjMoveStringLiteralDfa2_2(long old0, long active0)
5000 {
5001 if (((active0 &= old0)) == 0L)
5002 return jjStartNfa_2(0, old0, 0L);
5003 try { curChar = input_stream.readChar(); }
5004 catch(java.io.IOException e) {
5005 jjStopStringLiteralDfa_2(1, active0, 0L);
5006 return 2;
5007 }
5008 switch(curChar)
5009 {
5010 case 91:
5011 if ((active0 & 0x200000L) != 0L)
5012 return jjStopAtPos(2, 21);
5013 break;
5014 default :
5015 break;
5016 }
5017 return jjStartNfa_2(1, active0, 0L);
5018 }
jjStartNfaWithStates_2(int pos, int kind, int state)5019 private int jjStartNfaWithStates_2(int pos, int kind, int state)
5020 {
5021 jjmatchedKind = kind;
5022 jjmatchedPos = pos;
5023 try { curChar = input_stream.readChar(); }
5024 catch(java.io.IOException e) { return pos + 1; }
5025 return jjMoveNfa_2(state, pos + 1);
5026 }
jjMoveNfa_2(int startState, int curPos)5027 private int jjMoveNfa_2(int startState, int curPos)
5028 {
5029 int startsAt = 0;
5030 jjnewStateCnt = 34;
5031 int i = 1;
5032 jjstateSet[0] = startState;
5033 int kind = 0x7fffffff;
5034 for (;;)
5035 {
5036 if (++jjround == 0x7fffffff)
5037 ReInitRounds();
5038 if (curChar < 64)
5039 {
5040 long l = 1L << curChar;
5041 do
5042 {
5043 switch(jjstateSet[--i])
5044 {
5045 case 25:
5046 if (curChar == 42)
5047 jjstateSet[jjnewStateCnt++] = 31;
5048 break;
5049 case 4:
5050 if ((0x2400L & l) != 0L)
5051 {
5052 if (kind > 34)
5053 kind = 34;
5054 }
5055 else if ((0x100000200L & l) != 0L)
5056 jjCheckNAddStates(143, 145);
5057 else if (curChar == 35)
5058 jjAddStates(146, 148);
5059 else if (curChar == 36)
5060 {
5061 if (kind > 19)
5062 kind = 19;
5063 jjCheckNAddTwoStates(17, 18);
5064 }
5065 if (curChar == 36)
5066 jjCheckNAddStates(149, 152);
5067 else if (curChar == 13)
5068 jjstateSet[jjnewStateCnt++] = 2;
5069 break;
5070 case 0:
5071 if ((0x100000200L & l) != 0L)
5072 jjCheckNAddStates(143, 145);
5073 break;
5074 case 1:
5075 if ((0x2400L & l) != 0L && kind > 34)
5076 kind = 34;
5077 break;
5078 case 2:
5079 if (curChar == 10 && kind > 34)
5080 kind = 34;
5081 break;
5082 case 3:
5083 if (curChar == 13)
5084 jjstateSet[jjnewStateCnt++] = 2;
5085 break;
5086 case 5:
5087 if ((0x3ff200000000000L & l) == 0L)
5088 break;
5089 if (kind > 70)
5090 kind = 70;
5091 jjstateSet[jjnewStateCnt++] = 5;
5092 break;
5093 case 6:
5094 if (curChar == 36)
5095 jjCheckNAddStates(149, 152);
5096 break;
5097 case 8:
5098 case 9:
5099 if (curChar == 33)
5100 jjCheckNAdd(7);
5101 break;
5102 case 11:
5103 if (curChar == 46 && kind > 80)
5104 kind = 80;
5105 break;
5106 case 14:
5107 if (curChar == 36 && kind > 19)
5108 kind = 19;
5109 break;
5110 case 16:
5111 if (curChar == 36)
5112 jjCheckNAddTwoStates(17, 18);
5113 break;
5114 case 18:
5115 if (curChar == 33 && kind > 20)
5116 kind = 20;
5117 break;
5118 case 19:
5119 if (curChar != 36)
5120 break;
5121 if (kind > 19)
5122 kind = 19;
5123 jjCheckNAddTwoStates(17, 18);
5124 break;
5125 case 20:
5126 if (curChar == 35)
5127 jjAddStates(146, 148);
5128 break;
5129 case 22:
5130 if ((0x100000200L & l) != 0L)
5131 jjAddStates(153, 154);
5132 break;
5133 case 23:
5134 if (curChar == 40 && kind > 18)
5135 kind = 18;
5136 break;
5137 case 31:
5138 if (curChar == 42)
5139 jjstateSet[jjnewStateCnt++] = 32;
5140 break;
5141 case 32:
5142 if ((0xfffffff7efffffffL & l) != 0L && kind > 22)
5143 kind = 22;
5144 break;
5145 default : break;
5146 }
5147 } while(i != startsAt);
5148 }
5149 else if (curChar < 128)
5150 {
5151 long l = 1L << (curChar & 077);
5152 do
5153 {
5154 switch(jjstateSet[--i])
5155 {
5156 case 25:
5157 if (curChar == 123)
5158 jjstateSet[jjnewStateCnt++] = 29;
5159 else if (curChar == 115)
5160 jjstateSet[jjnewStateCnt++] = 24;
5161 break;
5162 case 4:
5163 if ((0x7fffffe87fffffeL & l) != 0L)
5164 {
5165 if (kind > 70)
5166 kind = 70;
5167 jjCheckNAdd(5);
5168 }
5169 else if (curChar == 92)
5170 jjCheckNAddStates(155, 158);
5171 break;
5172 case 5:
5173 if ((0x7fffffe87fffffeL & l) == 0L)
5174 break;
5175 if (kind > 70)
5176 kind = 70;
5177 jjCheckNAdd(5);
5178 break;
5179 case 7:
5180 if (curChar == 91 && kind > 80)
5181 kind = 80;
5182 break;
5183 case 10:
5184 if (curChar == 92)
5185 jjstateSet[jjnewStateCnt++] = 9;
5186 break;
5187 case 12:
5188 if (curChar == 92)
5189 jjCheckNAddStates(155, 158);
5190 break;
5191 case 13:
5192 if (curChar == 92)
5193 jjCheckNAddTwoStates(13, 14);
5194 break;
5195 case 15:
5196 if (curChar == 92)
5197 jjCheckNAddTwoStates(15, 16);
5198 break;
5199 case 17:
5200 if (curChar == 92)
5201 jjAddStates(159, 160);
5202 break;
5203 case 21:
5204 if (curChar == 116)
5205 jjCheckNAddTwoStates(22, 23);
5206 break;
5207 case 24:
5208 if (curChar == 101)
5209 jjstateSet[jjnewStateCnt++] = 21;
5210 break;
5211 case 26:
5212 if (curChar == 125)
5213 jjCheckNAddTwoStates(22, 23);
5214 break;
5215 case 27:
5216 if (curChar == 116)
5217 jjstateSet[jjnewStateCnt++] = 26;
5218 break;
5219 case 28:
5220 if (curChar == 101)
5221 jjstateSet[jjnewStateCnt++] = 27;
5222 break;
5223 case 29:
5224 if (curChar == 115)
5225 jjstateSet[jjnewStateCnt++] = 28;
5226 break;
5227 case 30:
5228 if (curChar == 123)
5229 jjstateSet[jjnewStateCnt++] = 29;
5230 break;
5231 case 32:
5232 if (kind > 22)
5233 kind = 22;
5234 break;
5235 default : break;
5236 }
5237 } while(i != startsAt);
5238 }
5239 else
5240 {
5241 int hiByte = (int)(curChar >> 8);
5242 int i1 = hiByte >> 6;
5243 long l1 = 1L << (hiByte & 077);
5244 int i2 = (curChar & 0xff) >> 6;
5245 long l2 = 1L << (curChar & 077);
5246 do
5247 {
5248 switch(jjstateSet[--i])
5249 {
5250 case 32:
5251 if (jjCanMove_0(hiByte, i1, i2, l1, l2) && kind > 22)
5252 kind = 22;
5253 break;
5254 default : break;
5255 }
5256 } while(i != startsAt);
5257 }
5258 if (kind != 0x7fffffff)
5259 {
5260 jjmatchedKind = kind;
5261 jjmatchedPos = curPos;
5262 kind = 0x7fffffff;
5263 }
5264 ++curPos;
5265 if ((i = jjnewStateCnt) == (startsAt = 34 - (jjnewStateCnt = startsAt)))
5266 return curPos;
5267 try { curChar = input_stream.readChar(); }
5268 catch(java.io.IOException e) { return curPos; }
5269 }
5270 }
jjStopStringLiteralDfa_10(int pos, long active0, long active1)5271 private final int jjStopStringLiteralDfa_10(int pos, long active0, long active1)
5272 {
5273 switch (pos)
5274 {
5275 case 0:
5276 if ((active0 & 0x3a00000L) != 0L)
5277 return 39;
5278 if ((active1 & 0x3000L) != 0L)
5279 return 18;
5280 return -1;
5281 case 1:
5282 if ((active0 & 0x800000L) != 0L)
5283 return 45;
5284 if ((active1 & 0x1000L) != 0L)
5285 return 51;
5286 return -1;
5287 default :
5288 return -1;
5289 }
5290 }
jjStartNfa_10(int pos, long active0, long active1)5291 private final int jjStartNfa_10(int pos, long active0, long active1)
5292 {
5293 return jjMoveNfa_10(jjStopStringLiteralDfa_10(pos, active0, active1), pos + 1);
5294 }
jjMoveStringLiteralDfa0_10()5295 private int jjMoveStringLiteralDfa0_10()
5296 {
5297 switch(curChar)
5298 {
5299 case 28:
5300 return jjStopAtPos(0, 2);
5301 case 35:
5302 jjmatchedKind = 24;
5303 return jjMoveStringLiteralDfa1_10(0x2a00000L, 0x0L);
5304 case 92:
5305 jjmatchedKind = 77;
5306 return jjMoveStringLiteralDfa1_10(0x0L, 0x1000L);
5307 default :
5308 return jjMoveNfa_10(1, 0);
5309 }
5310 }
jjMoveStringLiteralDfa1_10(long active0, long active1)5311 private int jjMoveStringLiteralDfa1_10(long active0, long active1)
5312 {
5313 try { curChar = input_stream.readChar(); }
5314 catch(java.io.IOException e) {
5315 jjStopStringLiteralDfa_10(0, active0, active1);
5316 return 1;
5317 }
5318 switch(curChar)
5319 {
5320 case 35:
5321 if ((active0 & 0x2000000L) != 0L)
5322 return jjStopAtPos(1, 25);
5323 break;
5324 case 42:
5325 if ((active0 & 0x800000L) != 0L)
5326 return jjStartNfaWithStates_10(1, 23, 45);
5327 break;
5328 case 91:
5329 return jjMoveStringLiteralDfa2_10(active0, 0x200000L, active1, 0L);
5330 case 92:
5331 if ((active1 & 0x1000L) != 0L)
5332 return jjStartNfaWithStates_10(1, 76, 51);
5333 break;
5334 default :
5335 break;
5336 }
5337 return jjStartNfa_10(0, active0, active1);
5338 }
jjMoveStringLiteralDfa2_10(long old0, long active0, long old1, long active1)5339 private int jjMoveStringLiteralDfa2_10(long old0, long active0, long old1, long active1)
5340 {
5341 if (((active0 &= old0) | (active1 &= old1)) == 0L)
5342 return jjStartNfa_10(0, old0, old1);
5343 try { curChar = input_stream.readChar(); }
5344 catch(java.io.IOException e) {
5345 jjStopStringLiteralDfa_10(1, active0, 0L);
5346 return 2;
5347 }
5348 switch(curChar)
5349 {
5350 case 91:
5351 if ((active0 & 0x200000L) != 0L)
5352 return jjStopAtPos(2, 21);
5353 break;
5354 default :
5355 break;
5356 }
5357 return jjStartNfa_10(1, active0, 0L);
5358 }
jjStartNfaWithStates_10(int pos, int kind, int state)5359 private int jjStartNfaWithStates_10(int pos, int kind, int state)
5360 {
5361 jjmatchedKind = kind;
5362 jjmatchedPos = pos;
5363 try { curChar = input_stream.readChar(); }
5364 catch(java.io.IOException e) { return pos + 1; }
5365 return jjMoveNfa_10(state, pos + 1);
5366 }
jjMoveNfa_10(int startState, int curPos)5367 private int jjMoveNfa_10(int startState, int curPos)
5368 {
5369 int startsAt = 0;
5370 jjnewStateCnt = 51;
5371 int i = 1;
5372 jjstateSet[0] = startState;
5373 int kind = 0x7fffffff;
5374 for (;;)
5375 {
5376 if (++jjround == 0x7fffffff)
5377 ReInitRounds();
5378 if (curChar < 64)
5379 {
5380 long l = 1L << curChar;
5381 do
5382 {
5383 switch(jjstateSet[--i])
5384 {
5385 case 39:
5386 if (curChar == 42)
5387 jjstateSet[jjnewStateCnt++] = 45;
5388 break;
5389 case 18:
5390 if (curChar == 36)
5391 jjCheckNAddTwoStates(31, 32);
5392 else if (curChar == 35)
5393 jjAddStates(161, 162);
5394 if (curChar == 36)
5395 {
5396 if (kind > 19)
5397 kind = 19;
5398 }
5399 break;
5400 case 51:
5401 if (curChar == 36)
5402 jjCheckNAddTwoStates(31, 32);
5403 if (curChar == 36)
5404 {
5405 if (kind > 19)
5406 kind = 19;
5407 }
5408 break;
5409 case 1:
5410 if ((0xffffffe7efffdbffL & l) != 0L)
5411 {
5412 if (kind > 79)
5413 kind = 79;
5414 jjCheckNAddStates(163, 165);
5415 }
5416 else if ((0x2400L & l) != 0L)
5417 {
5418 if (kind > 33)
5419 kind = 33;
5420 }
5421 else if (curChar == 35)
5422 jjAddStates(166, 168);
5423 else if (curChar == 36)
5424 {
5425 if (kind > 19)
5426 kind = 19;
5427 jjCheckNAddTwoStates(31, 32);
5428 }
5429 if ((0xffffffe6efffd9ffL & l) != 0L)
5430 jjCheckNAddStates(169, 172);
5431 else if ((0x100000200L & l) != 0L)
5432 {
5433 if (kind > 32)
5434 kind = 32;
5435 jjCheckNAdd(0);
5436 }
5437 else if (curChar == 36)
5438 jjCheckNAddStates(173, 176);
5439 else if (curChar == 13)
5440 jjstateSet[jjnewStateCnt++] = 2;
5441 break;
5442 case 0:
5443 if ((0x100000200L & l) == 0L)
5444 break;
5445 if (kind > 32)
5446 kind = 32;
5447 jjCheckNAdd(0);
5448 break;
5449 case 2:
5450 if (curChar == 10 && kind > 33)
5451 kind = 33;
5452 break;
5453 case 3:
5454 if (curChar == 13)
5455 jjstateSet[jjnewStateCnt++] = 2;
5456 break;
5457 case 4:
5458 if ((0xffffffe6efffd9ffL & l) != 0L)
5459 jjCheckNAddStates(169, 172);
5460 break;
5461 case 5:
5462 if ((0xffffffe7efffdbffL & l) != 0L)
5463 jjCheckNAddStates(177, 179);
5464 break;
5465 case 6:
5466 if ((0x2400L & l) == 0L)
5467 break;
5468 if (kind > 78)
5469 kind = 78;
5470 jjCheckNAddStates(180, 182);
5471 break;
5472 case 7:
5473 if ((0xffffffe7efffdbffL & l) != 0L)
5474 jjCheckNAddStates(180, 182);
5475 break;
5476 case 8:
5477 if (curChar != 10)
5478 break;
5479 if (kind > 78)
5480 kind = 78;
5481 jjCheckNAddStates(180, 182);
5482 break;
5483 case 9:
5484 case 10:
5485 if (curChar == 13)
5486 jjCheckNAdd(8);
5487 break;
5488 case 11:
5489 if (curChar == 36)
5490 jjCheckNAddStates(173, 176);
5491 break;
5492 case 13:
5493 case 14:
5494 if (curChar == 33)
5495 jjCheckNAdd(12);
5496 break;
5497 case 16:
5498 if (curChar == 46 && kind > 80)
5499 kind = 80;
5500 break;
5501 case 19:
5502 if (curChar == 35)
5503 jjAddStates(161, 162);
5504 break;
5505 case 21:
5506 if ((0x3ff000000000000L & l) == 0L)
5507 break;
5508 if (kind > 17)
5509 kind = 17;
5510 jjstateSet[jjnewStateCnt++] = 21;
5511 break;
5512 case 24:
5513 if ((0x3ff000000000000L & l) != 0L)
5514 jjAddStates(68, 69);
5515 break;
5516 case 28:
5517 if (curChar == 36 && kind > 19)
5518 kind = 19;
5519 break;
5520 case 30:
5521 if (curChar == 36)
5522 jjCheckNAddTwoStates(31, 32);
5523 break;
5524 case 32:
5525 if (curChar == 33 && kind > 20)
5526 kind = 20;
5527 break;
5528 case 33:
5529 if (curChar != 36)
5530 break;
5531 if (kind > 19)
5532 kind = 19;
5533 jjCheckNAddTwoStates(31, 32);
5534 break;
5535 case 34:
5536 if (curChar == 35)
5537 jjAddStates(166, 168);
5538 break;
5539 case 36:
5540 if ((0x100000200L & l) != 0L)
5541 jjAddStates(183, 184);
5542 break;
5543 case 37:
5544 if (curChar == 40 && kind > 18)
5545 kind = 18;
5546 break;
5547 case 45:
5548 if (curChar == 42)
5549 jjstateSet[jjnewStateCnt++] = 46;
5550 break;
5551 case 46:
5552 if ((0xfffffff7efffffffL & l) != 0L && kind > 22)
5553 kind = 22;
5554 break;
5555 case 48:
5556 if ((0xffffffe7efffdbffL & l) == 0L)
5557 break;
5558 if (kind > 79)
5559 kind = 79;
5560 jjCheckNAddStates(163, 165);
5561 break;
5562 case 49:
5563 if ((0xffffffe7efffdbffL & l) != 0L)
5564 jjCheckNAddTwoStates(49, 4);
5565 break;
5566 case 50:
5567 if ((0xffffffe7efffdbffL & l) == 0L)
5568 break;
5569 if (kind > 79)
5570 kind = 79;
5571 jjCheckNAdd(50);
5572 break;
5573 default : break;
5574 }
5575 } while(i != startsAt);
5576 }
5577 else if (curChar < 128)
5578 {
5579 long l = 1L << (curChar & 077);
5580 do
5581 {
5582 switch(jjstateSet[--i])
5583 {
5584 case 39:
5585 if (curChar == 123)
5586 jjstateSet[jjnewStateCnt++] = 43;
5587 else if (curChar == 115)
5588 jjstateSet[jjnewStateCnt++] = 38;
5589 break;
5590 case 18:
5591 if (curChar == 92)
5592 jjCheckNAddTwoStates(29, 30);
5593 if (curChar == 92)
5594 jjCheckNAddTwoStates(27, 28);
5595 if (curChar == 92)
5596 jjstateSet[jjnewStateCnt++] = 17;
5597 break;
5598 case 51:
5599 if (curChar == 92)
5600 jjAddStates(185, 186);
5601 if (curChar == 92)
5602 jjCheckNAddTwoStates(29, 30);
5603 if (curChar == 92)
5604 jjCheckNAddTwoStates(27, 28);
5605 break;
5606 case 1:
5607 if ((0xffffffffefffffffL & l) != 0L)
5608 {
5609 if (kind > 79)
5610 kind = 79;
5611 jjCheckNAddStates(163, 165);
5612 }
5613 else if (curChar == 92)
5614 jjCheckNAddStates(187, 190);
5615 if ((0xffffffffefffffffL & l) != 0L)
5616 jjCheckNAddStates(169, 172);
5617 else if (curChar == 92)
5618 jjAddStates(185, 186);
5619 break;
5620 case 4:
5621 if ((0xffffffffefffffffL & l) != 0L)
5622 jjCheckNAddStates(169, 172);
5623 break;
5624 case 5:
5625 if ((0xffffffffefffffffL & l) != 0L)
5626 jjCheckNAddStates(177, 179);
5627 break;
5628 case 7:
5629 if ((0xffffffffefffffffL & l) != 0L)
5630 jjCheckNAddStates(180, 182);
5631 break;
5632 case 12:
5633 if (curChar == 91 && kind > 80)
5634 kind = 80;
5635 break;
5636 case 15:
5637 if (curChar == 92)
5638 jjstateSet[jjnewStateCnt++] = 14;
5639 break;
5640 case 17:
5641 if (curChar == 92)
5642 jjAddStates(185, 186);
5643 break;
5644 case 20:
5645 if ((0x7fffffe87ffffffL & l) == 0L)
5646 break;
5647 if (kind > 17)
5648 kind = 17;
5649 jjCheckNAdd(21);
5650 break;
5651 case 21:
5652 if ((0x7fffffe87fffffeL & l) == 0L)
5653 break;
5654 if (kind > 17)
5655 kind = 17;
5656 jjCheckNAdd(21);
5657 break;
5658 case 22:
5659 if (curChar == 123)
5660 jjstateSet[jjnewStateCnt++] = 23;
5661 break;
5662 case 23:
5663 if ((0x7fffffe87ffffffL & l) != 0L)
5664 jjCheckNAddTwoStates(24, 25);
5665 break;
5666 case 24:
5667 if ((0x7fffffe87fffffeL & l) != 0L)
5668 jjCheckNAddTwoStates(24, 25);
5669 break;
5670 case 25:
5671 if (curChar == 125 && kind > 17)
5672 kind = 17;
5673 break;
5674 case 26:
5675 if (curChar == 92)
5676 jjCheckNAddStates(187, 190);
5677 break;
5678 case 27:
5679 if (curChar == 92)
5680 jjCheckNAddTwoStates(27, 28);
5681 break;
5682 case 29:
5683 if (curChar == 92)
5684 jjCheckNAddTwoStates(29, 30);
5685 break;
5686 case 31:
5687 if (curChar == 92)
5688 jjAddStates(70, 71);
5689 break;
5690 case 35:
5691 if (curChar == 116)
5692 jjCheckNAddTwoStates(36, 37);
5693 break;
5694 case 38:
5695 if (curChar == 101)
5696 jjstateSet[jjnewStateCnt++] = 35;
5697 break;
5698 case 40:
5699 if (curChar == 125)
5700 jjCheckNAddTwoStates(36, 37);
5701 break;
5702 case 41:
5703 if (curChar == 116)
5704 jjstateSet[jjnewStateCnt++] = 40;
5705 break;
5706 case 42:
5707 if (curChar == 101)
5708 jjstateSet[jjnewStateCnt++] = 41;
5709 break;
5710 case 43:
5711 if (curChar == 115)
5712 jjstateSet[jjnewStateCnt++] = 42;
5713 break;
5714 case 44:
5715 if (curChar == 123)
5716 jjstateSet[jjnewStateCnt++] = 43;
5717 break;
5718 case 46:
5719 if (kind > 22)
5720 kind = 22;
5721 break;
5722 case 48:
5723 if ((0xffffffffefffffffL & l) == 0L)
5724 break;
5725 if (kind > 79)
5726 kind = 79;
5727 jjCheckNAddStates(163, 165);
5728 break;
5729 case 49:
5730 if ((0xffffffffefffffffL & l) != 0L)
5731 jjCheckNAddTwoStates(49, 4);
5732 break;
5733 case 50:
5734 if ((0xffffffffefffffffL & l) == 0L)
5735 break;
5736 if (kind > 79)
5737 kind = 79;
5738 jjCheckNAdd(50);
5739 break;
5740 default : break;
5741 }
5742 } while(i != startsAt);
5743 }
5744 else
5745 {
5746 int hiByte = (int)(curChar >> 8);
5747 int i1 = hiByte >> 6;
5748 long l1 = 1L << (hiByte & 077);
5749 int i2 = (curChar & 0xff) >> 6;
5750 long l2 = 1L << (curChar & 077);
5751 do
5752 {
5753 switch(jjstateSet[--i])
5754 {
5755 case 1:
5756 if (jjCanMove_0(hiByte, i1, i2, l1, l2))
5757 jjCheckNAddStates(169, 172);
5758 if (jjCanMove_0(hiByte, i1, i2, l1, l2))
5759 {
5760 if (kind > 79)
5761 kind = 79;
5762 jjCheckNAddStates(163, 165);
5763 }
5764 break;
5765 case 4:
5766 if (jjCanMove_0(hiByte, i1, i2, l1, l2))
5767 jjCheckNAddStates(169, 172);
5768 break;
5769 case 5:
5770 if (jjCanMove_0(hiByte, i1, i2, l1, l2))
5771 jjCheckNAddStates(177, 179);
5772 break;
5773 case 7:
5774 if (jjCanMove_0(hiByte, i1, i2, l1, l2))
5775 jjCheckNAddStates(180, 182);
5776 break;
5777 case 46:
5778 if (jjCanMove_0(hiByte, i1, i2, l1, l2) && kind > 22)
5779 kind = 22;
5780 break;
5781 case 48:
5782 if (!jjCanMove_0(hiByte, i1, i2, l1, l2))
5783 break;
5784 if (kind > 79)
5785 kind = 79;
5786 jjCheckNAddStates(163, 165);
5787 break;
5788 case 49:
5789 if (jjCanMove_0(hiByte, i1, i2, l1, l2))
5790 jjCheckNAddTwoStates(49, 4);
5791 break;
5792 case 50:
5793 if (!jjCanMove_0(hiByte, i1, i2, l1, l2))
5794 break;
5795 if (kind > 79)
5796 kind = 79;
5797 jjCheckNAdd(50);
5798 break;
5799 default : break;
5800 }
5801 } while(i != startsAt);
5802 }
5803 if (kind != 0x7fffffff)
5804 {
5805 jjmatchedKind = kind;
5806 jjmatchedPos = curPos;
5807 kind = 0x7fffffff;
5808 }
5809 ++curPos;
5810 if ((i = jjnewStateCnt) == (startsAt = 51 - (jjnewStateCnt = startsAt)))
5811 return curPos;
5812 try { curChar = input_stream.readChar(); }
5813 catch(java.io.IOException e) { return curPos; }
5814 }
5815 }
jjStopStringLiteralDfa_1(int pos, long active0, long active1)5816 private final int jjStopStringLiteralDfa_1(int pos, long active0, long active1)
5817 {
5818 switch (pos)
5819 {
5820 case 0:
5821 if ((active0 & 0x3a00000L) != 0L)
5822 return 25;
5823 return -1;
5824 case 1:
5825 if ((active0 & 0x800000L) != 0L)
5826 return 31;
5827 return -1;
5828 default :
5829 return -1;
5830 }
5831 }
jjStartNfa_1(int pos, long active0, long active1)5832 private final int jjStartNfa_1(int pos, long active0, long active1)
5833 {
5834 return jjMoveNfa_1(jjStopStringLiteralDfa_1(pos, active0, active1), pos + 1);
5835 }
jjMoveStringLiteralDfa0_1()5836 private int jjMoveStringLiteralDfa0_1()
5837 {
5838 switch(curChar)
5839 {
5840 case 28:
5841 return jjStopAtPos(0, 1);
5842 case 35:
5843 jjmatchedKind = 24;
5844 return jjMoveStringLiteralDfa1_1(0x2a00000L);
5845 case 123:
5846 return jjStopAtPos(0, 72);
5847 case 125:
5848 return jjStopAtPos(0, 73);
5849 default :
5850 return jjMoveNfa_1(4, 0);
5851 }
5852 }
jjMoveStringLiteralDfa1_1(long active0)5853 private int jjMoveStringLiteralDfa1_1(long active0)
5854 {
5855 try { curChar = input_stream.readChar(); }
5856 catch(java.io.IOException e) {
5857 jjStopStringLiteralDfa_1(0, active0, 0L);
5858 return 1;
5859 }
5860 switch(curChar)
5861 {
5862 case 35:
5863 if ((active0 & 0x2000000L) != 0L)
5864 return jjStopAtPos(1, 25);
5865 break;
5866 case 42:
5867 if ((active0 & 0x800000L) != 0L)
5868 return jjStartNfaWithStates_1(1, 23, 31);
5869 break;
5870 case 91:
5871 return jjMoveStringLiteralDfa2_1(active0, 0x200000L);
5872 default :
5873 break;
5874 }
5875 return jjStartNfa_1(0, active0, 0L);
5876 }
jjMoveStringLiteralDfa2_1(long old0, long active0)5877 private int jjMoveStringLiteralDfa2_1(long old0, long active0)
5878 {
5879 if (((active0 &= old0)) == 0L)
5880 return jjStartNfa_1(0, old0, 0L);
5881 try { curChar = input_stream.readChar(); }
5882 catch(java.io.IOException e) {
5883 jjStopStringLiteralDfa_1(1, active0, 0L);
5884 return 2;
5885 }
5886 switch(curChar)
5887 {
5888 case 91:
5889 if ((active0 & 0x200000L) != 0L)
5890 return jjStopAtPos(2, 21);
5891 break;
5892 default :
5893 break;
5894 }
5895 return jjStartNfa_1(1, active0, 0L);
5896 }
jjStartNfaWithStates_1(int pos, int kind, int state)5897 private int jjStartNfaWithStates_1(int pos, int kind, int state)
5898 {
5899 jjmatchedKind = kind;
5900 jjmatchedPos = pos;
5901 try { curChar = input_stream.readChar(); }
5902 catch(java.io.IOException e) { return pos + 1; }
5903 return jjMoveNfa_1(state, pos + 1);
5904 }
jjMoveNfa_1(int startState, int curPos)5905 private int jjMoveNfa_1(int startState, int curPos)
5906 {
5907 int startsAt = 0;
5908 jjnewStateCnt = 34;
5909 int i = 1;
5910 jjstateSet[0] = startState;
5911 int kind = 0x7fffffff;
5912 for (;;)
5913 {
5914 if (++jjround == 0x7fffffff)
5915 ReInitRounds();
5916 if (curChar < 64)
5917 {
5918 long l = 1L << curChar;
5919 do
5920 {
5921 switch(jjstateSet[--i])
5922 {
5923 case 25:
5924 if (curChar == 42)
5925 jjstateSet[jjnewStateCnt++] = 31;
5926 break;
5927 case 4:
5928 if ((0x2400L & l) != 0L)
5929 {
5930 if (kind > 34)
5931 kind = 34;
5932 }
5933 else if ((0x100000200L & l) != 0L)
5934 jjCheckNAddStates(143, 145);
5935 else if (curChar == 35)
5936 jjAddStates(146, 148);
5937 else if (curChar == 36)
5938 {
5939 if (kind > 19)
5940 kind = 19;
5941 jjCheckNAddTwoStates(17, 18);
5942 }
5943 if (curChar == 36)
5944 jjCheckNAddStates(149, 152);
5945 else if (curChar == 13)
5946 jjstateSet[jjnewStateCnt++] = 2;
5947 break;
5948 case 0:
5949 if ((0x100000200L & l) != 0L)
5950 jjCheckNAddStates(143, 145);
5951 break;
5952 case 1:
5953 if ((0x2400L & l) != 0L && kind > 34)
5954 kind = 34;
5955 break;
5956 case 2:
5957 if (curChar == 10 && kind > 34)
5958 kind = 34;
5959 break;
5960 case 3:
5961 if (curChar == 13)
5962 jjstateSet[jjnewStateCnt++] = 2;
5963 break;
5964 case 5:
5965 if ((0x3ff000000000000L & l) == 0L)
5966 break;
5967 if (kind > 67)
5968 kind = 67;
5969 jjstateSet[jjnewStateCnt++] = 5;
5970 break;
5971 case 6:
5972 if (curChar == 36)
5973 jjCheckNAddStates(149, 152);
5974 break;
5975 case 8:
5976 case 9:
5977 if (curChar == 33)
5978 jjCheckNAdd(7);
5979 break;
5980 case 11:
5981 if (curChar == 46 && kind > 80)
5982 kind = 80;
5983 break;
5984 case 14:
5985 if (curChar == 36 && kind > 19)
5986 kind = 19;
5987 break;
5988 case 16:
5989 if (curChar == 36)
5990 jjCheckNAddTwoStates(17, 18);
5991 break;
5992 case 18:
5993 if (curChar == 33 && kind > 20)
5994 kind = 20;
5995 break;
5996 case 19:
5997 if (curChar != 36)
5998 break;
5999 if (kind > 19)
6000 kind = 19;
6001 jjCheckNAddTwoStates(17, 18);
6002 break;
6003 case 20:
6004 if (curChar == 35)
6005 jjAddStates(146, 148);
6006 break;
6007 case 22:
6008 if ((0x100000200L & l) != 0L)
6009 jjAddStates(153, 154);
6010 break;
6011 case 23:
6012 if (curChar == 40 && kind > 18)
6013 kind = 18;
6014 break;
6015 case 31:
6016 if (curChar == 42)
6017 jjstateSet[jjnewStateCnt++] = 32;
6018 break;
6019 case 32:
6020 if ((0xfffffff7efffffffL & l) != 0L && kind > 22)
6021 kind = 22;
6022 break;
6023 default : break;
6024 }
6025 } while(i != startsAt);
6026 }
6027 else if (curChar < 128)
6028 {
6029 long l = 1L << (curChar & 077);
6030 do
6031 {
6032 switch(jjstateSet[--i])
6033 {
6034 case 25:
6035 if (curChar == 123)
6036 jjstateSet[jjnewStateCnt++] = 29;
6037 else if (curChar == 115)
6038 jjstateSet[jjnewStateCnt++] = 24;
6039 break;
6040 case 4:
6041 if ((0x7fffffe87fffffeL & l) != 0L)
6042 {
6043 if (kind > 67)
6044 kind = 67;
6045 jjCheckNAdd(5);
6046 }
6047 else if (curChar == 92)
6048 jjCheckNAddStates(155, 158);
6049 break;
6050 case 5:
6051 if ((0x7fffffe87fffffeL & l) == 0L)
6052 break;
6053 if (kind > 67)
6054 kind = 67;
6055 jjCheckNAdd(5);
6056 break;
6057 case 7:
6058 if (curChar == 91 && kind > 80)
6059 kind = 80;
6060 break;
6061 case 10:
6062 if (curChar == 92)
6063 jjstateSet[jjnewStateCnt++] = 9;
6064 break;
6065 case 12:
6066 if (curChar == 92)
6067 jjCheckNAddStates(155, 158);
6068 break;
6069 case 13:
6070 if (curChar == 92)
6071 jjCheckNAddTwoStates(13, 14);
6072 break;
6073 case 15:
6074 if (curChar == 92)
6075 jjCheckNAddTwoStates(15, 16);
6076 break;
6077 case 17:
6078 if (curChar == 92)
6079 jjAddStates(159, 160);
6080 break;
6081 case 21:
6082 if (curChar == 116)
6083 jjCheckNAddTwoStates(22, 23);
6084 break;
6085 case 24:
6086 if (curChar == 101)
6087 jjstateSet[jjnewStateCnt++] = 21;
6088 break;
6089 case 26:
6090 if (curChar == 125)
6091 jjCheckNAddTwoStates(22, 23);
6092 break;
6093 case 27:
6094 if (curChar == 116)
6095 jjstateSet[jjnewStateCnt++] = 26;
6096 break;
6097 case 28:
6098 if (curChar == 101)
6099 jjstateSet[jjnewStateCnt++] = 27;
6100 break;
6101 case 29:
6102 if (curChar == 115)
6103 jjstateSet[jjnewStateCnt++] = 28;
6104 break;
6105 case 30:
6106 if (curChar == 123)
6107 jjstateSet[jjnewStateCnt++] = 29;
6108 break;
6109 case 32:
6110 if (kind > 22)
6111 kind = 22;
6112 break;
6113 default : break;
6114 }
6115 } while(i != startsAt);
6116 }
6117 else
6118 {
6119 int hiByte = (int)(curChar >> 8);
6120 int i1 = hiByte >> 6;
6121 long l1 = 1L << (hiByte & 077);
6122 int i2 = (curChar & 0xff) >> 6;
6123 long l2 = 1L << (curChar & 077);
6124 do
6125 {
6126 switch(jjstateSet[--i])
6127 {
6128 case 32:
6129 if (jjCanMove_0(hiByte, i1, i2, l1, l2) && kind > 22)
6130 kind = 22;
6131 break;
6132 default : break;
6133 }
6134 } while(i != startsAt);
6135 }
6136 if (kind != 0x7fffffff)
6137 {
6138 jjmatchedKind = kind;
6139 jjmatchedPos = curPos;
6140 kind = 0x7fffffff;
6141 }
6142 ++curPos;
6143 if ((i = jjnewStateCnt) == (startsAt = 34 - (jjnewStateCnt = startsAt)))
6144 return curPos;
6145 try { curChar = input_stream.readChar(); }
6146 catch(java.io.IOException e) { return curPos; }
6147 }
6148 }
jjStopStringLiteralDfa_6(int pos, long active0, long active1)6149 private final int jjStopStringLiteralDfa_6(int pos, long active0, long active1)
6150 {
6151 switch (pos)
6152 {
6153 case 0:
6154 if ((active0 & 0x3a00000L) != 0L)
6155 return 15;
6156 return -1;
6157 case 1:
6158 if ((active0 & 0x800000L) != 0L)
6159 return 21;
6160 return -1;
6161 default :
6162 return -1;
6163 }
6164 }
jjStartNfa_6(int pos, long active0, long active1)6165 private final int jjStartNfa_6(int pos, long active0, long active1)
6166 {
6167 return jjMoveNfa_6(jjStopStringLiteralDfa_6(pos, active0, active1), pos + 1);
6168 }
jjMoveStringLiteralDfa0_6()6169 private int jjMoveStringLiteralDfa0_6()
6170 {
6171 switch(curChar)
6172 {
6173 case 28:
6174 return jjStopAtPos(0, 2);
6175 case 35:
6176 jjmatchedKind = 24;
6177 return jjMoveStringLiteralDfa1_6(0x2a00000L);
6178 case 91:
6179 return jjStopAtPos(0, 3);
6180 case 123:
6181 return jjStopAtPos(0, 72);
6182 case 124:
6183 jjmatchedKind = 5;
6184 return jjMoveStringLiteralDfa1_6(0x10L);
6185 case 125:
6186 return jjStopAtPos(0, 73);
6187 default :
6188 return jjMoveNfa_6(0, 0);
6189 }
6190 }
jjMoveStringLiteralDfa1_6(long active0)6191 private int jjMoveStringLiteralDfa1_6(long active0)
6192 {
6193 try { curChar = input_stream.readChar(); }
6194 catch(java.io.IOException e) {
6195 jjStopStringLiteralDfa_6(0, active0, 0L);
6196 return 1;
6197 }
6198 switch(curChar)
6199 {
6200 case 35:
6201 if ((active0 & 0x2000000L) != 0L)
6202 return jjStopAtPos(1, 25);
6203 break;
6204 case 42:
6205 if ((active0 & 0x800000L) != 0L)
6206 return jjStartNfaWithStates_6(1, 23, 21);
6207 break;
6208 case 91:
6209 return jjMoveStringLiteralDfa2_6(active0, 0x200000L);
6210 case 124:
6211 if ((active0 & 0x10L) != 0L)
6212 return jjStopAtPos(1, 4);
6213 break;
6214 default :
6215 break;
6216 }
6217 return jjStartNfa_6(0, active0, 0L);
6218 }
jjMoveStringLiteralDfa2_6(long old0, long active0)6219 private int jjMoveStringLiteralDfa2_6(long old0, long active0)
6220 {
6221 if (((active0 &= old0)) == 0L)
6222 return jjStartNfa_6(0, old0, 0L);
6223 try { curChar = input_stream.readChar(); }
6224 catch(java.io.IOException e) {
6225 jjStopStringLiteralDfa_6(1, active0, 0L);
6226 return 2;
6227 }
6228 switch(curChar)
6229 {
6230 case 91:
6231 if ((active0 & 0x200000L) != 0L)
6232 return jjStopAtPos(2, 21);
6233 break;
6234 default :
6235 break;
6236 }
6237 return jjStartNfa_6(1, active0, 0L);
6238 }
jjStartNfaWithStates_6(int pos, int kind, int state)6239 private int jjStartNfaWithStates_6(int pos, int kind, int state)
6240 {
6241 jjmatchedKind = kind;
6242 jjmatchedPos = pos;
6243 try { curChar = input_stream.readChar(); }
6244 catch(java.io.IOException e) { return pos + 1; }
6245 return jjMoveNfa_6(state, pos + 1);
6246 }
jjMoveNfa_6(int startState, int curPos)6247 private int jjMoveNfa_6(int startState, int curPos)
6248 {
6249 int startsAt = 0;
6250 jjnewStateCnt = 24;
6251 int i = 1;
6252 jjstateSet[0] = startState;
6253 int kind = 0x7fffffff;
6254 for (;;)
6255 {
6256 if (++jjround == 0x7fffffff)
6257 ReInitRounds();
6258 if (curChar < 64)
6259 {
6260 long l = 1L << curChar;
6261 do
6262 {
6263 switch(jjstateSet[--i])
6264 {
6265 case 0:
6266 if (curChar == 35)
6267 jjAddStates(0, 2);
6268 else if (curChar == 36)
6269 {
6270 if (kind > 19)
6271 kind = 19;
6272 jjCheckNAddTwoStates(7, 8);
6273 }
6274 else if (curChar == 46)
6275 jjstateSet[jjnewStateCnt++] = 1;
6276 break;
6277 case 15:
6278 if (curChar == 42)
6279 jjstateSet[jjnewStateCnt++] = 21;
6280 break;
6281 case 4:
6282 if (curChar == 36 && kind > 19)
6283 kind = 19;
6284 break;
6285 case 6:
6286 if (curChar == 36)
6287 jjCheckNAddTwoStates(7, 8);
6288 break;
6289 case 8:
6290 if (curChar == 33 && kind > 20)
6291 kind = 20;
6292 break;
6293 case 9:
6294 if (curChar != 36)
6295 break;
6296 if (kind > 19)
6297 kind = 19;
6298 jjCheckNAddTwoStates(7, 8);
6299 break;
6300 case 10:
6301 if (curChar == 35)
6302 jjAddStates(0, 2);
6303 break;
6304 case 12:
6305 if ((0x100000200L & l) != 0L)
6306 jjAddStates(3, 4);
6307 break;
6308 case 13:
6309 if (curChar == 40 && kind > 18)
6310 kind = 18;
6311 break;
6312 case 21:
6313 if (curChar == 42)
6314 jjstateSet[jjnewStateCnt++] = 22;
6315 break;
6316 case 22:
6317 if ((0xfffffff7efffffffL & l) != 0L && kind > 22)
6318 kind = 22;
6319 break;
6320 default : break;
6321 }
6322 } while(i != startsAt);
6323 }
6324 else if (curChar < 128)
6325 {
6326 long l = 1L << (curChar & 077);
6327 do
6328 {
6329 switch(jjstateSet[--i])
6330 {
6331 case 0:
6332 if (curChar == 92)
6333 jjCheckNAddStates(5, 8);
6334 break;
6335 case 15:
6336 if (curChar == 123)
6337 jjstateSet[jjnewStateCnt++] = 19;
6338 else if (curChar == 115)
6339 jjstateSet[jjnewStateCnt++] = 14;
6340 break;
6341 case 1:
6342 if ((0x7fffffe87fffffeL & l) != 0L && kind > 71)
6343 kind = 71;
6344 break;
6345 case 3:
6346 if (curChar == 92)
6347 jjCheckNAddTwoStates(3, 4);
6348 break;
6349 case 5:
6350 if (curChar == 92)
6351 jjCheckNAddTwoStates(5, 6);
6352 break;
6353 case 7:
6354 if (curChar == 92)
6355 jjAddStates(9, 10);
6356 break;
6357 case 11:
6358 if (curChar == 116)
6359 jjCheckNAddTwoStates(12, 13);
6360 break;
6361 case 14:
6362 if (curChar == 101)
6363 jjstateSet[jjnewStateCnt++] = 11;
6364 break;
6365 case 16:
6366 if (curChar == 125)
6367 jjCheckNAddTwoStates(12, 13);
6368 break;
6369 case 17:
6370 if (curChar == 116)
6371 jjstateSet[jjnewStateCnt++] = 16;
6372 break;
6373 case 18:
6374 if (curChar == 101)
6375 jjstateSet[jjnewStateCnt++] = 17;
6376 break;
6377 case 19:
6378 if (curChar == 115)
6379 jjstateSet[jjnewStateCnt++] = 18;
6380 break;
6381 case 20:
6382 if (curChar == 123)
6383 jjstateSet[jjnewStateCnt++] = 19;
6384 break;
6385 case 22:
6386 if (kind > 22)
6387 kind = 22;
6388 break;
6389 default : break;
6390 }
6391 } while(i != startsAt);
6392 }
6393 else
6394 {
6395 int hiByte = (int)(curChar >> 8);
6396 int i1 = hiByte >> 6;
6397 long l1 = 1L << (hiByte & 077);
6398 int i2 = (curChar & 0xff) >> 6;
6399 long l2 = 1L << (curChar & 077);
6400 do
6401 {
6402 switch(jjstateSet[--i])
6403 {
6404 case 22:
6405 if (jjCanMove_0(hiByte, i1, i2, l1, l2) && kind > 22)
6406 kind = 22;
6407 break;
6408 default : break;
6409 }
6410 } while(i != startsAt);
6411 }
6412 if (kind != 0x7fffffff)
6413 {
6414 jjmatchedKind = kind;
6415 jjmatchedPos = curPos;
6416 kind = 0x7fffffff;
6417 }
6418 ++curPos;
6419 if ((i = jjnewStateCnt) == (startsAt = 24 - (jjnewStateCnt = startsAt)))
6420 return curPos;
6421 try { curChar = input_stream.readChar(); }
6422 catch(java.io.IOException e) { return curPos; }
6423 }
6424 }
jjStopStringLiteralDfa_9(int pos, long active0)6425 private final int jjStopStringLiteralDfa_9(int pos, long active0)
6426 {
6427 switch (pos)
6428 {
6429 case 0:
6430 if ((active0 & 0x4000000000L) != 0L)
6431 return 96;
6432 if ((active0 & 0x3000000000L) != 0L)
6433 {
6434 jjmatchedKind = 67;
6435 return 53;
6436 }
6437 if ((active0 & 0x10000000000000L) != 0L)
6438 return 45;
6439 if ((active0 & 0x400L) != 0L)
6440 return 107;
6441 if ((active0 & 0x3a00000L) != 0L)
6442 return 67;
6443 return -1;
6444 case 1:
6445 if ((active0 & 0x800000L) != 0L)
6446 return 73;
6447 if ((active0 & 0x3000000000L) != 0L)
6448 {
6449 jjmatchedKind = 67;
6450 jjmatchedPos = 1;
6451 return 53;
6452 }
6453 return -1;
6454 case 2:
6455 if ((active0 & 0x3000000000L) != 0L)
6456 {
6457 jjmatchedKind = 67;
6458 jjmatchedPos = 2;
6459 return 53;
6460 }
6461 return -1;
6462 case 3:
6463 if ((active0 & 0x1000000000L) != 0L)
6464 return 53;
6465 if ((active0 & 0x2000000000L) != 0L)
6466 {
6467 jjmatchedKind = 67;
6468 jjmatchedPos = 3;
6469 return 53;
6470 }
6471 return -1;
6472 default :
6473 return -1;
6474 }
6475 }
jjStartNfa_9(int pos, long active0)6476 private final int jjStartNfa_9(int pos, long active0)
6477 {
6478 return jjMoveNfa_9(jjStopStringLiteralDfa_9(pos, active0), pos + 1);
6479 }
jjMoveStringLiteralDfa0_9()6480 private int jjMoveStringLiteralDfa0_9()
6481 {
6482 switch(curChar)
6483 {
6484 case 28:
6485 return jjStopAtPos(0, 2);
6486 case 35:
6487 jjmatchedKind = 24;
6488 return jjMoveStringLiteralDfa1_9(0x2a00000L);
6489 case 37:
6490 return jjStopAtPos(0, 42);
6491 case 41:
6492 return jjStopAtPos(0, 16);
6493 case 42:
6494 return jjStopAtPos(0, 40);
6495 case 43:
6496 return jjStopAtPos(0, 39);
6497 case 44:
6498 return jjStopAtPos(0, 9);
6499 case 45:
6500 return jjStartNfaWithStates_9(0, 38, 96);
6501 case 46:
6502 return jjMoveStringLiteralDfa1_9(0x400L);
6503 case 47:
6504 return jjStopAtPos(0, 41);
6505 case 58:
6506 return jjStopAtPos(0, 11);
6507 case 61:
6508 return jjStartNfaWithStates_9(0, 52, 45);
6509 case 91:
6510 return jjStopAtPos(0, 7);
6511 case 93:
6512 return jjStopAtPos(0, 8);
6513 case 102:
6514 return jjMoveStringLiteralDfa1_9(0x2000000000L);
6515 case 116:
6516 return jjMoveStringLiteralDfa1_9(0x1000000000L);
6517 case 123:
6518 return jjStopAtPos(0, 12);
6519 case 125:
6520 return jjStopAtPos(0, 13);
6521 default :
6522 return jjMoveNfa_9(1, 0);
6523 }
6524 }
jjMoveStringLiteralDfa1_9(long active0)6525 private int jjMoveStringLiteralDfa1_9(long active0)
6526 {
6527 try { curChar = input_stream.readChar(); }
6528 catch(java.io.IOException e) {
6529 jjStopStringLiteralDfa_9(0, active0);
6530 return 1;
6531 }
6532 switch(curChar)
6533 {
6534 case 35:
6535 if ((active0 & 0x2000000L) != 0L)
6536 return jjStopAtPos(1, 25);
6537 break;
6538 case 42:
6539 if ((active0 & 0x800000L) != 0L)
6540 return jjStartNfaWithStates_9(1, 23, 73);
6541 break;
6542 case 46:
6543 if ((active0 & 0x400L) != 0L)
6544 return jjStopAtPos(1, 10);
6545 break;
6546 case 91:
6547 return jjMoveStringLiteralDfa2_9(active0, 0x200000L);
6548 case 97:
6549 return jjMoveStringLiteralDfa2_9(active0, 0x2000000000L);
6550 case 114:
6551 return jjMoveStringLiteralDfa2_9(active0, 0x1000000000L);
6552 default :
6553 break;
6554 }
6555 return jjStartNfa_9(0, active0);
6556 }
jjMoveStringLiteralDfa2_9(long old0, long active0)6557 private int jjMoveStringLiteralDfa2_9(long old0, long active0)
6558 {
6559 if (((active0 &= old0)) == 0L)
6560 return jjStartNfa_9(0, old0);
6561 try { curChar = input_stream.readChar(); }
6562 catch(java.io.IOException e) {
6563 jjStopStringLiteralDfa_9(1, active0);
6564 return 2;
6565 }
6566 switch(curChar)
6567 {
6568 case 91:
6569 if ((active0 & 0x200000L) != 0L)
6570 return jjStopAtPos(2, 21);
6571 break;
6572 case 108:
6573 return jjMoveStringLiteralDfa3_9(active0, 0x2000000000L);
6574 case 117:
6575 return jjMoveStringLiteralDfa3_9(active0, 0x1000000000L);
6576 default :
6577 break;
6578 }
6579 return jjStartNfa_9(1, active0);
6580 }
jjMoveStringLiteralDfa3_9(long old0, long active0)6581 private int jjMoveStringLiteralDfa3_9(long old0, long active0)
6582 {
6583 if (((active0 &= old0)) == 0L)
6584 return jjStartNfa_9(1, old0);
6585 try { curChar = input_stream.readChar(); }
6586 catch(java.io.IOException e) {
6587 jjStopStringLiteralDfa_9(2, active0);
6588 return 3;
6589 }
6590 switch(curChar)
6591 {
6592 case 101:
6593 if ((active0 & 0x1000000000L) != 0L)
6594 return jjStartNfaWithStates_9(3, 36, 53);
6595 break;
6596 case 115:
6597 return jjMoveStringLiteralDfa4_9(active0, 0x2000000000L);
6598 default :
6599 break;
6600 }
6601 return jjStartNfa_9(2, active0);
6602 }
jjMoveStringLiteralDfa4_9(long old0, long active0)6603 private int jjMoveStringLiteralDfa4_9(long old0, long active0)
6604 {
6605 if (((active0 &= old0)) == 0L)
6606 return jjStartNfa_9(2, old0);
6607 try { curChar = input_stream.readChar(); }
6608 catch(java.io.IOException e) {
6609 jjStopStringLiteralDfa_9(3, active0);
6610 return 4;
6611 }
6612 switch(curChar)
6613 {
6614 case 101:
6615 if ((active0 & 0x2000000000L) != 0L)
6616 return jjStartNfaWithStates_9(4, 37, 53);
6617 break;
6618 default :
6619 break;
6620 }
6621 return jjStartNfa_9(3, active0);
6622 }
jjStartNfaWithStates_9(int pos, int kind, int state)6623 private int jjStartNfaWithStates_9(int pos, int kind, int state)
6624 {
6625 jjmatchedKind = kind;
6626 jjmatchedPos = pos;
6627 try { curChar = input_stream.readChar(); }
6628 catch(java.io.IOException e) { return pos + 1; }
6629 return jjMoveNfa_9(state, pos + 1);
6630 }
jjMoveNfa_9(int startState, int curPos)6631 private int jjMoveNfa_9(int startState, int curPos)
6632 {
6633 int startsAt = 0;
6634 jjnewStateCnt = 108;
6635 int i = 1;
6636 jjstateSet[0] = startState;
6637 int kind = 0x7fffffff;
6638 for (;;)
6639 {
6640 if (++jjround == 0x7fffffff)
6641 ReInitRounds();
6642 if (curChar < 64)
6643 {
6644 long l = 1L << curChar;
6645 do
6646 {
6647 switch(jjstateSet[--i])
6648 {
6649 case 96:
6650 if ((0x3ff000000000000L & l) != 0L)
6651 jjCheckNAddTwoStates(101, 102);
6652 else if (curChar == 46)
6653 jjCheckNAdd(97);
6654 if ((0x3ff000000000000L & l) != 0L)
6655 jjCheckNAddTwoStates(90, 91);
6656 if ((0x3ff000000000000L & l) != 0L)
6657 {
6658 if (kind > 58)
6659 kind = 58;
6660 jjCheckNAddTwoStates(87, 89);
6661 }
6662 break;
6663 case 1:
6664 if ((0x3ff000000000000L & l) != 0L)
6665 {
6666 if (kind > 58)
6667 kind = 58;
6668 jjCheckNAddStates(191, 196);
6669 }
6670 else if ((0x2400L & l) != 0L)
6671 {
6672 if (kind > 33)
6673 kind = 33;
6674 }
6675 else if ((0x100000200L & l) != 0L)
6676 {
6677 if (kind > 32)
6678 kind = 32;
6679 jjCheckNAdd(0);
6680 }
6681 else if (curChar == 46)
6682 jjCheckNAddTwoStates(97, 107);
6683 else if (curChar == 45)
6684 jjCheckNAddStates(197, 200);
6685 else if (curChar == 35)
6686 jjAddStates(201, 203);
6687 else if (curChar == 36)
6688 {
6689 if (kind > 19)
6690 kind = 19;
6691 jjCheckNAddTwoStates(59, 60);
6692 }
6693 else if (curChar == 33)
6694 {
6695 if (kind > 51)
6696 kind = 51;
6697 }
6698 else if (curChar == 61)
6699 jjstateSet[jjnewStateCnt++] = 45;
6700 else if (curChar == 62)
6701 jjstateSet[jjnewStateCnt++] = 43;
6702 else if (curChar == 60)
6703 jjstateSet[jjnewStateCnt++] = 40;
6704 else if (curChar == 38)
6705 jjstateSet[jjnewStateCnt++] = 30;
6706 else if (curChar == 39)
6707 jjCheckNAddStates(204, 207);
6708 else if (curChar == 34)
6709 jjCheckNAddStates(208, 211);
6710 if (curChar == 33)
6711 jjstateSet[jjnewStateCnt++] = 49;
6712 else if (curChar == 62)
6713 {
6714 if (kind > 47)
6715 kind = 47;
6716 }
6717 else if (curChar == 60)
6718 {
6719 if (kind > 45)
6720 kind = 45;
6721 }
6722 else if (curChar == 13)
6723 jjstateSet[jjnewStateCnt++] = 2;
6724 break;
6725 case 107:
6726 case 97:
6727 if ((0x3ff000000000000L & l) == 0L)
6728 break;
6729 if (kind > 59)
6730 kind = 59;
6731 jjCheckNAddTwoStates(97, 98);
6732 break;
6733 case 67:
6734 if (curChar == 42)
6735 jjstateSet[jjnewStateCnt++] = 73;
6736 break;
6737 case 0:
6738 if ((0x100000200L & l) == 0L)
6739 break;
6740 if (kind > 32)
6741 kind = 32;
6742 jjCheckNAdd(0);
6743 break;
6744 case 2:
6745 if (curChar == 10 && kind > 33)
6746 kind = 33;
6747 break;
6748 case 3:
6749 if (curChar == 13)
6750 jjstateSet[jjnewStateCnt++] = 2;
6751 break;
6752 case 4:
6753 case 6:
6754 if (curChar == 34)
6755 jjCheckNAddStates(208, 211);
6756 break;
6757 case 5:
6758 if ((0xfffffffbefffffffL & l) != 0L)
6759 jjCheckNAddStates(208, 211);
6760 break;
6761 case 7:
6762 if (curChar == 34)
6763 jjstateSet[jjnewStateCnt++] = 6;
6764 break;
6765 case 8:
6766 if (curChar == 34 && kind > 35)
6767 kind = 35;
6768 break;
6769 case 11:
6770 if ((0xff000000000000L & l) != 0L)
6771 jjCheckNAddStates(212, 216);
6772 break;
6773 case 12:
6774 if ((0xff000000000000L & l) != 0L)
6775 jjCheckNAddStates(208, 211);
6776 break;
6777 case 13:
6778 if ((0xf000000000000L & l) != 0L)
6779 jjstateSet[jjnewStateCnt++] = 14;
6780 break;
6781 case 14:
6782 if ((0xff000000000000L & l) != 0L)
6783 jjCheckNAdd(12);
6784 break;
6785 case 16:
6786 if ((0x3ff000000000000L & l) != 0L)
6787 jjstateSet[jjnewStateCnt++] = 17;
6788 break;
6789 case 17:
6790 if ((0x3ff000000000000L & l) != 0L)
6791 jjstateSet[jjnewStateCnt++] = 18;
6792 break;
6793 case 18:
6794 if ((0x3ff000000000000L & l) != 0L)
6795 jjstateSet[jjnewStateCnt++] = 19;
6796 break;
6797 case 19:
6798 if ((0x3ff000000000000L & l) != 0L)
6799 jjCheckNAddStates(208, 211);
6800 break;
6801 case 20:
6802 if (curChar == 32)
6803 jjAddStates(217, 218);
6804 break;
6805 case 21:
6806 if (curChar == 10)
6807 jjCheckNAddStates(208, 211);
6808 break;
6809 case 22:
6810 case 24:
6811 if (curChar == 39)
6812 jjCheckNAddStates(204, 207);
6813 break;
6814 case 23:
6815 if ((0xffffff7fefffffffL & l) != 0L)
6816 jjCheckNAddStates(204, 207);
6817 break;
6818 case 25:
6819 if (curChar == 39)
6820 jjstateSet[jjnewStateCnt++] = 24;
6821 break;
6822 case 27:
6823 if (curChar == 32)
6824 jjAddStates(219, 220);
6825 break;
6826 case 28:
6827 if (curChar == 10)
6828 jjCheckNAddStates(204, 207);
6829 break;
6830 case 29:
6831 if (curChar == 39 && kind > 35)
6832 kind = 35;
6833 break;
6834 case 30:
6835 if (curChar == 38 && kind > 43)
6836 kind = 43;
6837 break;
6838 case 31:
6839 if (curChar == 38)
6840 jjstateSet[jjnewStateCnt++] = 30;
6841 break;
6842 case 39:
6843 if (curChar == 60 && kind > 45)
6844 kind = 45;
6845 break;
6846 case 40:
6847 if (curChar == 61 && kind > 46)
6848 kind = 46;
6849 break;
6850 case 41:
6851 if (curChar == 60)
6852 jjstateSet[jjnewStateCnt++] = 40;
6853 break;
6854 case 42:
6855 if (curChar == 62 && kind > 47)
6856 kind = 47;
6857 break;
6858 case 43:
6859 if (curChar == 61 && kind > 48)
6860 kind = 48;
6861 break;
6862 case 44:
6863 if (curChar == 62)
6864 jjstateSet[jjnewStateCnt++] = 43;
6865 break;
6866 case 45:
6867 if (curChar == 61 && kind > 49)
6868 kind = 49;
6869 break;
6870 case 46:
6871 if (curChar == 61)
6872 jjstateSet[jjnewStateCnt++] = 45;
6873 break;
6874 case 49:
6875 if (curChar == 61 && kind > 50)
6876 kind = 50;
6877 break;
6878 case 50:
6879 if (curChar == 33)
6880 jjstateSet[jjnewStateCnt++] = 49;
6881 break;
6882 case 51:
6883 if (curChar == 33 && kind > 51)
6884 kind = 51;
6885 break;
6886 case 53:
6887 if ((0x3ff000000000000L & l) == 0L)
6888 break;
6889 if (kind > 67)
6890 kind = 67;
6891 jjstateSet[jjnewStateCnt++] = 53;
6892 break;
6893 case 56:
6894 if (curChar == 36 && kind > 19)
6895 kind = 19;
6896 break;
6897 case 58:
6898 if (curChar == 36)
6899 jjCheckNAddTwoStates(59, 60);
6900 break;
6901 case 60:
6902 if (curChar == 33 && kind > 20)
6903 kind = 20;
6904 break;
6905 case 61:
6906 if (curChar != 36)
6907 break;
6908 if (kind > 19)
6909 kind = 19;
6910 jjCheckNAddTwoStates(59, 60);
6911 break;
6912 case 62:
6913 if (curChar == 35)
6914 jjAddStates(201, 203);
6915 break;
6916 case 64:
6917 if ((0x100000200L & l) != 0L)
6918 jjAddStates(221, 222);
6919 break;
6920 case 65:
6921 if (curChar == 40 && kind > 18)
6922 kind = 18;
6923 break;
6924 case 73:
6925 if (curChar == 42)
6926 jjstateSet[jjnewStateCnt++] = 74;
6927 break;
6928 case 74:
6929 if ((0xfffffff7efffffffL & l) != 0L && kind > 22)
6930 kind = 22;
6931 break;
6932 case 86:
6933 if (curChar == 45)
6934 jjCheckNAddStates(197, 200);
6935 break;
6936 case 87:
6937 if ((0x3ff000000000000L & l) == 0L)
6938 break;
6939 if (kind > 58)
6940 kind = 58;
6941 jjCheckNAddTwoStates(87, 89);
6942 break;
6943 case 88:
6944 if (curChar == 46 && kind > 58)
6945 kind = 58;
6946 break;
6947 case 89:
6948 if (curChar == 46)
6949 jjstateSet[jjnewStateCnt++] = 88;
6950 break;
6951 case 90:
6952 if ((0x3ff000000000000L & l) != 0L)
6953 jjCheckNAddTwoStates(90, 91);
6954 break;
6955 case 91:
6956 if (curChar != 46)
6957 break;
6958 if (kind > 59)
6959 kind = 59;
6960 jjCheckNAddTwoStates(92, 93);
6961 break;
6962 case 92:
6963 if ((0x3ff000000000000L & l) == 0L)
6964 break;
6965 if (kind > 59)
6966 kind = 59;
6967 jjCheckNAddTwoStates(92, 93);
6968 break;
6969 case 94:
6970 if ((0x280000000000L & l) != 0L)
6971 jjCheckNAdd(95);
6972 break;
6973 case 95:
6974 if ((0x3ff000000000000L & l) == 0L)
6975 break;
6976 if (kind > 59)
6977 kind = 59;
6978 jjCheckNAdd(95);
6979 break;
6980 case 99:
6981 if ((0x280000000000L & l) != 0L)
6982 jjCheckNAdd(100);
6983 break;
6984 case 100:
6985 if ((0x3ff000000000000L & l) == 0L)
6986 break;
6987 if (kind > 59)
6988 kind = 59;
6989 jjCheckNAdd(100);
6990 break;
6991 case 101:
6992 if ((0x3ff000000000000L & l) != 0L)
6993 jjCheckNAddTwoStates(101, 102);
6994 break;
6995 case 103:
6996 if ((0x280000000000L & l) != 0L)
6997 jjCheckNAdd(104);
6998 break;
6999 case 104:
7000 if ((0x3ff000000000000L & l) == 0L)
7001 break;
7002 if (kind > 59)
7003 kind = 59;
7004 jjCheckNAdd(104);
7005 break;
7006 case 105:
7007 if ((0x3ff000000000000L & l) == 0L)
7008 break;
7009 if (kind > 58)
7010 kind = 58;
7011 jjCheckNAddStates(191, 196);
7012 break;
7013 case 106:
7014 if (curChar == 46)
7015 jjCheckNAddTwoStates(97, 107);
7016 break;
7017 default : break;
7018 }
7019 } while(i != startsAt);
7020 }
7021 else if (curChar < 128)
7022 {
7023 long l = 1L << (curChar & 077);
7024 do
7025 {
7026 switch(jjstateSet[--i])
7027 {
7028 case 1:
7029 if ((0x7fffffe87fffffeL & l) != 0L)
7030 {
7031 if (kind > 67)
7032 kind = 67;
7033 jjCheckNAdd(53);
7034 }
7035 else if (curChar == 92)
7036 jjCheckNAddStates(223, 226);
7037 else if (curChar == 124)
7038 jjstateSet[jjnewStateCnt++] = 35;
7039 if (curChar == 110)
7040 jjAddStates(227, 228);
7041 else if (curChar == 103)
7042 jjAddStates(229, 230);
7043 else if (curChar == 108)
7044 jjAddStates(231, 232);
7045 else if (curChar == 101)
7046 jjstateSet[jjnewStateCnt++] = 47;
7047 else if (curChar == 111)
7048 jjstateSet[jjnewStateCnt++] = 37;
7049 else if (curChar == 97)
7050 jjstateSet[jjnewStateCnt++] = 33;
7051 break;
7052 case 107:
7053 if ((0x7fffffe87fffffeL & l) != 0L && kind > 71)
7054 kind = 71;
7055 break;
7056 case 67:
7057 if (curChar == 123)
7058 jjstateSet[jjnewStateCnt++] = 71;
7059 else if (curChar == 115)
7060 jjstateSet[jjnewStateCnt++] = 66;
7061 break;
7062 case 5:
7063 jjCheckNAddStates(208, 211);
7064 break;
7065 case 9:
7066 if (curChar == 92)
7067 jjAddStates(233, 238);
7068 break;
7069 case 10:
7070 if ((0x14404400000000L & l) != 0L)
7071 jjCheckNAddStates(208, 211);
7072 break;
7073 case 15:
7074 if (curChar == 117)
7075 jjstateSet[jjnewStateCnt++] = 16;
7076 break;
7077 case 16:
7078 if ((0x7e0000007eL & l) != 0L)
7079 jjstateSet[jjnewStateCnt++] = 17;
7080 break;
7081 case 17:
7082 if ((0x7e0000007eL & l) != 0L)
7083 jjstateSet[jjnewStateCnt++] = 18;
7084 break;
7085 case 18:
7086 if ((0x7e0000007eL & l) != 0L)
7087 jjstateSet[jjnewStateCnt++] = 19;
7088 break;
7089 case 19:
7090 if ((0x7e0000007eL & l) != 0L)
7091 jjCheckNAddStates(208, 211);
7092 break;
7093 case 23:
7094 jjAddStates(204, 207);
7095 break;
7096 case 26:
7097 if (curChar == 92)
7098 jjAddStates(219, 220);
7099 break;
7100 case 32:
7101 if (curChar == 100 && kind > 43)
7102 kind = 43;
7103 break;
7104 case 33:
7105 if (curChar == 110)
7106 jjstateSet[jjnewStateCnt++] = 32;
7107 break;
7108 case 34:
7109 if (curChar == 97)
7110 jjstateSet[jjnewStateCnt++] = 33;
7111 break;
7112 case 35:
7113 if (curChar == 124 && kind > 44)
7114 kind = 44;
7115 break;
7116 case 36:
7117 if (curChar == 124)
7118 jjstateSet[jjnewStateCnt++] = 35;
7119 break;
7120 case 37:
7121 if (curChar == 114 && kind > 44)
7122 kind = 44;
7123 break;
7124 case 38:
7125 if (curChar == 111)
7126 jjstateSet[jjnewStateCnt++] = 37;
7127 break;
7128 case 47:
7129 if (curChar == 113 && kind > 49)
7130 kind = 49;
7131 break;
7132 case 48:
7133 if (curChar == 101)
7134 jjstateSet[jjnewStateCnt++] = 47;
7135 break;
7136 case 52:
7137 case 53:
7138 if ((0x7fffffe87fffffeL & l) == 0L)
7139 break;
7140 if (kind > 67)
7141 kind = 67;
7142 jjCheckNAdd(53);
7143 break;
7144 case 54:
7145 if (curChar == 92)
7146 jjCheckNAddStates(223, 226);
7147 break;
7148 case 55:
7149 if (curChar == 92)
7150 jjCheckNAddTwoStates(55, 56);
7151 break;
7152 case 57:
7153 if (curChar == 92)
7154 jjCheckNAddTwoStates(57, 58);
7155 break;
7156 case 59:
7157 if (curChar == 92)
7158 jjAddStates(88, 89);
7159 break;
7160 case 63:
7161 if (curChar == 116)
7162 jjCheckNAddTwoStates(64, 65);
7163 break;
7164 case 66:
7165 if (curChar == 101)
7166 jjstateSet[jjnewStateCnt++] = 63;
7167 break;
7168 case 68:
7169 if (curChar == 125)
7170 jjCheckNAddTwoStates(64, 65);
7171 break;
7172 case 69:
7173 if (curChar == 116)
7174 jjstateSet[jjnewStateCnt++] = 68;
7175 break;
7176 case 70:
7177 if (curChar == 101)
7178 jjstateSet[jjnewStateCnt++] = 69;
7179 break;
7180 case 71:
7181 if (curChar == 115)
7182 jjstateSet[jjnewStateCnt++] = 70;
7183 break;
7184 case 72:
7185 if (curChar == 123)
7186 jjstateSet[jjnewStateCnt++] = 71;
7187 break;
7188 case 74:
7189 if (kind > 22)
7190 kind = 22;
7191 break;
7192 case 76:
7193 if (curChar == 108)
7194 jjAddStates(231, 232);
7195 break;
7196 case 77:
7197 if (curChar == 116 && kind > 45)
7198 kind = 45;
7199 break;
7200 case 78:
7201 if (curChar == 101 && kind > 46)
7202 kind = 46;
7203 break;
7204 case 79:
7205 if (curChar == 103)
7206 jjAddStates(229, 230);
7207 break;
7208 case 80:
7209 if (curChar == 116 && kind > 47)
7210 kind = 47;
7211 break;
7212 case 81:
7213 if (curChar == 101 && kind > 48)
7214 kind = 48;
7215 break;
7216 case 82:
7217 if (curChar == 110)
7218 jjAddStates(227, 228);
7219 break;
7220 case 83:
7221 if (curChar == 101 && kind > 50)
7222 kind = 50;
7223 break;
7224 case 84:
7225 if (curChar == 116 && kind > 51)
7226 kind = 51;
7227 break;
7228 case 85:
7229 if (curChar == 111)
7230 jjstateSet[jjnewStateCnt++] = 84;
7231 break;
7232 case 93:
7233 if ((0x2000000020L & l) != 0L)
7234 jjAddStates(239, 240);
7235 break;
7236 case 98:
7237 if ((0x2000000020L & l) != 0L)
7238 jjAddStates(241, 242);
7239 break;
7240 case 102:
7241 if ((0x2000000020L & l) != 0L)
7242 jjAddStates(243, 244);
7243 break;
7244 default : break;
7245 }
7246 } while(i != startsAt);
7247 }
7248 else
7249 {
7250 int hiByte = (int)(curChar >> 8);
7251 int i1 = hiByte >> 6;
7252 long l1 = 1L << (hiByte & 077);
7253 int i2 = (curChar & 0xff) >> 6;
7254 long l2 = 1L << (curChar & 077);
7255 do
7256 {
7257 switch(jjstateSet[--i])
7258 {
7259 case 5:
7260 if (jjCanMove_0(hiByte, i1, i2, l1, l2))
7261 jjAddStates(208, 211);
7262 break;
7263 case 23:
7264 if (jjCanMove_0(hiByte, i1, i2, l1, l2))
7265 jjAddStates(204, 207);
7266 break;
7267 case 74:
7268 if (jjCanMove_0(hiByte, i1, i2, l1, l2) && kind > 22)
7269 kind = 22;
7270 break;
7271 default : break;
7272 }
7273 } while(i != startsAt);
7274 }
7275 if (kind != 0x7fffffff)
7276 {
7277 jjmatchedKind = kind;
7278 jjmatchedPos = curPos;
7279 kind = 0x7fffffff;
7280 }
7281 ++curPos;
7282 if ((i = jjnewStateCnt) == (startsAt = 108 - (jjnewStateCnt = startsAt)))
7283 return curPos;
7284 try { curChar = input_stream.readChar(); }
7285 catch(java.io.IOException e) { return curPos; }
7286 }
7287 }
jjStopStringLiteralDfa_11(int pos, long active0)7288 private final int jjStopStringLiteralDfa_11(int pos, long active0)
7289 {
7290 switch (pos)
7291 {
7292 case 0:
7293 if ((active0 & 0x1a00000L) != 0L)
7294 return 2;
7295 return -1;
7296 case 1:
7297 if ((active0 & 0x800000L) != 0L)
7298 return 0;
7299 return -1;
7300 default :
7301 return -1;
7302 }
7303 }
jjStartNfa_11(int pos, long active0)7304 private final int jjStartNfa_11(int pos, long active0)
7305 {
7306 return jjMoveNfa_11(jjStopStringLiteralDfa_11(pos, active0), pos + 1);
7307 }
jjMoveStringLiteralDfa0_11()7308 private int jjMoveStringLiteralDfa0_11()
7309 {
7310 switch(curChar)
7311 {
7312 case 28:
7313 return jjStopAtPos(0, 2);
7314 case 35:
7315 jjmatchedKind = 24;
7316 return jjMoveStringLiteralDfa1_11(0xa00000L);
7317 default :
7318 return jjMoveNfa_11(3, 0);
7319 }
7320 }
jjMoveStringLiteralDfa1_11(long active0)7321 private int jjMoveStringLiteralDfa1_11(long active0)
7322 {
7323 try { curChar = input_stream.readChar(); }
7324 catch(java.io.IOException e) {
7325 jjStopStringLiteralDfa_11(0, active0);
7326 return 1;
7327 }
7328 switch(curChar)
7329 {
7330 case 42:
7331 if ((active0 & 0x800000L) != 0L)
7332 return jjStartNfaWithStates_11(1, 23, 0);
7333 break;
7334 case 91:
7335 return jjMoveStringLiteralDfa2_11(active0, 0x200000L);
7336 default :
7337 break;
7338 }
7339 return jjStartNfa_11(0, active0);
7340 }
jjMoveStringLiteralDfa2_11(long old0, long active0)7341 private int jjMoveStringLiteralDfa2_11(long old0, long active0)
7342 {
7343 if (((active0 &= old0)) == 0L)
7344 return jjStartNfa_11(0, old0);
7345 try { curChar = input_stream.readChar(); }
7346 catch(java.io.IOException e) {
7347 jjStopStringLiteralDfa_11(1, active0);
7348 return 2;
7349 }
7350 switch(curChar)
7351 {
7352 case 91:
7353 if ((active0 & 0x200000L) != 0L)
7354 return jjStopAtPos(2, 21);
7355 break;
7356 default :
7357 break;
7358 }
7359 return jjStartNfa_11(1, active0);
7360 }
jjStartNfaWithStates_11(int pos, int kind, int state)7361 private int jjStartNfaWithStates_11(int pos, int kind, int state)
7362 {
7363 jjmatchedKind = kind;
7364 jjmatchedPos = pos;
7365 try { curChar = input_stream.readChar(); }
7366 catch(java.io.IOException e) { return pos + 1; }
7367 return jjMoveNfa_11(state, pos + 1);
7368 }
jjMoveNfa_11(int startState, int curPos)7369 private int jjMoveNfa_11(int startState, int curPos)
7370 {
7371 int startsAt = 0;
7372 jjnewStateCnt = 12;
7373 int i = 1;
7374 jjstateSet[0] = startState;
7375 int kind = 0x7fffffff;
7376 for (;;)
7377 {
7378 if (++jjround == 0x7fffffff)
7379 ReInitRounds();
7380 if (curChar < 64)
7381 {
7382 long l = 1L << curChar;
7383 do
7384 {
7385 switch(jjstateSet[--i])
7386 {
7387 case 3:
7388 if (curChar == 36)
7389 {
7390 if (kind > 19)
7391 kind = 19;
7392 jjCheckNAddTwoStates(9, 10);
7393 }
7394 else if (curChar == 35)
7395 jjstateSet[jjnewStateCnt++] = 2;
7396 break;
7397 case 0:
7398 if (curChar == 42)
7399 jjstateSet[jjnewStateCnt++] = 1;
7400 break;
7401 case 1:
7402 if ((0xfffffff7efffffffL & l) != 0L && kind > 22)
7403 kind = 22;
7404 break;
7405 case 2:
7406 if (curChar == 42)
7407 jjstateSet[jjnewStateCnt++] = 0;
7408 break;
7409 case 6:
7410 if (curChar == 36 && kind > 19)
7411 kind = 19;
7412 break;
7413 case 8:
7414 if (curChar == 36)
7415 jjCheckNAddTwoStates(9, 10);
7416 break;
7417 case 10:
7418 if (curChar == 33 && kind > 20)
7419 kind = 20;
7420 break;
7421 case 11:
7422 if (curChar != 36)
7423 break;
7424 if (kind > 19)
7425 kind = 19;
7426 jjCheckNAddTwoStates(9, 10);
7427 break;
7428 default : break;
7429 }
7430 } while(i != startsAt);
7431 }
7432 else if (curChar < 128)
7433 {
7434 long l = 1L << (curChar & 077);
7435 do
7436 {
7437 switch(jjstateSet[--i])
7438 {
7439 case 3:
7440 if (curChar == 92)
7441 jjCheckNAddStates(111, 114);
7442 break;
7443 case 1:
7444 if (kind > 22)
7445 kind = 22;
7446 break;
7447 case 5:
7448 if (curChar == 92)
7449 jjCheckNAddTwoStates(5, 6);
7450 break;
7451 case 7:
7452 if (curChar == 92)
7453 jjCheckNAddTwoStates(7, 8);
7454 break;
7455 case 9:
7456 if (curChar == 92)
7457 jjAddStates(115, 116);
7458 break;
7459 default : break;
7460 }
7461 } while(i != startsAt);
7462 }
7463 else
7464 {
7465 int hiByte = (int)(curChar >> 8);
7466 int i1 = hiByte >> 6;
7467 long l1 = 1L << (hiByte & 077);
7468 int i2 = (curChar & 0xff) >> 6;
7469 long l2 = 1L << (curChar & 077);
7470 do
7471 {
7472 switch(jjstateSet[--i])
7473 {
7474 case 1:
7475 if (jjCanMove_0(hiByte, i1, i2, l1, l2) && kind > 22)
7476 kind = 22;
7477 break;
7478 default : break;
7479 }
7480 } while(i != startsAt);
7481 }
7482 if (kind != 0x7fffffff)
7483 {
7484 jjmatchedKind = kind;
7485 jjmatchedPos = curPos;
7486 kind = 0x7fffffff;
7487 }
7488 ++curPos;
7489 if ((i = jjnewStateCnt) == (startsAt = 12 - (jjnewStateCnt = startsAt)))
7490 return curPos;
7491 try { curChar = input_stream.readChar(); }
7492 catch(java.io.IOException e) { return curPos; }
7493 }
7494 }
jjStopStringLiteralDfa_4(int pos, long active0, long active1)7495 private final int jjStopStringLiteralDfa_4(int pos, long active0, long active1)
7496 {
7497 switch (pos)
7498 {
7499 case 0:
7500 if ((active0 & 0x3000000000L) != 0L)
7501 {
7502 jjmatchedKind = 67;
7503 return 1;
7504 }
7505 if ((active0 & 0x3a00000L) != 0L)
7506 return 17;
7507 return -1;
7508 case 1:
7509 if ((active0 & 0x3000000000L) != 0L)
7510 {
7511 jjmatchedKind = 67;
7512 jjmatchedPos = 1;
7513 return 1;
7514 }
7515 if ((active0 & 0x800000L) != 0L)
7516 return 23;
7517 return -1;
7518 case 2:
7519 if ((active0 & 0x3000000000L) != 0L)
7520 {
7521 jjmatchedKind = 67;
7522 jjmatchedPos = 2;
7523 return 1;
7524 }
7525 return -1;
7526 case 3:
7527 if ((active0 & 0x2000000000L) != 0L)
7528 {
7529 jjmatchedKind = 67;
7530 jjmatchedPos = 3;
7531 return 1;
7532 }
7533 if ((active0 & 0x1000000000L) != 0L)
7534 return 1;
7535 return -1;
7536 default :
7537 return -1;
7538 }
7539 }
jjStartNfa_4(int pos, long active0, long active1)7540 private final int jjStartNfa_4(int pos, long active0, long active1)
7541 {
7542 return jjMoveNfa_4(jjStopStringLiteralDfa_4(pos, active0, active1), pos + 1);
7543 }
jjMoveStringLiteralDfa0_4()7544 private int jjMoveStringLiteralDfa0_4()
7545 {
7546 switch(curChar)
7547 {
7548 case 28:
7549 return jjStopAtPos(0, 2);
7550 case 35:
7551 jjmatchedKind = 24;
7552 return jjMoveStringLiteralDfa1_4(0x2a00000L);
7553 case 40:
7554 return jjStopAtPos(0, 14);
7555 case 91:
7556 return jjStopAtPos(0, 3);
7557 case 102:
7558 return jjMoveStringLiteralDfa1_4(0x2000000000L);
7559 case 116:
7560 return jjMoveStringLiteralDfa1_4(0x1000000000L);
7561 case 123:
7562 return jjStopAtPos(0, 72);
7563 case 124:
7564 jjmatchedKind = 5;
7565 return jjMoveStringLiteralDfa1_4(0x10L);
7566 case 125:
7567 return jjStopAtPos(0, 73);
7568 default :
7569 return jjMoveNfa_4(0, 0);
7570 }
7571 }
jjMoveStringLiteralDfa1_4(long active0)7572 private int jjMoveStringLiteralDfa1_4(long active0)
7573 {
7574 try { curChar = input_stream.readChar(); }
7575 catch(java.io.IOException e) {
7576 jjStopStringLiteralDfa_4(0, active0, 0L);
7577 return 1;
7578 }
7579 switch(curChar)
7580 {
7581 case 35:
7582 if ((active0 & 0x2000000L) != 0L)
7583 return jjStopAtPos(1, 25);
7584 break;
7585 case 42:
7586 if ((active0 & 0x800000L) != 0L)
7587 return jjStartNfaWithStates_4(1, 23, 23);
7588 break;
7589 case 91:
7590 return jjMoveStringLiteralDfa2_4(active0, 0x200000L);
7591 case 97:
7592 return jjMoveStringLiteralDfa2_4(active0, 0x2000000000L);
7593 case 114:
7594 return jjMoveStringLiteralDfa2_4(active0, 0x1000000000L);
7595 case 124:
7596 if ((active0 & 0x10L) != 0L)
7597 return jjStopAtPos(1, 4);
7598 break;
7599 default :
7600 break;
7601 }
7602 return jjStartNfa_4(0, active0, 0L);
7603 }
jjMoveStringLiteralDfa2_4(long old0, long active0)7604 private int jjMoveStringLiteralDfa2_4(long old0, long active0)
7605 {
7606 if (((active0 &= old0)) == 0L)
7607 return jjStartNfa_4(0, old0, 0L);
7608 try { curChar = input_stream.readChar(); }
7609 catch(java.io.IOException e) {
7610 jjStopStringLiteralDfa_4(1, active0, 0L);
7611 return 2;
7612 }
7613 switch(curChar)
7614 {
7615 case 91:
7616 if ((active0 & 0x200000L) != 0L)
7617 return jjStopAtPos(2, 21);
7618 break;
7619 case 108:
7620 return jjMoveStringLiteralDfa3_4(active0, 0x2000000000L);
7621 case 117:
7622 return jjMoveStringLiteralDfa3_4(active0, 0x1000000000L);
7623 default :
7624 break;
7625 }
7626 return jjStartNfa_4(1, active0, 0L);
7627 }
jjMoveStringLiteralDfa3_4(long old0, long active0)7628 private int jjMoveStringLiteralDfa3_4(long old0, long active0)
7629 {
7630 if (((active0 &= old0)) == 0L)
7631 return jjStartNfa_4(1, old0, 0L);
7632 try { curChar = input_stream.readChar(); }
7633 catch(java.io.IOException e) {
7634 jjStopStringLiteralDfa_4(2, active0, 0L);
7635 return 3;
7636 }
7637 switch(curChar)
7638 {
7639 case 101:
7640 if ((active0 & 0x1000000000L) != 0L)
7641 return jjStartNfaWithStates_4(3, 36, 1);
7642 break;
7643 case 115:
7644 return jjMoveStringLiteralDfa4_4(active0, 0x2000000000L);
7645 default :
7646 break;
7647 }
7648 return jjStartNfa_4(2, active0, 0L);
7649 }
jjMoveStringLiteralDfa4_4(long old0, long active0)7650 private int jjMoveStringLiteralDfa4_4(long old0, long active0)
7651 {
7652 if (((active0 &= old0)) == 0L)
7653 return jjStartNfa_4(2, old0, 0L);
7654 try { curChar = input_stream.readChar(); }
7655 catch(java.io.IOException e) {
7656 jjStopStringLiteralDfa_4(3, active0, 0L);
7657 return 4;
7658 }
7659 switch(curChar)
7660 {
7661 case 101:
7662 if ((active0 & 0x2000000000L) != 0L)
7663 return jjStartNfaWithStates_4(4, 37, 1);
7664 break;
7665 default :
7666 break;
7667 }
7668 return jjStartNfa_4(3, active0, 0L);
7669 }
jjStartNfaWithStates_4(int pos, int kind, int state)7670 private int jjStartNfaWithStates_4(int pos, int kind, int state)
7671 {
7672 jjmatchedKind = kind;
7673 jjmatchedPos = pos;
7674 try { curChar = input_stream.readChar(); }
7675 catch(java.io.IOException e) { return pos + 1; }
7676 return jjMoveNfa_4(state, pos + 1);
7677 }
jjMoveNfa_4(int startState, int curPos)7678 private int jjMoveNfa_4(int startState, int curPos)
7679 {
7680 int startsAt = 0;
7681 jjnewStateCnt = 26;
7682 int i = 1;
7683 jjstateSet[0] = startState;
7684 int kind = 0x7fffffff;
7685 for (;;)
7686 {
7687 if (++jjround == 0x7fffffff)
7688 ReInitRounds();
7689 if (curChar < 64)
7690 {
7691 long l = 1L << curChar;
7692 do
7693 {
7694 switch(jjstateSet[--i])
7695 {
7696 case 0:
7697 if (curChar == 35)
7698 jjAddStates(106, 108);
7699 else if (curChar == 36)
7700 {
7701 if (kind > 19)
7702 kind = 19;
7703 jjCheckNAddTwoStates(9, 10);
7704 }
7705 else if (curChar == 46)
7706 jjstateSet[jjnewStateCnt++] = 3;
7707 break;
7708 case 17:
7709 if (curChar == 42)
7710 jjstateSet[jjnewStateCnt++] = 23;
7711 break;
7712 case 1:
7713 if ((0x3ff000000000000L & l) == 0L)
7714 break;
7715 if (kind > 67)
7716 kind = 67;
7717 jjstateSet[jjnewStateCnt++] = 1;
7718 break;
7719 case 2:
7720 if (curChar == 46)
7721 jjstateSet[jjnewStateCnt++] = 3;
7722 break;
7723 case 6:
7724 if (curChar == 36 && kind > 19)
7725 kind = 19;
7726 break;
7727 case 8:
7728 if (curChar == 36)
7729 jjCheckNAddTwoStates(9, 10);
7730 break;
7731 case 10:
7732 if (curChar == 33 && kind > 20)
7733 kind = 20;
7734 break;
7735 case 11:
7736 if (curChar != 36)
7737 break;
7738 if (kind > 19)
7739 kind = 19;
7740 jjCheckNAddTwoStates(9, 10);
7741 break;
7742 case 12:
7743 if (curChar == 35)
7744 jjAddStates(106, 108);
7745 break;
7746 case 14:
7747 if ((0x100000200L & l) != 0L)
7748 jjAddStates(109, 110);
7749 break;
7750 case 15:
7751 if (curChar == 40 && kind > 18)
7752 kind = 18;
7753 break;
7754 case 23:
7755 if (curChar == 42)
7756 jjstateSet[jjnewStateCnt++] = 24;
7757 break;
7758 case 24:
7759 if ((0xfffffff7efffffffL & l) != 0L && kind > 22)
7760 kind = 22;
7761 break;
7762 default : break;
7763 }
7764 } while(i != startsAt);
7765 }
7766 else if (curChar < 128)
7767 {
7768 long l = 1L << (curChar & 077);
7769 do
7770 {
7771 switch(jjstateSet[--i])
7772 {
7773 case 0:
7774 if ((0x7fffffe87fffffeL & l) != 0L)
7775 {
7776 if (kind > 67)
7777 kind = 67;
7778 jjCheckNAdd(1);
7779 }
7780 else if (curChar == 92)
7781 jjCheckNAddStates(111, 114);
7782 break;
7783 case 17:
7784 if (curChar == 123)
7785 jjstateSet[jjnewStateCnt++] = 21;
7786 else if (curChar == 115)
7787 jjstateSet[jjnewStateCnt++] = 16;
7788 break;
7789 case 1:
7790 if ((0x7fffffe87fffffeL & l) == 0L)
7791 break;
7792 if (kind > 67)
7793 kind = 67;
7794 jjCheckNAdd(1);
7795 break;
7796 case 3:
7797 if ((0x7fffffe87fffffeL & l) != 0L && kind > 71)
7798 kind = 71;
7799 break;
7800 case 4:
7801 if (curChar == 92)
7802 jjCheckNAddStates(111, 114);
7803 break;
7804 case 5:
7805 if (curChar == 92)
7806 jjCheckNAddTwoStates(5, 6);
7807 break;
7808 case 7:
7809 if (curChar == 92)
7810 jjCheckNAddTwoStates(7, 8);
7811 break;
7812 case 9:
7813 if (curChar == 92)
7814 jjAddStates(115, 116);
7815 break;
7816 case 13:
7817 if (curChar == 116)
7818 jjCheckNAddTwoStates(14, 15);
7819 break;
7820 case 16:
7821 if (curChar == 101)
7822 jjstateSet[jjnewStateCnt++] = 13;
7823 break;
7824 case 18:
7825 if (curChar == 125)
7826 jjCheckNAddTwoStates(14, 15);
7827 break;
7828 case 19:
7829 if (curChar == 116)
7830 jjstateSet[jjnewStateCnt++] = 18;
7831 break;
7832 case 20:
7833 if (curChar == 101)
7834 jjstateSet[jjnewStateCnt++] = 19;
7835 break;
7836 case 21:
7837 if (curChar == 115)
7838 jjstateSet[jjnewStateCnt++] = 20;
7839 break;
7840 case 22:
7841 if (curChar == 123)
7842 jjstateSet[jjnewStateCnt++] = 21;
7843 break;
7844 case 24:
7845 if (kind > 22)
7846 kind = 22;
7847 break;
7848 default : break;
7849 }
7850 } while(i != startsAt);
7851 }
7852 else
7853 {
7854 int hiByte = (int)(curChar >> 8);
7855 int i1 = hiByte >> 6;
7856 long l1 = 1L << (hiByte & 077);
7857 int i2 = (curChar & 0xff) >> 6;
7858 long l2 = 1L << (curChar & 077);
7859 do
7860 {
7861 switch(jjstateSet[--i])
7862 {
7863 case 24:
7864 if (jjCanMove_0(hiByte, i1, i2, l1, l2) && kind > 22)
7865 kind = 22;
7866 break;
7867 default : break;
7868 }
7869 } while(i != startsAt);
7870 }
7871 if (kind != 0x7fffffff)
7872 {
7873 jjmatchedKind = kind;
7874 jjmatchedPos = curPos;
7875 kind = 0x7fffffff;
7876 }
7877 ++curPos;
7878 if ((i = jjnewStateCnt) == (startsAt = 26 - (jjnewStateCnt = startsAt)))
7879 return curPos;
7880 try { curChar = input_stream.readChar(); }
7881 catch(java.io.IOException e) { return curPos; }
7882 }
7883 }
7884 static final int[] jjnextStates = {
7885 15, 20, 23, 12, 13, 3, 4, 5, 6, 7, 8, 61, 63, 64, 65, 70,
7886 71, 4, 5, 7, 61, 64, 10, 70, 19, 20, 44, 47, 54, 59, 22, 23,
7887 24, 25, 31, 36, 39, 13, 14, 26, 27, 68, 69, 72, 73, 80, 82, 83,
7888 84, 89, 90, 80, 83, 56, 89, 27, 29, 30, 33, 9, 11, 12, 13, 9,
7889 16, 11, 12, 13, 24, 25, 31, 32, 76, 78, 73, 74, 70, 71, 62, 63,
7890 64, 65, 14, 15, 17, 19, 24, 25, 59, 60, 66, 67, 87, 88, 91, 92,
7891 6, 7, 8, 9, 10, 11, 8, 9, 10, 11, 17, 22, 25, 14, 15, 5,
7892 6, 7, 8, 9, 10, 86, 88, 89, 90, 95, 96, 86, 89, 56, 95, 65,
7893 66, 68, 69, 70, 71, 82, 84, 79, 80, 76, 77, 93, 94, 97, 98, 0,
7894 1, 3, 25, 30, 33, 7, 8, 10, 11, 22, 23, 13, 14, 15, 16, 17,
7895 18, 20, 22, 49, 4, 50, 39, 44, 47, 4, 5, 6, 10, 12, 13, 15,
7896 16, 5, 6, 10, 7, 6, 9, 36, 37, 18, 19, 27, 28, 29, 30, 87,
7897 89, 90, 91, 101, 102, 87, 90, 96, 101, 67, 72, 75, 23, 25, 26, 29,
7898 5, 7, 8, 9, 5, 12, 7, 8, 9, 20, 21, 27, 28, 64, 65, 55,
7899 56, 57, 58, 83, 85, 80, 81, 77, 78, 10, 11, 13, 15, 20, 21, 94,
7900 95, 99, 100, 103, 104,
7901 };
jjCanMove_0(int hiByte, int i1, int i2, long l1, long l2)7902 private static final boolean jjCanMove_0(int hiByte, int i1, int i2, long l1, long l2)
7903 {
7904 switch(hiByte)
7905 {
7906 case 0:
7907 return ((jjbitVec2[i2] & l2) != 0L);
7908 default :
7909 if ((jjbitVec0[i1] & l1) != 0L)
7910 return true;
7911 return false;
7912 }
7913 }
7914
7915 /** Token literal values. */
7916 public static final String[] jjstrLiteralImages = {
7917 null, null, null, null, null, null, null, null, null, null, null, null, null,
7918 null, null, null, null, null, null, null, null, null, null, null, null, null, null,
7919 null, null, null, null, null, null, null, null, null, null, null, null, null, null,
7920 null, null, null, null, null, null, null, null, null, null, null, null, null, null,
7921 null, null, null, null, null, null, null, null, null, null, null, null, null, null,
7922 null, null, null, null, null, null, null, null, null, null, null, null, };
7923
7924 /** Lexer state names. */
7925 public static final String[] lexStateNames = {
7926 "PRE_DIRECTIVE",
7927 "PRE_REFERENCE",
7928 "PRE_OLD_REFERENCE",
7929 "REFERENCE",
7930 "REFMODIFIER",
7931 "OLD_REFMODIFIER",
7932 "REFMOD3",
7933 "REFINDEX",
7934 "DIRECTIVE",
7935 "REFMOD2",
7936 "DEFAULT",
7937 "REFMOD",
7938 "IN_TEXTBLOCK",
7939 "IN_MULTILINE_COMMENT",
7940 "IN_FORMAL_COMMENT",
7941 "IN_SINGLE_LINE_COMMENT",
7942 "ALT_VAL",
7943 "IN_MULTI_LINE_COMMENT",
7944 };
7945
7946 /** Lex State array. */
7947 public static final int[] jjnewLexState = {
7948 -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,
7949 -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,
7950 -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,
7951 -1, -1, -1, -1, -1, -1,
7952 };
7953 static final long[] jjtoToken = {
7954 0x8dffffff3e07ffffL, 0x1f3c9L,
7955 };
7956 static final long[] jjtoSkip = {
7957 0x40000000L, 0xc00L,
7958 };
7959 static final long[] jjtoSpecial = {
7960 0x0L, 0xc00L,
7961 };
7962 static final long[] jjtoMore = {
7963 0x81f80000L, 0x0L,
7964 };
7965 protected CharStream input_stream;
7966 private final int[] jjrounds = new int[108];
7967 private final int[] jjstateSet = new int[216];
7968 private final StringBuilder jjimage = new StringBuilder();
7969 private StringBuilder image = jjimage;
7970 private int jjimageLen;
7971 private int lengthOfMatch;
7972 protected char curChar;
7973
7974 /** Constructor with parser. */
StandardParserTokenManager(StandardParser parserArg, CharStream stream)7975 public StandardParserTokenManager(StandardParser parserArg, CharStream stream){
7976 parser = parserArg;
7977 input_stream = stream;
7978 }
7979
7980 /** Constructor with parser. */
StandardParserTokenManager(StandardParser parserArg, CharStream stream, int lexState)7981 public StandardParserTokenManager(StandardParser parserArg, CharStream stream, int lexState){
7982 this(parserArg, stream);
7983 SwitchTo(lexState);
7984 }
7985
7986 /** Reinitialise parser. */
ReInit(CharStream stream)7987 public void ReInit(CharStream stream)
7988 {
7989 jjmatchedPos = jjnewStateCnt = 0;
7990 curLexState = defaultLexState;
7991 input_stream = stream;
7992 ReInitRounds();
7993 }
ReInitRounds()7994 private void ReInitRounds()
7995 {
7996 int i;
7997 jjround = 0x80000001;
7998 for (i = 108; i-- > 0;)
7999 jjrounds[i] = 0x80000000;
8000 }
8001
8002 /** Reinitialise parser. */
ReInit(CharStream stream, int lexState)8003 public void ReInit(CharStream stream, int lexState)
8004 {
8005 ReInit(stream);
8006 SwitchTo(lexState);
8007 }
8008
8009 /** Switch to specified lex state. */
SwitchTo(int lexState)8010 public void SwitchTo(int lexState)
8011 {
8012 if (lexState >= 18 || lexState < 0)
8013 throw new TokenMgrError("Error: Ignoring invalid lexical state : " + lexState + ". State unchanged.", TokenMgrError.INVALID_LEXICAL_STATE);
8014 else
8015 curLexState = lexState;
8016 }
8017
jjFillToken()8018 protected Token jjFillToken()
8019 {
8020 final Token t;
8021 final String curTokenImage;
8022 final int beginLine;
8023 final int endLine;
8024 final int beginColumn;
8025 final int endColumn;
8026 String im = jjstrLiteralImages[jjmatchedKind];
8027 curTokenImage = (im == null) ? input_stream.GetImage() : im;
8028 beginLine = input_stream.getBeginLine();
8029 beginColumn = input_stream.getBeginColumn();
8030 endLine = input_stream.getEndLine();
8031 endColumn = input_stream.getEndColumn();
8032 t = Token.newToken(jjmatchedKind, curTokenImage);
8033
8034 t.beginLine = beginLine;
8035 t.endLine = endLine;
8036 t.beginColumn = beginColumn;
8037 t.endColumn = endColumn;
8038
8039 return t;
8040 }
8041
8042 int curLexState = 10;
8043 int defaultLexState = 10;
8044 int jjnewStateCnt;
8045 int jjround;
8046 int jjmatchedPos;
8047 int jjmatchedKind;
8048
8049 /** Get the next Token. */
getNextToken()8050 public Token getNextToken()
8051 {
8052 Token specialToken = null;
8053 Token matchedToken;
8054 int curPos = 0;
8055
8056 EOFLoop :
8057 for (;;)
8058 {
8059 try
8060 {
8061 curChar = input_stream.BeginToken();
8062 }
8063 catch(java.io.IOException e)
8064 {
8065 jjmatchedKind = 0;
8066 matchedToken = jjFillToken();
8067 matchedToken.specialToken = specialToken;
8068 return matchedToken;
8069 }
8070 image = jjimage;
8071 image.setLength(0);
8072 jjimageLen = 0;
8073
8074 for (;;)
8075 {
8076 switch(curLexState)
8077 {
8078 case 0:
8079 jjmatchedKind = 0x7fffffff;
8080 jjmatchedPos = 0;
8081 curPos = jjMoveStringLiteralDfa0_0();
8082 if (jjmatchedPos == 0 && jjmatchedKind > 75)
8083 {
8084 jjmatchedKind = 75;
8085 }
8086 break;
8087 case 1:
8088 jjmatchedKind = 0x7fffffff;
8089 jjmatchedPos = 0;
8090 curPos = jjMoveStringLiteralDfa0_1();
8091 if (jjmatchedPos == 0 && jjmatchedKind > 74)
8092 {
8093 jjmatchedKind = 74;
8094 }
8095 break;
8096 case 2:
8097 jjmatchedKind = 0x7fffffff;
8098 jjmatchedPos = 0;
8099 curPos = jjMoveStringLiteralDfa0_2();
8100 if (jjmatchedPos == 0 && jjmatchedKind > 74)
8101 {
8102 jjmatchedKind = 74;
8103 }
8104 break;
8105 case 3:
8106 jjmatchedKind = 0x7fffffff;
8107 jjmatchedPos = 0;
8108 curPos = jjMoveStringLiteralDfa0_3();
8109 if (jjmatchedPos == 0 && jjmatchedKind > 74)
8110 {
8111 jjmatchedKind = 74;
8112 }
8113 break;
8114 case 4:
8115 jjmatchedKind = 0x7fffffff;
8116 jjmatchedPos = 0;
8117 curPos = jjMoveStringLiteralDfa0_4();
8118 if (jjmatchedPos == 0 && jjmatchedKind > 74)
8119 {
8120 jjmatchedKind = 74;
8121 }
8122 break;
8123 case 5:
8124 jjmatchedKind = 0x7fffffff;
8125 jjmatchedPos = 0;
8126 curPos = jjMoveStringLiteralDfa0_5();
8127 if (jjmatchedPos == 0 && jjmatchedKind > 74)
8128 {
8129 jjmatchedKind = 74;
8130 }
8131 break;
8132 case 6:
8133 jjmatchedKind = 0x7fffffff;
8134 jjmatchedPos = 0;
8135 curPos = jjMoveStringLiteralDfa0_6();
8136 if (jjmatchedPos == 0 && jjmatchedKind > 74)
8137 {
8138 jjmatchedKind = 74;
8139 }
8140 break;
8141 case 7:
8142 jjmatchedKind = 0x7fffffff;
8143 jjmatchedPos = 0;
8144 curPos = jjMoveStringLiteralDfa0_7();
8145 break;
8146 case 8:
8147 jjmatchedKind = 0x7fffffff;
8148 jjmatchedPos = 0;
8149 curPos = jjMoveStringLiteralDfa0_8();
8150 break;
8151 case 9:
8152 jjmatchedKind = 0x7fffffff;
8153 jjmatchedPos = 0;
8154 curPos = jjMoveStringLiteralDfa0_9();
8155 break;
8156 case 10:
8157 jjmatchedKind = 0x7fffffff;
8158 jjmatchedPos = 0;
8159 curPos = jjMoveStringLiteralDfa0_10();
8160 break;
8161 case 11:
8162 jjmatchedKind = 0x7fffffff;
8163 jjmatchedPos = 0;
8164 curPos = jjMoveStringLiteralDfa0_11();
8165 if (jjmatchedPos == 0 && jjmatchedKind > 74)
8166 {
8167 jjmatchedKind = 74;
8168 }
8169 break;
8170 case 12:
8171 jjmatchedKind = 0x7fffffff;
8172 jjmatchedPos = 0;
8173 curPos = jjMoveStringLiteralDfa0_12();
8174 break;
8175 case 13:
8176 jjmatchedKind = 0x7fffffff;
8177 jjmatchedPos = 0;
8178 curPos = jjMoveStringLiteralDfa0_13();
8179 break;
8180 case 14:
8181 jjmatchedKind = 0x7fffffff;
8182 jjmatchedPos = 0;
8183 curPos = jjMoveStringLiteralDfa0_14();
8184 if (jjmatchedPos == 0 && jjmatchedKind > 30)
8185 {
8186 jjmatchedKind = 30;
8187 }
8188 break;
8189 case 15:
8190 jjmatchedKind = 0x7fffffff;
8191 jjmatchedPos = 0;
8192 curPos = jjMoveStringLiteralDfa0_15();
8193 if (jjmatchedPos == 0 && jjmatchedKind > 30)
8194 {
8195 jjmatchedKind = 30;
8196 }
8197 break;
8198 case 16:
8199 jjmatchedKind = 0x7fffffff;
8200 jjmatchedPos = 0;
8201 curPos = jjMoveStringLiteralDfa0_16();
8202 break;
8203 case 17:
8204 jjmatchedKind = 0x7fffffff;
8205 jjmatchedPos = 0;
8206 curPos = jjMoveStringLiteralDfa0_17();
8207 if (jjmatchedPos == 0 && jjmatchedKind > 30)
8208 {
8209 jjmatchedKind = 30;
8210 }
8211 break;
8212 }
8213 if (jjmatchedKind != 0x7fffffff)
8214 {
8215 if (jjmatchedPos + 1 < curPos)
8216 input_stream.backup(curPos - jjmatchedPos - 1);
8217 if ((jjtoToken[jjmatchedKind >> 6] & (1L << (jjmatchedKind & 077))) != 0L)
8218 {
8219 matchedToken = jjFillToken();
8220 matchedToken.specialToken = specialToken;
8221 TokenLexicalActions(matchedToken);
8222 if (jjnewLexState[jjmatchedKind] != -1)
8223 curLexState = jjnewLexState[jjmatchedKind];
8224 return matchedToken;
8225 }
8226 else if ((jjtoSkip[jjmatchedKind >> 6] & (1L << (jjmatchedKind & 077))) != 0L)
8227 {
8228 if ((jjtoSpecial[jjmatchedKind >> 6] & (1L << (jjmatchedKind & 077))) != 0L)
8229 {
8230 matchedToken = jjFillToken();
8231 if (specialToken == null)
8232 specialToken = matchedToken;
8233 else
8234 {
8235 matchedToken.specialToken = specialToken;
8236 specialToken = (specialToken.next = matchedToken);
8237 }
8238 SkipLexicalActions(matchedToken);
8239 }
8240 else
8241 SkipLexicalActions(null);
8242 if (jjnewLexState[jjmatchedKind] != -1)
8243 curLexState = jjnewLexState[jjmatchedKind];
8244 continue EOFLoop;
8245 }
8246 MoreLexicalActions();
8247 if (jjnewLexState[jjmatchedKind] != -1)
8248 curLexState = jjnewLexState[jjmatchedKind];
8249 curPos = 0;
8250 jjmatchedKind = 0x7fffffff;
8251 try {
8252 curChar = input_stream.readChar();
8253 continue;
8254 }
8255 catch (java.io.IOException e1) { }
8256 }
8257 int error_line = input_stream.getEndLine();
8258 int error_column = input_stream.getEndColumn();
8259 String error_after = null;
8260 boolean EOFSeen = false;
8261 try { input_stream.readChar(); input_stream.backup(1); }
8262 catch (java.io.IOException e1) {
8263 EOFSeen = true;
8264 error_after = curPos <= 1 ? "" : input_stream.GetImage();
8265 if (curChar == '\n' || curChar == '\r') {
8266 error_line++;
8267 error_column = 0;
8268 }
8269 else
8270 error_column++;
8271 }
8272 if (!EOFSeen) {
8273 input_stream.backup(1);
8274 error_after = curPos <= 1 ? "" : input_stream.GetImage();
8275 }
8276 throw new TokenMgrError(EOFSeen, curLexState, error_line, error_column, error_after, curChar, TokenMgrError.LEXICAL_ERROR);
8277 }
8278 }
8279 }
8280
SkipLexicalActions(Token matchedToken)8281 void SkipLexicalActions(Token matchedToken)
8282 {
8283 switch(jjmatchedKind)
8284 {
8285 case 74 :
8286 image.append(input_stream.GetSuffix(jjimageLen + (lengthOfMatch = jjmatchedPos + 1)));
8287 /*
8288 * push every terminator character back into the stream
8289 */
8290
8291 input_stream.backup(1);
8292
8293 trace("REF_TERM :");
8294
8295 stateStackPop();
8296 break;
8297 case 75 :
8298 image.append(input_stream.GetSuffix(jjimageLen + (lengthOfMatch = jjmatchedPos + 1)));
8299 trace("DIRECTIVE_TERM :");
8300
8301 input_stream.backup(1);
8302 stateStackPop();
8303 break;
8304 default :
8305 break;
8306 }
8307 }
MoreLexicalActions()8308 void MoreLexicalActions()
8309 {
8310 jjimageLen += (lengthOfMatch = jjmatchedPos + 1);
8311 switch(jjmatchedKind)
8312 {
8313 case 19 :
8314 image.append(input_stream.GetSuffix(jjimageLen));
8315 jjimageLen = 0;
8316 if (! inComment)
8317 {
8318 /*
8319 * if we find ourselves in REFERENCE or PRE_REFERENCE, we need to pop down
8320 * to end the previous ref
8321 */
8322
8323 if (curLexState == REFERENCE || curLexState == PRE_REFERENCE || curLexState == PRE_OLD_REFERENCE)
8324 {
8325 stateStackPop();
8326 }
8327
8328 int preReferenceState = parser.hyphenAllowedInIdentifiers ? PRE_OLD_REFERENCE : PRE_REFERENCE;
8329
8330 trace( " $ : going to " + lexStateNames[preReferenceState]);
8331
8332 /* do not push PRE states */
8333 if (curLexState != PRE_REFERENCE && curLexState != PRE_DIRECTIVE && curLexState != PRE_OLD_REFERENCE)
8334 {
8335 stateStackPush();
8336 }
8337 switchTo(preReferenceState);
8338 }
8339 break;
8340 case 20 :
8341 image.append(input_stream.GetSuffix(jjimageLen));
8342 jjimageLen = 0;
8343 if (! inComment)
8344 {
8345 /*
8346 * if we find ourselves in REFERENCE or PRE_REFERENCE, we need to pop down
8347 * to end the previous ref
8348 */
8349
8350 if (curLexState == REFERENCE || curLexState == PRE_REFERENCE || curLexState == PRE_OLD_REFERENCE)
8351 {
8352 stateStackPop();
8353 }
8354
8355 int preReferenceState = parser.hyphenAllowedInIdentifiers ? PRE_OLD_REFERENCE : PRE_REFERENCE;
8356
8357 trace( " $ : going to " + lexStateNames[preReferenceState]);
8358
8359 /* do not push PRE states */
8360 if (curLexState != PRE_REFERENCE && curLexState != PRE_DIRECTIVE && curLexState != PRE_OLD_REFERENCE)
8361 {
8362 stateStackPush();
8363 }
8364 switchTo(preReferenceState);
8365 }
8366 break;
8367 case 21 :
8368 image.append(input_stream.GetSuffix(jjimageLen));
8369 jjimageLen = 0;
8370 if (!inComment)
8371 {
8372 inComment = true;
8373 /* do not push PRE states */
8374 if (curLexState != PRE_REFERENCE && curLexState != PRE_DIRECTIVE && curLexState != PRE_OLD_REFERENCE)
8375 {
8376 stateStackPush();
8377 }
8378 switchTo( IN_TEXTBLOCK );
8379 }
8380 break;
8381 case 22 :
8382 image.append(input_stream.GetSuffix(jjimageLen));
8383 jjimageLen = 0;
8384 if (!inComment)
8385 {
8386 input_stream.backup(1);
8387 inComment = true;
8388 /* do not push PRE states */
8389 if (curLexState != PRE_REFERENCE && curLexState != PRE_DIRECTIVE && curLexState != PRE_OLD_REFERENCE)
8390 {
8391 stateStackPush();
8392 }
8393 switchTo( IN_FORMAL_COMMENT);
8394 }
8395 break;
8396 case 23 :
8397 image.append(input_stream.GetSuffix(jjimageLen));
8398 jjimageLen = 0;
8399 if (!inComment)
8400 {
8401 inComment=true;
8402 /* do not push PRE states */
8403 if (curLexState != PRE_REFERENCE && curLexState != PRE_DIRECTIVE && curLexState != PRE_OLD_REFERENCE)
8404 {
8405 stateStackPush();
8406 }
8407 switchTo( IN_MULTI_LINE_COMMENT );
8408 }
8409 break;
8410 case 24 :
8411 image.append(input_stream.GetSuffix(jjimageLen));
8412 jjimageLen = 0;
8413 if (! inComment)
8414 {
8415 /*
8416 * We can have the situation where #if($foo)$foo#end.
8417 * We need to transition out of REFERENCE before going to DIRECTIVE.
8418 * I don't really like this, but I can't think of a legal way
8419 * you are going into DIRECTIVE while in REFERENCE. -gmj
8420 */
8421
8422 if (curLexState == REFERENCE || curLexState == PRE_REFERENCE || curLexState == PRE_OLD_REFERENCE || curLexState == REFMODIFIER || curLexState == OLD_REFMODIFIER )
8423 {
8424 stateStackPop();
8425 }
8426
8427 trace(" # : going to PRE_DIRECTIVE" );
8428
8429 /* do not push PRE states */
8430 if (curLexState != PRE_REFERENCE && curLexState != PRE_DIRECTIVE && curLexState != PRE_OLD_REFERENCE)
8431 {
8432 stateStackPush();
8433 }
8434 switchTo(PRE_DIRECTIVE);
8435 }
8436 break;
8437 default :
8438 break;
8439 }
8440 }
TokenLexicalActions(Token matchedToken)8441 void TokenLexicalActions(Token matchedToken)
8442 {
8443 switch(jjmatchedKind)
8444 {
8445 case 1 :
8446 image.append(input_stream.GetSuffix(jjimageLen + (lengthOfMatch = jjmatchedPos + 1)));
8447 stateStackPop();
8448 break;
8449 case 3 :
8450 image.append(input_stream.GetSuffix(jjimageLen + (lengthOfMatch = jjmatchedPos + 1)));
8451 stateStackPush();
8452 switchTo(REFINDEX);
8453 break;
8454 case 4 :
8455 image.append(input_stream.GetSuffix(jjimageLen + (lengthOfMatch = jjmatchedPos + 1)));
8456 stateStackPop();
8457 break;
8458 case 5 :
8459 image.append(input_stream.GetSuffix(jjimageLen + (lengthOfMatch = jjmatchedPos + 1)));
8460 if (curlyLevel == 1)
8461 {
8462 switchTo(ALT_VAL);
8463 }
8464 else
8465 {
8466 stateStackPop();
8467 }
8468 break;
8469 case 6 :
8470 image.append(input_stream.GetSuffix(jjimageLen + (lengthOfMatch = jjmatchedPos + 1)));
8471 stateStackPop();
8472 break;
8473 case 12 :
8474 image.append(input_stream.GetSuffix(jjimageLen + (lengthOfMatch = jjmatchedPos + 1)));
8475 ++curlyLevel;
8476 break;
8477 case 13 :
8478 image.append(input_stream.GetSuffix(jjimageLen + (lengthOfMatch = jjmatchedPos + 1)));
8479 --curlyLevel;
8480 if (curLexState == ALT_VAL && curlyLevel == 0)
8481 {
8482 stateStackPop();
8483 }
8484 break;
8485 case 14 :
8486 image.append(input_stream.GetSuffix(jjimageLen + (lengthOfMatch = jjmatchedPos + 1)));
8487 if (!inComment)
8488 lparen++;
8489
8490 /*
8491 * If in REFERENCE and we have seen the dot, then move
8492 * to REFMOD2 -> Modifier()
8493 */
8494
8495 if (curLexState == REFMODIFIER || curLexState == OLD_REFMODIFIER )
8496 switchTo( REFMOD2 );
8497 break;
8498 case 15 :
8499 image.append(input_stream.GetSuffix(jjimageLen + (lengthOfMatch = jjmatchedPos + 1)));
8500 RPARENHandler();
8501 break;
8502 case 16 :
8503 image.append(input_stream.GetSuffix(jjimageLen + (lengthOfMatch = jjmatchedPos + 1)));
8504 /*
8505 * need to simply switch back to REFERENCE, not drop down the stack
8506 * because we can (infinitely) chain, ala
8507 * $foo.bar().blargh().woogie().doogie()
8508 */
8509
8510 switchTo( REFMOD3 );
8511 break;
8512 case 18 :
8513 image.append(input_stream.GetSuffix(jjimageLen + (lengthOfMatch = jjmatchedPos + 1)));
8514 if (! inComment)
8515 {
8516 trace(" #set : going to DIRECTIVE" );
8517
8518 stateStackPush();
8519 setInSet(true);
8520 switchTo(DIRECTIVE);
8521 }
8522
8523 /*
8524 * need the LPAREN action
8525 */
8526
8527 if (!inComment)
8528 {
8529 lparen++;
8530
8531 /*
8532 * If in REFERENCE and we have seen the dot, then move
8533 * to REFMOD2 -> Modifier()
8534 */
8535
8536 if (curLexState == REFMODIFIER || curLexState == OLD_REFMODIFIER )
8537 switchTo( REFMOD2 );
8538 }
8539 break;
8540 case 25 :
8541 image.append(input_stream.GetSuffix(jjimageLen + (lengthOfMatch = jjmatchedPos + 1)));
8542 if (!inComment)
8543 {
8544 if (curLexState == REFERENCE || curLexState == PRE_REFERENCE || curLexState == PRE_OLD_REFERENCE)
8545 {
8546 stateStackPop();
8547 }
8548
8549 inComment = true;
8550 stateStackPush();
8551 switchTo(IN_SINGLE_LINE_COMMENT);
8552 }
8553 break;
8554 case 26 :
8555 image.append(input_stream.GetSuffix(jjimageLen + (lengthOfMatch = jjmatchedPos + 1)));
8556 inComment = false;
8557 stateStackPop();
8558 if (curLexState == REFERENCE || curLexState == REFMOD3)
8559 {
8560 // end of reference: pop again
8561 stateStackPop();
8562 }
8563 break;
8564 case 27 :
8565 image.append(input_stream.GetSuffix(jjimageLen + (lengthOfMatch = jjmatchedPos + 1)));
8566 inComment = false;
8567 stateStackPop();
8568 if (curLexState == REFERENCE || curLexState == REFMOD3)
8569 {
8570 // end of reference: pop again
8571 stateStackPop();
8572 }
8573 break;
8574 case 28 :
8575 image.append(input_stream.GetSuffix(jjimageLen + (lengthOfMatch = jjmatchedPos + 1)));
8576 inComment = false;
8577 stateStackPop();
8578 if (curLexState == REFERENCE || curLexState == REFMOD3)
8579 {
8580 // end of reference: pop again
8581 stateStackPop();
8582 }
8583 break;
8584 case 29 :
8585 image.append(input_stream.GetSuffix(jjimageLen + (lengthOfMatch = jjmatchedPos + 1)));
8586 inComment = false;
8587 stateStackPop();
8588 break;
8589 case 33 :
8590 image.append(input_stream.GetSuffix(jjimageLen + (lengthOfMatch = jjmatchedPos + 1)));
8591 trace(" NEWLINE :");
8592
8593 /* if (isInSet()) */
8594 setInSet(false);
8595 break;
8596 case 34 :
8597 image.append(input_stream.GetSuffix(jjimageLen + (lengthOfMatch = jjmatchedPos + 1)));
8598 stateStackPop();
8599 break;
8600 case 35 :
8601 image.append(input_stream.GetSuffix(jjimageLen + (lengthOfMatch = jjmatchedPos + 1)));
8602 /*
8603 * - if we are in DIRECTIVE and haven't seen ( yet, then also drop out.
8604 * don't forget to account for the beloved yet wierd #set
8605 * - finally, if we are in REFMOD2 (remember : $foo.bar( ) then " is ok!
8606 */
8607
8608 if( curLexState == DIRECTIVE && !isInSet() && lparen == 0)
8609 stateStackPop();
8610 break;
8611 case 53 :
8612 image.append(input_stream.GetSuffix(jjimageLen + (lengthOfMatch = jjmatchedPos + 1)));
8613 stateStackPop();
8614 break;
8615 case 54 :
8616 image.append(input_stream.GetSuffix(jjimageLen + (lengthOfMatch = jjmatchedPos + 1)));
8617 switchTo(DIRECTIVE);
8618 break;
8619 case 55 :
8620 image.append(input_stream.GetSuffix(jjimageLen + (lengthOfMatch = jjmatchedPos + 1)));
8621 switchTo(DIRECTIVE);
8622 break;
8623 case 56 :
8624 image.append(input_stream.GetSuffix(jjimageLen + (lengthOfMatch = jjmatchedPos + 1)));
8625 stateStackPop();
8626 break;
8627 case 58 :
8628 image.append(input_stream.GetSuffix(jjimageLen + (lengthOfMatch = jjmatchedPos + 1)));
8629 /*
8630 * Remove the double period if it is there
8631 */
8632 if (matchedToken.image.endsWith("..")) {
8633 input_stream.backup(2);
8634 matchedToken.image = matchedToken.image.substring(0,matchedToken.image.length()-2);
8635 }
8636
8637 /*
8638 * check to see if we are in set
8639 * ex. #set($foo = $foo + 3)
8640 * because we want to handle the \n after
8641 */
8642
8643 if ( lparen == 0 && !isInSet() && curLexState != REFMOD2 && curLexState != REFINDEX && curLexState != ALT_VAL)
8644 {
8645 stateStackPop();
8646 }
8647 break;
8648 case 59 :
8649 image.append(input_stream.GetSuffix(jjimageLen + (lengthOfMatch = jjmatchedPos + 1)));
8650 /*
8651 * check to see if we are in set
8652 * ex. #set $foo = $foo + 3
8653 * because we want to handle the \n after
8654 */
8655
8656 if ( lparen == 0 && !isInSet() && curLexState != REFMOD2 && curLexState != ALT_VAL)
8657 {
8658 stateStackPop();
8659 }
8660 break;
8661 case 67 :
8662 image.append(input_stream.GetSuffix(jjimageLen + (lengthOfMatch = jjmatchedPos + 1)));
8663 if (curLexState == PRE_REFERENCE)
8664 {
8665 switchTo(REFERENCE);
8666 }
8667 break;
8668 case 70 :
8669 image.append(input_stream.GetSuffix(jjimageLen + (lengthOfMatch = jjmatchedPos + 1)));
8670 if (curLexState == PRE_OLD_REFERENCE)
8671 {
8672 switchTo(REFERENCE);
8673 }
8674 break;
8675 case 71 :
8676 image.append(input_stream.GetSuffix(jjimageLen + (lengthOfMatch = jjmatchedPos + 1)));
8677 /*
8678 * push the alpha char back into the stream so the following identifier
8679 * is complete
8680 */
8681
8682 input_stream.backup(1);
8683
8684 /*
8685 * and munge the <DOT> so we just get a . when we have normal text that
8686 * looks like a ref.ident
8687 */
8688
8689 matchedToken.image = ".";
8690
8691 int refModifierState = parser.hyphenAllowedInIdentifiers ? OLD_REFMODIFIER : REFMODIFIER;
8692
8693 trace("DOT : switching to " + lexStateNames[refModifierState]);
8694 switchTo(refModifierState);
8695 break;
8696 case 72 :
8697 image.append(input_stream.GetSuffix(jjimageLen + (lengthOfMatch = jjmatchedPos + 1)));
8698 ++curlyLevel;
8699 break;
8700 case 73 :
8701 image.append(input_stream.GetSuffix(jjimageLen + (lengthOfMatch = jjmatchedPos + 1)));
8702 /* maybe it wasn't for our state */
8703 while (curlyLevel == 0 && curLexState != DEFAULT)
8704 {
8705 stateStackPop();
8706 }
8707 /* At this point, here are all the possible states:
8708 * - DEFAULT, which means the '}' is schmoo
8709 * - DIRECTIVE or REFMOD2, which means the '}' is a closing map curly
8710 * - one of the other REFERENCE states or ALT_VAL, which means the '}' ends the reference
8711 * If we're in the last case, pop up state.
8712 */
8713 if (curLexState != DEFAULT && curLexState != DIRECTIVE && curLexState != REFMOD2)
8714 {
8715 stateStackPop();
8716 }
8717 break;
8718 default :
8719 break;
8720 }
8721 }
jjCheckNAdd(int state)8722 private void jjCheckNAdd(int state)
8723 {
8724 if (jjrounds[state] != jjround)
8725 {
8726 jjstateSet[jjnewStateCnt++] = state;
8727 jjrounds[state] = jjround;
8728 }
8729 }
jjAddStates(int start, int end)8730 private void jjAddStates(int start, int end)
8731 {
8732 do {
8733 jjstateSet[jjnewStateCnt++] = jjnextStates[start];
8734 } while (start++ != end);
8735 }
jjCheckNAddTwoStates(int state1, int state2)8736 private void jjCheckNAddTwoStates(int state1, int state2)
8737 {
8738 jjCheckNAdd(state1);
8739 jjCheckNAdd(state2);
8740 }
8741
jjCheckNAddStates(int start, int end)8742 private void jjCheckNAddStates(int start, int end)
8743 {
8744 do {
8745 jjCheckNAdd(jjnextStates[start]);
8746 } while (start++ != end);
8747 }
8748
8749 }
8750