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