src/main/java/org/lwes/db/ESFParserTokenManager.java

   1 /* Generated By:JavaCC: Do not edit this line. ESFParserTokenManager.java */
   2 package org.lwes.db;
   3
   4 public class ESFParserTokenManager implements ESFParserConstants {
   5     public java.io.PrintStream debugStream = System.out;
   6
   7     public void setDebugStream(java.io.PrintStream ds) {
   8         debugStream = ds;
   9     }
  10
  11     private final int jjStopStringLiteralDfa_0(int pos, long active0) {
  12         switch (pos) {
  13             default:
  14                 return -1;
  15         }
  16     }
  17
  18     private final int jjStartNfa_0(int pos, long active0) {
  19         return jjMoveNfa_0(jjStopStringLiteralDfa_0(pos, active0), pos + 1);
  20     }
  21
  22     private final int jjStopAtPos(int pos, int kind) {
  23         jjmatchedKind = kind;
  24         jjmatchedPos = pos;
  25         return pos + 1;
  26     }
  27
  28     private final int jjStartNfaWithStates_0(int pos, int kind, int state) {
  29         jjmatchedKind = kind;
  30         jjmatchedPos = pos;
  31         try {
  32             curChar = input_stream.readChar();
  33         }
  34         catch (java.io.IOException e) {
  35             return pos + 1;
  36         }
  37         return jjMoveNfa_0(state, pos + 1);
  38     }
  39
  40     private final int jjMoveStringLiteralDfa0_0() {
  41         switch (curChar) {
  42             case 35:
  43                 return jjStopAtPos(0, 5);
  44             case 59:
  45                 return jjStopAtPos(0, 13);
  46             case 123:
  47                 return jjStopAtPos(0, 11);
  48             case 125:
  49                 return jjStopAtPos(0, 12);
  50             default:
  51                 return jjMoveNfa_0(0, 0);
  52         }
  53     }
  54
  55     private final void jjCheckNAdd(int state) {
  56         if (jjrounds[state] != jjround) {
  57             jjstateSet[jjnewStateCnt++] = state;
  58             jjrounds[state] = jjround;
  59         }
  60     }
  61
  62     private final void jjAddStates(int start, int end) {
  63         do {
  64             jjstateSet[jjnewStateCnt++] = jjnextStates[start];
  65         } while (start++ != end);
  66     }
  67
  68     private final void jjCheckNAddTwoStates(int state1, int state2) {
  69         jjCheckNAdd(state1);
  70         jjCheckNAdd(state2);
  71     }
  72
  73     private final void jjCheckNAddStates(int start, int end) {
  74         do {
  75             jjCheckNAdd(jjnextStates[start]);
  76         } while (start++ != end);
  77     }
  78
  79     private final void jjCheckNAddStates(int start) {
  80         jjCheckNAdd(jjnextStates[start]);
  81         jjCheckNAdd(jjnextStates[start + 1]);
  82     }
  83
  84     private final int jjMoveNfa_0(int startState, int curPos) {
  85         int[] nextStates;
  86         int startsAt = 0;
  87         jjnewStateCnt = 1;
  88         int i = 1;
  89         jjstateSet[0] = startState;
  90         int j, kind = 0x7fffffff;
  91         for (; ;) {
  92             if (++jjround == 0x7fffffff) {
  93                 reInitRounds();
  94             }
  95             if (curChar < 64) {
  96                 long l = 1L << curChar;
  97                 MatchLoop:
  98                 do {
  99                     switch (jjstateSet[--i]) {
 100                         case 0:
 101                             if ((0x7ff000000000000L & l) == 0L) {
 102                                 break;
 103                             }
 104                             kind = 10;
 105                             jjstateSet[jjnewStateCnt++] = 0;
 106                             break;
 107                         default:
 108                             break;
 109                     }
 110                 } while (i != startsAt);
 111             }
 112             else if (curChar < 128) {
 113                 long l = 1L << (curChar & 077);
 114                 MatchLoop:
 115                 do {
 116                     switch (jjstateSet[--i]) {
 117                         case 0:
 118                             if ((0x7fffffe87fffffeL & l) == 0L) {
 119                                 break;
 120                             }
 121                             kind = 10;
 122                             jjstateSet[jjnewStateCnt++] = 0;
 123                             break;
 124                         default:
 125                             break;
 126                     }
 127                 } while (i != startsAt);
 128             }
 129             else {
 130                 int i2 = (curChar & 0xff) >> 6;
 131                 long l2 = 1L << (curChar & 077);
 132                 MatchLoop:
 133                 do {
 134                     switch (jjstateSet[--i]) {
 135                         default:
 136                             break;
 137                     }
 138                 } while (i != startsAt);
 139             }
 140             if (kind != 0x7fffffff) {
 141                 jjmatchedKind = kind;
 142                 jjmatchedPos = curPos;
 143                 kind = 0x7fffffff;
 144             }
 145             ++curPos;
 146             if ((i = jjnewStateCnt) == (startsAt = 1 - (jjnewStateCnt = startsAt))) {
 147                 return curPos;
 148             }
 149             try {
 150                 curChar = input_stream.readChar();
 151             }
 152             catch (java.io.IOException e) {
 153                 return curPos;
 154             }
 155         }
 156     }
 157
 158     private final int jjMoveStringLiteralDfa0_1() {
 159         switch (curChar) {
 160             case 10:
 161                 return jjStopAtPos(0, 6);
 162             case 13:
 163                 jjmatchedKind = 7;
 164                 return jjMoveStringLiteralDfa1_1(0x100L);
 165             default:
 166                 return 1;
 167         }
 168     }
 169
 170     private final int jjMoveStringLiteralDfa1_1(long active0) {
 171         try {
 172             curChar = input_stream.readChar();
 173         }
 174         catch (java.io.IOException e) {
 175             return 1;
 176         }
 177         switch (curChar) {
 178             case 10:
 179                 if ((active0 & 0x100L) != 0L) {
 180                     return jjStopAtPos(1, 8);
 181                 }
 182                 break;
 183             default:
 184                 return 2;
 185         }
 186         return 2;
 187     }
 188
 189     static final int[] jjnextStates = {
 190     };
 191     public static final String[] jjstrLiteralImages = {
 192             "", null, null, null, null, null, null, null, null, null, null, "\173",
 193             "\175", "\73",};
 194     public static final String[] lexStateNames = {
 195             "DEFAULT",
 196             "IN_LINE_COMMENT",
 197     };
 198     public static final int[] jjnewLexState = {
 199             -1, -1, -1, -1, -1, 1, 0, 0, 0, -1, -1, -1, -1, -1,
 200     };
 201     static final long[] jjtoToken = {
 202             0x3c01L,
 203     };
 204     static final long[] jjtoSkip = {
 205             0x1feL,
 206     };
 207     static final long[] jjtoMore = {
 208             0x200L,
 209     };
 210     protected SimpleCharStream input_stream;
 211     private final int[] jjrounds = new int[1];
 212     private final int[] jjstateSet = new int[2];
 213     protected char curChar;
 214
 215     public ESFParserTokenManager(SimpleCharStream stream) {
 216         if (SimpleCharStream.staticFlag) {
 217             throw new Error("ERROR: Cannot use a static CharStream class with a non-static lexical analyzer.");
 218         }
 219         input_stream = stream;
 220     }
 221
 222     public ESFParserTokenManager(SimpleCharStream stream, int lexState) {
 223         this(stream);
 224         switchTo(lexState);
 225     }
 226
 227     public void reInit(SimpleCharStream stream) {
 228         jjmatchedPos = jjnewStateCnt = 0;
 229         curLexState = defaultLexState;
 230         input_stream = stream;
 231         reInitRounds();
 232     }
 233
 234     private void reInitRounds() {
 235         int i;
 236         jjround = 0x80000001;
 237         for (i = 1; i-- > 0;) {
 238             jjrounds[i] = 0x80000000;
 239         }
 240     }
 241
 242     public void reInit(SimpleCharStream stream, int lexState) {
 243         reInit(stream);
 244         switchTo(lexState);
 245     }
 246
 247     public void switchTo(int lexState) {
 248         if (lexState >= 2 || lexState < 0) {
 249             throw new TokenMgrError("Error: Ignoring invalid lexical state : " + lexState + ". State unchanged.",
 250                                     TokenMgrError.INVALID_LEXICAL_STATE);
 251         }
 252         else {
 253             curLexState = lexState;
 254         }
 255     }
 256
 257     protected Token jjFillToken() {
 258         Token t = Token.newToken(jjmatchedKind);
 259         t.kind = jjmatchedKind;
 260         String im = jjstrLiteralImages[jjmatchedKind];
 261         t.image = (im == null) ? input_stream.getImage() : im;
 262         t.beginLine = input_stream.getBeginLine();
 263         t.beginColumn = input_stream.getBeginColumn();
 264         t.endLine = input_stream.getEndLine();
 265         t.endColumn = input_stream.getEndColumn();
 266         return t;
 267     }
 268
 269     int curLexState = 0;
 270     int defaultLexState = 0;
 271     int jjnewStateCnt;
 272     int jjround;
 273     int jjmatchedPos;
 274     int jjmatchedKind;
 275
 276     public Token getNextToken() {
 277         int kind;
 278         Token specialToken = null;
 279         Token matchedToken;
 280         int curPos = 0;
 281
 282         EOFLoop:
 283         for (; ;) {
 284             try {
 285                 curChar = input_stream.beginToken();
 286             }
 287             catch (java.io.IOException e) {
 288                 jjmatchedKind = 0;
 289                 matchedToken = jjFillToken();
 290                 return matchedToken;
 291             }
 292
 293             for (; ;) {
 294                 switch (curLexState) {
 295                     case 0:
 296                         try {
 297                             input_stream.backup(0);
 298                             while (curChar <= 32 && (0x100002600L & (1L << curChar)) != 0L) {
 299                                 curChar = input_stream.beginToken();
 300                             }
 301                         }
 302                         catch (java.io.IOException e1) {
 303                             continue EOFLoop;
 304                         }
 305                         jjmatchedKind = 0x7fffffff;
 306                         jjmatchedPos = 0;
 307                         curPos = jjMoveStringLiteralDfa0_0();
 308                         break;
 309                     case 1:
 310                         jjmatchedKind = 0x7fffffff;
 311                         jjmatchedPos = 0;
 312                         curPos = jjMoveStringLiteralDfa0_1();
 313                         if (jjmatchedPos == 0 && jjmatchedKind > 9) {
 314                             jjmatchedKind = 9;
 315                         }
 316                         break;
 317                 }
 318                 if (jjmatchedKind != 0x7fffffff) {
 319                     if (jjmatchedPos + 1 < curPos) {
 320                         input_stream.backup(curPos - jjmatchedPos - 1);
 321                     }
 322                     if ((jjtoToken[jjmatchedKind >> 6] & (1L << (jjmatchedKind & 077))) != 0L) {
 323                         matchedToken = jjFillToken();
 324                         if (jjnewLexState[jjmatchedKind] != -1) {
 325                             curLexState = jjnewLexState[jjmatchedKind];
 326                         }
 327                         return matchedToken;
 328                     }
 329                     else if ((jjtoSkip[jjmatchedKind >> 6] & (1L << (jjmatchedKind & 077))) != 0L) {
 330                         if (jjnewLexState[jjmatchedKind] != -1) {
 331                             curLexState = jjnewLexState[jjmatchedKind];
 332                         }
 333                         continue EOFLoop;
 334                     }
 335                     if (jjnewLexState[jjmatchedKind] != -1) {
 336                         curLexState = jjnewLexState[jjmatchedKind];
 337                     }
 338                     curPos = 0;
 339                     jjmatchedKind = 0x7fffffff;
 340                     try {
 341                         curChar = input_stream.readChar();
 342                         continue;
 343                     }
 344                     catch (java.io.IOException e1) {
 345                     }
 346                 }
 347                 int error_line = input_stream.getEndLine();
 348                 int error_column = input_stream.getEndColumn();
 349                 String error_after = null;
 350                 boolean EOFSeen = false;
 351                 try {
 352                     input_stream.readChar();
 353                     input_stream.backup(1);
 354                 }
 355                 catch (java.io.IOException e1) {
 356                     EOFSeen = true;
 357                     error_after = curPos <= 1 ? "" : input_stream.getImage();
 358                     if (curChar == '\n' || curChar == '\r') {
 359                         error_line++;
 360                         error_column = 0;
 361                     }
 362                     else {
 363                         error_column++;
 364                     }
 365                 }
 366                 if (!EOFSeen) {
 367                     input_stream.backup(1);
 368                     error_after = curPos <= 1 ? "" : input_stream.getImage();
 369                 }
 370                 throw new TokenMgrError(EOFSeen,
 371                                         curLexState,
 372                                         error_line,
 373                                         error_column,
 374                                         error_after,
 375                                         curChar,
 376                                         TokenMgrError.LEXICAL_ERROR);
 377             }
 378         }
 379     }
 380
 381 }