1
2 package cz.cuni.amis.pogamut.shady;
3 import java.util.*;
4
5
6 public class ShadyParserTokenManager implements ShadyParserConstants
7 {
8
9
10 public java.io.PrintStream debugStream = System.out;
11
12 public void setDebugStream(java.io.PrintStream ds) { debugStream = ds; }
13 private final int jjStopStringLiteralDfa_0(int pos, long active0)
14 {
15 switch (pos)
16 {
17 case 0:
18 if ((active0 & 0xe40L) != 0L)
19 {
20 jjmatchedKind = 18;
21 return 1;
22 }
23 if ((active0 & 0x4000000L) != 0L)
24 return 6;
25 return -1;
26 case 1:
27 if ((active0 & 0x640L) != 0L)
28 {
29 jjmatchedKind = 18;
30 jjmatchedPos = 1;
31 return 1;
32 }
33 if ((active0 & 0x800L) != 0L)
34 return 1;
35 return -1;
36 case 2:
37 if ((active0 & 0x40L) != 0L)
38 {
39 jjmatchedKind = 18;
40 jjmatchedPos = 2;
41 return 1;
42 }
43 if ((active0 & 0x600L) != 0L)
44 return 1;
45 return -1;
46 default :
47 return -1;
48 }
49 }
50 private final int jjStartNfa_0(int pos, long active0)
51 {
52 return jjMoveNfa_0(jjStopStringLiteralDfa_0(pos, active0), pos + 1);
53 }
54 private int jjStopAtPos(int pos, int kind)
55 {
56 jjmatchedKind = kind;
57 jjmatchedPos = pos;
58 return pos + 1;
59 }
60 private int jjMoveStringLiteralDfa0_0()
61 {
62 switch(curChar)
63 {
64 case 33:
65 return jjMoveStringLiteralDfa1_0(0x8000L);
66 case 40:
67 return jjStopAtPos(0, 7);
68 case 41:
69 return jjStopAtPos(0, 8);
70 case 46:
71 return jjStartNfaWithStates_0(0, 26, 6);
72 case 60:
73 jjmatchedKind = 17;
74 return jjMoveStringLiteralDfa1_0(0x10000L);
75 case 61:
76 return jjStopAtPos(0, 14);
77 case 62:
78 jjmatchedKind = 12;
79 return jjMoveStringLiteralDfa1_0(0x2000L);
80 case 97:
81 return jjMoveStringLiteralDfa1_0(0x200L);
82 case 110:
83 return jjMoveStringLiteralDfa1_0(0x440L);
84 case 111:
85 return jjMoveStringLiteralDfa1_0(0x800L);
86 default :
87 return jjMoveNfa_0(0, 0);
88 }
89 }
90 private int jjMoveStringLiteralDfa1_0(long active0)
91 {
92 try { curChar = input_stream.readChar(); }
93 catch(java.io.IOException e) {
94 jjStopStringLiteralDfa_0(0, active0);
95 return 1;
96 }
97 switch(curChar)
98 {
99 case 61:
100 if ((active0 & 0x2000L) != 0L)
101 return jjStopAtPos(1, 13);
102 else if ((active0 & 0x8000L) != 0L)
103 return jjStopAtPos(1, 15);
104 else if ((active0 & 0x10000L) != 0L)
105 return jjStopAtPos(1, 16);
106 break;
107 case 110:
108 return jjMoveStringLiteralDfa2_0(active0, 0x200L);
109 case 111:
110 return jjMoveStringLiteralDfa2_0(active0, 0x440L);
111 case 114:
112 if ((active0 & 0x800L) != 0L)
113 return jjStartNfaWithStates_0(1, 11, 1);
114 break;
115 default :
116 break;
117 }
118 return jjStartNfa_0(0, active0);
119 }
120 private int jjMoveStringLiteralDfa2_0(long old0, long active0)
121 {
122 if (((active0 &= old0)) == 0L)
123 return jjStartNfa_0(0, old0);
124 try { curChar = input_stream.readChar(); }
125 catch(java.io.IOException e) {
126 jjStopStringLiteralDfa_0(1, active0);
127 return 2;
128 }
129 switch(curChar)
130 {
131 case 100:
132 if ((active0 & 0x200L) != 0L)
133 return jjStartNfaWithStates_0(2, 9, 1);
134 return jjMoveStringLiteralDfa3_0(active0, 0x40L);
135 case 116:
136 if ((active0 & 0x400L) != 0L)
137 return jjStartNfaWithStates_0(2, 10, 1);
138 break;
139 default :
140 break;
141 }
142 return jjStartNfa_0(1, active0);
143 }
144 private int jjMoveStringLiteralDfa3_0(long old0, long active0)
145 {
146 if (((active0 &= old0)) == 0L)
147 return jjStartNfa_0(1, old0);
148 try { curChar = input_stream.readChar(); }
149 catch(java.io.IOException e) {
150 jjStopStringLiteralDfa_0(2, active0);
151 return 3;
152 }
153 switch(curChar)
154 {
155 case 101:
156 if ((active0 & 0x40L) != 0L)
157 return jjStartNfaWithStates_0(3, 6, 1);
158 break;
159 default :
160 break;
161 }
162 return jjStartNfa_0(2, active0);
163 }
164 private int jjStartNfaWithStates_0(int pos, int kind, int state)
165 {
166 jjmatchedKind = kind;
167 jjmatchedPos = pos;
168 try { curChar = input_stream.readChar(); }
169 catch(java.io.IOException e) { return pos + 1; }
170 return jjMoveNfa_0(state, pos + 1);
171 }
172 static final long[] jjbitVec0 = {
173 0x0L, 0x0L, 0xffffffffffffffffL, 0xffffffffffffffffL
174 };
175 private int jjMoveNfa_0(int startState, int curPos)
176 {
177 int startsAt = 0;
178 jjnewStateCnt = 55;
179 int i = 1;
180 jjstateSet[0] = startState;
181 int kind = 0x7fffffff;
182 for (;;)
183 {
184 if (++jjround == 0x7fffffff)
185 ReInitRounds();
186 if (curChar < 64)
187 {
188 long l = 1L << curChar;
189 do
190 {
191 switch(jjstateSet[--i])
192 {
193 case 0:
194 if ((0x3ff000000000000L & l) != 0L)
195 jjCheckNAddStates(0, 6);
196 else if (curChar == 45)
197 jjAddStates(7, 9);
198 else if (curChar == 34)
199 jjCheckNAddStates(10, 12);
200 else if (curChar == 39)
201 jjAddStates(13, 14);
202 else if (curChar == 46)
203 jjCheckNAdd(6);
204 else if (curChar == 36)
205 {
206 if (kind > 18)
207 kind = 18;
208 jjCheckNAdd(1);
209 }
210 if ((0x3fe000000000000L & l) != 0L)
211 {
212 if (kind > 21)
213 kind = 21;
214 jjCheckNAdd(3);
215 }
216 else if (curChar == 48)
217 {
218 if (kind > 21)
219 kind = 21;
220 }
221 break;
222 case 1:
223 if ((0x3ff201000000000L & l) == 0L)
224 break;
225 if (kind > 18)
226 kind = 18;
227 jjCheckNAdd(1);
228 break;
229 case 2:
230 if ((0x3fe000000000000L & l) == 0L)
231 break;
232 if (kind > 21)
233 kind = 21;
234 jjCheckNAdd(3);
235 break;
236 case 3:
237 if ((0x3ff000000000000L & l) == 0L)
238 break;
239 if (kind > 21)
240 kind = 21;
241 jjCheckNAdd(3);
242 break;
243 case 4:
244 if (curChar == 48 && kind > 21)
245 kind = 21;
246 break;
247 case 5:
248 if (curChar == 46)
249 jjCheckNAdd(6);
250 break;
251 case 6:
252 if ((0x3ff000000000000L & l) == 0L)
253 break;
254 if (kind > 22)
255 kind = 22;
256 jjCheckNAddStates(15, 17);
257 break;
258 case 8:
259 if ((0x280000000000L & l) != 0L)
260 jjCheckNAdd(9);
261 break;
262 case 9:
263 if ((0x3ff000000000000L & l) == 0L)
264 break;
265 if (kind > 22)
266 kind = 22;
267 jjCheckNAddTwoStates(9, 10);
268 break;
269 case 11:
270 if (curChar == 39)
271 jjAddStates(13, 14);
272 break;
273 case 12:
274 if ((0xffffff7fffffdbffL & l) != 0L)
275 jjCheckNAdd(13);
276 break;
277 case 13:
278 if (curChar == 39 && kind > 24)
279 kind = 24;
280 break;
281 case 15:
282 if ((0xff008400000000L & l) != 0L)
283 jjCheckNAdd(13);
284 break;
285 case 16:
286 if ((0xf000000000000L & l) != 0L)
287 jjstateSet[jjnewStateCnt++] = 17;
288 break;
289 case 17:
290 case 19:
291 if ((0xff000000000000L & l) != 0L)
292 jjCheckNAdd(18);
293 break;
294 case 18:
295 if ((0xff000000000000L & l) != 0L)
296 jjCheckNAdd(13);
297 break;
298 case 21:
299 if ((0x3ff000000000000L & l) != 0L)
300 jjstateSet[jjnewStateCnt++] = 22;
301 break;
302 case 22:
303 if ((0x3ff000000000000L & l) != 0L)
304 jjstateSet[jjnewStateCnt++] = 23;
305 break;
306 case 23:
307 if ((0x3ff000000000000L & l) != 0L)
308 jjstateSet[jjnewStateCnt++] = 24;
309 break;
310 case 24:
311 if ((0x3ff000000000000L & l) != 0L)
312 jjCheckNAdd(13);
313 break;
314 case 25:
315 if (curChar == 34)
316 jjCheckNAddStates(10, 12);
317 break;
318 case 26:
319 if ((0xfffffffbffffdbffL & l) != 0L)
320 jjCheckNAddStates(10, 12);
321 break;
322 case 28:
323 if ((0xff008400000000L & l) != 0L)
324 jjCheckNAddStates(10, 12);
325 break;
326 case 29:
327 if (curChar == 34 && kind > 25)
328 kind = 25;
329 break;
330 case 30:
331 if ((0xf000000000000L & l) != 0L)
332 jjstateSet[jjnewStateCnt++] = 31;
333 break;
334 case 31:
335 case 33:
336 if ((0xff000000000000L & l) != 0L)
337 jjCheckNAdd(32);
338 break;
339 case 32:
340 if ((0xff000000000000L & l) != 0L)
341 jjCheckNAddStates(10, 12);
342 break;
343 case 35:
344 if ((0x3ff000000000000L & l) != 0L)
345 jjstateSet[jjnewStateCnt++] = 36;
346 break;
347 case 36:
348 if ((0x3ff000000000000L & l) != 0L)
349 jjstateSet[jjnewStateCnt++] = 37;
350 break;
351 case 37:
352 if ((0x3ff000000000000L & l) != 0L)
353 jjstateSet[jjnewStateCnt++] = 38;
354 break;
355 case 38:
356 if ((0x3ff000000000000L & l) != 0L)
357 jjCheckNAddStates(10, 12);
358 break;
359 case 39:
360 if ((0x3ff000000000000L & l) != 0L)
361 jjCheckNAddStates(0, 6);
362 break;
363 case 40:
364 if ((0x3ff000000000000L & l) != 0L)
365 jjCheckNAddTwoStates(40, 41);
366 break;
367 case 41:
368 if (curChar != 46)
369 break;
370 if (kind > 22)
371 kind = 22;
372 jjCheckNAddStates(18, 20);
373 break;
374 case 42:
375 if ((0x3ff000000000000L & l) == 0L)
376 break;
377 if (kind > 22)
378 kind = 22;
379 jjCheckNAddStates(18, 20);
380 break;
381 case 44:
382 if ((0x280000000000L & l) != 0L)
383 jjCheckNAdd(45);
384 break;
385 case 45:
386 if ((0x3ff000000000000L & l) == 0L)
387 break;
388 if (kind > 22)
389 kind = 22;
390 jjCheckNAddTwoStates(45, 10);
391 break;
392 case 46:
393 if ((0x3ff000000000000L & l) != 0L)
394 jjCheckNAddTwoStates(46, 47);
395 break;
396 case 48:
397 if ((0x280000000000L & l) != 0L)
398 jjCheckNAdd(49);
399 break;
400 case 49:
401 if ((0x3ff000000000000L & l) == 0L)
402 break;
403 if (kind > 22)
404 kind = 22;
405 jjCheckNAddTwoStates(49, 10);
406 break;
407 case 50:
408 if ((0x3ff000000000000L & l) != 0L)
409 jjCheckNAddStates(21, 23);
410 break;
411 case 52:
412 if ((0x280000000000L & l) != 0L)
413 jjCheckNAdd(53);
414 break;
415 case 53:
416 if ((0x3ff000000000000L & l) != 0L)
417 jjCheckNAddTwoStates(53, 10);
418 break;
419 case 54:
420 if (curChar == 45)
421 jjAddStates(7, 9);
422 break;
423 default : break;
424 }
425 } while(i != startsAt);
426 }
427 else if (curChar < 128)
428 {
429 long l = 1L << (curChar & 077);
430 do
431 {
432 switch(jjstateSet[--i])
433 {
434 case 0:
435 case 1:
436 if ((0x7fffffe87fffffeL & l) == 0L)
437 break;
438 if (kind > 18)
439 kind = 18;
440 jjCheckNAdd(1);
441 break;
442 case 7:
443 if ((0x2000000020L & l) != 0L)
444 jjAddStates(24, 25);
445 break;
446 case 10:
447 if ((0x5000000050L & l) != 0L && kind > 22)
448 kind = 22;
449 break;
450 case 12:
451 if ((0xffffffffefffffffL & l) != 0L)
452 jjCheckNAdd(13);
453 break;
454 case 14:
455 if (curChar == 92)
456 jjCheckNAddStates(26, 29);
457 break;
458 case 15:
459 if ((0x14404410000000L & l) != 0L)
460 jjCheckNAdd(13);
461 break;
462 case 20:
463 if (curChar == 117)
464 jjCheckNAddTwoStates(20, 21);
465 break;
466 case 21:
467 if ((0x7e0000007eL & l) != 0L)
468 jjstateSet[jjnewStateCnt++] = 22;
469 break;
470 case 22:
471 if ((0x7e0000007eL & l) != 0L)
472 jjstateSet[jjnewStateCnt++] = 23;
473 break;
474 case 23:
475 if ((0x7e0000007eL & l) != 0L)
476 jjstateSet[jjnewStateCnt++] = 24;
477 break;
478 case 24:
479 if ((0x7e0000007eL & l) != 0L)
480 jjCheckNAdd(13);
481 break;
482 case 26:
483 if ((0xffffffffefffffffL & l) != 0L)
484 jjCheckNAddStates(10, 12);
485 break;
486 case 27:
487 if (curChar == 92)
488 jjCheckNAddStates(30, 33);
489 break;
490 case 28:
491 if ((0x14404410000000L & l) != 0L)
492 jjCheckNAddStates(10, 12);
493 break;
494 case 34:
495 if (curChar == 117)
496 jjCheckNAddTwoStates(34, 35);
497 break;
498 case 35:
499 if ((0x7e0000007eL & l) != 0L)
500 jjstateSet[jjnewStateCnt++] = 36;
501 break;
502 case 36:
503 if ((0x7e0000007eL & l) != 0L)
504 jjstateSet[jjnewStateCnt++] = 37;
505 break;
506 case 37:
507 if ((0x7e0000007eL & l) != 0L)
508 jjstateSet[jjnewStateCnt++] = 38;
509 break;
510 case 38:
511 if ((0x7e0000007eL & l) != 0L)
512 jjCheckNAddStates(10, 12);
513 break;
514 case 43:
515 if ((0x2000000020L & l) != 0L)
516 jjAddStates(34, 35);
517 break;
518 case 47:
519 if ((0x2000000020L & l) != 0L)
520 jjAddStates(36, 37);
521 break;
522 case 51:
523 if ((0x2000000020L & l) != 0L)
524 jjAddStates(38, 39);
525 break;
526 default : break;
527 }
528 } while(i != startsAt);
529 }
530 else
531 {
532 int i2 = (curChar & 0xff) >> 6;
533 long l2 = 1L << (curChar & 077);
534 do
535 {
536 switch(jjstateSet[--i])
537 {
538 case 12:
539 if ((jjbitVec0[i2] & l2) != 0L)
540 jjstateSet[jjnewStateCnt++] = 13;
541 break;
542 case 26:
543 if ((jjbitVec0[i2] & l2) != 0L)
544 jjAddStates(10, 12);
545 break;
546 default : break;
547 }
548 } while(i != startsAt);
549 }
550 if (kind != 0x7fffffff)
551 {
552 jjmatchedKind = kind;
553 jjmatchedPos = curPos;
554 kind = 0x7fffffff;
555 }
556 ++curPos;
557 if ((i = jjnewStateCnt) == (startsAt = 55 - (jjnewStateCnt = startsAt)))
558 return curPos;
559 try { curChar = input_stream.readChar(); }
560 catch(java.io.IOException e) { return curPos; }
561 }
562 }
563 static final int[] jjnextStates = {
564 40, 41, 46, 47, 50, 51, 10, 2, 5, 39, 26, 27, 29, 12, 14, 6,
565 7, 10, 42, 43, 10, 50, 51, 10, 8, 9, 15, 16, 19, 20, 28, 30,
566 33, 34, 44, 45, 48, 49, 52, 53,
567 };
568
569
570 public static final String[] jjstrLiteralImages = {
571 "", null, null, null, null, null, "\156\157\144\145", "\50", "\51",
572 "\141\156\144", "\156\157\164", "\157\162", "\76", "\76\75", "\75", "\41\75", "\74\75", "\74",
573 null, null, null, null, null, null, null, null, "\56", };
574
575
576 public static final String[] lexStateNames = {
577 "DEFAULT",
578 };
579 static final long[] jjtoToken = {
580 0x767ffc1L,
581 };
582 static final long[] jjtoSkip = {
583 0x3eL,
584 };
585 protected SimpleCharStream input_stream;
586 private final int[] jjrounds = new int[55];
587 private final int[] jjstateSet = new int[110];
588 protected char curChar;
589
590 public ShadyParserTokenManager(SimpleCharStream stream){
591 if (SimpleCharStream.staticFlag)
592 throw new Error("ERROR: Cannot use a static CharStream class with a non-static lexical analyzer.");
593 input_stream = stream;
594 }
595
596
597 public ShadyParserTokenManager(SimpleCharStream stream, int lexState){
598 this(stream);
599 SwitchTo(lexState);
600 }
601
602
603 public void ReInit(SimpleCharStream stream)
604 {
605 jjmatchedPos = jjnewStateCnt = 0;
606 curLexState = defaultLexState;
607 input_stream = stream;
608 ReInitRounds();
609 }
610 private void ReInitRounds()
611 {
612 int i;
613 jjround = 0x80000001;
614 for (i = 55; i-- > 0;)
615 jjrounds[i] = 0x80000000;
616 }
617
618
619 public void ReInit(SimpleCharStream stream, int lexState)
620 {
621 ReInit(stream);
622 SwitchTo(lexState);
623 }
624
625
626 public void SwitchTo(int lexState)
627 {
628 if (lexState >= 1 || lexState < 0)
629 throw new TokenMgrError("Error: Ignoring invalid lexical state : " + lexState + ". State unchanged.", TokenMgrError.INVALID_LEXICAL_STATE);
630 else
631 curLexState = lexState;
632 }
633
634 protected Token jjFillToken()
635 {
636 final Token t;
637 final String curTokenImage;
638 final int beginLine;
639 final int endLine;
640 final int beginColumn;
641 final int endColumn;
642 String im = jjstrLiteralImages[jjmatchedKind];
643 curTokenImage = (im == null) ? input_stream.GetImage() : im;
644 beginLine = input_stream.getBeginLine();
645 beginColumn = input_stream.getBeginColumn();
646 endLine = input_stream.getEndLine();
647 endColumn = input_stream.getEndColumn();
648 t = Token.newToken(jjmatchedKind, curTokenImage);
649
650 t.beginLine = beginLine;
651 t.endLine = endLine;
652 t.beginColumn = beginColumn;
653 t.endColumn = endColumn;
654
655 return t;
656 }
657
658 int curLexState = 0;
659 int defaultLexState = 0;
660 int jjnewStateCnt;
661 int jjround;
662 int jjmatchedPos;
663 int jjmatchedKind;
664
665
666 public Token getNextToken()
667 {
668 Token matchedToken;
669 int curPos = 0;
670
671 EOFLoop :
672 for (;;)
673 {
674 try
675 {
676 curChar = input_stream.BeginToken();
677 }
678 catch(java.io.IOException e)
679 {
680 jjmatchedKind = 0;
681 matchedToken = jjFillToken();
682 return matchedToken;
683 }
684
685 try { input_stream.backup(0);
686 while (curChar <= 32 && (0x100003600L & (1L << curChar)) != 0L)
687 curChar = input_stream.BeginToken();
688 }
689 catch (java.io.IOException e1) { continue EOFLoop; }
690 jjmatchedKind = 0x7fffffff;
691 jjmatchedPos = 0;
692 curPos = jjMoveStringLiteralDfa0_0();
693 if (jjmatchedKind != 0x7fffffff)
694 {
695 if (jjmatchedPos + 1 < curPos)
696 input_stream.backup(curPos - jjmatchedPos - 1);
697 if ((jjtoToken[jjmatchedKind >> 6] & (1L << (jjmatchedKind & 077))) != 0L)
698 {
699 matchedToken = jjFillToken();
700 return matchedToken;
701 }
702 else
703 {
704 continue EOFLoop;
705 }
706 }
707 int error_line = input_stream.getEndLine();
708 int error_column = input_stream.getEndColumn();
709 String error_after = null;
710 boolean EOFSeen = false;
711 try { input_stream.readChar(); input_stream.backup(1); }
712 catch (java.io.IOException e1) {
713 EOFSeen = true;
714 error_after = curPos <= 1 ? "" : input_stream.GetImage();
715 if (curChar == '\n' || curChar == '\r') {
716 error_line++;
717 error_column = 0;
718 }
719 else
720 error_column++;
721 }
722 if (!EOFSeen) {
723 input_stream.backup(1);
724 error_after = curPos <= 1 ? "" : input_stream.GetImage();
725 }
726 throw new TokenMgrError(EOFSeen, curLexState, error_line, error_column, error_after, curChar, TokenMgrError.LEXICAL_ERROR);
727 }
728 }
729
730 private void jjCheckNAdd(int state)
731 {
732 if (jjrounds[state] != jjround)
733 {
734 jjstateSet[jjnewStateCnt++] = state;
735 jjrounds[state] = jjround;
736 }
737 }
738 private void jjAddStates(int start, int end)
739 {
740 do {
741 jjstateSet[jjnewStateCnt++] = jjnextStates[start];
742 } while (start++ != end);
743 }
744 private void jjCheckNAddTwoStates(int state1, int state2)
745 {
746 jjCheckNAdd(state1);
747 jjCheckNAdd(state2);
748 }
749
750 private void jjCheckNAddStates(int start, int end)
751 {
752 do {
753 jjCheckNAdd(jjnextStates[start]);
754 } while (start++ != end);
755 }
756
757 }