|
1
2 package org.ejen.ext.parsers.java_1_2;
3
4 public class JavaParserTokenManager implements JavaParserConstants {
5 public static java.io.PrintStream  debugStream = System.out;
6 public static void setDebugStream(java.io.PrintStream ds) {
7 debugStream = ds;
8 }
9
10 private static final int jjStopStringLiteralDfa_0(int pos, long active0, long active1) {
11 switch (pos) {
12 case 0:
13 if ((active0 & 0x140L) != 0L || (active1 & 0x2004000000000L) != 0L) {
14 return 2;
15 }
16 if ((active1 & 0x80000L) != 0L) {
17 return 8;
18 }
19 if ((active0 & 0xffffffffffffe000L) != 0L) {
20 jjmatchedKind = 72;
21 return 32;
22 }
23 return -1;
24
25 case 1:
26 if ((active0 & 0x100L) != 0L) {
27 return 0;
28 }
29 if ((active0 & 0xfffffffbfcffe000L) != 0L) {
30 if (jjmatchedPos != 1) {
31 jjmatchedKind = 72;
32 jjmatchedPos = 1;
33 }
34 return 32;
35 }
36 if ((active0 & 0x403000000L) != 0L) {
37 return 32;
38 }
39 return -1;
40
41 case 2:
42 if ((active0 & 0xf7fffb3afeffe000L) != 0L) {
43 if (jjmatchedPos != 2) {
44 jjmatchedKind = 72;
45 jjmatchedPos = 2;
46 }
47 return 32;
48 }
49 if ((active0 & 0x80004c100000000L) != 0L) {
50 return 32;
51 }
52 return -1;
53
54 case 3:
55 if ((active0 & 0xe3bff2b8faf4e000L) != 0L) {
56 jjmatchedKind = 72;
57 jjmatchedPos = 3;
58 return 32;
59 }
60 if ((active0 & 0x14400902040b0000L) != 0L) {
61 return 32;
62 }
63 return -1;
64
65 case 4:
66 if ((active0 & 0xa235f2b80ac06000L) != 0L) {
67 if (jjmatchedPos != 4) {
68 jjmatchedKind = 72;
69 jjmatchedPos = 4;
70 }
71 return 32;
72 }
73 if ((active0 & 0x418a0000f0348000L) != 0L) {
74 return 32;
75 }
76 return -1;
77
78 case 5:
79 if ((active0 & 0xa22070a848c06000L) != 0L) {
80 jjmatchedKind = 72;
81 jjmatchedPos = 5;
82 return 32;
83 }
84 if ((active0 & 0x115821002000000L) != 0L) {
85 return 32;
86 }
87 return -1;
88
89 case 6:
90 if ((active0 & 0xa22040a800402000L) != 0L) {
91 jjmatchedKind = 72;
92 jjmatchedPos = 6;
93 return 32;
94 }
95 if ((active0 & 0x300048804000L) != 0L) {
96 return 32;
97 }
98 return -1;
99
100 case 7:
101 if ((active0 & 0x22040a800000000L) != 0L) {
102 jjmatchedKind = 72;
103 jjmatchedPos = 7;
104 return 32;
105 }
106 if ((active0 & 0xa000000000402000L) != 0L) {
107 return 32;
108 }
109 return -1;
110
111 case 8:
112 if ((active0 & 0x20002800000000L) != 0L) {
113 jjmatchedKind = 72;
114 jjmatchedPos = 8;
115 return 32;
116 }
117 if ((active0 & 0x200408000000000L) != 0L) {
118 return 32;
119 }
120 return -1;
121
122 case 9:
123 if ((active0 & 0x20000000000000L) != 0L) {
124 jjmatchedKind = 72;
125 jjmatchedPos = 9;
126 return 32;
127 }
128 if ((active0 & 0x2800000000L) != 0L) {
129 return 32;
130 }
131 return -1;
132
133 case 10:
134 if ((active0 & 0x20000000000000L) != 0L) {
135 jjmatchedKind = 72;
136 jjmatchedPos = 10;
137 return 32;
138 }
139 return -1;
140
141 default:
142 return -1;
143 }
144 }
145
146 private static final int jjStartNfa_0(int pos, long active0, long active1) {
147 return jjMoveNfa_0(jjStopStringLiteralDfa_0(pos, active0, active1),
148 pos + 1);
149 }
150
151 static private final int jjStopAtPos(int pos, int kind) {
152 jjmatchedKind = kind;
153 jjmatchedPos = pos;
154 return pos + 1;
155 }
156
157 static private final int jjStartNfaWithStates_0(int pos, int kind, int state) {
158 jjmatchedKind = kind;
159 jjmatchedPos = pos;
160 try {
161 curChar = input_stream.readChar();
162 } catch (java.io.IOException e) {
163 return pos + 1;
164 }
165 return jjMoveNfa_0(state, pos + 1);
166 }
167
168 static private final int jjMoveStringLiteralDfa0_0() {
169 switch (curChar) {
170 case 9:
171 return jjStopAtPos(0, 2);
172
173 case 10:
174 return jjStopAtPos(0, 3);
175
176 case 12:
177 return jjStopAtPos(0, 5);
178
179 case 13:
180 return jjStopAtPos(0, 4);
181
182 case 32:
183 return jjStopAtPos(0, 1);
184
185 case 33:
186 jjmatchedKind = 87;
187 return jjMoveStringLiteralDfa1_0(0x0L, 0x40000000L);
188
189 case 37:
190 jjmatchedKind = 106;
191 return jjMoveStringLiteralDfa1_0(0x0L, 0x20000000000000L);
192
193 case 38:
194 jjmatchedKind = 103;
195 return jjMoveStringLiteralDfa1_0(0x0L, 0x4000100000000L);
196
197 case 40:
198 return jjStopAtPos(0, 75);
199
200 case 41:
201 return jjStopAtPos(0, 76);
202
203 case 42:
204 jjmatchedKind = 101;
205 return jjMoveStringLiteralDfa1_0(0x0L, 0x1000000000000L);
206
207 case 43:
208 jjmatchedKind = 99;
209 return jjMoveStringLiteralDfa1_0(0x0L, 0x400200000000L);
210
211 case 44:
212 return jjStopAtPos(0, 82);
213
214 case 45:
215 jjmatchedKind = 100;
216 return jjMoveStringLiteralDfa1_0(0x0L, 0x800400000000L);
217
218 case 46:
219 return jjStartNfaWithStates_0(0, 83, 8);
220
221 case 47:
222 jjmatchedKind = 102;
223 return jjMoveStringLiteralDfa1_0(0x140L, 0x2000000000000L);
224
225 case 58:
226 return jjStopAtPos(0, 90);
227
228 case 59:
229 return jjStopAtPos(0, 81);
230
231 case 60:
232 jjmatchedKind = 86;
233 return jjMoveStringLiteralDfa1_0(0x0L, 0x40080010000000L);
234
235 case 61:
236 jjmatchedKind = 84;
237 return jjMoveStringLiteralDfa1_0(0x0L, 0x8000000L);
238
239 case 62:
240 jjmatchedKind = 85;
241 return jjMoveStringLiteralDfa1_0(0x0L, 0x180300020000000L);
242
243 case 63:
244 return jjStopAtPos(0, 89);
245
246 case 91:
247 return jjStopAtPos(0, 79);
248
249 case 93:
250 return jjStopAtPos(0, 80);
251
252 case 94:
253 jjmatchedKind = 105;
254 return jjMoveStringLiteralDfa1_0(0x0L, 0x10000000000000L);
255
256 case 97:
257 return jjMoveStringLiteralDfa1_0(0x2000L, 0x0L);
258
259 case 98:
260 return jjMoveStringLiteralDfa1_0(0x1c000L, 0x0L);
261
262 case 99:
263 return jjMoveStringLiteralDfa1_0(0x7e0000L, 0x0L);
264
265 case 100:
266 return jjMoveStringLiteralDfa1_0(0x3800000L, 0x0L);
267
268 case 101:
269 return jjMoveStringLiteralDfa1_0(0xc000000L, 0x0L);
270
271 case 102:
272 return jjMoveStringLiteralDfa1_0(0x1f0000000L, 0x0L);
273
274 case 103:
275 return jjMoveStringLiteralDfa1_0(0x200000000L, 0x0L);
276
277 case 105:
278 return jjMoveStringLiteralDfa1_0(0xfc00000000L, 0x0L);
279
280 case 108:
281 return jjMoveStringLiteralDfa1_0(0x10000000000L, 0x0L);
282
283 case 110:
284 return jjMoveStringLiteralDfa1_0(0xe0000000000L, 0x0L);
285
286 case 112:
287 return jjMoveStringLiteralDfa1_0(0xf00000000000L, 0x0L);
288
289 case 114:
290 return jjMoveStringLiteralDfa1_0(0x1000000000000L, 0x0L);
291
292 case 115:
293 return jjMoveStringLiteralDfa1_0(0x803e000000000000L, 0x0L);
294
295 case 116:
296 return jjMoveStringLiteralDfa1_0(0xfc0000000000000L, 0x0L);
297
298 case 118:
299 return jjMoveStringLiteralDfa1_0(0x3000000000000000L, 0x0L);
300
301 case 119:
302 return jjMoveStringLiteralDfa1_0(0x4000000000000000L, 0x0L);
303
304 case 123:
305 return jjStopAtPos(0, 77);
306
307 case 124:
308 jjmatchedKind = 104;
309 return jjMoveStringLiteralDfa1_0(0x0L, 0x8000080000000L);
310
311 case 125:
312 return jjStopAtPos(0, 78);
313
314 case 126:
315 return jjStopAtPos(0, 88);
316
317 default:
318 return jjMoveNfa_0(3, 0);
319 }
320 }
321
322 static private final int jjMoveStringLiteralDfa1_0(long active0, long active1) {
323 try {
324 curChar = input_stream.readChar();
325 } catch (java.io.IOException e) {
326 jjStopStringLiteralDfa_0(0, active0, active1);
327 return 1;
328 }
329 switch (curChar) {
330 case 38:
331 if ((active1 & 0x100000000L) != 0L) {
332 return jjStopAtPos(1, 96);
333 }
334 break;
335
336 case 42:
337 if ((active0 & 0x100L) != 0L) {
338 return jjStartNfaWithStates_0(1, 8, 0);
339 }
340 break;
341
342 case 43:
343 if ((active1 & 0x200000000L) != 0L) {
344 return jjStopAtPos(1, 97);
345 }
346 break;
347
348 case 45:
349 if ((active1 & 0x400000000L) != 0L) {
350 return jjStopAtPos(1, 98);
351 }
352 break;
353
354 case 47:
355 if ((active0 & 0x40L) != 0L) {
356 return jjStopAtPos(1, 6);
357 }
358 break;
359
360 case 60:
361 if ((active1 & 0x80000000000L) != 0L) {
362 jjmatchedKind = 107;
363 jjmatchedPos = 1;
364 }
365 return jjMoveStringLiteralDfa2_0(active0, 0L, active1,
366 0x40000000000000L);
367
368 case 61:
369 if ((active1 & 0x8000000L) != 0L) {
370 return jjStopAtPos(1, 91);
371 } else if ((active1 & 0x10000000L) != 0L) {
372 return jjStopAtPos(1, 92);
373 } else if ((active1 & 0x20000000L) != 0L) {
374 return jjStopAtPos(1, 93);
375 } else if ((active1 & 0x40000000L) != 0L) {
376 return jjStopAtPos(1, 94);
377 } else if ((active1 & 0x400000000000L) != 0L) {
378 return jjStopAtPos(1, 110);
379 } else if ((active1 & 0x800000000000L) != 0L) {
380 return jjStopAtPos(1, 111);
381 } else if ((active1 & 0x1000000000000L) != 0L) {
382 return jjStopAtPos(1, 112);
383 } else if ((active1 & 0x2000000000000L) != 0L) {
384 return jjStopAtPos(1, 113);
385 } else if ((active1 & 0x4000000000000L) != 0L) {
386 return jjStopAtPos(1, 114);
387 } else if ((active1 & 0x8000000000000L) != 0L) {
388 return jjStopAtPos(1, 115);
389 } else if ((active1 & 0x10000000000000L) != 0L) {
390 return jjStopAtPos(1, 116);
391 } else if ((active1 & 0x20000000000000L) != 0L) {
392 return jjStopAtPos(1, 117);
393 }
394 break;
395
396 case 62:
397 if ((active1 & 0x100000000000L) != 0L) {
398 jjmatchedKind = 108;
399 jjmatchedPos = 1;
400 }
401 return jjMoveStringLiteralDfa2_0(active0, 0L, active1,
402 0x180200000000000L);
403
404 case 97:
405 return jjMoveStringLiteralDfa2_0(active0, 0x120010060000L, active1,
406 0L);
407
408 case 98:
409 return jjMoveStringLiteralDfa2_0(active0, 0x2000L, active1, 0L);
410
411 case 101:
412 return jjMoveStringLiteralDfa2_0(active0, 0x1040000800000L, active1,
413 0L);
414
415 case 102:
416 if ((active0 & 0x400000000L) != 0L) {
417 return jjStartNfaWithStates_0(1, 34, 32);
418 }
419 break;
420
421 case 104:
422 return jjMoveStringLiteralDfa2_0(active0, 0x41c2000000080000L,
423 active1, 0L);
424
425 case 105:
426 return jjMoveStringLiteralDfa2_0(active0, 0x60000000L, active1, 0L);
427
428 case 108:
429 return jjMoveStringLiteralDfa2_0(active0, 0x84100000L, active1, 0L);
430
431 case 109:
432 return jjMoveStringLiteralDfa2_0(active0, 0x1800000000L, active1, 0L);
433
434 case 110:
435 return jjMoveStringLiteralDfa2_0(active0, 0xe000000000L, active1, 0L);
436
437 case 111:
438 if ((active0 & 0x1000000L) != 0L) {
439 jjmatchedKind = 24;
440 jjmatchedPos = 1;
441 }
442 return jjMoveStringLiteralDfa2_0(active0, 0x3000010302604000L,
443 active1, 0L);
444
445 case 114:
446 return jjMoveStringLiteralDfa2_0(active0, 0xe00600000008000L,
447 active1, 0L);
448
449 case 116:
450 return jjMoveStringLiteralDfa2_0(active0, 0x8004000000000000L,
451 active1, 0L);
452
453 case 117:
454 return jjMoveStringLiteralDfa2_0(active0, 0x8880000000000L, active1,
455 0L);
456
457 case 119:
458 return jjMoveStringLiteralDfa2_0(active0, 0x10000000000000L, active1,
459 0L);
460
461 case 120:
462 return jjMoveStringLiteralDfa2_0(active0, 0x8000000L, active1, 0L);
463
464 case 121:
465 return jjMoveStringLiteralDfa2_0(active0, 0x20000000010000L, active1,
466 0L);
467
468 case 124:
469 if ((active1 & 0x80000000L) != 0L) {
470 return jjStopAtPos(1, 95);
471 }
472 break;
473
474 default:
475 break;
476 }
477 return jjStartNfa_0(0, active0, active1);
478 }
479
480 static private final int jjMoveStringLiteralDfa2_0(long old0, long active0, long old1, long active1) {
481 if (((active0 &= old0) | (active1 &= old1)) == 0L) {
482 return jjStartNfa_0(0, old0, old1);
483 }
484 try {
485 curChar = input_stream.readChar();
486 } catch (java.io.IOException e) {
487 jjStopStringLiteralDfa_0(1, active0, active1);
488 return 2;
489 }
490 switch (curChar) {
491 case 61:
492 if ((active1 & 0x40000000000000L) != 0L) {
493 return jjStopAtPos(2, 118);
494 } else if ((active1 & 0x80000000000000L) != 0L) {
495 return jjStopAtPos(2, 119);
496 }
497 break;
498
499 case 62:
500 if ((active1 & 0x200000000000L) != 0L) {
501 jjmatchedKind = 109;
502 jjmatchedPos = 2;
503 }
504 return jjMoveStringLiteralDfa3_0(active0, 0L, active1,
505 0x100000000000000L);
506
507 case 97:
508 return jjMoveStringLiteralDfa3_0(active0, 0x204000000180000L,
509 active1, 0L);
510
511 case 98:
512 return jjMoveStringLiteralDfa3_0(active0, 0x800000000000L, active1,
513 0L);
514
515 case 99:
516 return jjMoveStringLiteralDfa3_0(active0, 0x100000000000L, active1,
517 0L);
518
519 case 101:
520 return jjMoveStringLiteralDfa3_0(active0, 0x8000L, active1, 0L);
521
522 case 102:
523 return jjMoveStringLiteralDfa3_0(active0, 0x800000L, active1, 0L);
524
525 case 105:
526 return jjMoveStringLiteralDfa3_0(active0, 0x5050200000000000L,
527 active1, 0L);
528
529 case 108:
530 return jjMoveStringLiteralDfa3_0(active0, 0x2000080010000000L,
531 active1, 0L);
532
533 case 110:
534 return jjMoveStringLiteralDfa3_0(active0, 0x20010060600000L, active1,
535 0L);
536
537 case 111:
538 return jjMoveStringLiteralDfa3_0(active0, 0x2400080004000L, active1,
539 0L);
540
541 case 112:
542 return jjMoveStringLiteralDfa3_0(active0, 0x8001800000000L, active1,
543 0L);
544
545 case 114:
546 if ((active0 & 0x100000000L) != 0L) {
547 return jjStartNfaWithStates_0(2, 32, 32);
548 }
549 return jjMoveStringLiteralDfa3_0(active0, 0x8180000000000000L,
550 active1, 0L);
551
552 case 115:
553 return jjMoveStringLiteralDfa3_0(active0, 0x2004022000L, active1, 0L);
554
555 case 116:
556 if ((active0 & 0x4000000000L) != 0L) {
557 jjmatchedKind = 38;
558 jjmatchedPos = 2;
559 }
560 return jjMoveStringLiteralDfa3_0(active0, 0x1028208050000L, active1,
561 0L);
562
563 case 117:
564 return jjMoveStringLiteralDfa3_0(active0, 0x400000002000000L,
565 active1, 0L);
566
567 case 119:
568 if ((active0 & 0x40000000000L) != 0L) {
569 return jjStartNfaWithStates_0(2, 42, 32);
570 }
571 break;
572
573 case 121:
574 if ((active0 & 0x800000000000000L) != 0L) {
575 return jjStartNfaWithStates_0(2, 59, 32);
576 }
577 break;
578
579 default:
580 break;
581 }
582 return jjStartNfa_0(1, active0, active1);
583 }
584
585 static private final int jjMoveStringLiteralDfa3_0(long old0, long active0, long old1, long active1) {
586 if (((active0 &= old0) | (active1 &= old1)) == 0L) {
587 return jjStartNfa_0(1, old0, old1);
588 }
589 try {
590 curChar = input_stream.readChar();
591 } catch (java.io.IOException e) {
592 jjStopStringLiteralDfa_0(2, active0, active1);
593 return 3;
594 }
595 switch (curChar) {
596 case 61:
597 if ((active1 & 0x100000000000000L) != 0L) {
598 return jjStopAtPos(3, 120);
599 }
600 break;
601
602 case 97:
603 return jjMoveStringLiteralDfa4_0(active0, 0x20000000e0808000L,
604 active1, 0L);
605
606 case 98:
607 return jjMoveStringLiteralDfa4_0(active0, 0x2000000L, active1, 0L);
608
609 case 99:
610 return jjMoveStringLiteralDfa4_0(active0, 0x20000000040000L, active1,
611 0L);
612
613 case 100:
614 if ((active0 & 0x1000000000000000L) != 0L) {
615 return jjStartNfaWithStates_0(3, 60, 32);
616 }
617 break;
618
619 case 101:
620 if ((active0 & 0x10000L) != 0L) {
621 return jjStartNfaWithStates_0(3, 16, 32);
622 } else if ((active0 & 0x20000L) != 0L) {
623 return jjStartNfaWithStates_0(3, 17, 32);
624 } else if ((active0 & 0x4000000L) != 0L) {
625 return jjStartNfaWithStates_0(3, 26, 32);
626 } else if ((active0 & 0x400000000000000L) != 0L) {
627 return jjStartNfaWithStates_0(3, 58, 32);
628 }
629 return jjMoveStringLiteralDfa4_0(active0, 0x8008008000000L, active1,
630 0L);
631
632 case 103:
633 if ((active0 & 0x10000000000L) != 0L) {
634 return jjStartNfaWithStates_0(3, 40, 32);
635 }
636 break;
637
638 case 105:
639 return jjMoveStringLiteralDfa4_0(active0, 0x8000020000000000L,
640 active1, 0L);
641
642 case 107:
643 return jjMoveStringLiteralDfa4_0(active0, 0x100000000000L, active1,
644 0L);
645
646 case 108:
647 if ((active0 & 0x80000000000L) != 0L) {
648 return jjStartNfaWithStates_0(3, 43, 32);
649 }
650 return jjMoveStringLiteralDfa4_0(active0, 0x4000800800004000L,
651 active1, 0L);
652
653 case 110:
654 return jjMoveStringLiteralDfa4_0(active0, 0x200000000000000L,
655 active1, 0L);
656
657 case 111:
658 if ((active0 & 0x200000000L) != 0L) {
659 return jjStartNfaWithStates_0(3, 33, 32);
660 }
661 return jjMoveStringLiteralDfa4_0(active0, 0x180001000000000L,
662 active1, 0L);
663
664 case 114:
665 if ((active0 & 0x80000L) != 0L) {
666 return jjStartNfaWithStates_0(3, 19, 32);
667 }
668 return jjMoveStringLiteralDfa4_0(active0, 0x2000000000000L, active1,
669 0L);
670
671 case 115:
672 if ((active0 & 0x40000000000000L) != 0L) {
673 return jjStartNfaWithStates_0(3, 54, 32);
674 }
675 return jjMoveStringLiteralDfa4_0(active0, 0x10300000L, active1, 0L);
676
677 case 116:
678 return jjMoveStringLiteralDfa4_0(active0, 0x14402000402000L, active1,
679 0L);
680
681 case 117:
682 return jjMoveStringLiteralDfa4_0(active0, 0x1000000000000L, active1,
683 0L);
684
685 case 118:
686 return jjMoveStringLiteralDfa4_0(active0, 0x200000000000L, active1,
687 0L);
688
689 default:
690 break;
691 }
692 return jjStartNfa_0(2, active0, active1);
693 }
694
695 static private final int jjMoveStringLiteralDfa4_0(long old0, long active0, long old1, long active1) {
696 if (((active0 &= old0) | (active1 &= old1)) == 0L) {
697 return jjStartNfa_0(2, old0, old1);
698 }
699 try {
700 curChar = input_stream.readChar();
701 } catch (java.io.IOException e) {
702 jjStopStringLiteralDfa_0(3, active0, 0L);
703 return 4;
704 }
705 switch (curChar) {
706 case 97:
707 return jjMoveStringLiteralDfa5_0(active0, 0x302000000000L);
708
709 case 99:
710 return jjMoveStringLiteralDfa5_0(active0, 0x8010000000000000L);
711
712 case 101:
713 if ((active0 & 0x10000000L) != 0L) {
714 return jjStartNfaWithStates_0(4, 28, 32);
715 } else if ((active0 & 0x4000000000000000L) != 0L) {
716 return jjStartNfaWithStates_0(4, 62, 32);
717 }
718 return jjMoveStringLiteralDfa5_0(active0, 0x400800004000L);
719
720 case 104:
721 if ((active0 & 0x40000L) != 0L) {
722 return jjStartNfaWithStates_0(4, 18, 32);
723 }
724 return jjMoveStringLiteralDfa5_0(active0, 0x20000000000000L);
725
726 case 105:
727 return jjMoveStringLiteralDfa5_0(active0, 0x4800000400000L);
728
729 case 107:
730 if ((active0 & 0x8000L) != 0L) {
731 return jjStartNfaWithStates_0(4, 15, 32);
732 }
733 break;
734
735 case 108:
736 if ((active0 & 0x20000000L) != 0L) {
737 jjmatchedKind = 29;
738 jjmatchedPos = 4;
739 }
740 return jjMoveStringLiteralDfa5_0(active0, 0x42000000L);
741
742 case 110:
743 return jjMoveStringLiteralDfa5_0(active0, 0x8000000L);
744
745 case 114:
746 if ((active0 & 0x8000000000000L) != 0L) {
747 return jjStartNfaWithStates_0(4, 51, 32);
748 }
749 return jjMoveStringLiteralDfa5_0(active0, 0x1009000002000L);
750
751 case 115:
752 if ((active0 & 0x100000L) != 0L) {
753 return jjStartNfaWithStates_0(4, 20, 32);
754 }
755 return jjMoveStringLiteralDfa5_0(active0, 0x200000000000000L);
756
757 case 116:
758 if ((active0 & 0x200000L) != 0L) {
759 return jjStartNfaWithStates_0(4, 21, 32);
760 } else if ((active0 & 0x80000000L) != 0L) {
761 return jjStartNfaWithStates_0(4, 31, 32);
762 } else if ((active0 & 0x2000000000000L) != 0L) {
763 return jjStartNfaWithStates_0(4, 49, 32);
764 }
765 return jjMoveStringLiteralDfa5_0(active0, 0x2000000000000000L);
766
767 case 117:
768 return jjMoveStringLiteralDfa5_0(active0, 0x800000L);
769
770 case 118:
771 return jjMoveStringLiteralDfa5_0(active0, 0x20000000000L);
772
773 case 119:
774 if ((active0 & 0x80000000000000L) != 0L) {
775 jjmatchedKind = 55;
776 jjmatchedPos = 4;
777 }
778 return jjMoveStringLiteralDfa5_0(active0, 0x100000000000000L);
779
780 default:
781 break;
782 }
783 return jjStartNfa_0(3, active0, 0L);
784 }
785
786 static private final int jjMoveStringLiteralDfa5_0(long old0, long active0) {
787 if (((active0 &= old0)) == 0L) {
788 return jjStartNfa_0(3, old0, 0L);
789 }
790 try {
791 curChar = input_stream.readChar();
792 } catch (java.io.IOException e) {
793 jjStopStringLiteralDfa_0(4, active0, 0L);
794 return 5;
795 }
796 switch (curChar) {
797 case 97:
798 return jjMoveStringLiteralDfa6_0(active0, 0x6000L);
799
800 case 99:
801 if ((active0 & 0x800000000000L) != 0L) {
802 return jjStartNfaWithStates_0(5, 47, 32);
803 } else if ((active0 & 0x4000000000000L) != 0L) {
804 return jjStartNfaWithStates_0(5, 50, 32);
805 }
806 return jjMoveStringLiteralDfa6_0(active0, 0x400000000000L);
807
808 case 100:
809 return jjMoveStringLiteralDfa6_0(active0, 0x8000000L);
810
811 case 101:
812 if ((active0 & 0x2000000L) != 0L) {
813 return jjStartNfaWithStates_0(5, 25, 32);
814 } else if ((active0 & 0x20000000000L) != 0L) {
815 return jjStartNfaWithStates_0(5, 41, 32);
816 }
817 break;
818
819 case 102:
820 return jjMoveStringLiteralDfa6_0(active0, 0x8000000000L);
821
822 case 103:
823 return jjMoveStringLiteralDfa6_0(active0, 0x100000000000L);
824
825 case 104:
826 if ((active0 & 0x10000000000000L) != 0L) {
827 return jjStartNfaWithStates_0(5, 52, 32);
828 }
829 break;
830
831 case 105:
832 return jjMoveStringLiteralDfa6_0(active0, 0x2200000000000000L);
833
834 case 108:
835 return jjMoveStringLiteralDfa6_0(active0, 0x40800000L);
836
837 case 109:
838 return jjMoveStringLiteralDfa6_0(active0, 0x800000000L);
839
840 case 110:
841 if ((active0 & 0x1000000000000L) != 0L) {
842 return jjStartNfaWithStates_0(5, 48, 32);
843 }
844 return jjMoveStringLiteralDfa6_0(active0, 0x2000400000L);
845
846 case 114:
847 return jjMoveStringLiteralDfa6_0(active0, 0x20000000000000L);
848
849 case 115:
850 if ((active0 & 0x100000000000000L) != 0L) {
851 return jjStartNfaWithStates_0(5, 56, 32);
852 }
853 break;
854
855 case 116:
856 if ((active0 & 0x1000000000L) != 0L) {
857 return jjStartNfaWithStates_0(5, 36, 32);
858 }
859 return jjMoveStringLiteralDfa6_0(active0, 0x8000200000000000L);
860
861 default:
862 break;
863 }
864 return jjStartNfa_0(4, active0, 0L);
865 }
866
867 static private final int jjMoveStringLiteralDfa6_0(long old0, long active0) {
868 if (((active0 &= old0)) == 0L) {
869 return jjStartNfa_0(4, old0, 0L);
870 }
871 try {
872 curChar = input_stream.readChar();
873 } catch (java.io.IOException e) {
874 jjStopStringLiteralDfa_0(5, active0, 0L);
875 return 6;
876 }
877 switch (curChar) {
878 case 97:
879 return jjMoveStringLiteralDfa7_0(active0, 0x8000000000L);
880
881 case 99:
882 return jjMoveStringLiteralDfa7_0(active0, 0x2000002000L);
883
884 case 101:
885 if ((active0 & 0x100000000000L) != 0L) {
886 return jjStartNfaWithStates_0(6, 44, 32);
887 } else if ((active0 & 0x200000000000L) != 0L) {
888 return jjStartNfaWithStates_0(6, 45, 32);
889 }
890 return jjMoveStringLiteralDfa7_0(active0, 0x200000800000000L);
891
892 case 102:
893 return jjMoveStringLiteralDfa7_0(active0, 0x8000000000000000L);
894
895 case 108:
896 return jjMoveStringLiteralDfa7_0(active0, 0x2000000000000000L);
897
898 case 110:
899 if ((active0 & 0x4000L) != 0L) {
900 return jjStartNfaWithStates_0(6, 14, 32);
901 }
902 break;
903
904 case 111:
905 return jjMoveStringLiteralDfa7_0(active0, 0x20000000000000L);
906
907 case 115:
908 if ((active0 & 0x8000000L) != 0L) {
909 return jjStartNfaWithStates_0(6, 27, 32);
910 }
911 break;
912
913 case 116:
914 if ((active0 & 0x800000L) != 0L) {
915 return jjStartNfaWithStates_0(6, 23, 32);
916 }
917 return jjMoveStringLiteralDfa7_0(active0, 0x400000000000L);
918
919 case 117:
920 return jjMoveStringLiteralDfa7_0(active0, 0x400000L);
921
922 case 121:
923 if ((active0 & 0x40000000L) != 0L) {
924 return jjStartNfaWithStates_0(6, 30, 32);
925 }
926 break;
927
928 default:
929 break;
930 }
931 return jjStartNfa_0(5, active0, 0L);
932 }
933
934 static private final int jjMoveStringLiteralDfa7_0(long old0, long active0) {
935 if (((active0 &= old0)) == 0L) {
936 return jjStartNfa_0(5, old0, 0L);
937 }
938 try {
939 curChar = input_stream.readChar();
940 } catch (java.io.IOException e) {
941 jjStopStringLiteralDfa_0(6, active0, 0L);
942 return 7;
943 }
944 switch (curChar) {
945 case 99:
946 return jjMoveStringLiteralDfa8_0(active0, 0x8000000000L);
947
948 case 101:
949 if ((active0 & 0x400000L) != 0L) {
950 return jjStartNfaWithStates_0(7, 22, 32);
951 } else if ((active0 & 0x2000000000000000L) != 0L) {
952 return jjStartNfaWithStates_0(7, 61, 32);
953 }
954 return jjMoveStringLiteralDfa8_0(active0, 0x402000000000L);
955
956 case 110:
957 return jjMoveStringLiteralDfa8_0(active0, 0x220000800000000L);
958
959 case 112:
960 if ((active0 & 0x8000000000000000L) != 0L) {
961 return jjStartNfaWithStates_0(7, 63, 32);
962 }
963 break;
964
965 case 116:
966 if ((active0 & 0x2000L) != 0L) {
967 return jjStartNfaWithStates_0(7, 13, 32);
968 }
969 break;
970
971 default:
972 break;
973 }
974 return jjStartNfa_0(6, active0, 0L);
975 }
976
977 static private final int jjMoveStringLiteralDfa8_0(long old0, long active0) {
978 if (((active0 &= old0)) == 0L) {
979 return jjStartNfa_0(6, old0, 0L);
980 }
981 try {
982 curChar = input_stream.readChar();
983 } catch (java.io.IOException e) {
984 jjStopStringLiteralDfa_0(7, active0, 0L);
985 return 8;
986 }
987 switch (curChar) {
988 case 100:
989 if ((active0 & 0x400000000000L) != 0L) {
990 return jjStartNfaWithStates_0(8, 46, 32);
991 }
992 break;
993
994 case 101:
995 if ((active0 & 0x8000000000L) != 0L) {
996 return jjStartNfaWithStates_0(8, 39, 32);
997 }
998 break;
999
1000 case 105:
1001 return jjMoveStringLiteralDfa9_0(active0, 0x20000000000000L);
1002
1003 case 111:
1004 return jjMoveStringLiteralDfa9_0(active0, 0x2000000000L);
1005
1006 case 116:
1007 if ((active0 & 0x200000000000000L) != 0L) {
1008 return jjStartNfaWithStates_0(8, 57, 32);
1009 }
1010 return jjMoveStringLiteralDfa9_0(active0, 0x800000000L);
1011
1012 default:
1013 break;
1014 }
1015 return jjStartNfa_0(7, active0, 0L);
1016 }
1017
1018 static private final int jjMoveStringLiteralDfa9_0(long old0, long active0) {
1019 if (((active0 &= old0)) == 0L) {
1020 return jjStartNfa_0(7, old0, 0L);
1021 }
1022 try {
1023 curChar = input_stream.readChar();
1024 } catch (java.io.IOException e) {
1025 jjStopStringLiteralDfa_0(8, active0, 0L);
1026 return 9;
1027 }
1028 switch (curChar) {
1029 case 102:
1030 if ((active0 & 0x2000000000L) != 0L) {
1031 return jjStartNfaWithStates_0(9, 37, 32);
1032 }
1033 break;
1034
1035 case 115:
1036 if ((active0 & 0x800000000L) != 0L) {
1037 return jjStartNfaWithStates_0(9, 35, 32);
1038 }
1039 break;
1040
1041 case 122:
1042 return jjMoveStringLiteralDfa10_0(active0, 0x20000000000000L);
1043
1044 default:
1045 break;
1046 }
1047 return jjStartNfa_0(8, active0, 0L);
1048 }
1049
1050 static private final int jjMoveStringLiteralDfa10_0(long old0, long active0) {
1051 if (((active0 &= old0)) == 0L) {
1052 return jjStartNfa_0(8, old0, 0L);
1053 }
1054 try {
1055 curChar = input_stream.readChar();
1056 } catch (java.io.IOException e) {
1057 jjStopStringLiteralDfa_0(9, active0, 0L);
1058 return 10;
1059 }
1060 switch (curChar) {
1061 case 101:
1062 return jjMoveStringLiteralDfa11_0(active0, 0x20000000000000L);
1063
1064 default:
1065 break;
1066 }
1067 return jjStartNfa_0(9, active0, 0L);
1068 }
1069
1070 static private final int jjMoveStringLiteralDfa11_0(long old0, long active0) {
1071 if (((active0 &= old0)) == 0L) {
1072 return jjStartNfa_0(9, old0, 0L);
1073 }
1074 try {
1075 curChar = input_stream.readChar();
1076 } catch (java.io.IOException e) {
1077 jjStopStringLiteralDfa_0(10, active0, 0L);
1078 return 11;
1079 }
1080 switch (curChar) {
1081 case 100:
1082 if ((active0 & 0x20000000000000L) != 0L) {
1083 return jjStartNfaWithStates_0(11, 53, 32);
1084 }
1085 break;
1086
1087 default:
1088 break;
1089 }
1090 return jjStartNfa_0(10, active0, 0L);
1091 }
1092
1093 static private final void jjCheckNAdd(int state) {
1094 if (jjrounds[state] != jjround) {
1095 jjstateSet[jjnewStateCnt++] = state;
1096 jjrounds[state] = jjround;
1097 }
1098 }
1099
1100 static private final void jjAddStates(int start, int end) {
1101 do {
1102 jjstateSet[jjnewStateCnt++] = jjnextStates[start];
1103 } while (start++ != end);
1104 }
1105
1106 static private final void jjCheckNAddTwoStates(int state1, int state2) {
1107 jjCheckNAdd(state1);
1108 jjCheckNAdd(state2);
1109 }
1110
1111 static private final void jjCheckNAddStates(int start, int end) {
1112 do {
1113 jjCheckNAdd(jjnextStates[start]);
1114 } while (start++ != end);
1115 }
1116
1117 static private final void jjCheckNAddStates(int start) {
1118 jjCheckNAdd(jjnextStates[start]);
1119 jjCheckNAdd(jjnextStates[start + 1]);
1120 }
1121 static final long[] jjbitVec0 = {
1122 0xfffffffffffffffeL, 0xffffffffffffffffL, 0xffffffffffffffffL,
1123 0xffffffffffffffffL
1124 };
1125 static final long[] jjbitVec2 = {
1126 0x0L, 0x0L, 0xffffffffffffffffL, 0xffffffffffffffffL
1127 };
1128 static final long[] jjbitVec3 = {
1129 0x1ff00000fffffffeL, 0xffffffffffffc000L, 0xffffffffL,
1130 0x600000000000000L
1131 };
1132 static final long[] jjbitVec4 = {
1133 0x0L, 0x0L, 0x0L, 0xff7fffffff7fffffL
1134 };
1135 static final long[] jjbitVec5 = {
1136 0x0L, 0xffffffffffffffffL, 0xffffffffffffffffL, 0xffffffffffffffffL
1137 };
1138 static final long[] jjbitVec6 = {
1139 0xffffffffffffffffL, 0xffffffffffffffffL, 0xffffL, 0x0L
1140 };
1141 static final long[] jjbitVec7 = {
1142 0xffffffffffffffffL, 0xffffffffffffffffL, 0x0L, 0x0L
1143 };
1144 static final long[] jjbitVec8 = {
1145 0x3fffffffffffL, 0x0L, 0x0L, 0x0L
1146 };
1147 static private final int jjMoveNfa_0(int startState, int curPos) {
1148 int[] nextStates;
1149 int startsAt = 0;
1150
1151 jjnewStateCnt = 52;
1152 int i = 1;
1153
1154 jjstateSet[0] = startState;
1155 int j, kind = 0x7fffffff;
1156
1157 for (;;) {
1158 if (++jjround == 0x7fffffff) {
1159 ReInitRounds();
1160 }
1161 if (curChar < 64) {
1162 long l = 1L << curChar;
1163
1164 MatchLoop:
1165 do {
1166 switch (jjstateSet[--i]) {
1167 case 3:
1168 if ((0x3ff000000000000L & l) != 0L) {
1169 jjCheckNAddStates(0, 6);
1170 } else if (curChar == 36) {
1171 if (kind > 72) {
1172 kind = 72;
1173 }
1174 jjCheckNAdd(32);
1175 } else if (curChar == 34) {
1176 jjCheckNAddStates(7, 9);
1177 } else if (curChar == 39) {
1178 jjAddStates(10, 11);
1179 } else if (curChar == 46) {
1180 jjCheckNAdd(8);
1181 } else if (curChar == 47) {
1182 jjstateSet[jjnewStateCnt++] = 2;
1183 }
1184 if ((0x3fe000000000000L & l) != 0L) {
1185 if (kind > 64) {
1186 kind = 64;
1187 }
1188 jjCheckNAddTwoStates(5, 6);
1189 } else if (curChar == 48) {
1190 if (kind > 64) {
1191 kind = 64;
1192 }
1193 jjCheckNAddStates(12, 14);
1194 }
1195 break;
1196
1197 case 0:
1198 if (curChar == 42) {
1199 jjstateSet[jjnewStateCnt++] = 1;
1200 }
1201 break;
1202
1203 case 1:
1204 if ((0xffff7fffffffffffL & l) != 0L && kind > 7) {
1205 kind = 7;
1206 }
1207 break;
1208
1209 case 2:
1210 if (curChar == 42) {
1211 jjstateSet[jjnewStateCnt++] = 0;
1212 }
1213 break;
1214
1215 case 4:
1216 if ((0x3fe000000000000L & l) == 0L) {
1217 break;
1218 }
1219 if (kind > 64) {
1220 kind = 64;
1221 }
1222 jjCheckNAddTwoStates(5, 6);
1223 break;
1224
1225 case 5:
1226 if ((0x3ff000000000000L & l) == 0L) {
1227 break;
1228 }
1229 if (kind > 64) {
1230 kind = 64;
1231 }
1232 jjCheckNAddTwoStates(5, 6);
1233 break;
1234
1235 case 7:
1236 if (curChar == 46) {
1237 jjCheckNAdd(8);
1238 }
1239 break;
1240
1241 case 8:
1242 if ((0x3ff000000000000L & l) == 0L) {
1243 break;
1244 }
1245 if (kind > 68) {
1246 kind = 68;
1247 }
1248 jjCheckNAddStates(15, 17);
1249 break;
1250
1251 case 10:
1252 if ((0x280000000000L & l) != 0L) {
1253 jjCheckNAdd(11);
1254 }
1255 break;
1256
1257 case 11:
1258 if ((0x3ff000000000000L & l) == 0L) {
1259 break;
1260 }
1261 if (kind > 68) {
1262 kind = 68;
1263 }
1264 jjCheckNAddTwoStates(11, 12);
1265 break;
1266
1267 case 13:
1268 if (curChar == 39) {
1269 jjAddStates(10, 11);
1270 }
1271 break;
1272
1273 case 14:
1274 if ((0xffffff7fffffdbffL & l) != 0L) {
1275 jjCheckNAdd(15);
1276 }
1277 break;
1278
1279 case 15:
1280 if (curChar == 39 && kind > 70) {
1281 kind = 70;
1282 }
1283 break;
1284
1285 case 17:
1286 if ((0x8400000000L & l) != 0L) {
1287 jjCheckNAdd(15);
1288 }
1289 break;
1290
1291 case 18:
1292 if ((0xff000000000000L & l) != 0L) {
1293 jjCheckNAddTwoStates(19, 15);
1294 }
1295 break;
1296
1297 case 19:
1298 if ((0xff000000000000L & l) != 0L) {
1299 jjCheckNAdd(15);
1300 }
1301 break;
1302
1303 case 20:
1304 if ((0xf000000000000L & l) != 0L) {
1305 jjstateSet[jjnewStateCnt++] = 21;
1306 }
1307 break;
1308
1309 case 21:
1310 if ((0xff000000000000L & l) != 0L) {
1311 jjCheckNAdd(19);
1312 }
1313 break;
1314
1315 case 22:
1316 if (curChar == 34) {
1317 jjCheckNAddStates(7, 9);
1318 }
1319 break;
1320
1321 case 23:
1322 if ((0xfffffffbffffdbffL & l) != 0L) {
1323 jjCheckNAddStates(7, 9);
1324 }
1325 break;
1326
1327 case 25:
1328 if ((0x8400000000L & l) != 0L) {
1329 jjCheckNAddStates(7, 9);
1330 }
1331 break;
1332
1333 case 26:
1334 if (curChar == 34 && kind > 71) {
1335 kind = 71;
1336 }
1337 break;
1338
1339 case 27:
1340 if ((0xff000000000000L & l) != 0L) {
1341 jjCheckNAddStates(18, 21);
1342 }
1343 break;
1344
1345 case 28:
1346 if ((0xff000000000000L & l) != 0L) {
1347 jjCheckNAddStates(7, 9);
1348 }
1349 break;
1350
1351 case 29:
1352 if ((0xf000000000000L & l) != 0L) {
1353 jjstateSet[jjnewStateCnt++] = 30;
1354 }
1355 break;
1356
1357 case 30:
1358 if ((0xff000000000000L & l) != 0L) {
1359 jjCheckNAdd(28);
1360 }
1361 break;
1362
1363 case 31:
1364 if (curChar != 36) {
1365 break;
1366 }
1367 if (kind > 72) {
1368 kind = 72;
1369 }
1370 jjCheckNAdd(32);
1371 break;
1372
1373 case 32:
1374 if ((0x3ff001000000000L & l) == 0L) {
1375 break;
1376 }
1377 if (kind > 72) {
1378 kind = 72;
1379 }
1380 jjCheckNAdd(32);
1381 break;
1382
1383 case 33:
1384 if ((0x3ff000000000000L & l) != 0L) {
1385 jjCheckNAddStates(0, 6);
1386 }
1387 break;
1388
1389 case 34:
1390 if ((0x3ff000000000000L & l) != 0L) {
1391 jjCheckNAddTwoStates(34, 35);
1392 }
1393 break;
1394
1395 case 35:
1396 if (curChar != 46) {
1397 break;
1398 }
1399 if (kind > 68) {
1400 kind = 68;
1401 }
1402 jjCheckNAddStates(22, 24);
1403 break;
1404
1405 case 36:
1406 if ((0x3ff000000000000L & l) == 0L) {
1407 break;
1408 }
1409 if (kind > 68) {
1410 kind = 68;
1411 }
1412 jjCheckNAddStates(22, 24);
1413 break;
1414
1415 case 38:
1416 if ((0x280000000000L & l) != 0L) {
1417 jjCheckNAdd(39);
1418 }
1419 break;
1420
1421 case 39:
1422 if ((0x3ff000000000000L & l) == 0L) {
1423 break;
1424 }
1425 if (kind > 68) {
1426 kind = 68;
1427 }
1428 jjCheckNAddTwoStates(39, 12);
1429 break;
1430
1431 case 40:
1432 if ((0x3ff000000000000L & l) != 0L) {
1433 jjCheckNAddTwoStates(40, 41);
1434 }
1435 break;
1436
1437 case 42:
1438 if ((0x280000000000L & l) != 0L) {
1439 jjCheckNAdd(43);
1440 }
1441 break;
1442
1443 case 43:
1444 if ((0x3ff000000000000L & l) == 0L) {
1445 break;
1446 }
1447 if (kind > 68) {
1448 kind = 68;
1449 }
1450 jjCheckNAddTwoStates(43, 12);
1451 break;
1452
1453 case 44:
1454 if ((0x3ff000000000000L & l) != 0L) {
1455 jjCheckNAddStates(25, 27);
1456 }
1457 break;
1458
1459 case 46:
1460 if ((0x280000000000L & l) != 0L) {
1461 jjCheckNAdd(47);
1462 }
1463 break;
1464
1465 case 47:
1466 if ((0x3ff000000000000L & l) != 0L) {
1467 jjCheckNAddTwoStates(47, 12);
1468 }
1469 break;
1470
1471 case 48:
1472 if (curChar != 48) {
1473 break;
1474 }
1475 if (kind > 64) {
1476 kind = 64;
1477 }
1478 jjCheckNAddStates(12, 14);
1479 break;
1480
1481 case 50:
1482 if ((0x3ff000000000000L & l) == 0L) {
1483 break;
1484 }
1485 if (kind > 64) {
1486 kind = 64;
1487 }
1488 jjCheckNAddTwoStates(50, 6);
1489 break;
1490
1491 case 51:
1492 if ((0xff000000000000L & l) == 0L) {
1493 break;
1494 }
1495 if (kind > 64) {
1496 kind = 64;
1497 }
1498 jjCheckNAddTwoStates(51, 6);
1499 break;
1500
1501 default:
1502 break;
1503 }
1504 } while (i != startsAt);
1505 } else if (curChar < 128) {
1506 long l = 1L << (curChar & 077);
1507
1508 MatchLoop:
1509 do {
1510 switch (jjstateSet[--i]) {
1511 case 3:
1512 case 32:
1513 if ((0x7fffffe87fffffeL & l) == 0L) {
1514 break;
1515 }
1516 if (kind > 72) {
1517 kind = 72;
1518 }
1519 jjCheckNAdd(32);
1520 break;
1521
1522 case 1:
1523 if (kind > 7) {
1524 kind = 7;
1525 }
1526 break;
1527
1528 case 6:
1529 if ((0x100000001000L & l) != 0L && kind > 64) {
1530 kind = 64;
1531 }
1532 break;
1533
1534 case 9:
1535 if ((0x2000000020L & l) != 0L) {
1536 jjAddStates(28, 29);
1537 }
1538 break;
1539
1540 case 12:
1541 if ((0x5000000050L & l) != 0L && kind > 68) {
1542 kind = 68;
1543 }
1544 break;
1545
1546 case 14:
1547 if ((0xffffffffefffffffL & l) != 0L) {
1548 jjCheckNAdd(15);
1549 }
1550 break;
1551
1552 case 16:
1553 if (curChar == 92) {
1554 jjAddStates(30, 32);
1555 }
1556 break;
1557
1558 case 17:
1559 if ((0x14404410000000L & l) != 0L) {
1560 jjCheckNAdd(15);
1561 }
1562 break;
1563
1564 case 23:
1565 if ((0xffffffffefffffffL & l) != 0L) {
1566 jjCheckNAddStates(7, 9);
1567 }
1568 break;
1569
1570 case 24:
1571 if (curChar == 92) {
1572 jjAddStates(33, 35);
1573 }
1574 break;
1575
1576 case 25:
1577 if ((0x14404410000000L & l) != 0L) {
1578 jjCheckNAddStates(7, 9);
1579 }
1580 break;
1581
1582 case 37:
1583 if ((0x2000000020L & l) != 0L) {
1584 jjAddStates(36, 37);
1585 }
1586 break;
1587
1588 case 41:
1589 if ((0x2000000020L & l) != 0L) {
1590 jjAddStates(38, 39);
1591 }
1592 break;
1593
1594 case 45:
1595 if ((0x2000000020L & l) != 0L) {
1596 jjAddStates(40, 41);
1597 }
1598 break;
1599
1600 case 49:
1601 if ((0x100000001000000L & l) != 0L) {
1602 jjCheckNAdd(50);
1603 }
1604 break;
1605
1606 case 50:
1607 if ((0x7e0000007eL & l) == 0L) {
1608 break;
1609 }
1610 if (kind > 64) {
1611 kind = 64;
1612 }
1613 jjCheckNAddTwoStates(50, 6);
1614 break;
1615
1616 default:
1617 break;
1618 }
1619 } while (i != startsAt);
1620 } else {
1621 int hiByte = (int) (curChar >> 8);
1622 int i1 = hiByte >> 6;
1623 long l1 = 1L << (hiByte & 077);
1624 int i2 = (curChar & 0xff) >> 6;
1625 long l2 = 1L << (curChar & 077);
1626
1627 MatchLoop:
1628 do {
1629 switch (jjstateSet[--i]) {
1630 case 3:
1631 case 32:
1632 if (!jjCanMove_1(hiByte, i1, i2, l1, l2)) {
1633 break;
1634 }
1635 if (kind > 72) {
1636 kind = 72;
1637 }
1638 jjCheckNAdd(32);
1639 break;
1640
1641 case 1:
1642 if (jjCanMove_0(hiByte, i1, i2, l1, l2) && kind > 7) {
1643 kind = 7;
1644 }
1645 break;
1646
1647 case 14:
1648 if (jjCanMove_0(hiByte, i1, i2, l1, l2)) {
1649 jjstateSet[jjnewStateCnt++] = 15;
1650 }
1651 break;
1652
1653 case 23:
1654 if (jjCanMove_0(hiByte, i1, i2, l1, l2)) {
1655 jjAddStates(7, 9);
1656 }
1657 break;
1658
1659 default:
1660 break;
1661 }
1662 } while (i != startsAt);
1663 }
1664 if (kind != 0x7fffffff) {
1665 jjmatchedKind = kind;
1666 jjmatchedPos = curPos;
1667 kind = 0x7fffffff;
1668 }
1669 ++curPos;
1670 if ((i = jjnewStateCnt)
1671 == (startsAt = 52 - (jjnewStateCnt = startsAt))) {
1672 return curPos;
1673 }
1674 try {
1675 curChar = input_stream.readChar();
1676 } catch (java.io.IOException e) {
1677 return curPos;
1678 }
1679 }
1680 }
1681
1682 static private final int jjMoveStringLiteralDfa0_3() {
1683 switch (curChar) {
1684 case 42:
1685 return jjMoveStringLiteralDfa1_3(0x800L);
1686
1687 default:
1688 return 1;
1689 }
1690 }
1691
1692 static private final int jjMoveStringLiteralDfa1_3(long active0) {
1693 try {
1694 curChar = input_stream.readChar();
1695 } catch (java.io.IOException e) {
1696 return 1;
1697 }
1698 switch (curChar) {
1699 case 47:
1700 if ((active0 & 0x800L) != 0L) {
1701 return jjStopAtPos(1, 11);
1702 }
1703 break;
1704
1705 default:
1706 return 2;
1707 }
1708 return 2;
1709 }
1710
1711 static private final int jjMoveStringLiteralDfa0_1() {
1712 return jjMoveNfa_1(0, 0);
1713 }
1714
1715 static private final int jjMoveNfa_1(int startState, int curPos) {
1716 int[] nextStates;
1717 int startsAt = 0;
1718
1719 jjnewStateCnt = 3;
1720 int i = 1;
1721
1722 jjstateSet[0] = startState;
1723 int j, kind = 0x7fffffff;
1724
1725 for (;;) {
1726 if (++jjround == 0x7fffffff) {
1727 ReInitRounds();
1728 }
1729 if (curChar < 64) {
1730 long l = 1L << curChar;
1731
1732 MatchLoop:
1733 do {
1734 switch (jjstateSet[--i]) {
1735 case 0:
1736 if ((0x2400L & l) != 0L) {
1737 if (kind > 9) {
1738 kind = 9;
1739 }
1740 }
1741 if (curChar == 13) {
1742 jjstateSet[jjnewStateCnt++] = 1;
1743 }
1744 break;
1745
1746 case 1:
1747 if (curChar == 10 && kind > 9) {
1748 kind = 9;
1749 }
1750 break;
1751
1752 case 2:
1753 if (curChar == 13) {
1754 jjstateSet[jjnewStateCnt++] = 1;
1755 }
1756 break;
1757
1758 default:
1759 break;
1760 }
1761 } while (i != startsAt);
1762 } else if (curChar < 128) {
1763 long l = 1L << (curChar & 077);
1764
1765 MatchLoop:
1766 do {
1767 switch (jjstateSet[--i]) {
1768 default:
1769 break;
1770 }
1771 } while (i != startsAt);
1772 } else {
1773 int hiByte = (int) (curChar >> 8);
1774 int i1 = hiByte >> 6;
1775 long l1 = 1L << (hiByte & 077);
1776 int i2 = (curChar & 0xff) >> 6;
1777 long l2 = 1L << (curChar & 077);
1778
1779 MatchLoop:
1780 do {
1781 switch (jjstateSet[--i]) {
1782 default:
1783 break;
1784 }
1785 } while (i != startsAt);
1786 }
1787 if (kind != 0x7fffffff) {
1788 jjmatchedKind = kind;
1789 jjmatchedPos = curPos;
1790 kind = 0x7fffffff;
1791 }
1792 ++curPos;
1793 if ((i = jjnewStateCnt)
1794 == (startsAt = 3 - (jjnewStateCnt = startsAt))) {
1795 return curPos;
1796 }
1797 try {
1798 curChar = input_stream.readChar();
1799 } catch (java.io.IOException e) {
1800 return curPos;
1801 }
1802 }
1803 }
1804
1805 static private final int jjMoveStringLiteralDfa0_2() {
1806 switch (curChar) {
1807 case 42:
1808 return jjMoveStringLiteralDfa1_2(0x400L);
1809
1810 default:
1811 return 1;
1812 }
1813 }
1814
1815 static private final int jjMoveStringLiteralDfa1_2(long active0) {
1816 try {
1817 curChar = input_stream.readChar();
1818 } catch (java.io.IOException e) {
1819 return 1;
1820 }
1821 switch (curChar) {
1822 case 47:
1823 if ((active0 & 0x400L) != 0L) {
1824 return jjStopAtPos(1, 10);
1825 }
1826 break;
1827
1828 default:
1829 return 2;
1830 }
1831 return 2;
1832 }
1833 static final int[] jjnextStates = {
1834 34, 35, 40, 41, 44, 45, 12, 23, 24, 26, 14, 16, 49, 51, 6, 8, 9, 12, 23,
1835 24, 28, 26, 36, 37, 12, 44, 45, 12, 10, 11, 17, 18, 20, 25, 27, 29, 38,
1836 39, 42, 43, 46, 47,
1837 };
1838 private static final boolean jjCanMove_0(int hiByte, int i1, int i2, long l1, long l2) {
1839 switch (hiByte) {
1840 case 0:
1841 return ((jjbitVec2[i2] & l2) != 0L);
1842
1843 default:
1844 if ((jjbitVec0[i1] & l1) != 0L) {
1845 return true;
1846 }
1847 return false;
1848 }
1849 }
1850
1851 private static final boolean jjCanMove_1(int hiByte, int i1, int i2, long l1, long l2) {
1852 switch (hiByte) {
1853 case 0:
1854 return ((jjbitVec4[i2] & l2) != 0L);
1855
1856 case 48:
1857 return ((jjbitVec5[i2] & l2) != 0L);
1858
1859 case 49:
1860 return ((jjbitVec6[i2] & l2) != 0L);
1861
1862 case 51:
1863 return ((jjbitVec7[i2] & l2) != 0L);
1864
1865 case 61:
1866 return ((jjbitVec8[i2] & l2) != 0L);
1867
1868 default:
1869 if ((jjbitVec3[i1] & l1) != 0L) {
1870 return true;
1871 }
1872 return false;
1873 }
1874 }
1875 public static final String [] jjstrLiteralImages = {
1876 "", null, null, null, null, null, null, null, null, null, null, null,
1877 null, "\141\142\163\164\162\141\143\164", "\142\157\157\154\145\141\156",
1878 "\142\162\145\141\153", "\142\171\164\145", "\143\141\163\145",
1879 "\143\141\164\143\150", "\143\150\141\162", "\143\154\141\163\163",
1880 "\143\157\156\163\164", "\143\157\156\164\151\156\165\145",
1881 "\144\145\146\141\165\154\164", "\144\157", "\144\157\165\142\154\145",
1882 "\145\154\163\145", "\145\170\164\145\156\144\163",
1883 "\146\141\154\163\145", "\146\151\156\141\154",
1884 "\146\151\156\141\154\154\171", "\146\154\157\141\164", "\146\157\162",
1885 "\147\157\164\157", "\151\146",
1886 "\151\155\160\154\145\155\145\156\164\163", "\151\155\160\157\162\164",
1887 "\151\156\163\164\141\156\143\145\157\146", "\151\156\164",
1888 "\151\156\164\145\162\146\141\143\145", "\154\157\156\147",
1889 "\156\141\164\151\166\145", "\156\145\167", "\156\165\154\154",
1890 "\160\141\143\153\141\147\145", "\160\162\151\166\141\164\145",
1891 "\160\162\157\164\145\143\164\145\144", "\160\165\142\154\151\143",
1892 "\162\145\164\165\162\156", "\163\150\157\162\164",
1893 "\163\164\141\164\151\143", "\163\165\160\145\162",
1894 "\163\167\151\164\143\150",
1895 "\163\171\156\143\150\162\157\156\151\172\145\144", "\164\150\151\163",
1896 "\164\150\162\157\167", "\164\150\162\157\167\163",
1897 "\164\162\141\156\163\151\145\156\164", "\164\162\165\145",
1898 "\164\162\171", "\166\157\151\144", "\166\157\154\141\164\151\154\145",
1899 "\167\150\151\154\145", "\163\164\162\151\143\164\146\160", null, null,
1900 null, null, null, null, null, null, null, null, null, "\50", "\51",
1901 "\173", "\175", "\133", "\135", "\73", "\54", "\56", "\75", "\76", "\74",
1902 "\41", "\176", "\77", "\72", "\75\75", "\74\75", "\76\75", "\41\75",
1903 "\174\174", "\46\46", "\53\53", "\55\55", "\53", "\55", "\52", "\57",
1904 "\46", "\174", "\136", "\45", "\74\74", "\76\76", "\76\76\76", "\53\75",
1905 "\55\75", "\52\75", "\57\75", "\46\75", "\174\75", "\136\75", "\45\75",
1906 "\74\74\75", "\76\76\75", "\76\76\76\75", };
1907 public static final String [] lexStateNames = {
1908 "DEFAULT", "IN_SINGLE_LINE_COMMENT", "IN_FORMAL_COMMENT",
1909 "IN_MULTI_LINE_COMMENT",
1910 };
1911 public static final int[] jjnewLexState = {
1912 -1, -1, -1, -1, -1, -1, 1, 2, 3, 0, 0, 0, -1, -1, -1, -1, -1, -1, -1, -1,
1913 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
1914 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
1915 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
1916 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
1917 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
1918 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
1919 };
1920 static final long[] jjtoToken = {
1921 0xffffffffffffe001L, 0x1fffffffffff9d1L,
1922 };
1923 static final long[] jjtoSkip = {
1924 0xe3eL, 0x0L,
1925 };
1926 static final long[] jjtoSpecial = {
1927 0xe3eL, 0x0L,
1928 };
1929 static final long[] jjtoMore = {
1930 0x11c0L, 0x0L,
1931 };
1932 static private JavaCharStream input_stream;
1933 static private final int[] jjrounds = new int[52];
1934 static private final int[] jjstateSet = new int[104];
1935 static StringBuffer image;
1936 static int jjimageLen;
1937 static int lengthOfMatch;
1938 static protected char curChar;
1939 public JavaParserTokenManager(JavaCharStream stream) {
1940 if (input_stream != null) {
1941 throw new TokenMgrError("ERROR: Second call to constructor of static lexer. You must use ReInit() to initialize the static variables.",
1942 TokenMgrError.STATIC_LEXER_ERROR);
1943 }
1944 input_stream = stream;
1945 }
1946
1947 public JavaParserTokenManager(JavaCharStream stream, int lexState) {
1948 this(stream);
1949 SwitchTo(lexState);
1950 }
1951
1952 static public void ReInit(JavaCharStream stream) {
1953 jjmatchedPos = jjnewStateCnt = 0;
1954 curLexState = defaultLexState;
1955 input_stream = stream;
1956 ReInitRounds();
1957 }
1958
1959 static private final void ReInitRounds() {
1960 int i;
1961
1962 jjround = 0x80000001;
1963 for (i = 52; i-- > 0;) {
1964 jjrounds[i] = 0x80000000;
1965 }
1966 }
1967
1968 static public void ReInit(JavaCharStream stream, int lexState) {
1969 ReInit(stream);
1970 SwitchTo(lexState);
1971 }
1972
1973 static public void SwitchTo(int lexState) {
1974 if (lexState >= 4 || lexState < 0) {
1975 throw new TokenMgrError("Error: Ignoring invalid lexical state : "
1976 + lexState + ". State unchanged.",
1977 TokenMgrError.INVALID_LEXICAL_STATE);
1978 } else {
1979 curLexState = lexState;
1980 }
1981 }
1982
1983 static private final Token jjFillToken() {
1984 Token t = Token.newToken(jjmatchedKind);
1985
1986 t.kind = jjmatchedKind;
1987 String im = jjstrLiteralImages[jjmatchedKind];
1988
1989 t.image = (im == null) ? input_stream.GetImage() : im;
1990 t.beginLine = input_stream.getBeginLine();
1991 t.beginColumn = input_stream.getBeginColumn();
1992 t.endLine = input_stream.getEndLine();
1993 t.endColumn = input_stream.getEndColumn();
1994 return t;
1995 }
1996 static int curLexState = 0;
1997 static int defaultLexState = 0;
1998 static int jjnewStateCnt;
1999 static int jjround;
2000 static int jjmatchedPos;
2001 static int jjmatchedKind;
2002 public static final Token getNextToken() {
2003 int kind;
2004 Token specialToken = null;
2005 Token matchedToken;
2006 int curPos = 0;
2007
2008 EOFLoop:
2009 for (;;) {
2010 try {
2011 curChar = input_stream.BeginToken();
2012 } catch (java.io.IOException e) {
2013 jjmatchedKind = 0;
2014 matchedToken = jjFillToken();
2015 matchedToken.specialToken = specialToken;
2016 return matchedToken;
2017 }
2018 image = null;
2019 jjimageLen = 0;
2020 for (;;) {
2021 switch (curLexState) {
2022 case 0:
2023 jjmatchedKind = 0x7fffffff;
2024 jjmatchedPos = 0;
2025 curPos = jjMoveStringLiteralDfa0_0();
2026 break;
2027
2028 case 1:
2029 jjmatchedKind = 0x7fffffff;
2030 jjmatchedPos = 0;
2031 curPos = jjMoveStringLiteralDfa0_1();
2032 if (jjmatchedPos == 0 && jjmatchedKind > 12) {
2033 jjmatchedKind = 12;
2034 }
2035 break;
2036
2037 case 2:
2038 jjmatchedKind = 0x7fffffff;
2039 jjmatchedPos = 0;
2040 curPos = jjMoveStringLiteralDfa0_2();
2041 if (jjmatchedPos == 0 && jjmatchedKind > 12) {
2042 jjmatchedKind = 12;
2043 }
2044 break;
2045
2046 case 3:
2047 jjmatchedKind = 0x7fffffff;
2048 jjmatchedPos = 0;
2049 curPos = jjMoveStringLiteralDfa0_3();
2050 if (jjmatchedPos == 0 && jjmatchedKind > 12) {
2051 jjmatchedKind = 12;
2052 }
2053 break;
2054 }
2055 if (jjmatchedKind != 0x7fffffff) {
2056 if (jjmatchedPos + 1 < curPos) {
2057 input_stream.backup(curPos - jjmatchedPos - 1);
2058 }
2059 if ((jjtoToken[jjmatchedKind >> 6]
2060 & (1L << (jjmatchedKind & 077)))
2061 != 0L) {
2062 matchedToken = jjFillToken();
2063 matchedToken.specialToken = specialToken;
2064 if (jjnewLexState[jjmatchedKind] != -1) {
2065 curLexState = jjnewLexState[jjmatchedKind];
2066 }
2067 return matchedToken;
2068 } else if ((jjtoSkip[jjmatchedKind >> 6]
2069 & (1L << (jjmatchedKind & 077)))
2070 != 0L) {
2071 if ((jjtoSpecial[jjmatchedKind >> 6]
2072 & (1L << (jjmatchedKind & 077)))
2073 != 0L) {
2074 matchedToken = jjFillToken();
2075 if (specialToken == null) {
2076 specialToken = matchedToken;
2077 } else {
2078 matchedToken.specialToken = specialToken;
2079 specialToken = (specialToken.next = matchedToken);
2080 }
2081 SkipLexicalActions(matchedToken);
2082 } else {
2083 SkipLexicalActions(null);
2084 }
2085 if (jjnewLexState[jjmatchedKind] != -1) {
2086 curLexState = jjnewLexState[jjmatchedKind];
2087 }
2088 continue EOFLoop;
2089 }
2090 MoreLexicalActions();
2091 if (jjnewLexState[jjmatchedKind] != -1) {
2092 curLexState = jjnewLexState[jjmatchedKind];
2093 }
2094 curPos = 0;
2095 jjmatchedKind = 0x7fffffff;
2096 try {
2097 curChar = input_stream.readChar();
2098 continue;
2099 } catch (java.io.IOException e1) {}
2100 }
2101 int error_line = input_stream.getEndLine();
2102 int error_column = input_stream.getEndColumn();
2103 String error_after = null;
2104 boolean EOFSeen = false;
2105
2106 try {
2107 input_stream.readChar();
2108 input_stream.backup(1);
2109 } catch (java.io.IOException e1) {
2110 EOFSeen = true;
2111 error_after = curPos <= 1 ? "" : input_stream.GetImage();
2112 if (curChar == '\n' || curChar == '\r') {
2113 error_line++;
2114 error_column = 0;
2115 } else {
2116 error_column++;
2117 }
2118 }
2119 if (!EOFSeen) {
2120 input_stream.backup(1);
2121 error_after = curPos <= 1 ? "" : input_stream.GetImage();
2122 }
2123 throw new TokenMgrError(EOFSeen, curLexState, error_line,
2124 error_column, error_after, curChar,
2125 TokenMgrError.LEXICAL_ERROR);
2126 }
2127 }
2128 }
2129
2130 static final void SkipLexicalActions(Token matchedToken) {
2131 switch (jjmatchedKind) {
2132 default:
2133 break;
2134 }
2135 }
2136
2137 static final void MoreLexicalActions() {
2138 jjimageLen += (lengthOfMatch = jjmatchedPos + 1);
2139 switch (jjmatchedKind) {
2140 case 7:
2141 if (image == null) {
2142 image = new StringBuffer (new String (input_stream.GetSuffix(jjimageLen)));
2143 } else {
2144 image.append(input_stream.GetSuffix(jjimageLen));
2145 }
2146 jjimageLen = 0;
2147 input_stream.backup(1);
2148 break;
2149
2150 default:
2151 break;
2152 }
2153 }
2154}
2155 |
Popular Tags |
Java API By Example, From Geeks To Geeks.