|
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 |
Java API By Example, From Geeks To Geeks.