View Javadoc

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