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