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