001/**
002 * Copyright (C) 2007 - 2016, Jens Lehmann
003 *
004 * This file is part of DL-Learner.
005 *
006 * DL-Learner is free software; you can redistribute it and/or modify
007 * it under the terms of the GNU General Public License as published by
008 * the Free Software Foundation; either version 3 of the License, or
009 * (at your option) any later version.
010 *
011 * DL-Learner is distributed in the hope that it will be useful,
012 * but WITHOUT ANY WARRANTY; without even the implied warranty of
013 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
014 * GNU General Public License for more details.
015 *
016 * You should have received a copy of the GNU General Public License
017 * along with this program.  If not, see <http://www.gnu.org/licenses/>.
018 */
019/* Generated By:JavaCC: Do not edit this line. PrologParserTokenManager.java */
020package org.dllearner.parser;
021
022/** Token Manager. */
023@SuppressWarnings("all")
024public class PrologParserTokenManager implements PrologParserConstants
025{
026
027  /** Debug output. */
028  public  java.io.PrintStream debugStream = System.out;
029  /** Set debug output. */
030  public  void setDebugStream(java.io.PrintStream ds) { debugStream = ds; }
031private final int jjStopStringLiteralDfa_0(int pos, long active0)
032{
033   switch (pos)
034   {
035      case 0:
036         if ((active0 & 0x80L) != 0L)
037         {
038            jjmatchedKind = 13;
039            return 28;
040         }
041         return -1;
042      case 1:
043         if ((active0 & 0x80L) != 0L)
044         {
045            jjmatchedKind = 13;
046            jjmatchedPos = 1;
047            return 28;
048         }
049         return -1;
050      default :
051         return -1;
052   }
053}
054private final int jjStartNfa_0(int pos, long active0)
055{
056   return jjMoveNfa_0(jjStopStringLiteralDfa_0(pos, active0), pos + 1);
057}
058private int jjStopAtPos(int pos, int kind)
059{
060   jjmatchedKind = kind;
061   jjmatchedPos = pos;
062   return pos + 1;
063}
064private int jjMoveStringLiteralDfa0_0()
065{
066   switch(curChar)
067   {
068      case 40:
069         return jjStopAtPos(0, 22);
070      case 41:
071         return jjStopAtPos(0, 23);
072      case 44:
073         return jjStopAtPos(0, 21);
074      case 46:
075         return jjStopAtPos(0, 20);
076      case 58:
077         return jjMoveStringLiteralDfa1_0(0x80000L);
078      case 91:
079         jjmatchedKind = 25;
080         return jjMoveStringLiteralDfa1_0(0x1000000L);
081      case 93:
082         return jjStopAtPos(0, 26);
083      case 110:
084         return jjMoveStringLiteralDfa1_0(0x80L);
085      case 124:
086         return jjStopAtPos(0, 27);
087      default :
088         return jjMoveNfa_0(0, 0);
089   }
090}
091private int jjMoveStringLiteralDfa1_0(long active0)
092{
093   try { curChar = input_stream.readChar(); }
094   catch(java.io.IOException e) {
095      jjStopStringLiteralDfa_0(0, active0);
096      return 1;
097   }
098   switch(curChar)
099   {
100      case 45:
101         if ((active0 & 0x80000L) != 0L)
102            return jjStopAtPos(1, 19);
103         break;
104      case 93:
105         if ((active0 & 0x1000000L) != 0L)
106            return jjStopAtPos(1, 24);
107         break;
108      case 111:
109         return jjMoveStringLiteralDfa2_0(active0, 0x80L);
110      default :
111         break;
112   }
113   return jjStartNfa_0(0, active0);
114}
115private int jjMoveStringLiteralDfa2_0(long old0, long active0)
116{
117   if (((active0 &= old0)) == 0L)
118      return jjStartNfa_0(0, old0);
119   try { curChar = input_stream.readChar(); }
120   catch(java.io.IOException e) {
121      jjStopStringLiteralDfa_0(1, active0);
122      return 2;
123   }
124   switch(curChar)
125   {
126      case 116:
127         if ((active0 & 0x80L) != 0L)
128            return jjStartNfaWithStates_0(2, 7, 28);
129         break;
130      default :
131         break;
132   }
133   return jjStartNfa_0(1, active0);
134}
135private int jjStartNfaWithStates_0(int pos, int kind, int state)
136{
137   jjmatchedKind = kind;
138   jjmatchedPos = pos;
139   try { curChar = input_stream.readChar(); }
140   catch(java.io.IOException e) { return pos + 1; }
141   return jjMoveNfa_0(state, pos + 1);
142}
143static final long[] jjbitVec0 = {
144   0x0L, 0x0L, 0xffffffffffffffffL, 0xffffffffffffffffL
145};
146private int jjMoveNfa_0(int startState, int curPos)
147{
148   int startsAt = 0;
149   jjnewStateCnt = 28;
150   int i = 1;
151   jjstateSet[0] = startState;
152   int kind = 0x7fffffff;
153   for (;;)
154   {
155      if (++jjround == 0x7fffffff)
156         ReInitRounds();
157      if (curChar < 64)
158      {
159         long l = 1L << curChar;
160         do
161         {
162            switch(jjstateSet[--i])
163            {
164               case 28:
165                  if ((0x53ff2c0000000000L & l) != 0L)
166                  {
167                     if (kind > 14)
168                        kind = 14;
169                     jjCheckNAdd(16);
170                  }
171                  if ((0x3ff000000000000L & l) != 0L)
172                  {
173                     if (kind > 13)
174                        kind = 13;
175                     jjCheckNAdd(14);
176                  }
177                  break;
178               case 0:
179                  if ((0x3ff000000000000L & l) != 0L)
180                  {
181                     if (kind > 8)
182                        kind = 8;
183                     jjCheckNAddStates(0, 3);
184                  }
185                  else if ((0x50002c0000000000L & l) != 0L)
186                  {
187                     if (kind > 14)
188                        kind = 14;
189                     jjCheckNAdd(16);
190                  }
191                  else if (curChar == 34)
192                     jjCheckNAddTwoStates(9, 10);
193                  else if (curChar == 39)
194                     jjCheckNAddTwoStates(6, 7);
195                  else if (curChar == 37)
196                     jjCheckNAddStates(4, 6);
197                  if (curChar == 45)
198                     jjCheckNAddTwoStates(18, 21);
199                  break;
200               case 1:
201                  if ((0xffffffffffffdbffL & l) != 0L)
202                     jjCheckNAddStates(4, 6);
203                  break;
204               case 2:
205                  if ((0x2400L & l) != 0L && kind > 6)
206                     kind = 6;
207                  break;
208               case 3:
209                  if (curChar == 10 && kind > 6)
210                     kind = 6;
211                  break;
212               case 4:
213                  if (curChar == 13)
214                     jjstateSet[jjnewStateCnt++] = 3;
215                  break;
216               case 5:
217                  if (curChar == 39)
218                     jjCheckNAddTwoStates(6, 7);
219                  break;
220               case 6:
221                  if ((0xffffff7fffffdbffL & l) != 0L)
222                     jjCheckNAddTwoStates(6, 7);
223                  break;
224               case 7:
225                  if (curChar == 39 && kind > 11)
226                     kind = 11;
227                  break;
228               case 8:
229                  if (curChar == 34)
230                     jjCheckNAddTwoStates(9, 10);
231                  break;
232               case 9:
233                  if ((0xffffff7fffffdbffL & l) != 0L)
234                     jjCheckNAddTwoStates(9, 10);
235                  break;
236               case 10:
237                  if (curChar == 34 && kind > 11)
238                     kind = 11;
239                  break;
240               case 12:
241                  if ((0x3ff000000000000L & l) == 0L)
242                     break;
243                  if (kind > 12)
244                     kind = 12;
245                  jjstateSet[jjnewStateCnt++] = 12;
246                  break;
247               case 14:
248                  if ((0x3ff000000000000L & l) == 0L)
249                     break;
250                  if (kind > 13)
251                     kind = 13;
252                  jjCheckNAdd(14);
253                  break;
254               case 15:
255                  if ((0x50002c0000000000L & l) == 0L)
256                     break;
257                  if (kind > 14)
258                     kind = 14;
259                  jjCheckNAdd(16);
260                  break;
261               case 16:
262                  if ((0x53ff2c0000000000L & l) == 0L)
263                     break;
264                  if (kind > 14)
265                     kind = 14;
266                  jjCheckNAdd(16);
267                  break;
268               case 17:
269                  if (curChar == 45)
270                     jjCheckNAddTwoStates(18, 21);
271                  break;
272               case 18:
273                  if ((0x3ff000000000000L & l) != 0L)
274                     jjCheckNAddTwoStates(18, 19);
275                  break;
276               case 19:
277                  if (curChar != 46)
278                     break;
279                  if (kind > 8)
280                     kind = 8;
281                  jjCheckNAdd(20);
282                  break;
283               case 20:
284                  if ((0x3ff000000000000L & l) == 0L)
285                     break;
286                  if (kind > 8)
287                     kind = 8;
288                  jjCheckNAdd(20);
289                  break;
290               case 21:
291                  if ((0x3ff000000000000L & l) == 0L)
292                     break;
293                  if (kind > 8)
294                     kind = 8;
295                  jjCheckNAdd(21);
296                  break;
297               case 22:
298                  if ((0x3ff000000000000L & l) == 0L)
299                     break;
300                  if (kind > 8)
301                     kind = 8;
302                  jjCheckNAddStates(0, 3);
303                  break;
304               case 23:
305                  if ((0x3ff000000000000L & l) != 0L)
306                     jjCheckNAddTwoStates(23, 24);
307                  break;
308               case 24:
309                  if (curChar != 46)
310                     break;
311                  if (kind > 8)
312                     kind = 8;
313                  jjCheckNAdd(25);
314                  break;
315               case 25:
316                  if ((0x3ff000000000000L & l) == 0L)
317                     break;
318                  if (kind > 8)
319                     kind = 8;
320                  jjCheckNAdd(25);
321                  break;
322               case 26:
323                  if ((0x3ff000000000000L & l) == 0L)
324                     break;
325                  if (kind > 8)
326                     kind = 8;
327                  jjCheckNAdd(26);
328                  break;
329               case 27:
330                  if ((0x3ff000000000000L & l) == 0L)
331                     break;
332                  if (kind > 9)
333                     kind = 9;
334                  jjCheckNAdd(27);
335                  break;
336               default : break;
337            }
338         } while(i != startsAt);
339      }
340      else if (curChar < 128)
341      {
342         long l = 1L << (curChar & 077);
343         do
344         {
345            switch(jjstateSet[--i])
346            {
347               case 28:
348                  if ((0x7fffffec7fffffeL & l) != 0L)
349                  {
350                     if (kind > 14)
351                        kind = 14;
352                     jjCheckNAdd(16);
353                  }
354                  if ((0x7fffffe87fffffeL & l) != 0L)
355                  {
356                     if (kind > 13)
357                        kind = 13;
358                     jjCheckNAdd(14);
359                  }
360                  break;
361               case 0:
362                  if ((0x7fffffe40000000L & l) != 0L)
363                  {
364                     if (kind > 14)
365                        kind = 14;
366                     jjCheckNAdd(16);
367                  }
368                  else if ((0x87fffffeL & l) != 0L)
369                  {
370                     if (kind > 12)
371                        kind = 12;
372                     jjCheckNAdd(12);
373                  }
374                  if ((0x7fffffe00000000L & l) != 0L)
375                  {
376                     if (kind > 13)
377                        kind = 13;
378                     jjCheckNAdd(14);
379                  }
380                  break;
381               case 1:
382                  jjAddStates(4, 6);
383                  break;
384               case 6:
385                  if ((0xffffffffefffffffL & l) != 0L)
386                     jjAddStates(7, 8);
387                  break;
388               case 9:
389                  if ((0xffffffffefffffffL & l) != 0L)
390                     jjAddStates(9, 10);
391                  break;
392               case 11:
393                  if ((0x87fffffeL & l) == 0L)
394                     break;
395                  if (kind > 12)
396                     kind = 12;
397                  jjCheckNAdd(12);
398                  break;
399               case 12:
400                  if ((0x7fffffe87fffffeL & l) == 0L)
401                     break;
402                  if (kind > 12)
403                     kind = 12;
404                  jjCheckNAdd(12);
405                  break;
406               case 13:
407                  if ((0x7fffffe00000000L & l) == 0L)
408                     break;
409                  if (kind > 13)
410                     kind = 13;
411                  jjCheckNAdd(14);
412                  break;
413               case 14:
414                  if ((0x7fffffe87fffffeL & l) == 0L)
415                     break;
416                  if (kind > 13)
417                     kind = 13;
418                  jjCheckNAdd(14);
419                  break;
420               case 15:
421                  if ((0x7fffffe40000000L & l) == 0L)
422                     break;
423                  if (kind > 14)
424                     kind = 14;
425                  jjCheckNAdd(16);
426                  break;
427               case 16:
428                  if ((0x7fffffec7fffffeL & l) == 0L)
429                     break;
430                  if (kind > 14)
431                     kind = 14;
432                  jjCheckNAdd(16);
433                  break;
434               default : break;
435            }
436         } while(i != startsAt);
437      }
438      else
439      {
440         int i2 = (curChar & 0xff) >> 6;
441         long l2 = 1L << (curChar & 077);
442         do
443         {
444            switch(jjstateSet[--i])
445            {
446               case 1:
447                  if ((jjbitVec0[i2] & l2) != 0L)
448                     jjAddStates(4, 6);
449                  break;
450               case 6:
451                  if ((jjbitVec0[i2] & l2) != 0L)
452                     jjAddStates(7, 8);
453                  break;
454               case 9:
455                  if ((jjbitVec0[i2] & l2) != 0L)
456                     jjAddStates(9, 10);
457                  break;
458               default : break;
459            }
460         } while(i != startsAt);
461      }
462      if (kind != 0x7fffffff)
463      {
464         jjmatchedKind = kind;
465         jjmatchedPos = curPos;
466         kind = 0x7fffffff;
467      }
468      ++curPos;
469      if ((i = jjnewStateCnt) == (startsAt = 28 - (jjnewStateCnt = startsAt)))
470         return curPos;
471      try { curChar = input_stream.readChar(); }
472      catch(java.io.IOException e) { return curPos; }
473   }
474}
475static final int[] jjnextStates = {
476   23, 24, 26, 27, 1, 2, 4, 6, 7, 9, 10, 
477};
478
479/** Token literal values. */
480public static final String[] jjstrLiteralImages = {
481"", null, null, null, null, null, null, "\156\157\164", null, null, null, null, 
482null, null, null, null, null, null, null, "\72\55", "\56", "\54", "\50", "\51", 
483"\133\135", "\133", "\135", "\174", };
484
485/** Lexer state names. */
486public static final String[] lexStateNames = {
487   "DEFAULT",
488};
489static final long[] jjtoToken = {
490   0xff87b81L, 
491};
492static final long[] jjtoSkip = {
493   0x7eL, 
494};
495static final long[] jjtoSpecial = {
496   0x40L, 
497};
498protected SimpleCharStream input_stream;
499private final int[] jjrounds = new int[28];
500private final int[] jjstateSet = new int[56];
501protected char curChar;
502/** Constructor. */
503public PrologParserTokenManager(SimpleCharStream stream){
504   if (SimpleCharStream.staticFlag)
505      throw new Error("ERROR: Cannot use a static CharStream class with a non-static lexical analyzer.");
506   input_stream = stream;
507}
508
509/** Constructor. */
510public PrologParserTokenManager(SimpleCharStream stream, int lexState){
511   this(stream);
512   SwitchTo(lexState);
513}
514
515/** Reinitialise parser. */
516public void ReInit(SimpleCharStream stream)
517{
518   jjmatchedPos = jjnewStateCnt = 0;
519   curLexState = defaultLexState;
520   input_stream = stream;
521   ReInitRounds();
522}
523private void ReInitRounds()
524{
525   int i;
526   jjround = 0x80000001;
527   for (i = 28; i-- > 0;)
528      jjrounds[i] = 0x80000000;
529}
530
531/** Reinitialise parser. */
532public void ReInit(SimpleCharStream stream, int lexState)
533{
534   ReInit(stream);
535   SwitchTo(lexState);
536}
537
538/** Switch to specified lex state. */
539public void SwitchTo(int lexState)
540{
541   if (lexState >= 1 || lexState < 0)
542      throw new TokenMgrError("Error: Ignoring invalid lexical state : " + lexState + ". State unchanged.", TokenMgrError.INVALID_LEXICAL_STATE);
543   else
544      curLexState = lexState;
545}
546
547protected Token jjFillToken()
548{
549   final Token t;
550   final String curTokenImage;
551   final int beginLine;
552   final int endLine;
553   final int beginColumn;
554   final int endColumn;
555   String im = jjstrLiteralImages[jjmatchedKind];
556   curTokenImage = (im == null) ? input_stream.GetImage() : im;
557   beginLine = input_stream.getBeginLine();
558   beginColumn = input_stream.getBeginColumn();
559   endLine = input_stream.getEndLine();
560   endColumn = input_stream.getEndColumn();
561   t = Token.newToken(jjmatchedKind, curTokenImage);
562
563   t.beginLine = beginLine;
564   t.endLine = endLine;
565   t.beginColumn = beginColumn;
566   t.endColumn = endColumn;
567
568   return t;
569}
570
571int curLexState = 0;
572int defaultLexState = 0;
573int jjnewStateCnt;
574int jjround;
575int jjmatchedPos;
576int jjmatchedKind;
577
578/** Get the next Token. */
579public Token getNextToken() 
580{
581  Token specialToken = null;
582  Token matchedToken;
583  int curPos = 0;
584
585  EOFLoop :
586  for (;;)
587  {
588   try
589   {
590      curChar = input_stream.BeginToken();
591   }
592   catch(java.io.IOException e)
593   {
594      jjmatchedKind = 0;
595      matchedToken = jjFillToken();
596      matchedToken.specialToken = specialToken;
597      return matchedToken;
598   }
599
600   try { input_stream.backup(0);
601      while (curChar <= 32 && (0x100003600L & (1L << curChar)) != 0L)
602         curChar = input_stream.BeginToken();
603   }
604   catch (java.io.IOException e1) { continue EOFLoop; }
605   jjmatchedKind = 0x7fffffff;
606   jjmatchedPos = 0;
607   curPos = jjMoveStringLiteralDfa0_0();
608   if (jjmatchedKind != 0x7fffffff)
609   {
610      if (jjmatchedPos + 1 < curPos)
611         input_stream.backup(curPos - jjmatchedPos - 1);
612      if ((jjtoToken[jjmatchedKind >> 6] & (1L << (jjmatchedKind & 077))) != 0L)
613      {
614         matchedToken = jjFillToken();
615         matchedToken.specialToken = specialToken;
616         return matchedToken;
617      }
618      else
619      {
620         if ((jjtoSpecial[jjmatchedKind >> 6] & (1L << (jjmatchedKind & 077))) != 0L)
621         {
622            matchedToken = jjFillToken();
623            if (specialToken == null)
624               specialToken = matchedToken;
625            else
626            {
627               matchedToken.specialToken = specialToken;
628               specialToken = (specialToken.next = matchedToken);
629            }
630         }
631         continue EOFLoop;
632      }
633   }
634   int error_line = input_stream.getEndLine();
635   int error_column = input_stream.getEndColumn();
636   String error_after = null;
637   boolean EOFSeen = false;
638   try { input_stream.readChar(); input_stream.backup(1); }
639   catch (java.io.IOException e1) {
640      EOFSeen = true;
641      error_after = curPos <= 1 ? "" : input_stream.GetImage();
642      if (curChar == '\n' || curChar == '\r') {
643         error_line++;
644         error_column = 0;
645      }
646      else
647         error_column++;
648   }
649   if (!EOFSeen) {
650      input_stream.backup(1);
651      error_after = curPos <= 1 ? "" : input_stream.GetImage();
652   }
653   throw new TokenMgrError(EOFSeen, curLexState, error_line, error_column, error_after, curChar, TokenMgrError.LEXICAL_ERROR);
654  }
655}
656
657private void jjCheckNAdd(int state)
658{
659   if (jjrounds[state] != jjround)
660   {
661      jjstateSet[jjnewStateCnt++] = state;
662      jjrounds[state] = jjround;
663   }
664}
665private void jjAddStates(int start, int end)
666{
667   do {
668      jjstateSet[jjnewStateCnt++] = jjnextStates[start];
669   } while (start++ != end);
670}
671private void jjCheckNAddTwoStates(int state1, int state2)
672{
673   jjCheckNAdd(state1);
674   jjCheckNAdd(state2);
675}
676
677private void jjCheckNAddStates(int start, int end)
678{
679   do {
680      jjCheckNAdd(jjnextStates[start]);
681   } while (start++ != end);
682}
683
684}