|
1
7
8
9 package com.sun.jmx.snmp.IPAcl;
10 import java.io.*;
11
12 class ParserTokenManager implements ParserConstants
13 {
14 private final int jjStopStringLiteralDfa_0(int pos, long active0)
15 {
16 switch (pos)
17 {
18 case 0:
19 if ((active0 & 0x8000L) != 0L)
20 return 0;
21 if ((active0 & 0xfe5000L) != 0L)
22 {
23 jjmatchedKind = 31;
24 return 47;
25 }
26 if ((active0 & 0xd80L) != 0L)
27 {
28 jjmatchedKind = 31;
29 return 48;
30 }
31 return -1;
32 case 1:
33 if ((active0 & 0xfe5c00L) != 0L)
34 {
35 jjmatchedKind = 31;
36 jjmatchedPos = 1;
37 return 49;
38 }
39 if ((active0 & 0x180L) != 0L)
40 {
41 jjmatchedKind = 31;
42 jjmatchedPos = 1;
43 return 50;
44 }
45 return -1;
46 case 2:
47 if ((active0 & 0xfe5c00L) != 0L)
48 {
49 jjmatchedKind = 31;
50 jjmatchedPos = 2;
51 return 49;
52 }
53 if ((active0 & 0x100L) != 0L)
54 return 49;
55 if ((active0 & 0x80L) != 0L)
56 {
57 jjmatchedKind = 31;
58 jjmatchedPos = 2;
59 return 50;
60 }
61 return -1;
62 case 3:
63 if ((active0 & 0x565c00L) != 0L)
64 {
65 if (jjmatchedPos != 3)
66 {
67 jjmatchedKind = 31;
68 jjmatchedPos = 3;
69 }
70 return 49;
71 }
72 if ((active0 & 0xa80000L) != 0L)
73 return 49;
74 if ((active0 & 0x80L) != 0L)
75 {
76 if (jjmatchedPos != 3)
77 {
78 jjmatchedKind = 31;
79 jjmatchedPos = 3;
80 }
81 return 50;
82 }
83 return -1;
84 case 4:
85 if ((active0 & 0xa00000L) != 0L)
86 return 51;
87 if ((active0 & 0x60000L) != 0L)
88 {
89 if (jjmatchedPos < 3)
90 {
91 jjmatchedKind = 31;
92 jjmatchedPos = 3;
93 }
94 return 51;
95 }
96 if ((active0 & 0x1000L) != 0L)
97 return 49;
98 if ((active0 & 0x504c80L) != 0L)
99 {
100 jjmatchedKind = 31;
101 jjmatchedPos = 4;
102 return 49;
103 }
104 return -1;
105 case 5:
106 if ((active0 & 0x500080L) != 0L)
107 return 49;
108 if ((active0 & 0x4c00L) != 0L)
109 {
110 if (jjmatchedPos != 5)
111 {
112 jjmatchedKind = 31;
113 jjmatchedPos = 5;
114 }
115 return 49;
116 }
117 if ((active0 & 0xa60000L) != 0L)
118 {
119 if (jjmatchedPos != 5)
120 {
121 jjmatchedKind = 31;
122 jjmatchedPos = 5;
123 }
124 return 51;
125 }
126 return -1;
127 case 6:
128 if ((active0 & 0x400000L) != 0L)
129 return 51;
130 if ((active0 & 0x4c00L) != 0L)
131 {
132 jjmatchedKind = 31;
133 jjmatchedPos = 6;
134 return 49;
135 }
136 if ((active0 & 0xa60000L) != 0L)
137 {
138 jjmatchedKind = 31;
139 jjmatchedPos = 6;
140 return 51;
141 }
142 return -1;
143 case 7:
144 if ((active0 & 0x660000L) != 0L)
145 {
146 jjmatchedKind = 31;
147 jjmatchedPos = 7;
148 return 51;
149 }
150 if ((active0 & 0x800000L) != 0L)
151 return 51;
152 if ((active0 & 0x4000L) != 0L)
153 return 49;
154 if ((active0 & 0xc00L) != 0L)
155 {
156 jjmatchedKind = 31;
157 jjmatchedPos = 7;
158 return 49;
159 }
160 return -1;
161 case 8:
162 if ((active0 & 0x20000L) != 0L)
163 return 51;
164 if ((active0 & 0xc00L) != 0L)
165 {
166 jjmatchedKind = 31;
167 jjmatchedPos = 8;
168 return 49;
169 }
170 if ((active0 & 0x640000L) != 0L)
171 {
172 jjmatchedKind = 31;
173 jjmatchedPos = 8;
174 return 51;
175 }
176 return -1;
177 case 9:
178 if ((active0 & 0x40000L) != 0L)
179 return 51;
180 if ((active0 & 0x800L) != 0L)
181 return 49;
182 if ((active0 & 0x600000L) != 0L)
183 {
184 jjmatchedKind = 31;
185 jjmatchedPos = 9;
186 return 51;
187 }
188 if ((active0 & 0x400L) != 0L)
189 {
190 jjmatchedKind = 31;
191 jjmatchedPos = 9;
192 return 49;
193 }
194 return -1;
195 case 10:
196 if ((active0 & 0x600000L) != 0L)
197 {
198 jjmatchedKind = 31;
199 jjmatchedPos = 10;
200 return 51;
201 }
202 if ((active0 & 0x400L) != 0L)
203 return 49;
204 return -1;
205 case 11:
206 if ((active0 & 0x600000L) != 0L)
207 {
208 jjmatchedKind = 31;
209 jjmatchedPos = 11;
210 return 51;
211 }
212 return -1;
213 case 12:
214 if ((active0 & 0x600000L) != 0L)
215 {
216 jjmatchedKind = 31;
217 jjmatchedPos = 12;
218 return 51;
219 }
220 return -1;
221 case 13:
222 if ((active0 & 0x400000L) != 0L)
223 {
224 jjmatchedKind = 31;
225 jjmatchedPos = 13;
226 return 51;
227 }
228 if ((active0 & 0x200000L) != 0L)
229 return 51;
230 return -1;
231 case 14:
232 if ((active0 & 0x400000L) != 0L)
233 {
234 jjmatchedKind = 31;
235 jjmatchedPos = 14;
236 return 51;
237 }
238 return -1;
239 default :
240 return -1;
241 }
242 }
243 private final int jjStartNfa_0(int pos, long active0)
244 {
245 return jjMoveNfa_0(jjStopStringLiteralDfa_0(pos, active0), pos + 1);
246 }
247 private final int jjStopAtPos(int pos, int kind)
248 {
249 jjmatchedKind = kind;
250 jjmatchedPos = pos;
251 return pos + 1;
252 }
253 private final int jjStartNfaWithStates_0(int pos, int kind, int state)
254 {
255 jjmatchedKind = kind;
256 jjmatchedPos = pos;
257 try { curChar = input_stream.readChar(); }
258 catch(java.io.IOException  e) { return pos + 1; }
259 return jjMoveNfa_0(state, pos + 1);
260 }
261 private final int jjMoveStringLiteralDfa0_0()
262 {
263 switch(curChar)
264 {
265 case 33:
266 return jjStopAtPos(0, 38);
267 case 44:
268 return jjStopAtPos(0, 36);
269 case 45:
270 return jjStartNfaWithStates_0(0, 15, 0);
271 case 46:
272 return jjStopAtPos(0, 37);
273 case 47:
274 return jjStopAtPos(0, 39);
275 case 61:
276 return jjStopAtPos(0, 9);
277 case 97:
278 return jjMoveStringLiteralDfa1_0(0x180L);
279 case 99:
280 return jjMoveStringLiteralDfa1_0(0x400L);
281 case 101:
282 return jjMoveStringLiteralDfa1_0(0x800L);
283 case 104:
284 return jjMoveStringLiteralDfa1_0(0x1000L);
285 case 105:
286 return jjMoveStringLiteralDfa1_0(0x500000L);
287 case 109:
288 return jjMoveStringLiteralDfa1_0(0x4000L);
289 case 114:
290 return jjMoveStringLiteralDfa1_0(0x60000L);
291 case 116:
292 return jjMoveStringLiteralDfa1_0(0xa80000L);
293 case 123:
294 return jjStopAtPos(0, 13);
295 case 125:
296 return jjStopAtPos(0, 16);
297 default :
298 return jjMoveNfa_0(5, 0);
299 }
300 }
301 private final int jjMoveStringLiteralDfa1_0(long active0)
302 {
303 try { curChar = input_stream.readChar(); }
304 catch(java.io.IOException e) {
305 jjStopStringLiteralDfa_0(0, active0);
306 return 1;
307 }
308 switch(curChar)
309 {
310 case 97:
311 return jjMoveStringLiteralDfa2_0(active0, 0x4000L);
312 case 99:
313 return jjMoveStringLiteralDfa2_0(active0, 0x180L);
314 case 101:
315 return jjMoveStringLiteralDfa2_0(active0, 0x60000L);
316 case 110:
317 return jjMoveStringLiteralDfa2_0(active0, 0x500800L);
318 case 111:
319 return jjMoveStringLiteralDfa2_0(active0, 0x1400L);
320 case 114:
321 return jjMoveStringLiteralDfa2_0(active0, 0xa80000L);
322 default :
323 break;
324 }
325 return jjStartNfa_0(0, active0);
326 }
327 private final int jjMoveStringLiteralDfa2_0(long old0, long active0)
328 {
329 if (((active0 &= old0)) == 0L)
330 return jjStartNfa_0(0, old0);
331 try { curChar = input_stream.readChar(); }
332 catch(java.io.IOException e) {
333 jjStopStringLiteralDfa_0(1, active0);
334 return 2;
335 }
336 switch(curChar)
337 {
338 case 97:
339 return jjMoveStringLiteralDfa3_0(active0, 0xae0000L);
340 case 99:
341 return jjMoveStringLiteralDfa3_0(active0, 0x80L);
342 case 102:
343 return jjMoveStringLiteralDfa3_0(active0, 0x500000L);
344 case 108:
345 if ((active0 & 0x100L) != 0L)
346 return jjStartNfaWithStates_0(2, 8, 49);
347 break;
348 case 109:
349 return jjMoveStringLiteralDfa3_0(active0, 0x400L);
350 case 110:
351 return jjMoveStringLiteralDfa3_0(active0, 0x4000L);
352 case 115:
353 return jjMoveStringLiteralDfa3_0(active0, 0x1000L);
354 case 116:
355 return jjMoveStringLiteralDfa3_0(active0, 0x800L);
356 default :
357 break;
358 }
359 return jjStartNfa_0(1, active0);
360 }
361 private final int jjMoveStringLiteralDfa3_0(long old0, long active0)
362 {
363 if (((active0 &= old0)) == 0L)
364 return jjStartNfa_0(1, old0);
365 try { curChar = input_stream.readChar(); }
366 catch(java.io.IOException e) {
367 jjStopStringLiteralDfa_0(2, active0);
368 return 3;
369 }
370 switch(curChar)
371 {
372 case 97:
373 return jjMoveStringLiteralDfa4_0(active0, 0x4000L);
374 case 100:
375 return jjMoveStringLiteralDfa4_0(active0, 0x60000L);
376 case 101:
377 return jjMoveStringLiteralDfa4_0(active0, 0x880L);
378 case 109:
379 return jjMoveStringLiteralDfa4_0(active0, 0x400L);
380 case 111:
381 return jjMoveStringLiteralDfa4_0(active0, 0x500000L);
382 case 112:
383 if ((active0 & 0x80000L) != 0L)
384 {
385 jjmatchedKind = 19;
386 jjmatchedPos = 3;
387 }
388 return jjMoveStringLiteralDfa4_0(active0, 0xa00000L);
389 case 116:
390 return jjMoveStringLiteralDfa4_0(active0, 0x1000L);
391 default :
392 break;
393 }
394 return jjStartNfa_0(2, active0);
395 }
396 private final int jjMoveStringLiteralDfa4_0(long old0, long active0)
397 {
398 if (((active0 &= old0)) == 0L)
399 return jjStartNfa_0(2, old0);
400 try { curChar = input_stream.readChar(); }
401 catch(java.io.IOException e) {
402 jjStopStringLiteralDfa_0(3, active0);
403 return 4;
404 }
405 switch(curChar)
406 {
407 case 45:
408 return jjMoveStringLiteralDfa5_0(active0, 0xa60000L);
409 case 103:
410 return jjMoveStringLiteralDfa5_0(active0, 0x4000L);
411 case 114:
412 return jjMoveStringLiteralDfa5_0(active0, 0x500800L);
413 case 115:
414 if ((active0 & 0x1000L) != 0L)
415 return jjStartNfaWithStates_0(4, 12, 49);
416 return jjMoveStringLiteralDfa5_0(active0, 0x80L);
417 case 117:
418 return jjMoveStringLiteralDfa5_0(active0, 0x400L);
419 default :
420 break;
421 }
422 return jjStartNfa_0(3, active0);
423 }
424 private final int jjMoveStringLiteralDfa5_0(long old0, long active0)
425 {
426 if (((active0 &= old0)) == 0L)
427 return jjStartNfa_0(3, old0);
428 try { curChar = input_stream.readChar(); }
429 catch(java.io.IOException e) {
430 jjStopStringLiteralDfa_0(4, active0);
431 return 5;
432 }
433 switch(curChar)
434 {
435 case 99:
436 return jjMoveStringLiteralDfa6_0(active0, 0x200000L);
437 case 101:
438 return jjMoveStringLiteralDfa6_0(active0, 0x4000L);
439 case 109:
440 if ((active0 & 0x100000L) != 0L)
441 {
442 jjmatchedKind = 20;
443 jjmatchedPos = 5;
444 }
445 return jjMoveStringLiteralDfa6_0(active0, 0x400000L);
446 case 110:
447 return jjMoveStringLiteralDfa6_0(active0, 0x800400L);
448 case 111:
449 return jjMoveStringLiteralDfa6_0(active0, 0x20000L);
450 case 112:
451 return jjMoveStringLiteralDfa6_0(active0, 0x800L);
452 case 115:
453 if ((active0 & 0x80L) != 0L)
454 return jjStartNfaWithStates_0(5, 7, 49);
455 break;
456 case 119:
457 return jjMoveStringLiteralDfa6_0(active0, 0x40000L);
458 default :
459 break;
460 }
461 return jjStartNfa_0(4, active0);
462 }
463 private final int jjMoveStringLiteralDfa6_0(long old0, long active0)
464 {
465 if (((active0 &= old0)) == 0L)
466 return jjStartNfa_0(4, old0);
467 try { curChar = input_stream.readChar(); }
468 catch(java.io.IOException e) {
469 jjStopStringLiteralDfa_0(5, active0);
470 return 6;
471 }
472 switch(curChar)
473 {
474 case 45:
475 return jjMoveStringLiteralDfa7_0(active0, 0x400000L);
476 case 105:
477 return jjMoveStringLiteralDfa7_0(active0, 0x400L);
478 case 110:
479 return jjMoveStringLiteralDfa7_0(active0, 0x20000L);
480 case 111:
481 return jjMoveStringLiteralDfa7_0(active0, 0x200000L);
482 case 114:
483 return jjMoveStringLiteralDfa7_0(active0, 0x44800L);
484 case 117:
485 return jjMoveStringLiteralDfa7_0(active0, 0x800000L);
486 default :
487 break;
488 }
489 return jjStartNfa_0(5, active0);
490 }
491 private final int jjMoveStringLiteralDfa7_0(long old0, long active0)
492 {
493 if (((active0 &= old0)) == 0L)
494 return jjStartNfa_0(5, old0);
495 try { curChar = input_stream.readChar(); }
496 catch(java.io.IOException e) {
497 jjStopStringLiteralDfa_0(6, active0);
498 return 7;
499 }
500 switch(curChar)
501 {
502 case 99:
503 return jjMoveStringLiteralDfa8_0(active0, 0x400000L);
504 case 105:
505 return jjMoveStringLiteralDfa8_0(active0, 0x40800L);
506 case 108:
507 return jjMoveStringLiteralDfa8_0(active0, 0x20000L);
508 case 109:
509 if ((active0 & 0x800000L) != 0L)
510 return jjStartNfaWithStates_0(7, 23, 51);
511 return jjMoveStringLiteralDfa8_0(active0, 0x200000L);
512 case 115:
513 if ((active0 & 0x4000L) != 0L)
514 return jjStartNfaWithStates_0(7, 14, 49);
515 break;
516 case 116:
517 return jjMoveStringLiteralDfa8_0(active0, 0x400L);
518 default :
519 break;
520 }
521 return jjStartNfa_0(6, active0);
522 }
523 private final int jjMoveStringLiteralDfa8_0(long old0, long active0)
524 {
525 if (((active0 &= old0)) == 0L)
526 return jjStartNfa_0(6, old0);
527 try { curChar = input_stream.readChar(); }
528 catch(java.io.IOException e) {
529 jjStopStringLiteralDfa_0(7, active0);
530 return 8;
531 }
532 switch(curChar)
533 {
534 case 105:
535 return jjMoveStringLiteralDfa9_0(active0, 0x400L);
536 case 109:
537 return jjMoveStringLiteralDfa9_0(active0, 0x200000L);
538 case 111:
539 return jjMoveStringLiteralDfa9_0(active0, 0x400000L);
540 case 115:
541 return jjMoveStringLiteralDfa9_0(active0, 0x800L);
542 case 116:
543 return jjMoveStringLiteralDfa9_0(active0, 0x40000L);
544 case 121:
545 if ((active0 & 0x20000L) != 0L)
546 return jjStartNfaWithStates_0(8, 17, 51);
547 break;
548 default :
549 break;
550 }
551 return jjStartNfa_0(7, active0);
552 }
553 private final int jjMoveStringLiteralDfa9_0(long old0, long active0)
554 {
555 if (((active0 &= old0)) == 0L)
556 return jjStartNfa_0(7, old0);
557 try { curChar = input_stream.readChar(); }
558 catch(java.io.IOException e) {
559 jjStopStringLiteralDfa_0(8, active0);
560 return 9;
561 }
562 switch(curChar)
563 {
564 case 101:
565 if ((active0 & 0x800L) != 0L)
566 return jjStartNfaWithStates_0(9, 11, 49);
567 else if ((active0 & 0x40000L) != 0L)
568 return jjStartNfaWithStates_0(9, 18, 51);
569 return jjMoveStringLiteralDfa10_0(active0, 0x400L);
570 case 109:
571 return jjMoveStringLiteralDfa10_0(active0, 0x400000L);
572 case 117:
573 return jjMoveStringLiteralDfa10_0(active0, 0x200000L);
574 default :
575 break;
576 }
577 return jjStartNfa_0(8, active0);
578 }
579 private final int jjMoveStringLiteralDfa10_0(long old0, long active0)
580 {
581 if (((active0 &= old0)) == 0L)
582 return jjStartNfa_0(8, old0);
583 try { curChar = input_stream.readChar(); }
584 catch(java.io.IOException e) {
585 jjStopStringLiteralDfa_0(9, active0);
586 return 10;
587 }
588 switch(curChar)
589 {
590 case 109:
591 return jjMoveStringLiteralDfa11_0(active0, 0x400000L);
592 case 110:
593 return jjMoveStringLiteralDfa11_0(active0, 0x200000L);
594 case 115:
595 if ((active0 & 0x400L) != 0L)
596 return jjStartNfaWithStates_0(10, 10, 49);
597 break;
598 default :
599 break;
600 }
601 return jjStartNfa_0(9, active0);
602 }
603 private final int jjMoveStringLiteralDfa11_0(long old0, long active0)
604 {
605 if (((active0 &= old0)) == 0L)
606 return jjStartNfa_0(9, old0);
607 try { curChar = input_stream.readChar(); }
608 catch(java.io.IOException e) {
609 jjStopStringLiteralDfa_0(10, active0);
610 return 11;
611 }
612 switch(curChar)
613 {
614 case 105:
615 return jjMoveStringLiteralDfa12_0(active0, 0x200000L);
616 case 117:
617 return jjMoveStringLiteralDfa12_0(active0, 0x400000L);
618 default :
619 break;
620 }
621 return jjStartNfa_0(10, active0);
622 }
623 private final int jjMoveStringLiteralDfa12_0(long old0, long active0)
624 {
625 if (((active0 &= old0)) == 0L)
626 return jjStartNfa_0(10, old0);
627 try { curChar = input_stream.readChar(); }
628 catch(java.io.IOException e) {
629 jjStopStringLiteralDfa_0(11, active0);
630 return 12;
631 }
632 switch(curChar)
633 {
634 case 110:
635 return jjMoveStringLiteralDfa13_0(active0, 0x400000L);
636 case 116:
637 return jjMoveStringLiteralDfa13_0(active0, 0x200000L);
638 default :
639 break;
640 }
641 return jjStartNfa_0(11, active0);
642 }
643 private final int jjMoveStringLiteralDfa13_0(long old0, long active0)
644 {
645 if (((active0 &= old0)) == 0L)
646 return jjStartNfa_0(11, old0);
647 try { curChar = input_stream.readChar(); }
648 catch(java.io.IOException e) {
649 jjStopStringLiteralDfa_0(12, active0);
650 return 13;
651 }
652 switch(curChar)
653 {
654 case 105:
655 return jjMoveStringLiteralDfa14_0(active0, 0x400000L);
656 case 121:
657 if ((active0 & 0x200000L) != 0L)
658 return jjStartNfaWithStates_0(13, 21, 51);
659 break;
660 default :
661 break;
662 }
663 return jjStartNfa_0(12, active0);
664 }
665 private final int jjMoveStringLiteralDfa14_0(long old0, long active0)
666 {
667 if (((active0 &= old0)) == 0L)
668 return jjStartNfa_0(12, old0);
669 try { curChar = input_stream.readChar(); }
670 catch(java.io.IOException e) {
671 jjStopStringLiteralDfa_0(13, active0);
672 return 14;
673 }
674 switch(curChar)
675 {
676 case 116:
677 return jjMoveStringLiteralDfa15_0(active0, 0x400000L);
678 default :
679 break;
680 }
681 return jjStartNfa_0(13, active0);
682 }
683 private final int jjMoveStringLiteralDfa15_0(long old0, long active0)
684 {
685 if (((active0 &= old0)) == 0L)
686 return jjStartNfa_0(13, old0);
687 try { curChar = input_stream.readChar(); }
688 catch(java.io.IOException e) {
689 jjStopStringLiteralDfa_0(14, active0);
690 return 15;
691 }
692 switch(curChar)
693 {
694 case 121:
695 if ((active0 & 0x400000L) != 0L)
696 return jjStartNfaWithStates_0(15, 22, 51);
697 break;
698 default :
699 break;
700 }
701 return jjStartNfa_0(14, active0);
702 }
703 private final void jjCheckNAdd(int state)
704 {
705 if (jjrounds[state] != jjround)
706 {
707 jjstateSet[jjnewStateCnt++] = state;
708 jjrounds[state] = jjround;
709 }
710 }
711 private final void jjAddStates(int start, int end)
712 {
713 do {
714 jjstateSet[jjnewStateCnt++] = jjnextStates[start];
715 } while (start++ != end);
716 }
717 private final void jjCheckNAddTwoStates(int state1, int state2)
718 {
719 jjCheckNAdd(state1);
720 jjCheckNAdd(state2);
721 }
722 private final void jjCheckNAddStates(int start, int end)
723 {
724 do {
725 jjCheckNAdd(jjnextStates[start]);
726 } while (start++ != end);
727 }
728 private final void jjCheckNAddStates(int start)
729 {
730 jjCheckNAdd(jjnextStates[start]);
731 jjCheckNAdd(jjnextStates[start + 1]);
732 }
733 static final long[] jjbitVec0 = {
734 0x0L, 0x0L, 0xffffffffffffffffL, 0xffffffffffffffffL
735 };
736 private final int jjMoveNfa_0(int startState, int curPos)
737 {
738 int[] nextStates;
739 int startsAt = 0;
740 jjnewStateCnt = 47;
741 int i = 1;
742 jjstateSet[0] = startState;
743 int j, kind = 0x7fffffff;
744 for (;;)
745 {
746 if (++jjround == 0x7fffffff)
747 ReInitRounds();
748 if (curChar < 64)
749 {
750 long l = 1L << curChar;
751 MatchLoop: do
752 {
753 switch(jjstateSet[--i])
754 {
755 case 49:
756 if ((0x3ff200000000000L & l) != 0L)
757 jjCheckNAddTwoStates(18, 19);
758 if ((0x3ff000000000000L & l) != 0L)
759 {
760 if (kind > 31)
761 kind = 31;
762 jjCheckNAddStates(0, 2);
763 }
764 if ((0x3ff000000000000L & l) != 0L)
765 {
766 if (kind > 31)
767 kind = 31;
768 jjCheckNAdd(20);
769 }
770 if ((0x3ff000000000000L & l) != 0L)
771 {
772 if (kind > 31)
773 kind = 31;
774 jjCheckNAdd(19);
775 }
776 break;
777 case 48:
778 if ((0x3ff200000000000L & l) != 0L)
779 jjCheckNAddTwoStates(18, 19);
780 else if (curChar == 58)
781 jjCheckNAddStates(3, 5);
782 if ((0x3ff000000000000L & l) != 0L)
783 {
784 if (kind > 31)
785 kind = 31;
786 jjCheckNAddStates(0, 2);
787 }
788 else if (curChar == 58)
789 jjCheckNAddTwoStates(23, 25);
790 if ((0x3ff000000000000L & l) != 0L)
791 {
792 if (kind > 31)
793 kind = 31;
794 jjCheckNAdd(20);
795 }
796 if ((0x3ff000000000000L & l) != 0L)
797 jjCheckNAddTwoStates(26, 27);
798 if ((0x3ff000000000000L & l) != 0L)
799 jjCheckNAddTwoStates(23, 24);
800 break;
801 case 47:
802 if ((0x3ff200000000000L & l) != 0L)
803 jjCheckNAddTwoStates(18, 19);
804 if ((0x3ff000000000000L & l) != 0L)
805 {
806 if (kind > 31)
807 kind = 31;
808 jjCheckNAddStates(0, 2);
809 }
810 if ((0x3ff000000000000L & l) != 0L)
811 {
812 if (kind > 31)
813 kind = 31;
814 jjCheckNAdd(20);
815 }
816 break;
817 case 50:
818 if ((0x3ff200000000000L & l) != 0L)
819 jjCheckNAddTwoStates(18, 19);
820 else if (curChar == 58)
821 jjCheckNAddStates(3, 5);
822 if ((0x3ff000000000000L & l) != 0L)
823 {
824 if (kind > 31)
825 kind = 31;
826 jjCheckNAddStates(0, 2);
827 }
828 else if (curChar == 58)
829 jjCheckNAddTwoStates(23, 25);
830 if ((0x3ff000000000000L & l) != 0L)
831 {
832 if (kind > 31)
833 kind = 31;
834 jjCheckNAdd(20);
835 }
836 if ((0x3ff000000000000L & l) != 0L)
837 {
838 if (kind > 31)
839 kind = 31;
840 jjCheckNAdd(19);
841 }
842 if ((0x3ff000000000000L & l) != 0L)
843 jjCheckNAddTwoStates(26, 27);
844 if ((0x3ff000000000000L & l) != 0L)
845 jjCheckNAddTwoStates(23, 24);
846 break;
847 case 5:
848 if ((0x3ff000000000000L & l) != 0L)
849 jjCheckNAddStates(6, 9);
850 else if (curChar == 58)
851 jjAddStates(10, 11);
852 else if (curChar == 34)
853 jjCheckNAddTwoStates(15, 16);
854 else if (curChar == 35)
855 jjCheckNAddStates(12, 14);
856 else if (curChar == 45)
857 jjstateSet[jjnewStateCnt++] = 0;
858 if ((0x3ff000000000000L & l) != 0L)
859 {
860 if (kind > 31)
861 kind = 31;
862 jjCheckNAddStates(15, 17);
863 }
864 if ((0x3fe000000000000L & l) != 0L)
865 {
866 if (kind > 24)
867 kind = 24;
868 jjCheckNAddTwoStates(12, 13);
869 }
870 else if (curChar == 48)
871 {
872 if (kind > 24)
873 kind = 24;
874 jjCheckNAddStates(18, 20);
875 }
876 break;
877 case 51:
878 if ((0x3ff200000000000L & l) != 0L)
879 jjCheckNAddTwoStates(18, 19);
880 if ((0x3ff000000000000L & l) != 0L)
881 {
882 if (kind > 31)
883 kind = 31;
884 jjCheckNAdd(19);
885 }
886 break;
887 case 0:
888 if (curChar == 45)
889 jjCheckNAddStates(21, 23);
890 break;
891 case 1:
892 if ((0xffffffffffffdbffL & l) != 0L)
893 jjCheckNAddStates(21, 23);
894 break;
895 case 2:
896 if ((0x2400L & l) != 0L && kind > 5)
897 kind = 5;
898 break;
899 case 3:
900 if (curChar == 10 && kind > 5)
901 kind = 5;
902 break;
903 case 4:
904 if (curChar == 13)
905 jjstateSet[jjnewStateCnt++] = 3;
906 break;
907 case 6:
908 if (curChar == 35)
909 jjCheckNAddStates(12, 14);
910 break;
911 case 7:
912 if ((0xffffffffffffdbffL & l) != 0L)
913 jjCheckNAddStates(12, 14);
914 break;
915 case 8:
916 if ((0x2400L & l) != 0L && kind > 6)
917 kind = 6;
918 break;
919 case 9:
920 if (curChar == 10 && kind > 6)
921 kind = 6;
922 break;
923 case 10:
924 if (curChar == 13)
925 jjstateSet[jjnewStateCnt++] = 9;
926 break;
927 case 11:
928 if ((0x3fe000000000000L & l) == 0L)
929 break;
930 if (kind > 24)
931 kind = 24;
932 jjCheckNAddTwoStates(12, 13);
933 break;
934 case 12:
935 if ((0x3ff000000000000L & l) == 0L)
936 break;
937 if (kind > 24)
938 kind = 24;
939 jjCheckNAddTwoStates(12, 13);
940 break;
941 case 14:
942 if (curChar == 34)
943 jjCheckNAddTwoStates(15, 16);
944 break;
945 case 15:
946 if ((0xfffffffbffffffffL & l) != 0L)
947 jjCheckNAddTwoStates(15, 16);
948 break;
949 case 16:
950 if (curChar == 34 && kind > 35)
951 kind = 35;
952 break;
953 case 17:
954 if ((0x3ff000000000000L & l) == 0L)
955 break;
956 if (kind > 31)
957 kind = 31;
958 jjCheckNAddStates(15, 17);
959 break;
960 case 18:
961 if ((0x3ff200000000000L & l) != 0L)
962 jjCheckNAddTwoStates(18, 19);
963 break;
964 case 19:
965 if ((0x3ff000000000000L & l) == 0L)
966 break;
967 if (kind > 31)
968 kind = 31;
969 jjCheckNAdd(19);
970 break;
971 case 20:
972 if ((0x3ff000000000000L & l) == 0L)
973 break;
974 if (kind > 31)
975 kind = 31;
976 jjCheckNAdd(20);
977 break;
978 case 21:
979 if ((0x3ff000000000000L & l) == 0L)
980 break;
981 if (kind > 31)
982 kind = 31;
983 jjCheckNAddStates(0, 2);
984 break;
985 case 22:
986 if ((0x3ff000000000000L & l) != 0L)
987 jjCheckNAddStates(6, 9);
988 break;
989 case 23:
990 if ((0x3ff000000000000L & l) != 0L)
991 jjCheckNAddTwoStates(23, 24);
992 break;
993 case 24:
994 if (curChar == 58)
995 jjCheckNAddTwoStates(23, 25);
996 break;
997 case 25:
998 case 41:
999 if (curChar == 58 && kind > 28)
1000 kind = 28;
1001 break;
1002 case 26:
1003 if ((0x3ff000000000000L & l) != 0L)
1004 jjCheckNAddTwoStates(26, 27);
1005 break;
1006 case 27:
1007 if (curChar == 58)
1008 jjCheckNAddStates(3, 5);
1009 break;
1010 case 28:
1011 case 42:
1012 if (curChar == 58)
1013 jjCheckNAddTwoStates(29, 36);
1014 break;
1015 case 29:
1016 if ((0x3ff000000000000L & l) != 0L)
1017 jjCheckNAddTwoStates(29, 30);
1018 break;
1019 case 30:
1020 if (curChar == 46)
1021 jjCheckNAdd(31);
1022 break;
1023 case 31:
1024 if ((0x3ff000000000000L & l) != 0L)
1025 jjCheckNAddTwoStates(31, 32);
1026 break;
1027 case 32:
1028 if (curChar == 46)
1029 jjCheckNAdd(33);
1030 break;
1031 case 33:
1032 if ((0x3ff000000000000L & l) != 0L)
1033 jjCheckNAddTwoStates(33, 34);
1034 break;
1035 case 34:
1036 if (curChar == 46)
1037 jjCheckNAdd(35);
1038 break;
1039 case 35:
1040 if ((0x3ff000000000000L & l) == 0L)
1041 break;
1042 if (kind > 28)
1043 kind = 28;
1044 jjCheckNAdd(35);
1045 break;
1046 case 36:
1047 if ((0x3ff000000000000L & l) == 0L)
1048 break;
1049 if (kind > 28)
1050 kind = 28;
1051 jjCheckNAddStates(24, 26);
1052 break;
1053 case 37:
1054 if ((0x3ff000000000000L & l) != 0L)
1055 jjCheckNAddTwoStates(37, 28);
1056 break;
1057 case 38:
1058 if ((0x3ff000000000000L & l) == 0L)
1059 break;
1060 if (kind > 28)
1061 kind = 28;
1062 jjCheckNAdd(38);
1063 break;
1064 case 39:
1065 if ((0x3ff000000000000L & l) == 0L)
1066 break;
1067 if (kind > 28)
1068 kind = 28;
1069 jjCheckNAddStates(27, 31);
1070 break;
1071 case 40:
1072 if (curChar == 58)
1073 jjAddStates(10, 11);
1074 break;
1075 case 43:
1076 if (curChar != 48)
1077 break;
1078 if (kind > 24)
1079 kind = 24;
1080 jjCheckNAddStates(18, 20);
1081 break;
1082 case 45:
1083 if ((0x3ff000000000000L & l) == 0L)
1084 break;
1085 if (kind > 24)
1086 kind = 24;
1087 jjCheckNAddTwoStates(45, 13);
1088 break;
1089 case 46:
1090 if ((0xff000000000000L & l) == 0L)
1091 break;
1092 if (kind > 24)
1093 kind = 24;
1094 jjCheckNAddTwoStates(46, 13);
1095 break;
1096 default : break;
1097 }
1098 } while(i != startsAt);
1099 }
1100 else if (curChar < 128)
1101 {
1102 long l = 1L << (curChar & 077);
1103 MatchLoop: do
1104 {
1105 switch(jjstateSet[--i])
1106 {
1107 case 49:
1108 if ((0x7fffffe87fffffeL & l) != 0L)
1109 jjCheckNAddTwoStates(18, 19);
1110 if ((0x7fffffe07fffffeL & l) != 0L)
1111 {
1112 if (kind > 31)
1113 kind = 31;
1114 jjCheckNAddStates(0, 2);
1115 }
1116 if ((0x7fffffe07fffffeL & l) != 0L)
1117 {
1118 if (kind > 31)
1119 kind = 31;
1120 jjCheckNAdd(20);
1121 }
1122 if ((0x7fffffe07fffffeL & l) != 0L)
1123 {
1124 if (kind > 31)
1125 kind = 31;
1126 jjCheckNAdd(19);
1127 }
1128 break;
1129 case 48:
1130 if ((0x7fffffe87fffffeL & l) != 0L)
1131 jjCheckNAddTwoStates(18, 19);
1132 if ((0x7fffffe07fffffeL & l) != 0L)
1133 {
1134 if (kind > 31)
1135 kind = 31;
1136 jjCheckNAddStates(0, 2);
1137 }
1138 if ((0x7fffffe07fffffeL & l) != 0L)
1139 {
1140 if (kind > 31)
1141 kind = 31;
1142 jjCheckNAdd(20);
1143 }
1144 if ((0x7e0000007eL & l) != 0L)
1145 jjCheckNAddTwoStates(26, 27);
1146 if ((0x7e0000007eL & l) != 0L)
1147 jjCheckNAddTwoStates(23, 24);
1148 break;
1149 case 47:
1150 if ((0x7fffffe87fffffeL & l) != 0L)
1151 jjCheckNAddTwoStates(18, 19);
1152 if ((0x7fffffe07fffffeL & l) != 0L)
1153 {
1154 if (kind > 31)
1155 kind = 31;
1156 jjCheckNAddStates(0, 2);
1157 }
1158 if ((0x7fffffe07fffffeL & l) != 0L)
1159 {
1160 if (kind > 31)
1161 kind = 31;
1162 jjCheckNAdd(20);
1163 }
1164 break;
1165 case 50:
1166 if ((0x7fffffe87fffffeL & l) != 0L)
1167 jjCheckNAddTwoStates(18, 19);
1168 if ((0x7fffffe07fffffeL & l) != 0L)
1169 {
1170 if (kind > 31)
1171 kind = 31;
1172 jjCheckNAddStates(0, 2);
1173 }
1174 if ((0x7fffffe07fffffeL & l) != 0L)
1175 {
1176 if (kind > 31)
1177 kind = 31;
1178 jjCheckNAdd(20);
1179 }
1180 if ((0x7fffffe07fffffeL & l) != 0L)
1181 {
1182 if (kind > 31)
1183 kind = 31;
1184 jjCheckNAdd(19);
1185 }
1186 if ((0x7e0000007eL & l) != 0L)
1187 jjCheckNAddTwoStates(26, 27);
1188 if ((0x7e0000007eL & l) != 0L)
1189 jjCheckNAddTwoStates(23, 24);
1190 break;
1191 case 5:
1192 if ((0x7fffffe07fffffeL & l) != 0L)
1193 {
1194 if (kind > 31)
1195 kind = 31;
1196 jjCheckNAddStates(15, 17);
1197 }
1198 if ((0x7e0000007eL & l) != 0L)
1199 jjCheckNAddStates(6, 9);
1200 break;
1201 case 51:
1202 if ((0x7fffffe87fffffeL & l) != 0L)
1203 jjCheckNAddTwoStates(18, 19);
1204 if ((0x7fffffe07fffffeL & l) != 0L)
1205 {
1206 if (kind > 31)
1207 kind = 31;
1208 jjCheckNAdd(19);
1209 }
1210 break;
1211 case 1:
1212 jjAddStates(21, 23);
1213 break;
1214 case 7:
1215 jjAddStates(12, 14);
1216 break;
1217 case 13:
1218 if ((0x100000001000L & l) != 0L && kind > 24)
1219 kind = 24;
1220 break;
1221 case 15:
1222 jjAddStates(32, 33);
1223 break;
1224 case 17:
1225 if ((0x7fffffe07fffffeL & l) == 0L)
1226 break;
1227 if (kind > 31)
1228 kind = 31;
1229 jjCheckNAddStates(15, 17);
1230 break;
1231 case 18:
1232 if ((0x7fffffe87fffffeL & l) != 0L)
1233 jjCheckNAddTwoStates(18, 19);
1234 break;
1235 case 19:
1236 if ((0x7fffffe07fffffeL & l) == 0L)
1237 break;
1238 if (kind > 31)
1239 kind = 31;
1240 jjCheckNAdd(19);
1241 break;
1242 case 20:
1243 if ((0x7fffffe07fffffeL & l) == 0L)
1244 break;
1245 if (kind > 31)
1246 kind = 31;
1247 jjCheckNAdd(20);
1248 break;
1249 case 21:
1250 if ((0x7fffffe07fffffeL & l) == 0L)
1251 break;
1252 if (kind > 31)
1253 kind = 31;
1254 jjCheckNAddStates(0, 2);
1255 break;
1256 case 22:
1257 if ((0x7e0000007eL & l) != 0L)
1258 jjCheckNAddStates(6, 9);
1259 break;
1260 case 23:
1261 if ((0x7e0000007eL & l) != 0L)
1262 jjCheckNAddTwoStates(23, 24);
1263 break;
1264 case 26:
1265 if ((0x7e0000007eL & l) != 0L)
1266 jjCheckNAddTwoStates(26, 27);
1267 break;
1268 case 36:
1269 if ((0x7e0000007eL & l) == 0L)
1270 break;
1271 if (kind > 28)
1272 kind = 28;
1273 jjCheckNAddStates(24, 26);
1274 break;
1275 case 37:
1276 if ((0x7e0000007eL & l) != 0L)
1277 jjCheckNAddTwoStates(37, 28);
1278 break;
1279 case 38:
1280 if ((0x7e0000007eL & l) == 0L)
1281 break;
1282 if (kind > 28)
1283 kind = 28;
1284 jjCheckNAdd(38);
1285 break;
1286 case 39:
1287 if ((0x7e0000007eL & l) == 0L)
1288 break;
1289 if (kind > 28)
1290 kind = 28;
1291 jjCheckNAddStates(27, 31);
1292 break;
1293 case 44:
1294 if ((0x100000001000000L & l) != 0L)
1295 jjCheckNAdd(45);
1296 break;
1297 case 45:
1298 if ((0x7e0000007eL & l) == 0L)
1299 break;
1300 if (kind > 24)
1301 kind = 24;
1302 jjCheckNAddTwoStates(45, 13);
1303 break;
1304 default : break;
1305 }
1306 } while(i != startsAt);
1307 }
1308 else
1309 {
1310 int i2 = (curChar & 0xff) >> 6;
1311 long l2 = 1L << (curChar & 077);
1312 MatchLoop: do
1313 {
1314 switch(jjstateSet[--i])
1315 {
1316 case 1:
1317 if ((jjbitVec0[i2] & l2) != 0L)
1318 jjAddStates(21, 23);
1319 break;
1320 case 7:
1321 if ((jjbitVec0[i2] & l2) != 0L)
1322 jjAddStates(12, 14);
1323 break;
1324 case 15:
1325 if ((jjbitVec0[i2] & l2) != 0L)
1326 jjAddStates(32, 33);
1327 break;
1328 default : break;
1329 }
1330 } while(i != startsAt);
1331 }
1332 if (kind != 0x7fffffff)
1333 {
1334 jjmatchedKind = kind;
1335 jjmatchedPos = curPos;
1336 kind = 0x7fffffff;
1337 }
1338 ++curPos;
1339 if ((i = jjnewStateCnt) == (startsAt = 47 - (jjnewStateCnt = startsAt)))
1340 return curPos;
1341 try { curChar = input_stream.readChar(); }
1342 catch(java.io.IOException e) { return curPos; }
1343 }
1344}
1345static final int[] jjnextStates = {
1346 18, 19, 21, 28, 29, 39, 23, 24, 26, 27, 41, 42, 7, 8, 10, 18,
1347 20, 21, 44, 46, 13, 1, 2, 4, 37, 28, 38, 26, 27, 37, 28, 38,
1348 15, 16,
1349};
1350public static final String [] jjstrLiteralImages = {
1351"", null, null, null, null, null, null, "\141\143\143\145\163\163",
1352"\141\143\154", "\75", "\143\157\155\155\165\156\151\164\151\145\163",
1353"\145\156\164\145\162\160\162\151\163\145", "\150\157\163\164\163", "\173", "\155\141\156\141\147\145\162\163", "\55",
1354"\175", "\162\145\141\144\55\157\156\154\171",
1355"\162\145\141\144\55\167\162\151\164\145", "\164\162\141\160", "\151\156\146\157\162\155",
1356"\164\162\141\160\55\143\157\155\155\165\156\151\164\171", "\151\156\146\157\162\155\55\143\157\155\155\165\156\151\164\171",
1357"\164\162\141\160\55\156\165\155", null, null, null, null, null, null, null, null, null, null, null, null, "\54",
1358"\56", "\41", "\57", };
1359public static final String [] lexStateNames = {
1360 "DEFAULT",
1361};
1362static final long[] jjtoToken = {
1363 0xf891ffff81L,
1364};
1365static final long[] jjtoSkip = {
1366 0x7eL,
1367};
1368private ASCII_CharStream input_stream;
1369private final int[] jjrounds = new int[47];
1370private final int[] jjstateSet = new int[94];
1371protected char curChar;
1372public ParserTokenManager(ASCII_CharStream stream)
1373{
1374 if (ASCII_CharStream.staticFlag)
1375 throw new Error ("ERROR: Cannot use a static CharStream class with a non-static lexical analyzer.");
1376 input_stream = stream;
1377}
1378public ParserTokenManager(ASCII_CharStream stream, int lexState)
1379{
1380 this(stream);
1381 SwitchTo(lexState);
1382}
1383public void ReInit(ASCII_CharStream stream)
1384{
1385 jjmatchedPos = jjnewStateCnt = 0;
1386 curLexState = defaultLexState;
1387 input_stream = stream;
1388 ReInitRounds();
1389}
1390private final void ReInitRounds()
1391{
1392 int i;
1393 jjround = 0x80000001;
1394 for (i = 47; i-- > 0;)
1395 jjrounds[i] = 0x80000000;
1396}
1397public void ReInit(ASCII_CharStream stream, int lexState)
1398{
1399 ReInit(stream);
1400 SwitchTo(lexState);
1401}
1402public void SwitchTo(int lexState)
1403{
1404 if (lexState >= 1 || lexState < 0)
1405 throw new TokenMgrError("Error: Ignoring invalid lexical state : " + lexState + ". State unchanged.", TokenMgrError.INVALID_LEXICAL_STATE);
1406 else
1407 curLexState = lexState;
1408}
1409
1410private final Token jjFillToken()
1411{
1412 Token t = Token.newToken(jjmatchedKind);
1413 t.kind = jjmatchedKind;
1414 String im = jjstrLiteralImages[jjmatchedKind];
1415 t.image = (im == null) ? input_stream.GetImage() : im;
1416 t.beginLine = input_stream.getBeginLine();
1417 t.beginColumn = input_stream.getBeginColumn();
1418 t.endLine = input_stream.getEndLine();
1419 t.endColumn = input_stream.getEndColumn();
1420 return t;
1421}
1422
1423int curLexState = 0;
1424int defaultLexState = 0;
1425int jjnewStateCnt;
1426int jjround;
1427int jjmatchedPos;
1428int jjmatchedKind;
1429
1430public final Token getNextToken()
1431{
1432 int kind;
1433 Token specialToken = null;
1434 Token matchedToken;
1435 int curPos = 0;
1436
1437 EOFLoop :
1438 for (;;)
1439 {
1440 try
1441 {
1442 curChar = input_stream.BeginToken();
1443 }
1444 catch(java.io.IOException e)
1445 {
1446 jjmatchedKind = 0;
1447 matchedToken = jjFillToken();
1448 return matchedToken;
1449 }
1450
1451 try { input_stream.backup(0);
1452 while (curChar <= 32 && (0x100002600L & (1L << curChar)) != 0L)
1453 curChar = input_stream.BeginToken();
1454 }
1455 catch (java.io.IOException e1) { continue EOFLoop; }
1456 jjmatchedKind = 0x7fffffff;
1457 jjmatchedPos = 0;
1458 curPos = jjMoveStringLiteralDfa0_0();
1459 if (jjmatchedKind != 0x7fffffff)
1460 {
1461 if (jjmatchedPos + 1 < curPos)
1462 input_stream.backup(curPos - jjmatchedPos - 1);
1463 if ((jjtoToken[jjmatchedKind >> 6] & (1L << (jjmatchedKind & 077))) != 0L)
1464 {
1465 matchedToken = jjFillToken();
1466 return matchedToken;
1467 }
1468 else
1469 {
1470 continue EOFLoop;
1471 }
1472 }
1473 int error_line = input_stream.getEndLine();
1474 int error_column = input_stream.getEndColumn();
1475 String error_after = null;
1476 boolean EOFSeen = false;
1477 try { input_stream.readChar(); input_stream.backup(1); }
1478 catch (java.io.IOException e1) {
1479 EOFSeen = true;
1480 error_after = curPos <= 1 ? "" : input_stream.GetImage();
1481 if (curChar == '\n' || curChar == '\r') {
1482 error_line++;
1483 error_column = 0;
1484 }
1485 else
1486 error_column++;
1487 }
1488 if (!EOFSeen) {
1489 input_stream.backup(1);
1490 error_after = curPos <= 1 ? "" : input_stream.GetImage();
1491 }
1492 throw new TokenMgrError(EOFSeen, curLexState, error_line, error_column, error_after, curChar, TokenMgrError.LEXICAL_ERROR);
1493 }
1494}
1495
1496}
1497 |
Popular Tags |
Java API By Example, From Geeks To Geeks.