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