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