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 & 0x10000L) != 0L)
22 {
23 jjmatchedKind = 32;
24 return 50;
25 }
26 if ((active0 & 0x800L) != 0L)
27 return 60;
28 if ((active0 & 0xc00000L) != 0L)
29 {
30 jjmatchedKind = 32;
31 return 61;
32 }
33 if ((active0 & 0x193ef600L) != 0L)
34 {
35 jjmatchedKind = 32;
36 return 60;
37 }
38 if ((active0 & 0x4000000L) != 0L)
39 return 9;
40 return -1;
41 case 1:
42 if ((active0 & 0x60600L) != 0L)
43 return 60;
44 if ((active0 & 0x19f9f000L) != 0L)
45 {
46 jjmatchedKind = 32;
47 jjmatchedPos = 1;
48 return 60;
49 }
50 return -1;
51 case 2:
52 if ((active0 & 0x200000L) != 0L)
53 return 60;
54 if ((active0 & 0x19d9f000L) != 0L)
55 {
56 jjmatchedKind = 32;
57 jjmatchedPos = 2;
58 return 60;
59 }
60 return -1;
61 case 3:
62 if ((active0 & 0x9082000L) != 0L)
63 return 60;
64 if ((active0 & 0x10d1d000L) != 0L)
65 {
66 jjmatchedKind = 32;
67 jjmatchedPos = 3;
68 return 60;
69 }
70 return -1;
71 case 4:
72 if ((active0 & 0x10004000L) != 0L)
73 return 60;
74 if ((active0 & 0xd19000L) != 0L)
75 {
76 jjmatchedKind = 32;
77 jjmatchedPos = 4;
78 return 60;
79 }
80 return -1;
81 case 5:
82 if ((active0 & 0x400000L) != 0L)
83 return 60;
84 if ((active0 & 0x919000L) != 0L)
85 {
86 jjmatchedKind = 32;
87 jjmatchedPos = 5;
88 return 60;
89 }
90 return -1;
91 case 6:
92 if ((active0 & 0x118000L) != 0L)
93 return 60;
94 if ((active0 & 0x801000L) != 0L)
95 {
96 jjmatchedKind = 32;
97 jjmatchedPos = 6;
98 return 60;
99 }
100 return -1;
101 case 7:
102 if ((active0 & 0x1000L) != 0L)
103 return 60;
104 if ((active0 & 0x800000L) != 0L)
105 {
106 jjmatchedKind = 32;
107 jjmatchedPos = 7;
108 return 60;
109 }
110 return -1;
111 case 8:
112 if ((active0 & 0x800000L) != 0L)
113 {
114 jjmatchedKind = 32;
115 jjmatchedPos = 8;
116 return 60;
117 }
118 return -1;
119 case 9:
120 if ((active0 & 0x800000L) != 0L)
121 {
122 jjmatchedKind = 32;
123 jjmatchedPos = 9;
124 return 60;
125 }
126 return -1;
127 case 10:
128 if ((active0 & 0x800000L) != 0L)
129 {
130 jjmatchedKind = 32;
131 jjmatchedPos = 10;
132 return 60;
133 }
134 return -1;
135 case 11:
136 if ((active0 & 0x800000L) != 0L)
137 {
138 jjmatchedKind = 32;
139 jjmatchedPos = 11;
140 return 60;
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, 60);
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, 60);
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, 60);
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, 60);
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, 60);
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, 60);
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, 60);
321 else if ((active0 & 0x8000000L) != 0L)
322 return jjStartNfaWithStates_0(3, 27, 60);
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, 60);
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, 60);
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, 60);
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, 60);
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, 60);
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, 60);
443 break;
444 case 83:
445 case 115:
446 if ((active0 & 0x8000L) != 0L)
447 return jjStartNfaWithStates_0(6, 15, 60);
448 else if ((active0 & 0x10000L) != 0L)
449 return jjStartNfaWithStates_0(6, 16, 60);
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, 60);
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, 60);
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 = 60;
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 61:
610 if ((0x3ff200000000000L & l) != 0L)
611 {
612 if (kind > 32)
613 kind = 32;
614 jjCheckNAdd(48);
615 }
616 else if (curChar == 46)
617 jjstateSet[jjnewStateCnt++] = 45;
618 if ((0x3ff200000000000L & l) != 0L)
619 jjCheckNAddTwoStates(46, 47);
620 break;
621 case 60:
622 if ((0x3ff200000000000L & l) != 0L)
623 {
624 if (kind > 32)
625 kind = 32;
626 jjCheckNAdd(48);
627 }
628 else if (curChar == 46)
629 jjstateSet[jjnewStateCnt++] = 45;
630 if ((0x3ff200000000000L & l) != 0L)
631 jjCheckNAddTwoStates(46, 47);
632 break;
633 case 0:
634 if ((0x3ff000000000000L & l) != 0L)
635 {
636 if (kind > 31)
637 kind = 31;
638 jjCheckNAddStates(0, 4);
639 }
640 else if ((0x7000000000000000L & l) != 0L)
641 {
642 if (kind > 29)
643 kind = 29;
644 }
645 else if (curChar == 45)
646 jjCheckNAddStates(5, 7);
647 else if (curChar == 36)
648 jjCheckNAdd(41);
649 else if (curChar == 34)
650 jjCheckNAddStates(8, 10);
651 else if (curChar == 39)
652 jjstateSet[jjnewStateCnt++] = 21;
653 else if (curChar == 46)
654 jjCheckNAdd(16);
655 else if (curChar == 33)
656 jjCheckNAdd(9);
657 else if (curChar == 59)
658 jjCheckNAddStates(11, 13);
659 if (curChar == 62)
660 jjCheckNAdd(9);
661 else if (curChar == 60)
662 jjCheckNAdd(9);
663 else if (curChar == 61)
664 jjCheckNAdd(9);
665 break;
666 case 50:
667 if ((0x3ff200000000000L & l) != 0L)
668 {
669 if (kind > 32)
670 kind = 32;
671 jjCheckNAdd(48);
672 }
673 else if (curChar == 46)
674 jjstateSet[jjnewStateCnt++] = 45;
675 if ((0x3ff200000000000L & l) != 0L)
676 jjCheckNAddTwoStates(46, 47);
677 break;
678 case 1:
679 if ((0xffffffffffffdbffL & l) != 0L)
680 jjCheckNAddStates(11, 13);
681 break;
682 case 2:
683 if ((0x2400L & l) != 0L && kind > 5)
684 kind = 5;
685 break;
686 case 3:
687 if (curChar == 10 && kind > 5)
688 kind = 5;
689 break;
690 case 4:
691 if (curChar == 13)
692 jjstateSet[jjnewStateCnt++] = 3;
693 break;
694 case 9:
695 if (curChar == 61 && kind > 29)
696 kind = 29;
697 break;
698 case 10:
699 if (curChar == 61)
700 jjCheckNAdd(9);
701 break;
702 case 11:
703 if ((0x7000000000000000L & l) != 0L && kind > 29)
704 kind = 29;
705 break;
706 case 12:
707 if (curChar == 33)
708 jjCheckNAdd(9);
709 break;
710 case 13:
711 if (curChar == 60)
712 jjCheckNAdd(9);
713 break;
714 case 14:
715 if (curChar == 62)
716 jjCheckNAdd(9);
717 break;
718 case 15:
719 if (curChar == 46)
720 jjCheckNAdd(16);
721 break;
722 case 16:
723 if ((0x3ff000000000000L & l) == 0L)
724 break;
725 if (kind > 30)
726 kind = 30;
727 jjCheckNAddTwoStates(16, 17);
728 break;
729 case 18:
730 if ((0x280000000000L & l) != 0L)
731 jjCheckNAdd(19);
732 break;
733 case 19:
734 if ((0x3ff000000000000L & l) == 0L)
735 break;
736 if (kind > 30)
737 kind = 30;
738 jjCheckNAdd(19);
739 break;
740 case 20:
741 if (curChar == 39)
742 jjstateSet[jjnewStateCnt++] = 21;
743 break;
744 case 22:
745 if ((0x3ff000000000000L & l) == 0L)
746 break;
747 if (kind > 34)
748 kind = 34;
749 jjCheckNAddTwoStates(22, 23);
750 break;
751 case 23:
752 if (curChar == 46)
753 jjstateSet[jjnewStateCnt++] = 24;
754 break;
755 case 25:
756 if ((0x3ff000000000000L & l) == 0L)
757 break;
758 if (kind > 34)
759 kind = 34;
760 jjCheckNAddTwoStates(23, 25);
761 break;
762 case 26:
763 if (curChar == 34)
764 jjCheckNAddStates(8, 10);
765 break;
766 case 27:
767 if ((0xfffffffbffffffffL & l) != 0L)
768 jjCheckNAddStates(8, 10);
769 break;
770 case 29:
771 if ((0xff008400000000L & l) != 0L)
772 jjCheckNAddStates(8, 10);
773 break;
774 case 30:
775 if (curChar == 34 && kind > 35)
776 kind = 35;
777 break;
778 case 31:
779 if ((0xf000000000000L & l) != 0L)
780 jjstateSet[jjnewStateCnt++] = 32;
781 break;
782 case 32:
783 case 34:
784 if ((0xff000000000000L & l) != 0L)
785 jjCheckNAdd(33);
786 break;
787 case 33:
788 if ((0xff000000000000L & l) != 0L)
789 jjCheckNAddStates(8, 10);
790 break;
791 case 36:
792 if ((0x3ff000000000000L & l) != 0L)
793 jjstateSet[jjnewStateCnt++] = 37;
794 break;
795 case 37:
796 if ((0x3ff000000000000L & l) != 0L)
797 jjstateSet[jjnewStateCnt++] = 38;
798 break;
799 case 38:
800 if ((0x3ff000000000000L & l) != 0L)
801 jjstateSet[jjnewStateCnt++] = 39;
802 break;
803 case 39:
804 if ((0x3ff000000000000L & l) != 0L)
805 jjCheckNAddStates(8, 10);
806 break;
807 case 40:
808 if (curChar == 36)
809 jjCheckNAdd(41);
810 break;
811 case 42:
812 if ((0x3ff200000000000L & l) != 0L)
813 jjAddStates(14, 15);
814 break;
815 case 43:
816 if (curChar == 46)
817 jjCheckNAdd(41);
818 break;
819 case 44:
820 if ((0x3ff200000000000L & l) == 0L)
821 break;
822 if (kind > 36)
823 kind = 36;
824 jjstateSet[jjnewStateCnt++] = 44;
825 break;
826 case 46:
827 if ((0x3ff200000000000L & l) != 0L)
828 jjCheckNAddTwoStates(46, 47);
829 break;
830 case 47:
831 if (curChar == 46)
832 jjstateSet[jjnewStateCnt++] = 45;
833 break;
834 case 48:
835 if ((0x3ff200000000000L & l) == 0L)
836 break;
837 if (kind > 32)
838 kind = 32;
839 jjCheckNAdd(48);
840 break;
841 case 53:
842 if (curChar == 45)
843 jjCheckNAddStates(5, 7);
844 break;
845 case 54:
846 if ((0x3ff000000000000L & l) == 0L)
847 break;
848 if (kind > 31)
849 kind = 31;
850 jjCheckNAdd(54);
851 break;
852 case 55:
853 if ((0x3ff000000000000L & l) != 0L)
854 jjCheckNAddStates(16, 19);
855 break;
856 case 56:
857 if ((0x3ff000000000000L & l) != 0L)
858 jjCheckNAddTwoStates(56, 15);
859 break;
860 case 57:
861 if ((0x3ff000000000000L & l) != 0L)
862 jjCheckNAddTwoStates(57, 58);
863 break;
864 case 58:
865 if (curChar != 46)
866 break;
867 if (kind > 30)
868 kind = 30;
869 jjCheckNAdd(17);
870 break;
871 case 59:
872 if ((0x3ff000000000000L & l) == 0L)
873 break;
874 if (kind > 31)
875 kind = 31;
876 jjCheckNAddStates(0, 4);
877 break;
878 default : break;
879 }
880 } while(i != startsAt);
881 }
882 else if (curChar < 128)
883 {
884 long l = 1L << (curChar & 077);
885 do
886 {
887 switch(jjstateSet[--i])
888 {
889 case 61:
890 if ((0x7fffffe87fffffeL & l) != 0L)
891 {
892 if (kind > 32)
893 kind = 32;
894 jjCheckNAdd(48);
895 }
896 if ((0x7fffffe87fffffeL & l) != 0L)
897 jjCheckNAddTwoStates(46, 47);
898 if ((0x800000008L & l) != 0L)
899 {
900 if (kind > 8)
901 kind = 8;
902 }
903 break;
904 case 60:
905 if ((0x7fffffe87fffffeL & l) != 0L)
906 {
907 if (kind > 32)
908 kind = 32;
909 jjCheckNAdd(48);
910 }
911 if ((0x7fffffe87fffffeL & l) != 0L)
912 jjCheckNAddTwoStates(46, 47);
913 break;
914 case 0:
915 if ((0x7fffffe07fffffeL & l) != 0L)
916 {
917 if (kind > 32)
918 kind = 32;
919 jjCheckNAddStates(20, 22);
920 }
921 if ((0x8000000080000L & l) != 0L)
922 jjAddStates(23, 24);
923 else if ((0x4000000040000L & l) != 0L)
924 jjstateSet[jjnewStateCnt++] = 7;
925 else if ((0x1000000010L & l) != 0L)
926 jjCheckNAdd(5);
927 break;
928 case 50:
929 if ((0x7fffffe87fffffeL & l) != 0L)
930 {
931 if (kind > 32)
932 kind = 32;
933 jjCheckNAdd(48);
934 }
935 if ((0x7fffffe87fffffeL & l) != 0L)
936 jjCheckNAddTwoStates(46, 47);
937 if ((0x4000000040000L & l) != 0L)
938 jjstateSet[jjnewStateCnt++] = 51;
939 else if ((0x1000000010L & l) != 0L)
940 jjCheckNAdd(5);
941 break;
942 case 1:
943 jjAddStates(11, 13);
944 break;
945 case 5:
946 if ((0x800000008L & l) != 0L && kind > 8)
947 kind = 8;
948 break;
949 case 6:
950 case 7:
951 case 51:
952 if ((0x1000000010L & l) != 0L)
953 jjCheckNAdd(5);
954 break;
955 case 8:
956 if ((0x4000000040000L & l) != 0L)
957 jjstateSet[jjnewStateCnt++] = 7;
958 break;
959 case 17:
960 if ((0x2000000020L & l) != 0L)
961 jjAddStates(25, 26);
962 break;
963 case 21:
964 case 22:
965 if ((0x7fffffe87fffffeL & l) == 0L)
966 break;
967 if (kind > 34)
968 kind = 34;
969 jjCheckNAddTwoStates(22, 23);
970 break;
971 case 24:
972 case 25:
973 if ((0x7fffffe87fffffeL & l) == 0L)
974 break;
975 if (kind > 34)
976 kind = 34;
977 jjCheckNAddTwoStates(23, 25);
978 break;
979 case 27:
980 if ((0xffffffffefffffffL & l) != 0L)
981 jjCheckNAddStates(8, 10);
982 break;
983 case 28:
984 if (curChar == 92)
985 jjCheckNAddStates(27, 30);
986 break;
987 case 29:
988 if ((0x14404410144044L & l) != 0L)
989 jjCheckNAddStates(8, 10);
990 break;
991 case 35:
992 if ((0x20000000200000L & l) != 0L)
993 jjCheckNAddTwoStates(35, 36);
994 break;
995 case 36:
996 if ((0x7e0000007eL & l) != 0L)
997 jjstateSet[jjnewStateCnt++] = 37;
998 break;
999 case 37:
1000 if ((0x7e0000007eL & l) != 0L)
1001 jjstateSet[jjnewStateCnt++] = 38;
1002 break;
1003 case 38:
1004 if ((0x7e0000007eL & l) != 0L)
1005 jjstateSet[jjnewStateCnt++] = 39;
1006 break;
1007 case 39:
1008 if ((0x7e0000007eL & l) != 0L)
1009 jjCheckNAddStates(8, 10);
1010 break;
1011 case 41:
1012 if ((0x7fffffe07fffffeL & l) == 0L)
1013 break;
1014 if (kind > 36)
1015 kind = 36;
1016 jjCheckNAddStates(31, 33);
1017 break;
1018 case 42:
1019 if ((0x7fffffe87fffffeL & l) != 0L)
1020 jjCheckNAddTwoStates(42, 43);
1021 break;
1022 case 44:
1023 if ((0x7fffffe87fffffeL & l) == 0L)
1024 break;
1025 if (kind > 36)
1026 kind = 36;
1027 jjCheckNAdd(44);
1028 break;
1029 case 45:
1030 if ((0x7fffffe07fffffeL & l) == 0L)
1031 break;
1032 if (kind > 32)
1033 kind = 32;
1034 jjCheckNAddStates(20, 22);
1035 break;
1036 case 46:
1037 if ((0x7fffffe87fffffeL & l) != 0L)
1038 jjCheckNAddTwoStates(46, 47);
1039 break;
1040 case 48:
1041 if ((0x7fffffe87fffffeL & l) == 0L)
1042 break;
1043 if (kind > 32)
1044 kind = 32;
1045 jjCheckNAdd(48);
1046 break;
1047 case 49:
1048 if ((0x8000000080000L & l) != 0L)
1049 jjAddStates(23, 24);
1050 break;
1051 case 52:
1052 if ((0x4000000040000L & l) != 0L)
1053 jjstateSet[jjnewStateCnt++] = 51;
1054 break;
1055 default : break;
1056 }
1057 } while(i != startsAt);
1058 }
1059 else
1060 {
1061 int i2 = (curChar & 0xff) >> 6;
1062 long l2 = 1L << (curChar & 077);
1063 do
1064 {
1065 switch(jjstateSet[--i])
1066 {
1067 case 1:
1068 if ((jjbitVec0[i2] & l2) != 0L)
1069 jjAddStates(11, 13);
1070 break;
1071 case 27:
1072 if ((jjbitVec0[i2] & l2) != 0L)
1073 jjAddStates(8, 10);
1074 break;
1075 default : break;
1076 }
1077 } while(i != startsAt);
1078 }
1079 if (kind != 0x7fffffff)
1080 {
1081 jjmatchedKind = kind;
1082 jjmatchedPos = curPos;
1083 kind = 0x7fffffff;
1084 }
1085 ++curPos;
1086 if ((i = jjnewStateCnt) == (startsAt = 60 - (jjnewStateCnt = startsAt)))
1087 return curPos;
1088 try { curChar = input_stream.readChar(); }
1089 catch(java.io.IOException e) { return curPos; }
1090 }
1091 }
1092 static final int[] jjnextStates = {
1093 56, 15, 57, 58, 54, 15, 54, 55, 27, 28, 30, 1, 2, 4, 42, 43,
1094 56, 15, 57, 58, 46, 47, 48, 50, 52, 18, 19, 29, 31, 34, 35, 42,
1095 43, 44,
1096 };
1097
1098
1099 public static final String[] jjstrLiteralImages = {
1100 "", null, null, null, null, null, "\50", "\51", null, null, null, null, null,
1101 null, null, null, null, null, null, null, null, null, null, null, null, "\54",
1102 "\75", null, null, null, null, null, null, null, null, null, null, null, };
1103
1104
1105 public static final String[] lexStateNames = {
1106 "DEFAULT",
1107 };
1108 static final long[] jjtoToken = {
1109 0x3dffffffc1L,
1110 };
1111 static final long[] jjtoSkip = {
1112 0x3eL,
1113 };
1114 static final long[] jjtoSpecial = {
1115 0x20L,
1116 };
1117 protected SimpleCharStream input_stream;
1118 private final int[] jjrounds = new int[60];
1119 private final int[] jjstateSet = new int[120];
1120 protected char curChar;
1121
1122 public PoshParserTokenManager(SimpleCharStream stream){
1123 if (SimpleCharStream.staticFlag)
1124 throw new Error("ERROR: Cannot use a static CharStream class with a non-static lexical analyzer.");
1125 input_stream = stream;
1126 }
1127
1128
1129 public PoshParserTokenManager(SimpleCharStream stream, int lexState){
1130 this(stream);
1131 SwitchTo(lexState);
1132 }
1133
1134
1135 public void ReInit(SimpleCharStream stream)
1136 {
1137 jjmatchedPos = jjnewStateCnt = 0;
1138 curLexState = defaultLexState;
1139 input_stream = stream;
1140 ReInitRounds();
1141 }
1142 private void ReInitRounds()
1143 {
1144 int i;
1145 jjround = 0x80000001;
1146 for (i = 60; i-- > 0;)
1147 jjrounds[i] = 0x80000000;
1148 }
1149
1150
1151 public void ReInit(SimpleCharStream stream, int lexState)
1152 {
1153 ReInit(stream);
1154 SwitchTo(lexState);
1155 }
1156
1157
1158 public void SwitchTo(int lexState)
1159 {
1160 if (lexState >= 1 || lexState < 0)
1161 throw new TokenMgrError("Error: Ignoring invalid lexical state : " + lexState + ". State unchanged.", TokenMgrError.INVALID_LEXICAL_STATE);
1162 else
1163 curLexState = lexState;
1164 }
1165
1166 protected Token jjFillToken()
1167 {
1168 final Token t;
1169 final String curTokenImage;
1170 final int beginLine;
1171 final int endLine;
1172 final int beginColumn;
1173 final int endColumn;
1174 String im = jjstrLiteralImages[jjmatchedKind];
1175 curTokenImage = (im == null) ? input_stream.GetImage() : im;
1176 beginLine = input_stream.getBeginLine();
1177 beginColumn = input_stream.getBeginColumn();
1178 endLine = input_stream.getEndLine();
1179 endColumn = input_stream.getEndColumn();
1180 t = Token.newToken(jjmatchedKind, curTokenImage);
1181
1182 t.beginLine = beginLine;
1183 t.endLine = endLine;
1184 t.beginColumn = beginColumn;
1185 t.endColumn = endColumn;
1186
1187 return t;
1188 }
1189
1190 int curLexState = 0;
1191 int defaultLexState = 0;
1192 int jjnewStateCnt;
1193 int jjround;
1194 int jjmatchedPos;
1195 int jjmatchedKind;
1196
1197
1198 public Token getNextToken()
1199 {
1200 Token specialToken = null;
1201 Token matchedToken;
1202 int curPos = 0;
1203
1204 EOFLoop :
1205 for (;;)
1206 {
1207 try
1208 {
1209 curChar = input_stream.BeginToken();
1210 }
1211 catch(java.io.IOException e)
1212 {
1213 jjmatchedKind = 0;
1214 matchedToken = jjFillToken();
1215 matchedToken.specialToken = specialToken;
1216 return matchedToken;
1217 }
1218
1219 try { input_stream.backup(0);
1220 while (curChar <= 32 && (0x100002600L & (1L << curChar)) != 0L)
1221 curChar = input_stream.BeginToken();
1222 }
1223 catch (java.io.IOException e1) { continue EOFLoop; }
1224 jjmatchedKind = 0x7fffffff;
1225 jjmatchedPos = 0;
1226 curPos = jjMoveStringLiteralDfa0_0();
1227 if (jjmatchedPos == 0 && jjmatchedKind > 37)
1228 {
1229 jjmatchedKind = 37;
1230 }
1231 if (jjmatchedKind != 0x7fffffff)
1232 {
1233 if (jjmatchedPos + 1 < curPos)
1234 input_stream.backup(curPos - jjmatchedPos - 1);
1235 if ((jjtoToken[jjmatchedKind >> 6] & (1L << (jjmatchedKind & 077))) != 0L)
1236 {
1237 matchedToken = jjFillToken();
1238 matchedToken.specialToken = specialToken;
1239 return matchedToken;
1240 }
1241 else
1242 {
1243 if ((jjtoSpecial[jjmatchedKind >> 6] & (1L << (jjmatchedKind & 077))) != 0L)
1244 {
1245 matchedToken = jjFillToken();
1246 if (specialToken == null)
1247 specialToken = matchedToken;
1248 else
1249 {
1250 matchedToken.specialToken = specialToken;
1251 specialToken = (specialToken.next = matchedToken);
1252 }
1253 }
1254 continue EOFLoop;
1255 }
1256 }
1257 int error_line = input_stream.getEndLine();
1258 int error_column = input_stream.getEndColumn();
1259 String error_after = null;
1260 boolean EOFSeen = false;
1261 try { input_stream.readChar(); input_stream.backup(1); }
1262 catch (java.io.IOException e1) {
1263 EOFSeen = true;
1264 error_after = curPos <= 1 ? "" : input_stream.GetImage();
1265 if (curChar == '\n' || curChar == '\r') {
1266 error_line++;
1267 error_column = 0;
1268 }
1269 else
1270 error_column++;
1271 }
1272 if (!EOFSeen) {
1273 input_stream.backup(1);
1274 error_after = curPos <= 1 ? "" : input_stream.GetImage();
1275 }
1276 throw new TokenMgrError(EOFSeen, curLexState, error_line, error_column, error_after, curChar, TokenMgrError.LEXICAL_ERROR);
1277 }
1278 }
1279
1280 private void jjCheckNAdd(int state)
1281 {
1282 if (jjrounds[state] != jjround)
1283 {
1284 jjstateSet[jjnewStateCnt++] = state;
1285 jjrounds[state] = jjround;
1286 }
1287 }
1288 private void jjAddStates(int start, int end)
1289 {
1290 do {
1291 jjstateSet[jjnewStateCnt++] = jjnextStates[start];
1292 } while (start++ != end);
1293 }
1294 private void jjCheckNAddTwoStates(int state1, int state2)
1295 {
1296 jjCheckNAdd(state1);
1297 jjCheckNAdd(state2);
1298 }
1299
1300 private void jjCheckNAddStates(int start, int end)
1301 {
1302 do {
1303 jjCheckNAdd(jjnextStates[start]);
1304 } while (start++ != end);
1305 }
1306
1307 }