001 /* Generated By:JJTree&JavaCC: Do not edit this line. ParserTokenManager.java */
002 package org.apache.commons.jexl2.parser;
003 import java.io.Reader;
004 import org.apache.commons.jexl2.JexlInfo;
005
006 /** Token Manager. */
007 public class ParserTokenManager implements ParserConstants
008 {
009
010 /** Debug output. */
011 public java.io.PrintStream debugStream = System.out;
012 /** Set debug output. */
013 public void setDebugStream(java.io.PrintStream ds) { debugStream = ds; }
014 private final int jjStopStringLiteralDfa_2(int pos, long active0)
015 {
016 switch (pos)
017 {
018 case 0:
019 if ((active0 & 0x3aba00L) != 0L)
020 {
021 jjmatchedKind = 56;
022 return 37;
023 }
024 if ((active0 & 0x20000000000000L) != 0L)
025 return 6;
026 if ((active0 & 0x44000L) != 0L)
027 {
028 jjmatchedKind = 56;
029 return 75;
030 }
031 if ((active0 & 0x40000000000000L) != 0L)
032 return 11;
033 if ((active0 & 0x10000000000L) != 0L)
034 {
035 jjmatchedKind = 48;
036 return 19;
037 }
038 if ((active0 & 0x208000000000L) != 0L)
039 return 15;
040 if ((active0 & 0x10400L) != 0L)
041 {
042 jjmatchedKind = 56;
043 return 17;
044 }
045 return -1;
046 case 1:
047 if ((active0 & 0x4000L) != 0L)
048 {
049 jjmatchedKind = 38;
050 jjmatchedPos = 1;
051 return 37;
052 }
053 if ((active0 & 0x3fbc00L) != 0L)
054 {
055 jjmatchedKind = 56;
056 jjmatchedPos = 1;
057 return 37;
058 }
059 if ((active0 & 0x200L) != 0L)
060 return 37;
061 return -1;
062 case 2:
063 if ((active0 & 0xd800L) != 0L)
064 return 37;
065 if ((active0 & 0x3f2400L) != 0L)
066 {
067 if (jjmatchedPos != 2)
068 {
069 jjmatchedKind = 56;
070 jjmatchedPos = 2;
071 }
072 return 37;
073 }
074 return -1;
075 case 3:
076 if ((active0 & 0x313000L) != 0L)
077 {
078 jjmatchedKind = 56;
079 jjmatchedPos = 3;
080 return 37;
081 }
082 if ((active0 & 0xe0400L) != 0L)
083 return 37;
084 return -1;
085 case 4:
086 if ((active0 & 0x201000L) != 0L)
087 {
088 jjmatchedKind = 56;
089 jjmatchedPos = 4;
090 return 37;
091 }
092 if ((active0 & 0x112000L) != 0L)
093 return 37;
094 return -1;
095 case 5:
096 if ((active0 & 0x1000L) != 0L)
097 {
098 jjmatchedKind = 56;
099 jjmatchedPos = 5;
100 return 37;
101 }
102 if ((active0 & 0x200000L) != 0L)
103 return 37;
104 return -1;
105 default :
106 return -1;
107 }
108 }
109 private final int jjStartNfa_2(int pos, long active0)
110 {
111 return jjMoveNfa_2(jjStopStringLiteralDfa_2(pos, active0), pos + 1);
112 }
113 private int jjStopAtPos(int pos, int kind)
114 {
115 jjmatchedKind = kind;
116 jjmatchedPos = pos;
117 return pos + 1;
118 }
119 private int jjMoveStringLiteralDfa0_2()
120 {
121 switch(curChar)
122 {
123 case 33:
124 return jjMoveStringLiteralDfa1_2(0x10000000000L);
125 case 38:
126 return jjStartNfaWithStates_2(0, 53, 6);
127 case 40:
128 return jjStopAtPos(0, 23);
129 case 41:
130 return jjStopAtPos(0, 24);
131 case 42:
132 return jjStopAtPos(0, 51);
133 case 43:
134 return jjStopAtPos(0, 49);
135 case 44:
136 return jjStopAtPos(0, 31);
137 case 45:
138 return jjStopAtPos(0, 50);
139 case 46:
140 return jjStopAtPos(0, 32);
141 case 58:
142 return jjStopAtPos(0, 30);
143 case 59:
144 return jjStopAtPos(0, 29);
145 case 61:
146 jjmatchedKind = 45;
147 return jjMoveStringLiteralDfa1_2(0x8000000000L);
148 case 63:
149 jjmatchedKind = 33;
150 return jjMoveStringLiteralDfa1_2(0x400000000L);
151 case 91:
152 return jjStopAtPos(0, 27);
153 case 93:
154 return jjStopAtPos(0, 28);
155 case 94:
156 return jjStopAtPos(0, 55);
157 case 101:
158 return jjMoveStringLiteralDfa1_2(0x10400L);
159 case 102:
160 return jjMoveStringLiteralDfa1_2(0x101800L);
161 case 105:
162 return jjMoveStringLiteralDfa1_2(0x200L);
163 case 110:
164 return jjMoveStringLiteralDfa1_2(0x44000L);
165 case 114:
166 return jjMoveStringLiteralDfa1_2(0x200000L);
167 case 115:
168 return jjMoveStringLiteralDfa1_2(0x20000L);
169 case 116:
170 return jjMoveStringLiteralDfa1_2(0x80000L);
171 case 118:
172 return jjMoveStringLiteralDfa1_2(0x8000L);
173 case 119:
174 return jjMoveStringLiteralDfa1_2(0x2000L);
175 case 123:
176 return jjStopAtPos(0, 25);
177 case 124:
178 return jjStartNfaWithStates_2(0, 54, 11);
179 case 125:
180 return jjStopAtPos(0, 26);
181 case 126:
182 return jjStopAtPos(0, 52);
183 default :
184 return jjMoveNfa_2(5, 0);
185 }
186 }
187 private int jjMoveStringLiteralDfa1_2(long active0)
188 {
189 try { curChar = input_stream.readChar(); }
190 catch(java.io.IOException e) {
191 jjStopStringLiteralDfa_2(0, active0);
192 return 1;
193 }
194 switch(curChar)
195 {
196 case 58:
197 if ((active0 & 0x400000000L) != 0L)
198 return jjStopAtPos(1, 34);
199 break;
200 case 97:
201 return jjMoveStringLiteralDfa2_2(active0, 0x108000L);
202 case 101:
203 return jjMoveStringLiteralDfa2_2(active0, 0x204000L);
204 case 102:
205 if ((active0 & 0x200L) != 0L)
206 return jjStartNfaWithStates_2(1, 9, 37);
207 break;
208 case 104:
209 return jjMoveStringLiteralDfa2_2(active0, 0x2000L);
210 case 105:
211 return jjMoveStringLiteralDfa2_2(active0, 0x20000L);
212 case 108:
213 return jjMoveStringLiteralDfa2_2(active0, 0x400L);
214 case 109:
215 return jjMoveStringLiteralDfa2_2(active0, 0x10000L);
216 case 111:
217 return jjMoveStringLiteralDfa2_2(active0, 0x1800L);
218 case 114:
219 return jjMoveStringLiteralDfa2_2(active0, 0x80000L);
220 case 117:
221 return jjMoveStringLiteralDfa2_2(active0, 0x40000L);
222 case 126:
223 if ((active0 & 0x8000000000L) != 0L)
224 return jjStopAtPos(1, 39);
225 else if ((active0 & 0x10000000000L) != 0L)
226 return jjStopAtPos(1, 40);
227 break;
228 default :
229 break;
230 }
231 return jjStartNfa_2(0, active0);
232 }
233 private int jjMoveStringLiteralDfa2_2(long old0, long active0)
234 {
235 if (((active0 &= old0)) == 0L)
236 return jjStartNfa_2(0, old0);
237 try { curChar = input_stream.readChar(); }
238 catch(java.io.IOException e) {
239 jjStopStringLiteralDfa_2(1, active0);
240 return 2;
241 }
242 switch(curChar)
243 {
244 case 105:
245 return jjMoveStringLiteralDfa3_2(active0, 0x2000L);
246 case 108:
247 return jjMoveStringLiteralDfa3_2(active0, 0x140000L);
248 case 112:
249 return jjMoveStringLiteralDfa3_2(active0, 0x10000L);
250 case 114:
251 if ((active0 & 0x800L) != 0L)
252 {
253 jjmatchedKind = 11;
254 jjmatchedPos = 2;
255 }
256 else if ((active0 & 0x8000L) != 0L)
257 return jjStartNfaWithStates_2(2, 15, 37);
258 return jjMoveStringLiteralDfa3_2(active0, 0x1000L);
259 case 115:
260 return jjMoveStringLiteralDfa3_2(active0, 0x400L);
261 case 116:
262 return jjMoveStringLiteralDfa3_2(active0, 0x200000L);
263 case 117:
264 return jjMoveStringLiteralDfa3_2(active0, 0x80000L);
265 case 119:
266 if ((active0 & 0x4000L) != 0L)
267 return jjStartNfaWithStates_2(2, 14, 37);
268 break;
269 case 122:
270 return jjMoveStringLiteralDfa3_2(active0, 0x20000L);
271 default :
272 break;
273 }
274 return jjStartNfa_2(1, active0);
275 }
276 private int jjMoveStringLiteralDfa3_2(long old0, long active0)
277 {
278 if (((active0 &= old0)) == 0L)
279 return jjStartNfa_2(1, old0);
280 try { curChar = input_stream.readChar(); }
281 catch(java.io.IOException e) {
282 jjStopStringLiteralDfa_2(2, active0);
283 return 3;
284 }
285 switch(curChar)
286 {
287 case 101:
288 if ((active0 & 0x400L) != 0L)
289 return jjStartNfaWithStates_2(3, 10, 37);
290 else if ((active0 & 0x20000L) != 0L)
291 return jjStartNfaWithStates_2(3, 17, 37);
292 else if ((active0 & 0x80000L) != 0L)
293 return jjStartNfaWithStates_2(3, 19, 37);
294 return jjMoveStringLiteralDfa4_2(active0, 0x1000L);
295 case 108:
296 if ((active0 & 0x40000L) != 0L)
297 return jjStartNfaWithStates_2(3, 18, 37);
298 return jjMoveStringLiteralDfa4_2(active0, 0x2000L);
299 case 115:
300 return jjMoveStringLiteralDfa4_2(active0, 0x100000L);
301 case 116:
302 return jjMoveStringLiteralDfa4_2(active0, 0x10000L);
303 case 117:
304 return jjMoveStringLiteralDfa4_2(active0, 0x200000L);
305 default :
306 break;
307 }
308 return jjStartNfa_2(2, active0);
309 }
310 private int jjMoveStringLiteralDfa4_2(long old0, long active0)
311 {
312 if (((active0 &= old0)) == 0L)
313 return jjStartNfa_2(2, old0);
314 try { curChar = input_stream.readChar(); }
315 catch(java.io.IOException e) {
316 jjStopStringLiteralDfa_2(3, active0);
317 return 4;
318 }
319 switch(curChar)
320 {
321 case 97:
322 return jjMoveStringLiteralDfa5_2(active0, 0x1000L);
323 case 101:
324 if ((active0 & 0x2000L) != 0L)
325 return jjStartNfaWithStates_2(4, 13, 37);
326 else if ((active0 & 0x100000L) != 0L)
327 return jjStartNfaWithStates_2(4, 20, 37);
328 break;
329 case 114:
330 return jjMoveStringLiteralDfa5_2(active0, 0x200000L);
331 case 121:
332 if ((active0 & 0x10000L) != 0L)
333 return jjStartNfaWithStates_2(4, 16, 37);
334 break;
335 default :
336 break;
337 }
338 return jjStartNfa_2(3, active0);
339 }
340 private int jjMoveStringLiteralDfa5_2(long old0, long active0)
341 {
342 if (((active0 &= old0)) == 0L)
343 return jjStartNfa_2(3, old0);
344 try { curChar = input_stream.readChar(); }
345 catch(java.io.IOException e) {
346 jjStopStringLiteralDfa_2(4, active0);
347 return 5;
348 }
349 switch(curChar)
350 {
351 case 99:
352 return jjMoveStringLiteralDfa6_2(active0, 0x1000L);
353 case 110:
354 if ((active0 & 0x200000L) != 0L)
355 return jjStartNfaWithStates_2(5, 21, 37);
356 break;
357 default :
358 break;
359 }
360 return jjStartNfa_2(4, active0);
361 }
362 private int jjMoveStringLiteralDfa6_2(long old0, long active0)
363 {
364 if (((active0 &= old0)) == 0L)
365 return jjStartNfa_2(4, old0);
366 try { curChar = input_stream.readChar(); }
367 catch(java.io.IOException e) {
368 jjStopStringLiteralDfa_2(5, active0);
369 return 6;
370 }
371 switch(curChar)
372 {
373 case 104:
374 if ((active0 & 0x1000L) != 0L)
375 return jjStartNfaWithStates_2(6, 12, 37);
376 break;
377 default :
378 break;
379 }
380 return jjStartNfa_2(5, active0);
381 }
382 private int jjStartNfaWithStates_2(int pos, int kind, int state)
383 {
384 jjmatchedKind = kind;
385 jjmatchedPos = pos;
386 try { curChar = input_stream.readChar(); }
387 catch(java.io.IOException e) { return pos + 1; }
388 return jjMoveNfa_2(state, pos + 1);
389 }
390 static final long[] jjbitVec0 = {
391 0xfffffffffffffffeL, 0xffffffffffffffffL, 0xffffffffffffffffL, 0xffffffffffffffffL
392 };
393 static final long[] jjbitVec2 = {
394 0x0L, 0x0L, 0xffffffffffffffffL, 0xffffffffffffffffL
395 };
396 static final long[] jjbitVec3 = {
397 0xfffffffefffffffeL, 0xffffffffffffffffL, 0xffffffffffffffffL, 0xffffffffffffffffL
398 };
399 static final long[] jjbitVec4 = {
400 0xfffffcffffffffffL, 0xffffffffffffffffL, 0xffffffffffffffffL, 0xffffffffffffffffL
401 };
402 private int jjMoveNfa_2(int startState, int curPos)
403 {
404 int startsAt = 0;
405 jjnewStateCnt = 84;
406 int i = 1;
407 jjstateSet[0] = startState;
408 int kind = 0x7fffffff;
409 for (;;)
410 {
411 if (++jjround == 0x7fffffff)
412 ReInitRounds();
413 if (curChar < 64)
414 {
415 long l = 1L << curChar;
416 do
417 {
418 switch(jjstateSet[--i])
419 {
420 case 17:
421 case 37:
422 if ((0x3ff001000000000L & l) == 0L)
423 break;
424 if (kind > 56)
425 kind = 56;
426 jjCheckNAdd(37);
427 break;
428 case 75:
429 if ((0x3ff001000000000L & l) == 0L)
430 break;
431 if (kind > 56)
432 kind = 56;
433 jjCheckNAdd(37);
434 break;
435 case 5:
436 if ((0x3ff000000000000L & l) != 0L)
437 jjCheckNAddTwoStates(41, 42);
438 else if (curChar == 47)
439 jjAddStates(0, 1);
440 else if (curChar == 39)
441 jjCheckNAddStates(2, 4);
442 else if (curChar == 34)
443 jjCheckNAddStates(5, 7);
444 else if (curChar == 36)
445 {
446 if (kind > 56)
447 kind = 56;
448 jjCheckNAdd(37);
449 }
450 else if (curChar == 33)
451 {
452 if (kind > 48)
453 kind = 48;
454 }
455 else if (curChar == 37)
456 {
457 if (kind > 46)
458 kind = 46;
459 }
460 else if (curChar == 60)
461 jjstateSet[jjnewStateCnt++] = 25;
462 else if (curChar == 62)
463 jjstateSet[jjnewStateCnt++] = 22;
464 else if (curChar == 61)
465 jjstateSet[jjnewStateCnt++] = 15;
466 else if (curChar == 38)
467 jjstateSet[jjnewStateCnt++] = 6;
468 else if (curChar == 35)
469 jjstateSet[jjnewStateCnt++] = 0;
470 if ((0x3fe000000000000L & l) != 0L)
471 {
472 if (kind > 60)
473 kind = 60;
474 jjCheckNAddTwoStates(39, 40);
475 }
476 else if (curChar == 48)
477 {
478 if (kind > 60)
479 kind = 60;
480 jjCheckNAddStates(8, 10);
481 }
482 else if (curChar == 47)
483 {
484 if (kind > 47)
485 kind = 47;
486 }
487 else if (curChar == 60)
488 {
489 if (kind > 43)
490 kind = 43;
491 }
492 else if (curChar == 62)
493 {
494 if (kind > 41)
495 kind = 41;
496 }
497 else if (curChar == 33)
498 jjstateSet[jjnewStateCnt++] = 19;
499 break;
500 case 0:
501 if (curChar != 35)
502 break;
503 if (kind > 1)
504 kind = 1;
505 jjCheckNAddStates(11, 13);
506 break;
507 case 1:
508 if ((0xffffffffffffdbffL & l) == 0L)
509 break;
510 if (kind > 1)
511 kind = 1;
512 jjCheckNAddStates(11, 13);
513 break;
514 case 2:
515 if ((0x2400L & l) != 0L && kind > 1)
516 kind = 1;
517 break;
518 case 3:
519 if (curChar == 10 && kind > 1)
520 kind = 1;
521 break;
522 case 4:
523 if (curChar == 13)
524 jjstateSet[jjnewStateCnt++] = 3;
525 break;
526 case 6:
527 if (curChar == 38 && kind > 35)
528 kind = 35;
529 break;
530 case 7:
531 if (curChar == 38)
532 jjstateSet[jjnewStateCnt++] = 6;
533 break;
534 case 15:
535 if (curChar == 61 && kind > 37)
536 kind = 37;
537 break;
538 case 16:
539 if (curChar == 61)
540 jjstateSet[jjnewStateCnt++] = 15;
541 break;
542 case 19:
543 if (curChar == 61 && kind > 38)
544 kind = 38;
545 break;
546 case 20:
547 if (curChar == 33)
548 jjstateSet[jjnewStateCnt++] = 19;
549 break;
550 case 21:
551 if (curChar == 62 && kind > 41)
552 kind = 41;
553 break;
554 case 22:
555 if (curChar == 61 && kind > 42)
556 kind = 42;
557 break;
558 case 23:
559 if (curChar == 62)
560 jjstateSet[jjnewStateCnt++] = 22;
561 break;
562 case 24:
563 if (curChar == 60 && kind > 43)
564 kind = 43;
565 break;
566 case 25:
567 if (curChar == 61 && kind > 44)
568 kind = 44;
569 break;
570 case 26:
571 if (curChar == 60)
572 jjstateSet[jjnewStateCnt++] = 25;
573 break;
574 case 27:
575 if (curChar == 37 && kind > 46)
576 kind = 46;
577 break;
578 case 31:
579 if (curChar == 47 && kind > 47)
580 kind = 47;
581 break;
582 case 35:
583 if (curChar == 33 && kind > 48)
584 kind = 48;
585 break;
586 case 36:
587 if (curChar != 36)
588 break;
589 if (kind > 56)
590 kind = 56;
591 jjCheckNAdd(37);
592 break;
593 case 38:
594 if ((0x3fe000000000000L & l) == 0L)
595 break;
596 if (kind > 60)
597 kind = 60;
598 jjCheckNAddTwoStates(39, 40);
599 break;
600 case 39:
601 if ((0x3ff000000000000L & l) == 0L)
602 break;
603 if (kind > 60)
604 kind = 60;
605 jjCheckNAddTwoStates(39, 40);
606 break;
607 case 41:
608 if ((0x3ff000000000000L & l) != 0L)
609 jjCheckNAddTwoStates(41, 42);
610 break;
611 case 42:
612 if (curChar == 46)
613 jjCheckNAdd(43);
614 break;
615 case 43:
616 if ((0x3ff000000000000L & l) == 0L)
617 break;
618 if (kind > 61)
619 kind = 61;
620 jjCheckNAddStates(14, 16);
621 break;
622 case 45:
623 if ((0x280000000000L & l) != 0L)
624 jjCheckNAdd(46);
625 break;
626 case 46:
627 if ((0x3ff000000000000L & l) == 0L)
628 break;
629 if (kind > 61)
630 kind = 61;
631 jjCheckNAddTwoStates(46, 47);
632 break;
633 case 48:
634 if (curChar == 34)
635 jjCheckNAddStates(5, 7);
636 break;
637 case 49:
638 if ((0xfffffffbffffdbffL & l) != 0L)
639 jjCheckNAddStates(5, 7);
640 break;
641 case 51:
642 if ((0xffffffffffffdbffL & l) != 0L)
643 jjCheckNAddStates(5, 7);
644 break;
645 case 52:
646 if (curChar == 34 && kind > 62)
647 kind = 62;
648 break;
649 case 53:
650 if (curChar == 39)
651 jjCheckNAddStates(2, 4);
652 break;
653 case 54:
654 if ((0xffffff7fffffdbffL & l) != 0L)
655 jjCheckNAddStates(2, 4);
656 break;
657 case 56:
658 if ((0xffffffffffffdbffL & l) != 0L)
659 jjCheckNAddStates(2, 4);
660 break;
661 case 57:
662 if (curChar == 39 && kind > 62)
663 kind = 62;
664 break;
665 case 58:
666 if (curChar != 48)
667 break;
668 if (kind > 60)
669 kind = 60;
670 jjCheckNAddStates(8, 10);
671 break;
672 case 59:
673 if ((0xff000000000000L & l) == 0L)
674 break;
675 if (kind > 60)
676 kind = 60;
677 jjCheckNAddTwoStates(59, 40);
678 break;
679 case 61:
680 if ((0x3ff000000000000L & l) == 0L)
681 break;
682 if (kind > 60)
683 kind = 60;
684 jjCheckNAddTwoStates(61, 40);
685 break;
686 case 62:
687 if (curChar == 47)
688 jjAddStates(0, 1);
689 break;
690 case 63:
691 if (curChar == 42)
692 jjCheckNAddTwoStates(64, 65);
693 break;
694 case 64:
695 if ((0xfffffbffffffffffL & l) != 0L)
696 jjCheckNAddTwoStates(64, 65);
697 break;
698 case 65:
699 if (curChar == 42)
700 jjCheckNAddStates(17, 19);
701 break;
702 case 66:
703 if ((0xffff7bffffffffffL & l) != 0L)
704 jjCheckNAddTwoStates(67, 65);
705 break;
706 case 67:
707 if ((0xfffffbffffffffffL & l) != 0L)
708 jjCheckNAddTwoStates(67, 65);
709 break;
710 case 68:
711 if (curChar == 47 && kind > 2)
712 kind = 2;
713 break;
714 case 69:
715 if (curChar != 47)
716 break;
717 if (kind > 3)
718 kind = 3;
719 jjCheckNAddStates(20, 22);
720 break;
721 case 70:
722 if ((0xffffffffffffdbffL & l) == 0L)
723 break;
724 if (kind > 3)
725 kind = 3;
726 jjCheckNAddStates(20, 22);
727 break;
728 case 71:
729 if ((0x2400L & l) != 0L && kind > 3)
730 kind = 3;
731 break;
732 case 72:
733 if (curChar == 10 && kind > 3)
734 kind = 3;
735 break;
736 case 73:
737 if (curChar == 13)
738 jjstateSet[jjnewStateCnt++] = 72;
739 break;
740 default : break;
741 }
742 } while(i != startsAt);
743 }
744 else if (curChar < 128)
745 {
746 long l = 1L << (curChar & 077);
747 do
748 {
749 switch(jjstateSet[--i])
750 {
751 case 17:
752 if ((0x7fffffe87ffffffL & l) != 0L)
753 {
754 if (kind > 56)
755 kind = 56;
756 jjCheckNAdd(37);
757 }
758 if (curChar == 113)
759 {
760 if (kind > 37)
761 kind = 37;
762 }
763 break;
764 case 75:
765 if ((0x7fffffe87ffffffL & l) != 0L)
766 {
767 if (kind > 56)
768 kind = 56;
769 jjCheckNAdd(37);
770 }
771 if (curChar == 111)
772 jjstateSet[jjnewStateCnt++] = 76;
773 else if (curChar == 101)
774 {
775 if (kind > 38)
776 kind = 38;
777 }
778 break;
779 case 5:
780 if ((0x7fffffe87ffffffL & l) != 0L)
781 {
782 if (kind > 56)
783 kind = 56;
784 jjCheckNAdd(37);
785 }
786 else if (curChar == 124)
787 jjstateSet[jjnewStateCnt++] = 11;
788 if (curChar == 108)
789 jjAddStates(23, 24);
790 else if (curChar == 103)
791 jjAddStates(25, 26);
792 else if (curChar == 110)
793 jjAddStates(27, 28);
794 else if (curChar == 100)
795 jjstateSet[jjnewStateCnt++] = 33;
796 else if (curChar == 109)
797 jjstateSet[jjnewStateCnt++] = 29;
798 else if (curChar == 101)
799 jjstateSet[jjnewStateCnt++] = 17;
800 else if (curChar == 111)
801 jjstateSet[jjnewStateCnt++] = 13;
802 else if (curChar == 97)
803 jjstateSet[jjnewStateCnt++] = 9;
804 break;
805 case 1:
806 if (kind > 1)
807 kind = 1;
808 jjAddStates(11, 13);
809 break;
810 case 8:
811 if (curChar == 100 && kind > 35)
812 kind = 35;
813 break;
814 case 9:
815 if (curChar == 110)
816 jjstateSet[jjnewStateCnt++] = 8;
817 break;
818 case 10:
819 if (curChar == 97)
820 jjstateSet[jjnewStateCnt++] = 9;
821 break;
822 case 11:
823 if (curChar == 124 && kind > 36)
824 kind = 36;
825 break;
826 case 12:
827 if (curChar == 124)
828 jjstateSet[jjnewStateCnt++] = 11;
829 break;
830 case 13:
831 if (curChar == 114 && kind > 36)
832 kind = 36;
833 break;
834 case 14:
835 if (curChar == 111)
836 jjstateSet[jjnewStateCnt++] = 13;
837 break;
838 case 18:
839 if (curChar == 101)
840 jjstateSet[jjnewStateCnt++] = 17;
841 break;
842 case 28:
843 if (curChar == 100 && kind > 46)
844 kind = 46;
845 break;
846 case 29:
847 if (curChar == 111)
848 jjstateSet[jjnewStateCnt++] = 28;
849 break;
850 case 30:
851 if (curChar == 109)
852 jjstateSet[jjnewStateCnt++] = 29;
853 break;
854 case 32:
855 if (curChar == 118 && kind > 47)
856 kind = 47;
857 break;
858 case 33:
859 if (curChar == 105)
860 jjstateSet[jjnewStateCnt++] = 32;
861 break;
862 case 34:
863 if (curChar == 100)
864 jjstateSet[jjnewStateCnt++] = 33;
865 break;
866 case 36:
867 if ((0x7fffffe87ffffffL & l) == 0L)
868 break;
869 if (kind > 56)
870 kind = 56;
871 jjCheckNAdd(37);
872 break;
873 case 37:
874 if ((0x7fffffe87ffffffL & l) == 0L)
875 break;
876 if (kind > 56)
877 kind = 56;
878 jjCheckNAdd(37);
879 break;
880 case 40:
881 if ((0x110000001100L & l) != 0L && kind > 60)
882 kind = 60;
883 break;
884 case 44:
885 if ((0x2000000020L & l) != 0L)
886 jjAddStates(29, 30);
887 break;
888 case 47:
889 if ((0x5400000054L & l) != 0L && kind > 61)
890 kind = 61;
891 break;
892 case 49:
893 if ((0xffffffffefffffffL & l) != 0L)
894 jjCheckNAddStates(5, 7);
895 break;
896 case 50:
897 if (curChar == 92)
898 jjstateSet[jjnewStateCnt++] = 51;
899 break;
900 case 51:
901 jjCheckNAddStates(5, 7);
902 break;
903 case 54:
904 if ((0xffffffffefffffffL & l) != 0L)
905 jjCheckNAddStates(2, 4);
906 break;
907 case 55:
908 if (curChar == 92)
909 jjstateSet[jjnewStateCnt++] = 56;
910 break;
911 case 56:
912 jjCheckNAddStates(2, 4);
913 break;
914 case 60:
915 if ((0x100000001000000L & l) != 0L)
916 jjCheckNAdd(61);
917 break;
918 case 61:
919 if ((0x7e0000007eL & l) == 0L)
920 break;
921 if (kind > 60)
922 kind = 60;
923 jjCheckNAddTwoStates(61, 40);
924 break;
925 case 64:
926 jjCheckNAddTwoStates(64, 65);
927 break;
928 case 66:
929 case 67:
930 jjCheckNAddTwoStates(67, 65);
931 break;
932 case 70:
933 if (kind > 3)
934 kind = 3;
935 jjAddStates(20, 22);
936 break;
937 case 74:
938 if (curChar == 110)
939 jjAddStates(27, 28);
940 break;
941 case 76:
942 if (curChar == 116 && kind > 48)
943 kind = 48;
944 break;
945 case 77:
946 if (curChar == 111)
947 jjstateSet[jjnewStateCnt++] = 76;
948 break;
949 case 78:
950 if (curChar == 103)
951 jjAddStates(25, 26);
952 break;
953 case 79:
954 if (curChar == 116 && kind > 41)
955 kind = 41;
956 break;
957 case 80:
958 if (curChar == 101 && kind > 42)
959 kind = 42;
960 break;
961 case 81:
962 if (curChar == 108)
963 jjAddStates(23, 24);
964 break;
965 case 82:
966 if (curChar == 116 && kind > 43)
967 kind = 43;
968 break;
969 case 83:
970 if (curChar == 101 && kind > 44)
971 kind = 44;
972 break;
973 default : break;
974 }
975 } while(i != startsAt);
976 }
977 else
978 {
979 int hiByte = (int)(curChar >> 8);
980 int i1 = hiByte >> 6;
981 long l1 = 1L << (hiByte & 077);
982 int i2 = (curChar & 0xff) >> 6;
983 long l2 = 1L << (curChar & 077);
984 do
985 {
986 switch(jjstateSet[--i])
987 {
988 case 1:
989 if (!jjCanMove_0(hiByte, i1, i2, l1, l2))
990 break;
991 if (kind > 1)
992 kind = 1;
993 jjAddStates(11, 13);
994 break;
995 case 49:
996 case 51:
997 if (jjCanMove_1(hiByte, i1, i2, l1, l2))
998 jjCheckNAddStates(5, 7);
999 break;
1000 case 54:
1001 case 56:
1002 if (jjCanMove_1(hiByte, i1, i2, l1, l2))
1003 jjCheckNAddStates(2, 4);
1004 break;
1005 case 64:
1006 if (jjCanMove_0(hiByte, i1, i2, l1, l2))
1007 jjCheckNAddTwoStates(64, 65);
1008 break;
1009 case 66:
1010 case 67:
1011 if (jjCanMove_0(hiByte, i1, i2, l1, l2))
1012 jjCheckNAddTwoStates(67, 65);
1013 break;
1014 case 70:
1015 if (!jjCanMove_0(hiByte, i1, i2, l1, l2))
1016 break;
1017 if (kind > 3)
1018 kind = 3;
1019 jjAddStates(20, 22);
1020 break;
1021 default : break;
1022 }
1023 } while(i != startsAt);
1024 }
1025 if (kind != 0x7fffffff)
1026 {
1027 jjmatchedKind = kind;
1028 jjmatchedPos = curPos;
1029 kind = 0x7fffffff;
1030 }
1031 ++curPos;
1032 if ((i = jjnewStateCnt) == (startsAt = 84 - (jjnewStateCnt = startsAt)))
1033 return curPos;
1034 try { curChar = input_stream.readChar(); }
1035 catch(java.io.IOException e) { return curPos; }
1036 }
1037 }
1038 private final int jjStopStringLiteralDfa_1(int pos, long active0)
1039 {
1040 switch (pos)
1041 {
1042 case 0:
1043 if ((active0 & 0x7aba00L) != 0L)
1044 {
1045 jjmatchedKind = 56;
1046 return 37;
1047 }
1048 if ((active0 & 0x20000000000000L) != 0L)
1049 return 6;
1050 if ((active0 & 0x44000L) != 0L)
1051 {
1052 jjmatchedKind = 56;
1053 return 75;
1054 }
1055 if ((active0 & 0x40000000000000L) != 0L)
1056 return 11;
1057 if ((active0 & 0x10000000000L) != 0L)
1058 {
1059 jjmatchedKind = 48;
1060 return 19;
1061 }
1062 if ((active0 & 0x208000000000L) != 0L)
1063 return 15;
1064 if ((active0 & 0x10400L) != 0L)
1065 {
1066 jjmatchedKind = 56;
1067 return 17;
1068 }
1069 return -1;
1070 case 1:
1071 if ((active0 & 0x4000L) != 0L)
1072 {
1073 jjmatchedKind = 38;
1074 jjmatchedPos = 1;
1075 return 37;
1076 }
1077 if ((active0 & 0x3fbc00L) != 0L)
1078 {
1079 jjmatchedKind = 56;
1080 jjmatchedPos = 1;
1081 return 37;
1082 }
1083 if ((active0 & 0x400200L) != 0L)
1084 return 37;
1085 return -1;
1086 case 2:
1087 if ((active0 & 0xd800L) != 0L)
1088 return 37;
1089 if ((active0 & 0x3f2400L) != 0L)
1090 {
1091 if (jjmatchedPos != 2)
1092 {
1093 jjmatchedKind = 56;
1094 jjmatchedPos = 2;
1095 }
1096 return 37;
1097 }
1098 return -1;
1099 case 3:
1100 if ((active0 & 0x313000L) != 0L)
1101 {
1102 jjmatchedKind = 56;
1103 jjmatchedPos = 3;
1104 return 37;
1105 }
1106 if ((active0 & 0xe0400L) != 0L)
1107 return 37;
1108 return -1;
1109 case 4:
1110 if ((active0 & 0x201000L) != 0L)
1111 {
1112 jjmatchedKind = 56;
1113 jjmatchedPos = 4;
1114 return 37;
1115 }
1116 if ((active0 & 0x112000L) != 0L)
1117 return 37;
1118 return -1;
1119 case 5:
1120 if ((active0 & 0x1000L) != 0L)
1121 {
1122 jjmatchedKind = 56;
1123 jjmatchedPos = 5;
1124 return 37;
1125 }
1126 if ((active0 & 0x200000L) != 0L)
1127 return 37;
1128 return -1;
1129 default :
1130 return -1;
1131 }
1132 }
1133 private final int jjStartNfa_1(int pos, long active0)
1134 {
1135 return jjMoveNfa_1(jjStopStringLiteralDfa_1(pos, active0), pos + 1);
1136 }
1137 private int jjMoveStringLiteralDfa0_1()
1138 {
1139 switch(curChar)
1140 {
1141 case 33:
1142 return jjMoveStringLiteralDfa1_1(0x10000000000L);
1143 case 38:
1144 return jjStartNfaWithStates_1(0, 53, 6);
1145 case 40:
1146 return jjStopAtPos(0, 23);
1147 case 41:
1148 return jjStopAtPos(0, 24);
1149 case 42:
1150 return jjStopAtPos(0, 51);
1151 case 43:
1152 return jjStopAtPos(0, 49);
1153 case 44:
1154 return jjStopAtPos(0, 31);
1155 case 45:
1156 return jjStopAtPos(0, 50);
1157 case 46:
1158 return jjStopAtPos(0, 32);
1159 case 58:
1160 return jjStopAtPos(0, 30);
1161 case 59:
1162 return jjStopAtPos(0, 29);
1163 case 61:
1164 jjmatchedKind = 45;
1165 return jjMoveStringLiteralDfa1_1(0x8000000000L);
1166 case 63:
1167 jjmatchedKind = 33;
1168 return jjMoveStringLiteralDfa1_1(0x400000000L);
1169 case 91:
1170 return jjStopAtPos(0, 27);
1171 case 93:
1172 return jjStopAtPos(0, 28);
1173 case 94:
1174 return jjStopAtPos(0, 55);
1175 case 101:
1176 return jjMoveStringLiteralDfa1_1(0x10400L);
1177 case 102:
1178 return jjMoveStringLiteralDfa1_1(0x101800L);
1179 case 105:
1180 return jjMoveStringLiteralDfa1_1(0x400200L);
1181 case 110:
1182 return jjMoveStringLiteralDfa1_1(0x44000L);
1183 case 114:
1184 return jjMoveStringLiteralDfa1_1(0x200000L);
1185 case 115:
1186 return jjMoveStringLiteralDfa1_1(0x20000L);
1187 case 116:
1188 return jjMoveStringLiteralDfa1_1(0x80000L);
1189 case 118:
1190 return jjMoveStringLiteralDfa1_1(0x8000L);
1191 case 119:
1192 return jjMoveStringLiteralDfa1_1(0x2000L);
1193 case 123:
1194 return jjStopAtPos(0, 25);
1195 case 124:
1196 return jjStartNfaWithStates_1(0, 54, 11);
1197 case 125:
1198 return jjStopAtPos(0, 26);
1199 case 126:
1200 return jjStopAtPos(0, 52);
1201 default :
1202 return jjMoveNfa_1(5, 0);
1203 }
1204 }
1205 private int jjMoveStringLiteralDfa1_1(long active0)
1206 {
1207 try { curChar = input_stream.readChar(); }
1208 catch(java.io.IOException e) {
1209 jjStopStringLiteralDfa_1(0, active0);
1210 return 1;
1211 }
1212 switch(curChar)
1213 {
1214 case 58:
1215 if ((active0 & 0x400000000L) != 0L)
1216 return jjStopAtPos(1, 34);
1217 break;
1218 case 97:
1219 return jjMoveStringLiteralDfa2_1(active0, 0x108000L);
1220 case 101:
1221 return jjMoveStringLiteralDfa2_1(active0, 0x204000L);
1222 case 102:
1223 if ((active0 & 0x200L) != 0L)
1224 return jjStartNfaWithStates_1(1, 9, 37);
1225 break;
1226 case 104:
1227 return jjMoveStringLiteralDfa2_1(active0, 0x2000L);
1228 case 105:
1229 return jjMoveStringLiteralDfa2_1(active0, 0x20000L);
1230 case 108:
1231 return jjMoveStringLiteralDfa2_1(active0, 0x400L);
1232 case 109:
1233 return jjMoveStringLiteralDfa2_1(active0, 0x10000L);
1234 case 110:
1235 if ((active0 & 0x400000L) != 0L)
1236 return jjStartNfaWithStates_1(1, 22, 37);
1237 break;
1238 case 111:
1239 return jjMoveStringLiteralDfa2_1(active0, 0x1800L);
1240 case 114:
1241 return jjMoveStringLiteralDfa2_1(active0, 0x80000L);
1242 case 117:
1243 return jjMoveStringLiteralDfa2_1(active0, 0x40000L);
1244 case 126:
1245 if ((active0 & 0x8000000000L) != 0L)
1246 return jjStopAtPos(1, 39);
1247 else if ((active0 & 0x10000000000L) != 0L)
1248 return jjStopAtPos(1, 40);
1249 break;
1250 default :
1251 break;
1252 }
1253 return jjStartNfa_1(0, active0);
1254 }
1255 private int jjMoveStringLiteralDfa2_1(long old0, long active0)
1256 {
1257 if (((active0 &= old0)) == 0L)
1258 return jjStartNfa_1(0, old0);
1259 try { curChar = input_stream.readChar(); }
1260 catch(java.io.IOException e) {
1261 jjStopStringLiteralDfa_1(1, active0);
1262 return 2;
1263 }
1264 switch(curChar)
1265 {
1266 case 105:
1267 return jjMoveStringLiteralDfa3_1(active0, 0x2000L);
1268 case 108:
1269 return jjMoveStringLiteralDfa3_1(active0, 0x140000L);
1270 case 112:
1271 return jjMoveStringLiteralDfa3_1(active0, 0x10000L);
1272 case 114:
1273 if ((active0 & 0x800L) != 0L)
1274 {
1275 jjmatchedKind = 11;
1276 jjmatchedPos = 2;
1277 }
1278 else if ((active0 & 0x8000L) != 0L)
1279 return jjStartNfaWithStates_1(2, 15, 37);
1280 return jjMoveStringLiteralDfa3_1(active0, 0x1000L);
1281 case 115:
1282 return jjMoveStringLiteralDfa3_1(active0, 0x400L);
1283 case 116:
1284 return jjMoveStringLiteralDfa3_1(active0, 0x200000L);
1285 case 117:
1286 return jjMoveStringLiteralDfa3_1(active0, 0x80000L);
1287 case 119:
1288 if ((active0 & 0x4000L) != 0L)
1289 return jjStartNfaWithStates_1(2, 14, 37);
1290 break;
1291 case 122:
1292 return jjMoveStringLiteralDfa3_1(active0, 0x20000L);
1293 default :
1294 break;
1295 }
1296 return jjStartNfa_1(1, active0);
1297 }
1298 private int jjMoveStringLiteralDfa3_1(long old0, long active0)
1299 {
1300 if (((active0 &= old0)) == 0L)
1301 return jjStartNfa_1(1, old0);
1302 try { curChar = input_stream.readChar(); }
1303 catch(java.io.IOException e) {
1304 jjStopStringLiteralDfa_1(2, active0);
1305 return 3;
1306 }
1307 switch(curChar)
1308 {
1309 case 101:
1310 if ((active0 & 0x400L) != 0L)
1311 return jjStartNfaWithStates_1(3, 10, 37);
1312 else if ((active0 & 0x20000L) != 0L)
1313 return jjStartNfaWithStates_1(3, 17, 37);
1314 else if ((active0 & 0x80000L) != 0L)
1315 return jjStartNfaWithStates_1(3, 19, 37);
1316 return jjMoveStringLiteralDfa4_1(active0, 0x1000L);
1317 case 108:
1318 if ((active0 & 0x40000L) != 0L)
1319 return jjStartNfaWithStates_1(3, 18, 37);
1320 return jjMoveStringLiteralDfa4_1(active0, 0x2000L);
1321 case 115:
1322 return jjMoveStringLiteralDfa4_1(active0, 0x100000L);
1323 case 116:
1324 return jjMoveStringLiteralDfa4_1(active0, 0x10000L);
1325 case 117:
1326 return jjMoveStringLiteralDfa4_1(active0, 0x200000L);
1327 default :
1328 break;
1329 }
1330 return jjStartNfa_1(2, active0);
1331 }
1332 private int jjMoveStringLiteralDfa4_1(long old0, long active0)
1333 {
1334 if (((active0 &= old0)) == 0L)
1335 return jjStartNfa_1(2, old0);
1336 try { curChar = input_stream.readChar(); }
1337 catch(java.io.IOException e) {
1338 jjStopStringLiteralDfa_1(3, active0);
1339 return 4;
1340 }
1341 switch(curChar)
1342 {
1343 case 97:
1344 return jjMoveStringLiteralDfa5_1(active0, 0x1000L);
1345 case 101:
1346 if ((active0 & 0x2000L) != 0L)
1347 return jjStartNfaWithStates_1(4, 13, 37);
1348 else if ((active0 & 0x100000L) != 0L)
1349 return jjStartNfaWithStates_1(4, 20, 37);
1350 break;
1351 case 114:
1352 return jjMoveStringLiteralDfa5_1(active0, 0x200000L);
1353 case 121:
1354 if ((active0 & 0x10000L) != 0L)
1355 return jjStartNfaWithStates_1(4, 16, 37);
1356 break;
1357 default :
1358 break;
1359 }
1360 return jjStartNfa_1(3, active0);
1361 }
1362 private int jjMoveStringLiteralDfa5_1(long old0, long active0)
1363 {
1364 if (((active0 &= old0)) == 0L)
1365 return jjStartNfa_1(3, old0);
1366 try { curChar = input_stream.readChar(); }
1367 catch(java.io.IOException e) {
1368 jjStopStringLiteralDfa_1(4, active0);
1369 return 5;
1370 }
1371 switch(curChar)
1372 {
1373 case 99:
1374 return jjMoveStringLiteralDfa6_1(active0, 0x1000L);
1375 case 110:
1376 if ((active0 & 0x200000L) != 0L)
1377 return jjStartNfaWithStates_1(5, 21, 37);
1378 break;
1379 default :
1380 break;
1381 }
1382 return jjStartNfa_1(4, active0);
1383 }
1384 private int jjMoveStringLiteralDfa6_1(long old0, long active0)
1385 {
1386 if (((active0 &= old0)) == 0L)
1387 return jjStartNfa_1(4, old0);
1388 try { curChar = input_stream.readChar(); }
1389 catch(java.io.IOException e) {
1390 jjStopStringLiteralDfa_1(5, active0);
1391 return 6;
1392 }
1393 switch(curChar)
1394 {
1395 case 104:
1396 if ((active0 & 0x1000L) != 0L)
1397 return jjStartNfaWithStates_1(6, 12, 37);
1398 break;
1399 default :
1400 break;
1401 }
1402 return jjStartNfa_1(5, active0);
1403 }
1404 private int jjStartNfaWithStates_1(int pos, int kind, int state)
1405 {
1406 jjmatchedKind = kind;
1407 jjmatchedPos = pos;
1408 try { curChar = input_stream.readChar(); }
1409 catch(java.io.IOException e) { return pos + 1; }
1410 return jjMoveNfa_1(state, pos + 1);
1411 }
1412 private int jjMoveNfa_1(int startState, int curPos)
1413 {
1414 int startsAt = 0;
1415 jjnewStateCnt = 84;
1416 int i = 1;
1417 jjstateSet[0] = startState;
1418 int kind = 0x7fffffff;
1419 for (;;)
1420 {
1421 if (++jjround == 0x7fffffff)
1422 ReInitRounds();
1423 if (curChar < 64)
1424 {
1425 long l = 1L << curChar;
1426 do
1427 {
1428 switch(jjstateSet[--i])
1429 {
1430 case 17:
1431 case 37:
1432 if ((0x3ff001000000000L & l) == 0L)
1433 break;
1434 if (kind > 56)
1435 kind = 56;
1436 jjCheckNAdd(37);
1437 break;
1438 case 75:
1439 if ((0x3ff001000000000L & l) == 0L)
1440 break;
1441 if (kind > 56)
1442 kind = 56;
1443 jjCheckNAdd(37);
1444 break;
1445 case 5:
1446 if ((0x3ff000000000000L & l) != 0L)
1447 jjCheckNAddTwoStates(41, 42);
1448 else if (curChar == 47)
1449 jjAddStates(0, 1);
1450 else if (curChar == 39)
1451 jjCheckNAddStates(2, 4);
1452 else if (curChar == 34)
1453 jjCheckNAddStates(5, 7);
1454 else if (curChar == 36)
1455 {
1456 if (kind > 56)
1457 kind = 56;
1458 jjCheckNAdd(37);
1459 }
1460 else if (curChar == 33)
1461 {
1462 if (kind > 48)
1463 kind = 48;
1464 }
1465 else if (curChar == 37)
1466 {
1467 if (kind > 46)
1468 kind = 46;
1469 }
1470 else if (curChar == 60)
1471 jjstateSet[jjnewStateCnt++] = 25;
1472 else if (curChar == 62)
1473 jjstateSet[jjnewStateCnt++] = 22;
1474 else if (curChar == 61)
1475 jjstateSet[jjnewStateCnt++] = 15;
1476 else if (curChar == 38)
1477 jjstateSet[jjnewStateCnt++] = 6;
1478 else if (curChar == 35)
1479 jjstateSet[jjnewStateCnt++] = 0;
1480 if ((0x3fe000000000000L & l) != 0L)
1481 {
1482 if (kind > 60)
1483 kind = 60;
1484 jjCheckNAddTwoStates(39, 40);
1485 }
1486 else if (curChar == 48)
1487 {
1488 if (kind > 60)
1489 kind = 60;
1490 jjCheckNAddStates(8, 10);
1491 }
1492 else if (curChar == 47)
1493 {
1494 if (kind > 47)
1495 kind = 47;
1496 }
1497 else if (curChar == 60)
1498 {
1499 if (kind > 43)
1500 kind = 43;
1501 }
1502 else if (curChar == 62)
1503 {
1504 if (kind > 41)
1505 kind = 41;
1506 }
1507 else if (curChar == 33)
1508 jjstateSet[jjnewStateCnt++] = 19;
1509 break;
1510 case 0:
1511 if (curChar != 35)
1512 break;
1513 if (kind > 1)
1514 kind = 1;
1515 jjCheckNAddStates(11, 13);
1516 break;
1517 case 1:
1518 if ((0xffffffffffffdbffL & l) == 0L)
1519 break;
1520 if (kind > 1)
1521 kind = 1;
1522 jjCheckNAddStates(11, 13);
1523 break;
1524 case 2:
1525 if ((0x2400L & l) != 0L && kind > 1)
1526 kind = 1;
1527 break;
1528 case 3:
1529 if (curChar == 10 && kind > 1)
1530 kind = 1;
1531 break;
1532 case 4:
1533 if (curChar == 13)
1534 jjstateSet[jjnewStateCnt++] = 3;
1535 break;
1536 case 6:
1537 if (curChar == 38 && kind > 35)
1538 kind = 35;
1539 break;
1540 case 7:
1541 if (curChar == 38)
1542 jjstateSet[jjnewStateCnt++] = 6;
1543 break;
1544 case 15:
1545 if (curChar == 61 && kind > 37)
1546 kind = 37;
1547 break;
1548 case 16:
1549 if (curChar == 61)
1550 jjstateSet[jjnewStateCnt++] = 15;
1551 break;
1552 case 19:
1553 if (curChar == 61 && kind > 38)
1554 kind = 38;
1555 break;
1556 case 20:
1557 if (curChar == 33)
1558 jjstateSet[jjnewStateCnt++] = 19;
1559 break;
1560 case 21:
1561 if (curChar == 62 && kind > 41)
1562 kind = 41;
1563 break;
1564 case 22:
1565 if (curChar == 61 && kind > 42)
1566 kind = 42;
1567 break;
1568 case 23:
1569 if (curChar == 62)
1570 jjstateSet[jjnewStateCnt++] = 22;
1571 break;
1572 case 24:
1573 if (curChar == 60 && kind > 43)
1574 kind = 43;
1575 break;
1576 case 25:
1577 if (curChar == 61 && kind > 44)
1578 kind = 44;
1579 break;
1580 case 26:
1581 if (curChar == 60)
1582 jjstateSet[jjnewStateCnt++] = 25;
1583 break;
1584 case 27:
1585 if (curChar == 37 && kind > 46)
1586 kind = 46;
1587 break;
1588 case 31:
1589 if (curChar == 47 && kind > 47)
1590 kind = 47;
1591 break;
1592 case 35:
1593 if (curChar == 33 && kind > 48)
1594 kind = 48;
1595 break;
1596 case 36:
1597 if (curChar != 36)
1598 break;
1599 if (kind > 56)
1600 kind = 56;
1601 jjCheckNAdd(37);
1602 break;
1603 case 38:
1604 if ((0x3fe000000000000L & l) == 0L)
1605 break;
1606 if (kind > 60)
1607 kind = 60;
1608 jjCheckNAddTwoStates(39, 40);
1609 break;
1610 case 39:
1611 if ((0x3ff000000000000L & l) == 0L)
1612 break;
1613 if (kind > 60)
1614 kind = 60;
1615 jjCheckNAddTwoStates(39, 40);
1616 break;
1617 case 41:
1618 if ((0x3ff000000000000L & l) != 0L)
1619 jjCheckNAddTwoStates(41, 42);
1620 break;
1621 case 42:
1622 if (curChar == 46)
1623 jjCheckNAdd(43);
1624 break;
1625 case 43:
1626 if ((0x3ff000000000000L & l) == 0L)
1627 break;
1628 if (kind > 61)
1629 kind = 61;
1630 jjCheckNAddStates(14, 16);
1631 break;
1632 case 45:
1633 if ((0x280000000000L & l) != 0L)
1634 jjCheckNAdd(46);
1635 break;
1636 case 46:
1637 if ((0x3ff000000000000L & l) == 0L)
1638 break;
1639 if (kind > 61)
1640 kind = 61;
1641 jjCheckNAddTwoStates(46, 47);
1642 break;
1643 case 48:
1644 if (curChar == 34)
1645 jjCheckNAddStates(5, 7);
1646 break;
1647 case 49:
1648 if ((0xfffffffbffffdbffL & l) != 0L)
1649 jjCheckNAddStates(5, 7);
1650 break;
1651 case 51:
1652 if ((0xffffffffffffdbffL & l) != 0L)
1653 jjCheckNAddStates(5, 7);
1654 break;
1655 case 52:
1656 if (curChar == 34 && kind > 62)
1657 kind = 62;
1658 break;
1659 case 53:
1660 if (curChar == 39)
1661 jjCheckNAddStates(2, 4);
1662 break;
1663 case 54:
1664 if ((0xffffff7fffffdbffL & l) != 0L)
1665 jjCheckNAddStates(2, 4);
1666 break;
1667 case 56:
1668 if ((0xffffffffffffdbffL & l) != 0L)
1669 jjCheckNAddStates(2, 4);
1670 break;
1671 case 57:
1672 if (curChar == 39 && kind > 62)
1673 kind = 62;
1674 break;
1675 case 58:
1676 if (curChar != 48)
1677 break;
1678 if (kind > 60)
1679 kind = 60;
1680 jjCheckNAddStates(8, 10);
1681 break;
1682 case 59:
1683 if ((0xff000000000000L & l) == 0L)
1684 break;
1685 if (kind > 60)
1686 kind = 60;
1687 jjCheckNAddTwoStates(59, 40);
1688 break;
1689 case 61:
1690 if ((0x3ff000000000000L & l) == 0L)
1691 break;
1692 if (kind > 60)
1693 kind = 60;
1694 jjCheckNAddTwoStates(61, 40);
1695 break;
1696 case 62:
1697 if (curChar == 47)
1698 jjAddStates(0, 1);
1699 break;
1700 case 63:
1701 if (curChar == 42)
1702 jjCheckNAddTwoStates(64, 65);
1703 break;
1704 case 64:
1705 if ((0xfffffbffffffffffL & l) != 0L)
1706 jjCheckNAddTwoStates(64, 65);
1707 break;
1708 case 65:
1709 if (curChar == 42)
1710 jjCheckNAddStates(17, 19);
1711 break;
1712 case 66:
1713 if ((0xffff7bffffffffffL & l) != 0L)
1714 jjCheckNAddTwoStates(67, 65);
1715 break;
1716 case 67:
1717 if ((0xfffffbffffffffffL & l) != 0L)
1718 jjCheckNAddTwoStates(67, 65);
1719 break;
1720 case 68:
1721 if (curChar == 47 && kind > 2)
1722 kind = 2;
1723 break;
1724 case 69:
1725 if (curChar != 47)
1726 break;
1727 if (kind > 3)
1728 kind = 3;
1729 jjCheckNAddStates(20, 22);
1730 break;
1731 case 70:
1732 if ((0xffffffffffffdbffL & l) == 0L)
1733 break;
1734 if (kind > 3)
1735 kind = 3;
1736 jjCheckNAddStates(20, 22);
1737 break;
1738 case 71:
1739 if ((0x2400L & l) != 0L && kind > 3)
1740 kind = 3;
1741 break;
1742 case 72:
1743 if (curChar == 10 && kind > 3)
1744 kind = 3;
1745 break;
1746 case 73:
1747 if (curChar == 13)
1748 jjstateSet[jjnewStateCnt++] = 72;
1749 break;
1750 default : break;
1751 }
1752 } while(i != startsAt);
1753 }
1754 else if (curChar < 128)
1755 {
1756 long l = 1L << (curChar & 077);
1757 do
1758 {
1759 switch(jjstateSet[--i])
1760 {
1761 case 17:
1762 if ((0x7fffffe87ffffffL & l) != 0L)
1763 {
1764 if (kind > 56)
1765 kind = 56;
1766 jjCheckNAdd(37);
1767 }
1768 if (curChar == 113)
1769 {
1770 if (kind > 37)
1771 kind = 37;
1772 }
1773 break;
1774 case 75:
1775 if ((0x7fffffe87ffffffL & l) != 0L)
1776 {
1777 if (kind > 56)
1778 kind = 56;
1779 jjCheckNAdd(37);
1780 }
1781 if (curChar == 111)
1782 jjstateSet[jjnewStateCnt++] = 76;
1783 else if (curChar == 101)
1784 {
1785 if (kind > 38)
1786 kind = 38;
1787 }
1788 break;
1789 case 5:
1790 if ((0x7fffffe87ffffffL & l) != 0L)
1791 {
1792 if (kind > 56)
1793 kind = 56;
1794 jjCheckNAdd(37);
1795 }
1796 else if (curChar == 124)
1797 jjstateSet[jjnewStateCnt++] = 11;
1798 if (curChar == 108)
1799 jjAddStates(23, 24);
1800 else if (curChar == 103)
1801 jjAddStates(25, 26);
1802 else if (curChar == 110)
1803 jjAddStates(27, 28);
1804 else if (curChar == 100)
1805 jjstateSet[jjnewStateCnt++] = 33;
1806 else if (curChar == 109)
1807 jjstateSet[jjnewStateCnt++] = 29;
1808 else if (curChar == 101)
1809 jjstateSet[jjnewStateCnt++] = 17;
1810 else if (curChar == 111)
1811 jjstateSet[jjnewStateCnt++] = 13;
1812 else if (curChar == 97)
1813 jjstateSet[jjnewStateCnt++] = 9;
1814 break;
1815 case 1:
1816 if (kind > 1)
1817 kind = 1;
1818 jjAddStates(11, 13);
1819 break;
1820 case 8:
1821 if (curChar == 100 && kind > 35)
1822 kind = 35;
1823 break;
1824 case 9:
1825 if (curChar == 110)
1826 jjstateSet[jjnewStateCnt++] = 8;
1827 break;
1828 case 10:
1829 if (curChar == 97)
1830 jjstateSet[jjnewStateCnt++] = 9;
1831 break;
1832 case 11:
1833 if (curChar == 124 && kind > 36)
1834 kind = 36;
1835 break;
1836 case 12:
1837 if (curChar == 124)
1838 jjstateSet[jjnewStateCnt++] = 11;
1839 break;
1840 case 13:
1841 if (curChar == 114 && kind > 36)
1842 kind = 36;
1843 break;
1844 case 14:
1845 if (curChar == 111)
1846 jjstateSet[jjnewStateCnt++] = 13;
1847 break;
1848 case 18:
1849 if (curChar == 101)
1850 jjstateSet[jjnewStateCnt++] = 17;
1851 break;
1852 case 28:
1853 if (curChar == 100 && kind > 46)
1854 kind = 46;
1855 break;
1856 case 29:
1857 if (curChar == 111)
1858 jjstateSet[jjnewStateCnt++] = 28;
1859 break;
1860 case 30:
1861 if (curChar == 109)
1862 jjstateSet[jjnewStateCnt++] = 29;
1863 break;
1864 case 32:
1865 if (curChar == 118 && kind > 47)
1866 kind = 47;
1867 break;
1868 case 33:
1869 if (curChar == 105)
1870 jjstateSet[jjnewStateCnt++] = 32;
1871 break;
1872 case 34:
1873 if (curChar == 100)
1874 jjstateSet[jjnewStateCnt++] = 33;
1875 break;
1876 case 36:
1877 if ((0x7fffffe87ffffffL & l) == 0L)
1878 break;
1879 if (kind > 56)
1880 kind = 56;
1881 jjCheckNAdd(37);
1882 break;
1883 case 37:
1884 if ((0x7fffffe87ffffffL & l) == 0L)
1885 break;
1886 if (kind > 56)
1887 kind = 56;
1888 jjCheckNAdd(37);
1889 break;
1890 case 40:
1891 if ((0x110000001100L & l) != 0L && kind > 60)
1892 kind = 60;
1893 break;
1894 case 44:
1895 if ((0x2000000020L & l) != 0L)
1896 jjAddStates(29, 30);
1897 break;
1898 case 47:
1899 if ((0x5400000054L & l) != 0L && kind > 61)
1900 kind = 61;
1901 break;
1902 case 49:
1903 if ((0xffffffffefffffffL & l) != 0L)
1904 jjCheckNAddStates(5, 7);
1905 break;
1906 case 50:
1907 if (curChar == 92)
1908 jjstateSet[jjnewStateCnt++] = 51;
1909 break;
1910 case 51:
1911 jjCheckNAddStates(5, 7);
1912 break;
1913 case 54:
1914 if ((0xffffffffefffffffL & l) != 0L)
1915 jjCheckNAddStates(2, 4);
1916 break;
1917 case 55:
1918 if (curChar == 92)
1919 jjstateSet[jjnewStateCnt++] = 56;
1920 break;
1921 case 56:
1922 jjCheckNAddStates(2, 4);
1923 break;
1924 case 60:
1925 if ((0x100000001000000L & l) != 0L)
1926 jjCheckNAdd(61);
1927 break;
1928 case 61:
1929 if ((0x7e0000007eL & l) == 0L)
1930 break;
1931 if (kind > 60)
1932 kind = 60;
1933 jjCheckNAddTwoStates(61, 40);
1934 break;
1935 case 64:
1936 jjCheckNAddTwoStates(64, 65);
1937 break;
1938 case 66:
1939 case 67:
1940 jjCheckNAddTwoStates(67, 65);
1941 break;
1942 case 70:
1943 if (kind > 3)
1944 kind = 3;
1945 jjAddStates(20, 22);
1946 break;
1947 case 74:
1948 if (curChar == 110)
1949 jjAddStates(27, 28);
1950 break;
1951 case 76:
1952 if (curChar == 116 && kind > 48)
1953 kind = 48;
1954 break;
1955 case 77:
1956 if (curChar == 111)
1957 jjstateSet[jjnewStateCnt++] = 76;
1958 break;
1959 case 78:
1960 if (curChar == 103)
1961 jjAddStates(25, 26);
1962 break;
1963 case 79:
1964 if (curChar == 116 && kind > 41)
1965 kind = 41;
1966 break;
1967 case 80:
1968 if (curChar == 101 && kind > 42)
1969 kind = 42;
1970 break;
1971 case 81:
1972 if (curChar == 108)
1973 jjAddStates(23, 24);
1974 break;
1975 case 82:
1976 if (curChar == 116 && kind > 43)
1977 kind = 43;
1978 break;
1979 case 83:
1980 if (curChar == 101 && kind > 44)
1981 kind = 44;
1982 break;
1983 default : break;
1984 }
1985 } while(i != startsAt);
1986 }
1987 else
1988 {
1989 int hiByte = (int)(curChar >> 8);
1990 int i1 = hiByte >> 6;
1991 long l1 = 1L << (hiByte & 077);
1992 int i2 = (curChar & 0xff) >> 6;
1993 long l2 = 1L << (curChar & 077);
1994 do
1995 {
1996 switch(jjstateSet[--i])
1997 {
1998 case 1:
1999 if (!jjCanMove_0(hiByte, i1, i2, l1, l2))
2000 break;
2001 if (kind > 1)
2002 kind = 1;
2003 jjAddStates(11, 13);
2004 break;
2005 case 49:
2006 case 51:
2007 if (jjCanMove_1(hiByte, i1, i2, l1, l2))
2008 jjCheckNAddStates(5, 7);
2009 break;
2010 case 54:
2011 case 56:
2012 if (jjCanMove_1(hiByte, i1, i2, l1, l2))
2013 jjCheckNAddStates(2, 4);
2014 break;
2015 case 64:
2016 if (jjCanMove_0(hiByte, i1, i2, l1, l2))
2017 jjCheckNAddTwoStates(64, 65);
2018 break;
2019 case 66:
2020 case 67:
2021 if (jjCanMove_0(hiByte, i1, i2, l1, l2))
2022 jjCheckNAddTwoStates(67, 65);
2023 break;
2024 case 70:
2025 if (!jjCanMove_0(hiByte, i1, i2, l1, l2))
2026 break;
2027 if (kind > 3)
2028 kind = 3;
2029 jjAddStates(20, 22);
2030 break;
2031 default : break;
2032 }
2033 } while(i != startsAt);
2034 }
2035 if (kind != 0x7fffffff)
2036 {
2037 jjmatchedKind = kind;
2038 jjmatchedPos = curPos;
2039 kind = 0x7fffffff;
2040 }
2041 ++curPos;
2042 if ((i = jjnewStateCnt) == (startsAt = 84 - (jjnewStateCnt = startsAt)))
2043 return curPos;
2044 try { curChar = input_stream.readChar(); }
2045 catch(java.io.IOException e) { return curPos; }
2046 }
2047 }
2048 private final int jjStopStringLiteralDfa_0(int pos, long active0)
2049 {
2050 switch (pos)
2051 {
2052 case 0:
2053 if ((active0 & 0x3aba00L) != 0L)
2054 {
2055 jjmatchedKind = 56;
2056 return 37;
2057 }
2058 if ((active0 & 0x20000000000000L) != 0L)
2059 return 6;
2060 if ((active0 & 0x44000L) != 0L)
2061 {
2062 jjmatchedKind = 56;
2063 return 77;
2064 }
2065 if ((active0 & 0x40000000000000L) != 0L)
2066 return 11;
2067 if ((active0 & 0x10000000000L) != 0L)
2068 {
2069 jjmatchedKind = 48;
2070 return 19;
2071 }
2072 if ((active0 & 0x208000000000L) != 0L)
2073 return 15;
2074 if ((active0 & 0x10400L) != 0L)
2075 {
2076 jjmatchedKind = 56;
2077 return 17;
2078 }
2079 return -1;
2080 case 1:
2081 if ((active0 & 0x4000L) != 0L)
2082 {
2083 jjmatchedKind = 38;
2084 jjmatchedPos = 1;
2085 return 37;
2086 }
2087 if ((active0 & 0x3fbc00L) != 0L)
2088 {
2089 jjmatchedKind = 56;
2090 jjmatchedPos = 1;
2091 return 37;
2092 }
2093 if ((active0 & 0x200L) != 0L)
2094 return 37;
2095 return -1;
2096 case 2:
2097 if ((active0 & 0xd800L) != 0L)
2098 return 37;
2099 if ((active0 & 0x3f2400L) != 0L)
2100 {
2101 if (jjmatchedPos != 2)
2102 {
2103 jjmatchedKind = 56;
2104 jjmatchedPos = 2;
2105 }
2106 return 37;
2107 }
2108 return -1;
2109 case 3:
2110 if ((active0 & 0x313000L) != 0L)
2111 {
2112 jjmatchedKind = 56;
2113 jjmatchedPos = 3;
2114 return 37;
2115 }
2116 if ((active0 & 0xe0400L) != 0L)
2117 return 37;
2118 return -1;
2119 case 4:
2120 if ((active0 & 0x201000L) != 0L)
2121 {
2122 jjmatchedKind = 56;
2123 jjmatchedPos = 4;
2124 return 37;
2125 }
2126 if ((active0 & 0x112000L) != 0L)
2127 return 37;
2128 return -1;
2129 case 5:
2130 if ((active0 & 0x1000L) != 0L)
2131 {
2132 jjmatchedKind = 56;
2133 jjmatchedPos = 5;
2134 return 37;
2135 }
2136 if ((active0 & 0x200000L) != 0L)
2137 return 37;
2138 return -1;
2139 default :
2140 return -1;
2141 }
2142 }
2143 private final int jjStartNfa_0(int pos, long active0)
2144 {
2145 return jjMoveNfa_0(jjStopStringLiteralDfa_0(pos, active0), pos + 1);
2146 }
2147 private int jjMoveStringLiteralDfa0_0()
2148 {
2149 switch(curChar)
2150 {
2151 case 33:
2152 return jjMoveStringLiteralDfa1_0(0x10000000000L);
2153 case 38:
2154 return jjStartNfaWithStates_0(0, 53, 6);
2155 case 40:
2156 return jjStopAtPos(0, 23);
2157 case 41:
2158 return jjStopAtPos(0, 24);
2159 case 42:
2160 return jjStopAtPos(0, 51);
2161 case 43:
2162 return jjStopAtPos(0, 49);
2163 case 44:
2164 return jjStopAtPos(0, 31);
2165 case 45:
2166 return jjStopAtPos(0, 50);
2167 case 46:
2168 return jjStopAtPos(0, 32);
2169 case 58:
2170 return jjStopAtPos(0, 30);
2171 case 59:
2172 return jjStopAtPos(0, 29);
2173 case 61:
2174 jjmatchedKind = 45;
2175 return jjMoveStringLiteralDfa1_0(0x8000000000L);
2176 case 63:
2177 jjmatchedKind = 33;
2178 return jjMoveStringLiteralDfa1_0(0x400000000L);
2179 case 91:
2180 return jjStopAtPos(0, 27);
2181 case 93:
2182 return jjStopAtPos(0, 28);
2183 case 94:
2184 return jjStopAtPos(0, 55);
2185 case 101:
2186 return jjMoveStringLiteralDfa1_0(0x10400L);
2187 case 102:
2188 return jjMoveStringLiteralDfa1_0(0x101800L);
2189 case 105:
2190 return jjMoveStringLiteralDfa1_0(0x200L);
2191 case 110:
2192 return jjMoveStringLiteralDfa1_0(0x44000L);
2193 case 114:
2194 return jjMoveStringLiteralDfa1_0(0x200000L);
2195 case 115:
2196 return jjMoveStringLiteralDfa1_0(0x20000L);
2197 case 116:
2198 return jjMoveStringLiteralDfa1_0(0x80000L);
2199 case 118:
2200 return jjMoveStringLiteralDfa1_0(0x8000L);
2201 case 119:
2202 return jjMoveStringLiteralDfa1_0(0x2000L);
2203 case 123:
2204 return jjStopAtPos(0, 25);
2205 case 124:
2206 return jjStartNfaWithStates_0(0, 54, 11);
2207 case 125:
2208 return jjStopAtPos(0, 26);
2209 case 126:
2210 return jjStopAtPos(0, 52);
2211 default :
2212 return jjMoveNfa_0(5, 0);
2213 }
2214 }
2215 private int jjMoveStringLiteralDfa1_0(long active0)
2216 {
2217 try { curChar = input_stream.readChar(); }
2218 catch(java.io.IOException e) {
2219 jjStopStringLiteralDfa_0(0, active0);
2220 return 1;
2221 }
2222 switch(curChar)
2223 {
2224 case 58:
2225 if ((active0 & 0x400000000L) != 0L)
2226 return jjStopAtPos(1, 34);
2227 break;
2228 case 97:
2229 return jjMoveStringLiteralDfa2_0(active0, 0x108000L);
2230 case 101:
2231 return jjMoveStringLiteralDfa2_0(active0, 0x204000L);
2232 case 102:
2233 if ((active0 & 0x200L) != 0L)
2234 return jjStartNfaWithStates_0(1, 9, 37);
2235 break;
2236 case 104:
2237 return jjMoveStringLiteralDfa2_0(active0, 0x2000L);
2238 case 105:
2239 return jjMoveStringLiteralDfa2_0(active0, 0x20000L);
2240 case 108:
2241 return jjMoveStringLiteralDfa2_0(active0, 0x400L);
2242 case 109:
2243 return jjMoveStringLiteralDfa2_0(active0, 0x10000L);
2244 case 111:
2245 return jjMoveStringLiteralDfa2_0(active0, 0x1800L);
2246 case 114:
2247 return jjMoveStringLiteralDfa2_0(active0, 0x80000L);
2248 case 117:
2249 return jjMoveStringLiteralDfa2_0(active0, 0x40000L);
2250 case 126:
2251 if ((active0 & 0x8000000000L) != 0L)
2252 return jjStopAtPos(1, 39);
2253 else if ((active0 & 0x10000000000L) != 0L)
2254 return jjStopAtPos(1, 40);
2255 break;
2256 default :
2257 break;
2258 }
2259 return jjStartNfa_0(0, active0);
2260 }
2261 private int jjMoveStringLiteralDfa2_0(long old0, long active0)
2262 {
2263 if (((active0 &= old0)) == 0L)
2264 return jjStartNfa_0(0, old0);
2265 try { curChar = input_stream.readChar(); }
2266 catch(java.io.IOException e) {
2267 jjStopStringLiteralDfa_0(1, active0);
2268 return 2;
2269 }
2270 switch(curChar)
2271 {
2272 case 105:
2273 return jjMoveStringLiteralDfa3_0(active0, 0x2000L);
2274 case 108:
2275 return jjMoveStringLiteralDfa3_0(active0, 0x140000L);
2276 case 112:
2277 return jjMoveStringLiteralDfa3_0(active0, 0x10000L);
2278 case 114:
2279 if ((active0 & 0x800L) != 0L)
2280 {
2281 jjmatchedKind = 11;
2282 jjmatchedPos = 2;
2283 }
2284 else if ((active0 & 0x8000L) != 0L)
2285 return jjStartNfaWithStates_0(2, 15, 37);
2286 return jjMoveStringLiteralDfa3_0(active0, 0x1000L);
2287 case 115:
2288 return jjMoveStringLiteralDfa3_0(active0, 0x400L);
2289 case 116:
2290 return jjMoveStringLiteralDfa3_0(active0, 0x200000L);
2291 case 117:
2292 return jjMoveStringLiteralDfa3_0(active0, 0x80000L);
2293 case 119:
2294 if ((active0 & 0x4000L) != 0L)
2295 return jjStartNfaWithStates_0(2, 14, 37);
2296 break;
2297 case 122:
2298 return jjMoveStringLiteralDfa3_0(active0, 0x20000L);
2299 default :
2300 break;
2301 }
2302 return jjStartNfa_0(1, active0);
2303 }
2304 private int jjMoveStringLiteralDfa3_0(long old0, long active0)
2305 {
2306 if (((active0 &= old0)) == 0L)
2307 return jjStartNfa_0(1, old0);
2308 try { curChar = input_stream.readChar(); }
2309 catch(java.io.IOException e) {
2310 jjStopStringLiteralDfa_0(2, active0);
2311 return 3;
2312 }
2313 switch(curChar)
2314 {
2315 case 101:
2316 if ((active0 & 0x400L) != 0L)
2317 return jjStartNfaWithStates_0(3, 10, 37);
2318 else if ((active0 & 0x20000L) != 0L)
2319 return jjStartNfaWithStates_0(3, 17, 37);
2320 else if ((active0 & 0x80000L) != 0L)
2321 return jjStartNfaWithStates_0(3, 19, 37);
2322 return jjMoveStringLiteralDfa4_0(active0, 0x1000L);
2323 case 108:
2324 if ((active0 & 0x40000L) != 0L)
2325 return jjStartNfaWithStates_0(3, 18, 37);
2326 return jjMoveStringLiteralDfa4_0(active0, 0x2000L);
2327 case 115:
2328 return jjMoveStringLiteralDfa4_0(active0, 0x100000L);
2329 case 116:
2330 return jjMoveStringLiteralDfa4_0(active0, 0x10000L);
2331 case 117:
2332 return jjMoveStringLiteralDfa4_0(active0, 0x200000L);
2333 default :
2334 break;
2335 }
2336 return jjStartNfa_0(2, active0);
2337 }
2338 private int jjMoveStringLiteralDfa4_0(long old0, long active0)
2339 {
2340 if (((active0 &= old0)) == 0L)
2341 return jjStartNfa_0(2, old0);
2342 try { curChar = input_stream.readChar(); }
2343 catch(java.io.IOException e) {
2344 jjStopStringLiteralDfa_0(3, active0);
2345 return 4;
2346 }
2347 switch(curChar)
2348 {
2349 case 97:
2350 return jjMoveStringLiteralDfa5_0(active0, 0x1000L);
2351 case 101:
2352 if ((active0 & 0x2000L) != 0L)
2353 return jjStartNfaWithStates_0(4, 13, 37);
2354 else if ((active0 & 0x100000L) != 0L)
2355 return jjStartNfaWithStates_0(4, 20, 37);
2356 break;
2357 case 114:
2358 return jjMoveStringLiteralDfa5_0(active0, 0x200000L);
2359 case 121:
2360 if ((active0 & 0x10000L) != 0L)
2361 return jjStartNfaWithStates_0(4, 16, 37);
2362 break;
2363 default :
2364 break;
2365 }
2366 return jjStartNfa_0(3, active0);
2367 }
2368 private int jjMoveStringLiteralDfa5_0(long old0, long active0)
2369 {
2370 if (((active0 &= old0)) == 0L)
2371 return jjStartNfa_0(3, old0);
2372 try { curChar = input_stream.readChar(); }
2373 catch(java.io.IOException e) {
2374 jjStopStringLiteralDfa_0(4, active0);
2375 return 5;
2376 }
2377 switch(curChar)
2378 {
2379 case 99:
2380 return jjMoveStringLiteralDfa6_0(active0, 0x1000L);
2381 case 110:
2382 if ((active0 & 0x200000L) != 0L)
2383 return jjStartNfaWithStates_0(5, 21, 37);
2384 break;
2385 default :
2386 break;
2387 }
2388 return jjStartNfa_0(4, active0);
2389 }
2390 private int jjMoveStringLiteralDfa6_0(long old0, long active0)
2391 {
2392 if (((active0 &= old0)) == 0L)
2393 return jjStartNfa_0(4, old0);
2394 try { curChar = input_stream.readChar(); }
2395 catch(java.io.IOException e) {
2396 jjStopStringLiteralDfa_0(5, active0);
2397 return 6;
2398 }
2399 switch(curChar)
2400 {
2401 case 104:
2402 if ((active0 & 0x1000L) != 0L)
2403 return jjStartNfaWithStates_0(6, 12, 37);
2404 break;
2405 default :
2406 break;
2407 }
2408 return jjStartNfa_0(5, active0);
2409 }
2410 private int jjStartNfaWithStates_0(int pos, int kind, int state)
2411 {
2412 jjmatchedKind = kind;
2413 jjmatchedPos = pos;
2414 try { curChar = input_stream.readChar(); }
2415 catch(java.io.IOException e) { return pos + 1; }
2416 return jjMoveNfa_0(state, pos + 1);
2417 }
2418 private int jjMoveNfa_0(int startState, int curPos)
2419 {
2420 int startsAt = 0;
2421 jjnewStateCnt = 86;
2422 int i = 1;
2423 jjstateSet[0] = startState;
2424 int kind = 0x7fffffff;
2425 for (;;)
2426 {
2427 if (++jjround == 0x7fffffff)
2428 ReInitRounds();
2429 if (curChar < 64)
2430 {
2431 long l = 1L << curChar;
2432 do
2433 {
2434 switch(jjstateSet[--i])
2435 {
2436 case 5:
2437 if ((0x3ff000000000000L & l) != 0L)
2438 jjCheckNAddTwoStates(43, 44);
2439 else if (curChar == 47)
2440 jjAddStates(31, 32);
2441 else if (curChar == 39)
2442 jjCheckNAddStates(33, 35);
2443 else if (curChar == 34)
2444 jjCheckNAddStates(36, 38);
2445 else if (curChar == 35)
2446 jjCheckNAdd(39);
2447 else if (curChar == 36)
2448 {
2449 if (kind > 56)
2450 kind = 56;
2451 jjCheckNAdd(37);
2452 }
2453 else if (curChar == 33)
2454 {
2455 if (kind > 48)
2456 kind = 48;
2457 }
2458 else if (curChar == 37)
2459 {
2460 if (kind > 46)
2461 kind = 46;
2462 }
2463 else if (curChar == 60)
2464 jjstateSet[jjnewStateCnt++] = 25;
2465 else if (curChar == 62)
2466 jjstateSet[jjnewStateCnt++] = 22;
2467 else if (curChar == 61)
2468 jjstateSet[jjnewStateCnt++] = 15;
2469 else if (curChar == 38)
2470 jjstateSet[jjnewStateCnt++] = 6;
2471 if ((0x3fe000000000000L & l) != 0L)
2472 {
2473 if (kind > 60)
2474 kind = 60;
2475 jjCheckNAddTwoStates(41, 42);
2476 }
2477 else if (curChar == 48)
2478 {
2479 if (kind > 60)
2480 kind = 60;
2481 jjCheckNAddStates(39, 41);
2482 }
2483 else if (curChar == 47)
2484 {
2485 if (kind > 47)
2486 kind = 47;
2487 }
2488 else if (curChar == 60)
2489 {
2490 if (kind > 43)
2491 kind = 43;
2492 }
2493 else if (curChar == 62)
2494 {
2495 if (kind > 41)
2496 kind = 41;
2497 }
2498 else if (curChar == 33)
2499 jjstateSet[jjnewStateCnt++] = 19;
2500 else if (curChar == 35)
2501 jjstateSet[jjnewStateCnt++] = 0;
2502 break;
2503 case 17:
2504 case 37:
2505 if ((0x3ff001000000000L & l) == 0L)
2506 break;
2507 if (kind > 56)
2508 kind = 56;
2509 jjCheckNAdd(37);
2510 break;
2511 case 77:
2512 if ((0x3ff001000000000L & l) == 0L)
2513 break;
2514 if (kind > 56)
2515 kind = 56;
2516 jjCheckNAdd(37);
2517 break;
2518 case 0:
2519 if (curChar != 35)
2520 break;
2521 if (kind > 1)
2522 kind = 1;
2523 jjCheckNAddStates(11, 13);
2524 break;
2525 case 1:
2526 if ((0xffffffffffffdbffL & l) == 0L)
2527 break;
2528 if (kind > 1)
2529 kind = 1;
2530 jjCheckNAddStates(11, 13);
2531 break;
2532 case 2:
2533 if ((0x2400L & l) != 0L && kind > 1)
2534 kind = 1;
2535 break;
2536 case 3:
2537 if (curChar == 10 && kind > 1)
2538 kind = 1;
2539 break;
2540 case 4:
2541 if (curChar == 13)
2542 jjstateSet[jjnewStateCnt++] = 3;
2543 break;
2544 case 6:
2545 if (curChar == 38 && kind > 35)
2546 kind = 35;
2547 break;
2548 case 7:
2549 if (curChar == 38)
2550 jjstateSet[jjnewStateCnt++] = 6;
2551 break;
2552 case 15:
2553 if (curChar == 61 && kind > 37)
2554 kind = 37;
2555 break;
2556 case 16:
2557 if (curChar == 61)
2558 jjstateSet[jjnewStateCnt++] = 15;
2559 break;
2560 case 19:
2561 if (curChar == 61 && kind > 38)
2562 kind = 38;
2563 break;
2564 case 20:
2565 if (curChar == 33)
2566 jjstateSet[jjnewStateCnt++] = 19;
2567 break;
2568 case 21:
2569 if (curChar == 62 && kind > 41)
2570 kind = 41;
2571 break;
2572 case 22:
2573 if (curChar == 61 && kind > 42)
2574 kind = 42;
2575 break;
2576 case 23:
2577 if (curChar == 62)
2578 jjstateSet[jjnewStateCnt++] = 22;
2579 break;
2580 case 24:
2581 if (curChar == 60 && kind > 43)
2582 kind = 43;
2583 break;
2584 case 25:
2585 if (curChar == 61 && kind > 44)
2586 kind = 44;
2587 break;
2588 case 26:
2589 if (curChar == 60)
2590 jjstateSet[jjnewStateCnt++] = 25;
2591 break;
2592 case 27:
2593 if (curChar == 37 && kind > 46)
2594 kind = 46;
2595 break;
2596 case 31:
2597 if (curChar == 47 && kind > 47)
2598 kind = 47;
2599 break;
2600 case 35:
2601 if (curChar == 33 && kind > 48)
2602 kind = 48;
2603 break;
2604 case 36:
2605 if (curChar != 36)
2606 break;
2607 if (kind > 56)
2608 kind = 56;
2609 jjCheckNAdd(37);
2610 break;
2611 case 38:
2612 if (curChar == 35)
2613 jjCheckNAdd(39);
2614 break;
2615 case 39:
2616 if ((0x3ff000000000000L & l) == 0L)
2617 break;
2618 if (kind > 59)
2619 kind = 59;
2620 jjCheckNAdd(39);
2621 break;
2622 case 40:
2623 if ((0x3fe000000000000L & l) == 0L)
2624 break;
2625 if (kind > 60)
2626 kind = 60;
2627 jjCheckNAddTwoStates(41, 42);
2628 break;
2629 case 41:
2630 if ((0x3ff000000000000L & l) == 0L)
2631 break;
2632 if (kind > 60)
2633 kind = 60;
2634 jjCheckNAddTwoStates(41, 42);
2635 break;
2636 case 43:
2637 if ((0x3ff000000000000L & l) != 0L)
2638 jjCheckNAddTwoStates(43, 44);
2639 break;
2640 case 44:
2641 if (curChar == 46)
2642 jjCheckNAdd(45);
2643 break;
2644 case 45:
2645 if ((0x3ff000000000000L & l) == 0L)
2646 break;
2647 if (kind > 61)
2648 kind = 61;
2649 jjCheckNAddStates(42, 44);
2650 break;
2651 case 47:
2652 if ((0x280000000000L & l) != 0L)
2653 jjCheckNAdd(48);
2654 break;
2655 case 48:
2656 if ((0x3ff000000000000L & l) == 0L)
2657 break;
2658 if (kind > 61)
2659 kind = 61;
2660 jjCheckNAddTwoStates(48, 49);
2661 break;
2662 case 50:
2663 if (curChar == 34)
2664 jjCheckNAddStates(36, 38);
2665 break;
2666 case 51:
2667 if ((0xfffffffbffffdbffL & l) != 0L)
2668 jjCheckNAddStates(36, 38);
2669 break;
2670 case 53:
2671 if ((0xffffffffffffdbffL & l) != 0L)
2672 jjCheckNAddStates(36, 38);
2673 break;
2674 case 54:
2675 if (curChar == 34 && kind > 62)
2676 kind = 62;
2677 break;
2678 case 55:
2679 if (curChar == 39)
2680 jjCheckNAddStates(33, 35);
2681 break;
2682 case 56:
2683 if ((0xffffff7fffffdbffL & l) != 0L)
2684 jjCheckNAddStates(33, 35);
2685 break;
2686 case 58:
2687 if ((0xffffffffffffdbffL & l) != 0L)
2688 jjCheckNAddStates(33, 35);
2689 break;
2690 case 59:
2691 if (curChar == 39 && kind > 62)
2692 kind = 62;
2693 break;
2694 case 60:
2695 if (curChar != 48)
2696 break;
2697 if (kind > 60)
2698 kind = 60;
2699 jjCheckNAddStates(39, 41);
2700 break;
2701 case 61:
2702 if ((0xff000000000000L & l) == 0L)
2703 break;
2704 if (kind > 60)
2705 kind = 60;
2706 jjCheckNAddTwoStates(61, 42);
2707 break;
2708 case 63:
2709 if ((0x3ff000000000000L & l) == 0L)
2710 break;
2711 if (kind > 60)
2712 kind = 60;
2713 jjCheckNAddTwoStates(63, 42);
2714 break;
2715 case 64:
2716 if (curChar == 47)
2717 jjAddStates(31, 32);
2718 break;
2719 case 65:
2720 if (curChar == 42)
2721 jjCheckNAddTwoStates(66, 67);
2722 break;
2723 case 66:
2724 if ((0xfffffbffffffffffL & l) != 0L)
2725 jjCheckNAddTwoStates(66, 67);
2726 break;
2727 case 67:
2728 if (curChar == 42)
2729 jjCheckNAddStates(45, 47);
2730 break;
2731 case 68:
2732 if ((0xffff7bffffffffffL & l) != 0L)
2733 jjCheckNAddTwoStates(69, 67);
2734 break;
2735 case 69:
2736 if ((0xfffffbffffffffffL & l) != 0L)
2737 jjCheckNAddTwoStates(69, 67);
2738 break;
2739 case 70:
2740 if (curChar == 47 && kind > 2)
2741 kind = 2;
2742 break;
2743 case 71:
2744 if (curChar != 47)
2745 break;
2746 if (kind > 3)
2747 kind = 3;
2748 jjCheckNAddStates(48, 50);
2749 break;
2750 case 72:
2751 if ((0xffffffffffffdbffL & l) == 0L)
2752 break;
2753 if (kind > 3)
2754 kind = 3;
2755 jjCheckNAddStates(48, 50);
2756 break;
2757 case 73:
2758 if ((0x2400L & l) != 0L && kind > 3)
2759 kind = 3;
2760 break;
2761 case 74:
2762 if (curChar == 10 && kind > 3)
2763 kind = 3;
2764 break;
2765 case 75:
2766 if (curChar == 13)
2767 jjstateSet[jjnewStateCnt++] = 74;
2768 break;
2769 default : break;
2770 }
2771 } while(i != startsAt);
2772 }
2773 else if (curChar < 128)
2774 {
2775 long l = 1L << (curChar & 077);
2776 do
2777 {
2778 switch(jjstateSet[--i])
2779 {
2780 case 5:
2781 if ((0x7fffffe87ffffffL & l) != 0L)
2782 {
2783 if (kind > 56)
2784 kind = 56;
2785 jjCheckNAdd(37);
2786 }
2787 else if (curChar == 124)
2788 jjstateSet[jjnewStateCnt++] = 11;
2789 if (curChar == 108)
2790 jjAddStates(51, 52);
2791 else if (curChar == 103)
2792 jjAddStates(53, 54);
2793 else if (curChar == 110)
2794 jjAddStates(55, 56);
2795 else if (curChar == 100)
2796 jjstateSet[jjnewStateCnt++] = 33;
2797 else if (curChar == 109)
2798 jjstateSet[jjnewStateCnt++] = 29;
2799 else if (curChar == 101)
2800 jjstateSet[jjnewStateCnt++] = 17;
2801 else if (curChar == 111)
2802 jjstateSet[jjnewStateCnt++] = 13;
2803 else if (curChar == 97)
2804 jjstateSet[jjnewStateCnt++] = 9;
2805 break;
2806 case 17:
2807 if ((0x7fffffe87ffffffL & l) != 0L)
2808 {
2809 if (kind > 56)
2810 kind = 56;
2811 jjCheckNAdd(37);
2812 }
2813 if (curChar == 113)
2814 {
2815 if (kind > 37)
2816 kind = 37;
2817 }
2818 break;
2819 case 77:
2820 if ((0x7fffffe87ffffffL & l) != 0L)
2821 {
2822 if (kind > 56)
2823 kind = 56;
2824 jjCheckNAdd(37);
2825 }
2826 if (curChar == 111)
2827 jjstateSet[jjnewStateCnt++] = 78;
2828 else if (curChar == 101)
2829 {
2830 if (kind > 38)
2831 kind = 38;
2832 }
2833 break;
2834 case 1:
2835 if (kind > 1)
2836 kind = 1;
2837 jjAddStates(11, 13);
2838 break;
2839 case 8:
2840 if (curChar == 100 && kind > 35)
2841 kind = 35;
2842 break;
2843 case 9:
2844 if (curChar == 110)
2845 jjstateSet[jjnewStateCnt++] = 8;
2846 break;
2847 case 10:
2848 if (curChar == 97)
2849 jjstateSet[jjnewStateCnt++] = 9;
2850 break;
2851 case 11:
2852 if (curChar == 124 && kind > 36)
2853 kind = 36;
2854 break;
2855 case 12:
2856 if (curChar == 124)
2857 jjstateSet[jjnewStateCnt++] = 11;
2858 break;
2859 case 13:
2860 if (curChar == 114 && kind > 36)
2861 kind = 36;
2862 break;
2863 case 14:
2864 if (curChar == 111)
2865 jjstateSet[jjnewStateCnt++] = 13;
2866 break;
2867 case 18:
2868 if (curChar == 101)
2869 jjstateSet[jjnewStateCnt++] = 17;
2870 break;
2871 case 28:
2872 if (curChar == 100 && kind > 46)
2873 kind = 46;
2874 break;
2875 case 29:
2876 if (curChar == 111)
2877 jjstateSet[jjnewStateCnt++] = 28;
2878 break;
2879 case 30:
2880 if (curChar == 109)
2881 jjstateSet[jjnewStateCnt++] = 29;
2882 break;
2883 case 32:
2884 if (curChar == 118 && kind > 47)
2885 kind = 47;
2886 break;
2887 case 33:
2888 if (curChar == 105)
2889 jjstateSet[jjnewStateCnt++] = 32;
2890 break;
2891 case 34:
2892 if (curChar == 100)
2893 jjstateSet[jjnewStateCnt++] = 33;
2894 break;
2895 case 36:
2896 if ((0x7fffffe87ffffffL & l) == 0L)
2897 break;
2898 if (kind > 56)
2899 kind = 56;
2900 jjCheckNAdd(37);
2901 break;
2902 case 37:
2903 if ((0x7fffffe87ffffffL & l) == 0L)
2904 break;
2905 if (kind > 56)
2906 kind = 56;
2907 jjCheckNAdd(37);
2908 break;
2909 case 42:
2910 if ((0x110000001100L & l) != 0L && kind > 60)
2911 kind = 60;
2912 break;
2913 case 46:
2914 if ((0x2000000020L & l) != 0L)
2915 jjAddStates(57, 58);
2916 break;
2917 case 49:
2918 if ((0x5400000054L & l) != 0L && kind > 61)
2919 kind = 61;
2920 break;
2921 case 51:
2922 if ((0xffffffffefffffffL & l) != 0L)
2923 jjCheckNAddStates(36, 38);
2924 break;
2925 case 52:
2926 if (curChar == 92)
2927 jjstateSet[jjnewStateCnt++] = 53;
2928 break;
2929 case 53:
2930 jjCheckNAddStates(36, 38);
2931 break;
2932 case 56:
2933 if ((0xffffffffefffffffL & l) != 0L)
2934 jjCheckNAddStates(33, 35);
2935 break;
2936 case 57:
2937 if (curChar == 92)
2938 jjstateSet[jjnewStateCnt++] = 58;
2939 break;
2940 case 58:
2941 jjCheckNAddStates(33, 35);
2942 break;
2943 case 62:
2944 if ((0x100000001000000L & l) != 0L)
2945 jjCheckNAdd(63);
2946 break;
2947 case 63:
2948 if ((0x7e0000007eL & l) == 0L)
2949 break;
2950 if (kind > 60)
2951 kind = 60;
2952 jjCheckNAddTwoStates(63, 42);
2953 break;
2954 case 66:
2955 jjCheckNAddTwoStates(66, 67);
2956 break;
2957 case 68:
2958 case 69:
2959 jjCheckNAddTwoStates(69, 67);
2960 break;
2961 case 72:
2962 if (kind > 3)
2963 kind = 3;
2964 jjAddStates(48, 50);
2965 break;
2966 case 76:
2967 if (curChar == 110)
2968 jjAddStates(55, 56);
2969 break;
2970 case 78:
2971 if (curChar == 116 && kind > 48)
2972 kind = 48;
2973 break;
2974 case 79:
2975 if (curChar == 111)
2976 jjstateSet[jjnewStateCnt++] = 78;
2977 break;
2978 case 80:
2979 if (curChar == 103)
2980 jjAddStates(53, 54);
2981 break;
2982 case 81:
2983 if (curChar == 116 && kind > 41)
2984 kind = 41;
2985 break;
2986 case 82:
2987 if (curChar == 101 && kind > 42)
2988 kind = 42;
2989 break;
2990 case 83:
2991 if (curChar == 108)
2992 jjAddStates(51, 52);
2993 break;
2994 case 84:
2995 if (curChar == 116 && kind > 43)
2996 kind = 43;
2997 break;
2998 case 85:
2999 if (curChar == 101 && kind > 44)
3000 kind = 44;
3001 break;
3002 default : break;
3003 }
3004 } while(i != startsAt);
3005 }
3006 else
3007 {
3008 int hiByte = (int)(curChar >> 8);
3009 int i1 = hiByte >> 6;
3010 long l1 = 1L << (hiByte & 077);
3011 int i2 = (curChar & 0xff) >> 6;
3012 long l2 = 1L << (curChar & 077);
3013 do
3014 {
3015 switch(jjstateSet[--i])
3016 {
3017 case 1:
3018 if (!jjCanMove_0(hiByte, i1, i2, l1, l2))
3019 break;
3020 if (kind > 1)
3021 kind = 1;
3022 jjAddStates(11, 13);
3023 break;
3024 case 51:
3025 case 53:
3026 if (jjCanMove_1(hiByte, i1, i2, l1, l2))
3027 jjCheckNAddStates(36, 38);
3028 break;
3029 case 56:
3030 case 58:
3031 if (jjCanMove_1(hiByte, i1, i2, l1, l2))
3032 jjCheckNAddStates(33, 35);
3033 break;
3034 case 66:
3035 if (jjCanMove_0(hiByte, i1, i2, l1, l2))
3036 jjCheckNAddTwoStates(66, 67);
3037 break;
3038 case 68:
3039 case 69:
3040 if (jjCanMove_0(hiByte, i1, i2, l1, l2))
3041 jjCheckNAddTwoStates(69, 67);
3042 break;
3043 case 72:
3044 if (!jjCanMove_0(hiByte, i1, i2, l1, l2))
3045 break;
3046 if (kind > 3)
3047 kind = 3;
3048 jjAddStates(48, 50);
3049 break;
3050 default : break;
3051 }
3052 } while(i != startsAt);
3053 }
3054 if (kind != 0x7fffffff)
3055 {
3056 jjmatchedKind = kind;
3057 jjmatchedPos = curPos;
3058 kind = 0x7fffffff;
3059 }
3060 ++curPos;
3061 if ((i = jjnewStateCnt) == (startsAt = 86 - (jjnewStateCnt = startsAt)))
3062 return curPos;
3063 try { curChar = input_stream.readChar(); }
3064 catch(java.io.IOException e) { return curPos; }
3065 }
3066 }
3067 static final int[] jjnextStates = {
3068 63, 69, 54, 55, 57, 49, 50, 52, 59, 60, 40, 1, 2, 4, 43, 44,
3069 47, 65, 66, 68, 70, 71, 73, 82, 83, 79, 80, 75, 77, 45, 46, 65,
3070 71, 56, 57, 59, 51, 52, 54, 61, 62, 42, 45, 46, 49, 67, 68, 70,
3071 72, 73, 75, 84, 85, 81, 82, 77, 79, 47, 48,
3072 };
3073 private static final boolean jjCanMove_0(int hiByte, int i1, int i2, long l1, long l2)
3074 {
3075 switch(hiByte)
3076 {
3077 case 0:
3078 return ((jjbitVec2[i2] & l2) != 0L);
3079 default :
3080 if ((jjbitVec0[i1] & l1) != 0L)
3081 return true;
3082 return false;
3083 }
3084 }
3085 private static final boolean jjCanMove_1(int hiByte, int i1, int i2, long l1, long l2)
3086 {
3087 switch(hiByte)
3088 {
3089 case 0:
3090 return ((jjbitVec2[i2] & l2) != 0L);
3091 case 32:
3092 return ((jjbitVec4[i2] & l2) != 0L);
3093 default :
3094 if ((jjbitVec3[i1] & l1) != 0L)
3095 return true;
3096 return false;
3097 }
3098 }
3099
3100 /** Token literal values. */
3101 public static final String[] jjstrLiteralImages = {
3102 "", null, null, null, null, null, null, null, null, "\151\146",
3103 "\145\154\163\145", "\146\157\162", "\146\157\162\145\141\143\150", "\167\150\151\154\145",
3104 "\156\145\167", "\166\141\162", "\145\155\160\164\171", "\163\151\172\145",
3105 "\156\165\154\154", "\164\162\165\145", "\146\141\154\163\145", "\162\145\164\165\162\156",
3106 "\151\156", "\50", "\51", "\173", "\175", "\133", "\135", "\73", "\72", "\54", "\56",
3107 "\77", "\77\72", null, null, null, null, "\75\176", "\41\176", null, null, null, null,
3108 "\75", null, null, null, "\53", "\55", "\52", "\176", "\46", "\174", "\136", null,
3109 null, null, null, null, null, null, };
3110
3111 /** Lexer state names. */
3112 public static final String[] lexStateNames = {
3113 "REGISTERS",
3114 "FOR_EACH_IN",
3115 "DEFAULT",
3116 };
3117
3118 /** Lex State array. */
3119 public static final int[] jjnewLexState = {
3120 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 2, -1, -1,
3121 -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,
3122 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
3123 };
3124 static final long[] jjtoToken = {
3125 0x79fffffffffffe01L,
3126 };
3127 static final long[] jjtoSkip = {
3128 0x1feL,
3129 };
3130 protected SimpleCharStream input_stream;
3131 private final int[] jjrounds = new int[86];
3132 private final int[] jjstateSet = new int[172];
3133 protected char curChar;
3134 /** Constructor. */
3135 public ParserTokenManager(SimpleCharStream stream){
3136 if (SimpleCharStream.staticFlag)
3137 throw new Error("ERROR: Cannot use a static CharStream class with a non-static lexical analyzer.");
3138 input_stream = stream;
3139 }
3140
3141 /** Constructor. */
3142 public ParserTokenManager(SimpleCharStream stream, int lexState){
3143 this(stream);
3144 SwitchTo(lexState);
3145 }
3146
3147 /** Reinitialise parser. */
3148 public void ReInit(SimpleCharStream stream)
3149 {
3150 jjmatchedPos = jjnewStateCnt = 0;
3151 curLexState = defaultLexState;
3152 input_stream = stream;
3153 ReInitRounds();
3154 }
3155 private void ReInitRounds()
3156 {
3157 int i;
3158 jjround = 0x80000001;
3159 for (i = 86; i-- > 0;)
3160 jjrounds[i] = 0x80000000;
3161 }
3162
3163 /** Reinitialise parser. */
3164 public void ReInit(SimpleCharStream stream, int lexState)
3165 {
3166 ReInit(stream);
3167 SwitchTo(lexState);
3168 }
3169
3170 /** Switch to specified lex state. */
3171 public void SwitchTo(int lexState)
3172 {
3173 if (lexState >= 3 || lexState < 0)
3174 throw new TokenMgrError("Error: Ignoring invalid lexical state : " + lexState + ". State unchanged.", TokenMgrError.INVALID_LEXICAL_STATE);
3175 else
3176 curLexState = lexState;
3177 }
3178
3179 protected Token jjFillToken()
3180 {
3181 final Token t;
3182 final String curTokenImage;
3183 final int beginLine;
3184 final int endLine;
3185 final int beginColumn;
3186 final int endColumn;
3187 String im = jjstrLiteralImages[jjmatchedKind];
3188 curTokenImage = (im == null) ? input_stream.GetImage() : im;
3189 beginLine = input_stream.getBeginLine();
3190 beginColumn = input_stream.getBeginColumn();
3191 endLine = input_stream.getEndLine();
3192 endColumn = input_stream.getEndColumn();
3193 t = Token.newToken(jjmatchedKind, curTokenImage);
3194
3195 t.beginLine = beginLine;
3196 t.endLine = endLine;
3197 t.beginColumn = beginColumn;
3198 t.endColumn = endColumn;
3199
3200 return t;
3201 }
3202
3203 int curLexState = 2;
3204 int defaultLexState = 2;
3205 int jjnewStateCnt;
3206 int jjround;
3207 int jjmatchedPos;
3208 int jjmatchedKind;
3209
3210 /** Get the next Token. */
3211 public Token getNextToken()
3212 {
3213 Token matchedToken;
3214 int curPos = 0;
3215
3216 EOFLoop :
3217 for (;;)
3218 {
3219 try
3220 {
3221 curChar = input_stream.BeginToken();
3222 }
3223 catch(java.io.IOException e)
3224 {
3225 jjmatchedKind = 0;
3226 matchedToken = jjFillToken();
3227 return matchedToken;
3228 }
3229
3230 switch(curLexState)
3231 {
3232 case 0:
3233 try { input_stream.backup(0);
3234 while (curChar <= 32 && (0x100003600L & (1L << curChar)) != 0L)
3235 curChar = input_stream.BeginToken();
3236 }
3237 catch (java.io.IOException e1) { continue EOFLoop; }
3238 jjmatchedKind = 0x7fffffff;
3239 jjmatchedPos = 0;
3240 curPos = jjMoveStringLiteralDfa0_0();
3241 break;
3242 case 1:
3243 try { input_stream.backup(0);
3244 while (curChar <= 32 && (0x100003600L & (1L << curChar)) != 0L)
3245 curChar = input_stream.BeginToken();
3246 }
3247 catch (java.io.IOException e1) { continue EOFLoop; }
3248 jjmatchedKind = 0x7fffffff;
3249 jjmatchedPos = 0;
3250 curPos = jjMoveStringLiteralDfa0_1();
3251 break;
3252 case 2:
3253 try { input_stream.backup(0);
3254 while (curChar <= 32 && (0x100003600L & (1L << curChar)) != 0L)
3255 curChar = input_stream.BeginToken();
3256 }
3257 catch (java.io.IOException e1) { continue EOFLoop; }
3258 jjmatchedKind = 0x7fffffff;
3259 jjmatchedPos = 0;
3260 curPos = jjMoveStringLiteralDfa0_2();
3261 break;
3262 }
3263 if (jjmatchedKind != 0x7fffffff)
3264 {
3265 if (jjmatchedPos + 1 < curPos)
3266 input_stream.backup(curPos - jjmatchedPos - 1);
3267 if ((jjtoToken[jjmatchedKind >> 6] & (1L << (jjmatchedKind & 077))) != 0L)
3268 {
3269 matchedToken = jjFillToken();
3270 if (jjnewLexState[jjmatchedKind] != -1)
3271 curLexState = jjnewLexState[jjmatchedKind];
3272 return matchedToken;
3273 }
3274 else
3275 {
3276 if (jjnewLexState[jjmatchedKind] != -1)
3277 curLexState = jjnewLexState[jjmatchedKind];
3278 continue EOFLoop;
3279 }
3280 }
3281 int error_line = input_stream.getEndLine();
3282 int error_column = input_stream.getEndColumn();
3283 String error_after = null;
3284 boolean EOFSeen = false;
3285 try { input_stream.readChar(); input_stream.backup(1); }
3286 catch (java.io.IOException e1) {
3287 EOFSeen = true;
3288 error_after = curPos <= 1 ? "" : input_stream.GetImage();
3289 if (curChar == '\n' || curChar == '\r') {
3290 error_line++;
3291 error_column = 0;
3292 }
3293 else
3294 error_column++;
3295 }
3296 if (!EOFSeen) {
3297 input_stream.backup(1);
3298 error_after = curPos <= 1 ? "" : input_stream.GetImage();
3299 }
3300 throw new TokenMgrError(EOFSeen, curLexState, error_line, error_column, error_after, curChar, TokenMgrError.LEXICAL_ERROR);
3301 }
3302 }
3303
3304 private void jjCheckNAdd(int state)
3305 {
3306 if (jjrounds[state] != jjround)
3307 {
3308 jjstateSet[jjnewStateCnt++] = state;
3309 jjrounds[state] = jjround;
3310 }
3311 }
3312 private void jjAddStates(int start, int end)
3313 {
3314 do {
3315 jjstateSet[jjnewStateCnt++] = jjnextStates[start];
3316 } while (start++ != end);
3317 }
3318 private void jjCheckNAddTwoStates(int state1, int state2)
3319 {
3320 jjCheckNAdd(state1);
3321 jjCheckNAdd(state2);
3322 }
3323
3324 private void jjCheckNAddStates(int start, int end)
3325 {
3326 do {
3327 jjCheckNAdd(jjnextStates[start]);
3328 } while (start++ != end);
3329 }
3330
3331 }