| ParseCpslTokenManager |

    1   /* Generated By:JavaCC: Do not edit this line. ParseCpslTokenManager.java */
    2   package gate.jape.parser;
    3   import java.io.*;
    4   import java.net.*;
    5   import java.util.*;
    6   import gate.util.*;
    7   import gate.*;
    8   import gate.jape.*;
    9   import gate.event.*;
    10
    11  public class ParseCpslTokenManager implements ParseCpslConstants
    12  {
    13  private final int jjStopAtPos(int pos, int kind)
    14  {
    15     jjmatchedKind = kind;
    16     jjmatchedPos = pos;
    17     return pos + 1;
    18  }
    19  private final int jjMoveStringLiteralDfa0_0()
    20  {
    21     switch(curChar)
    22     {
    23        case 33:
    24           jjmatchedKind = 25;
    25           return jjMoveNfa_0(0, 0);
    26        case 34:
    27           jjmatchedKind = 28;
    28           return jjMoveNfa_0(0, 0);
    29        case 40:
    30           jjmatchedKind = 46;
    31           return jjMoveNfa_0(0, 0);
    32        case 41:
    33           jjmatchedKind = 47;
    34           return jjMoveNfa_0(0, 0);
    35        case 44:
    36           jjmatchedKind = 43;
    37           return jjMoveNfa_0(0, 0);
    38        case 45:
    39           return jjMoveStringLiteralDfa1_0(0x400000000000000L);
    40        case 46:
    41           jjmatchedKind = 41;
    42           return jjMoveNfa_0(0, 0);
    43        case 58:
    44           jjmatchedKind = 39;
    45           return jjMoveStringLiteralDfa1_0(0x4000000000000L);
    46        case 59:
    47           jjmatchedKind = 40;
    48           return jjMoveNfa_0(0, 0);
    49        case 61:
    50           jjmatchedKind = 48;
    51           return jjMoveStringLiteralDfa1_0(0x2000000000000L);
    52        case 73:
    53           return jjMoveStringLiteralDfa1_0(0x100000L);
    54        case 77:
    55           return jjMoveStringLiteralDfa1_0(0x800400L);
    56        case 79:
    57           return jjMoveStringLiteralDfa1_0(0x200000L);
    58        case 80:
    59           return jjMoveStringLiteralDfa1_0(0x1080800L);
    60        case 82:
    61           return jjMoveStringLiteralDfa1_0(0x400000L);
    62        case 105:
    63           return jjMoveStringLiteralDfa1_0(0x100000L);
    64        case 109:
    65           return jjMoveStringLiteralDfa1_0(0x800400L);
    66        case 111:
    67           return jjMoveStringLiteralDfa1_0(0x200000L);
    68        case 112:
    69           return jjMoveStringLiteralDfa1_0(0x1080800L);
    70        case 114:
    71           return jjMoveStringLiteralDfa1_0(0x400000L);
    72        case 123:
    73           jjmatchedKind = 44;
    74           return jjMoveNfa_0(0, 0);
    75        case 124:
    76           jjmatchedKind = 42;
    77           return jjMoveNfa_0(0, 0);
    78        case 125:
    79           jjmatchedKind = 45;
    80           return jjMoveNfa_0(0, 0);
    81        default :
    82           return jjMoveNfa_0(0, 0);
    83     }
    84  }
    85  private final int jjMoveStringLiteralDfa1_0(long active0)
    86  {
    87     try { curChar = input_stream.readChar(); }
    88     catch(java.io.IOException e) {
    89     return jjMoveNfa_0(0, 0);
    90     }
    91     switch(curChar)
    92     {
    93        case 43:
    94           if ((active0 & 0x4000000000000L) != 0L)
    95           {
    96              jjmatchedKind = 50;
    97              jjmatchedPos = 1;
    98           }
    99           break;
    100       case 45:
    101          return jjMoveStringLiteralDfa2_0(active0, 0x400000000000000L);
    102       case 61:
    103          if ((active0 & 0x2000000000000L) != 0L)
    104          {
    105             jjmatchedKind = 49;
    106             jjmatchedPos = 1;
    107          }
    108          break;
    109       case 65:
    110          return jjMoveStringLiteralDfa2_0(active0, 0x800000L);
    111       case 72:
    112          return jjMoveStringLiteralDfa2_0(active0, 0x80800L);
    113       case 78:
    114          return jjMoveStringLiteralDfa2_0(active0, 0x100000L);
    115       case 80:
    116          return jjMoveStringLiteralDfa2_0(active0, 0x200000L);
    117       case 82:
    118          return jjMoveStringLiteralDfa2_0(active0, 0x1000000L);
    119       case 85:
    120          return jjMoveStringLiteralDfa2_0(active0, 0x400400L);
    121       case 97:
    122          return jjMoveStringLiteralDfa2_0(active0, 0x800000L);
    123       case 104:
    124          return jjMoveStringLiteralDfa2_0(active0, 0x80800L);
    125       case 110:
    126          return jjMoveStringLiteralDfa2_0(active0, 0x100000L);
    127       case 112:
    128          return jjMoveStringLiteralDfa2_0(active0, 0x200000L);
    129       case 114:
    130          return jjMoveStringLiteralDfa2_0(active0, 0x1000000L);
    131       case 117:
    132          return jjMoveStringLiteralDfa2_0(active0, 0x400400L);
    133       default :
    134          break;
    135    }
    136    return jjMoveNfa_0(0, 1);
    137 }
    138 private final int jjMoveStringLiteralDfa2_0(long old0, long active0)
    139 {
    140    if (((active0 &= old0)) == 0L)
    141       return jjMoveNfa_0(0, 1);
    142    try { curChar = input_stream.readChar(); }
    143    catch(java.io.IOException e) {
    144    return jjMoveNfa_0(0, 1);
    145    }
    146    switch(curChar)
    147    {
    148       case 62:
    149          if ((active0 & 0x400000000000000L) != 0L)
    150          {
    151             jjmatchedKind = 58;
    152             jjmatchedPos = 2;
    153          }
    154          break;
    155       case 65:
    156          return jjMoveStringLiteralDfa3_0(active0, 0x80800L);
    157       case 67:
    158          return jjMoveStringLiteralDfa3_0(active0, 0x800000L);
    159       case 73:
    160          return jjMoveStringLiteralDfa3_0(active0, 0x1000000L);
    161       case 76:
    162          return jjMoveStringLiteralDfa3_0(active0, 0x400400L);
    163       case 80:
    164          return jjMoveStringLiteralDfa3_0(active0, 0x100000L);
    165       case 84:
    166          return jjMoveStringLiteralDfa3_0(active0, 0x200000L);
    167       case 97:
    168          return jjMoveStringLiteralDfa3_0(active0, 0x80800L);
    169       case 99:
    170          return jjMoveStringLiteralDfa3_0(active0, 0x800000L);
    171       case 105:
    172          return jjMoveStringLiteralDfa3_0(active0, 0x1000000L);
    173       case 108:
    174          return jjMoveStringLiteralDfa3_0(active0, 0x400400L);
    175       case 112:
    176          return jjMoveStringLiteralDfa3_0(active0, 0x100000L);
    177       case 116:
    178          return jjMoveStringLiteralDfa3_0(active0, 0x200000L);
    179       default :
    180          break;
    181    }
    182    return jjMoveNfa_0(0, 2);
    183 }
    184 private final int jjMoveStringLiteralDfa3_0(long old0, long active0)
    185 {
    186    if (((active0 &= old0)) == 0L)
    187       return jjMoveNfa_0(0, 2);
    188    try { curChar = input_stream.readChar(); }
    189    catch(java.io.IOException e) {
    190    return jjMoveNfa_0(0, 2);
    191    }
    192    switch(curChar)
    193    {
    194       case 69:
    195          return jjMoveStringLiteralDfa4_0(active0, 0x400000L);
    196       case 73:
    197          return jjMoveStringLiteralDfa4_0(active0, 0x200000L);
    198       case 79:
    199          return jjMoveStringLiteralDfa4_0(active0, 0x1000000L);
    200       case 82:
    201          return jjMoveStringLiteralDfa4_0(active0, 0x800000L);
    202       case 83:
    203          return jjMoveStringLiteralDfa4_0(active0, 0x80800L);
    204       case 84:
    205          return jjMoveStringLiteralDfa4_0(active0, 0x400L);
    206       case 85:
    207          return jjMoveStringLiteralDfa4_0(active0, 0x100000L);
    208       case 101:
    209          return jjMoveStringLiteralDfa4_0(active0, 0x400000L);
    210       case 105:
    211          return jjMoveStringLiteralDfa4_0(active0, 0x200000L);
    212       case 111:
    213          return jjMoveStringLiteralDfa4_0(active0, 0x1000000L);
    214       case 114:
    215          return jjMoveStringLiteralDfa4_0(active0, 0x800000L);
    216       case 115:
    217          return jjMoveStringLiteralDfa4_0(active0, 0x80800L);
    218       case 116:
    219          return jjMoveStringLiteralDfa4_0(active0, 0x400L);
    220       case 117:
    221          return jjMoveStringLiteralDfa4_0(active0, 0x100000L);
    222       default :
    223          break;
    224    }
    225    return jjMoveNfa_0(0, 3);
    226 }
    227 private final int jjMoveStringLiteralDfa4_0(long old0, long active0)
    228 {
    229    if (((active0 &= old0)) == 0L)
    230       return jjMoveNfa_0(0, 3);
    231    try { curChar = input_stream.readChar(); }
    232    catch(java.io.IOException e) {
    233    return jjMoveNfa_0(0, 3);
    234    }
    235    switch(curChar)
    236    {
    237       case 58:
    238          if ((active0 & 0x400000L) != 0L)
    239          {
    240             jjmatchedKind = 22;
    241             jjmatchedPos = 4;
    242          }
    243          break;
    244       case 69:
    245          return jjMoveStringLiteralDfa5_0(active0, 0x80800L);
    246       case 73:
    247          return jjMoveStringLiteralDfa5_0(active0, 0x400L);
    248       case 79:
    249          return jjMoveStringLiteralDfa5_0(active0, 0xa00000L);
    250       case 82:
    251          return jjMoveStringLiteralDfa5_0(active0, 0x1000000L);
    252       case 84:
    253          return jjMoveStringLiteralDfa5_0(active0, 0x100000L);
    254       case 101:
    255          return jjMoveStringLiteralDfa5_0(active0, 0x80800L);
    256       case 105:
    257          return jjMoveStringLiteralDfa5_0(active0, 0x400L);
    258       case 111:
    259          return jjMoveStringLiteralDfa5_0(active0, 0xa00000L);
    260       case 114:
    261          return jjMoveStringLiteralDfa5_0(active0, 0x1000000L);
    262       case 116:
    263          return jjMoveStringLiteralDfa5_0(active0, 0x100000L);
    264       default :
    265          break;
    266    }
    267    return jjMoveNfa_0(0, 4);
    268 }
    269 private final int jjMoveStringLiteralDfa5_0(long old0, long active0)
    270 {
    271    if (((active0 &= old0)) == 0L)
    272       return jjMoveNfa_0(0, 4);
    273    try { curChar = input_stream.readChar(); }
    274    catch(java.io.IOException e) {
    275    return jjMoveNfa_0(0, 4);
    276    }
    277    switch(curChar)
    278    {
    279       case 58:
    280          if ((active0 & 0x80000L) != 0L)
    281          {
    282             jjmatchedKind = 19;
    283             jjmatchedPos = 5;
    284          }
    285          else if ((active0 & 0x100000L) != 0L)
    286          {
    287             jjmatchedKind = 20;
    288             jjmatchedPos = 5;
    289          }
    290          else if ((active0 & 0x800000L) != 0L)
    291          {
    292             jjmatchedKind = 23;
    293             jjmatchedPos = 5;
    294          }
    295          break;
    296       case 73:
    297          return jjMoveStringLiteralDfa6_0(active0, 0x1000000L);
    298       case 78:
    299          return jjMoveStringLiteralDfa6_0(active0, 0x200000L);
    300       case 80:
    301          return jjMoveStringLiteralDfa6_0(active0, 0x400L);
    302       case 83:
    303          return jjMoveStringLiteralDfa6_0(active0, 0x800L);
    304       case 105:
    305          return jjMoveStringLiteralDfa6_0(active0, 0x1000000L);
    306       case 110:
    307          return jjMoveStringLiteralDfa6_0(active0, 0x200000L);
    308       case 112:
    309          return jjMoveStringLiteralDfa6_0(active0, 0x400L);
    310       case 115:
    311          return jjMoveStringLiteralDfa6_0(active0, 0x800L);
    312       default :
    313          break;
    314    }
    315    return jjMoveNfa_0(0, 5);
    316 }
    317 private final int jjMoveStringLiteralDfa6_0(long old0, long active0)
    318 {
    319    if (((active0 &= old0)) == 0L)
    320       return jjMoveNfa_0(0, 5);
    321    try { curChar = input_stream.readChar(); }
    322    catch(java.io.IOException e) {
    323    return jjMoveNfa_0(0, 5);
    324    }
    325    switch(curChar)
    326    {
    327       case 58:
    328          if ((active0 & 0x800L) != 0L)
    329          {
    330             jjmatchedKind = 11;
    331             jjmatchedPos = 6;
    332          }
    333          break;
    334       case 72:
    335          return jjMoveStringLiteralDfa7_0(active0, 0x400L);
    336       case 83:
    337          return jjMoveStringLiteralDfa7_0(active0, 0x200000L);
    338       case 84:
    339          return jjMoveStringLiteralDfa7_0(active0, 0x1000000L);
    340       case 104:
    341          return jjMoveStringLiteralDfa7_0(active0, 0x400L);
    342       case 115:
    343          return jjMoveStringLiteralDfa7_0(active0, 0x200000L);
    344       case 116:
    345          return jjMoveStringLiteralDfa7_0(active0, 0x1000000L);
    346       default :
    347          break;
    348    }
    349    return jjMoveNfa_0(0, 6);
    350 }
    351 private final int jjMoveStringLiteralDfa7_0(long old0, long active0)
    352 {
    353    if (((active0 &= old0)) == 0L)
    354       return jjMoveNfa_0(0, 6);
    355    try { curChar = input_stream.readChar(); }
    356    catch(java.io.IOException e) {
    357    return jjMoveNfa_0(0, 6);
    358    }
    359    switch(curChar)
    360    {
    361       case 58:
    362          if ((active0 & 0x200000L) != 0L)
    363          {
    364             jjmatchedKind = 21;
    365             jjmatchedPos = 7;
    366          }
    367          break;
    368       case 65:
    369          return jjMoveStringLiteralDfa8_0(active0, 0x400L);
    370       case 89:
    371          return jjMoveStringLiteralDfa8_0(active0, 0x1000000L);
    372       case 97:
    373          return jjMoveStringLiteralDfa8_0(active0, 0x400L);
    374       case 121:
    375          return jjMoveStringLiteralDfa8_0(active0, 0x1000000L);
    376       default :
    377          break;
    378    }
    379    return jjMoveNfa_0(0, 7);
    380 }
    381 private final int jjMoveStringLiteralDfa8_0(long old0, long active0)
    382 {
    383    if (((active0 &= old0)) == 0L)
    384       return jjMoveNfa_0(0, 7);
    385    try { curChar = input_stream.readChar(); }
    386    catch(java.io.IOException e) {
    387    return jjMoveNfa_0(0, 7);
    388    }
    389    switch(curChar)
    390    {
    391       case 58:
    392          if ((active0 & 0x1000000L) != 0L)
    393          {
    394             jjmatchedKind = 24;
    395             jjmatchedPos = 8;
    396          }
    397          break;
    398       case 83:
    399          return jjMoveStringLiteralDfa9_0(active0, 0x400L);
    400       case 115:
    401          return jjMoveStringLiteralDfa9_0(active0, 0x400L);
    402       default :
    403          break;
    404    }
    405    return jjMoveNfa_0(0, 8);
    406 }
    407 private final int jjMoveStringLiteralDfa9_0(long old0, long active0)
    408 {
    409    if (((active0 &= old0)) == 0L)
    410       return jjMoveNfa_0(0, 8);
    411    try { curChar = input_stream.readChar(); }
    412    catch(java.io.IOException e) {
    413    return jjMoveNfa_0(0, 8);
    414    }
    415    switch(curChar)
    416    {
    417       case 69:
    418          return jjMoveStringLiteralDfa10_0(active0, 0x400L);
    419       case 101:
    420          return jjMoveStringLiteralDfa10_0(active0, 0x400L);
    421       default :
    422          break;
    423    }
    424    return jjMoveNfa_0(0, 9);
    425 }
    426 private final int jjMoveStringLiteralDfa10_0(long old0, long active0)
    427 {
    428    if (((active0 &= old0)) == 0L)
    429       return jjMoveNfa_0(0, 9);
    430    try { curChar = input_stream.readChar(); }
    431    catch(java.io.IOException e) {
    432    return jjMoveNfa_0(0, 9);
    433    }
    434    switch(curChar)
    435    {
    436       case 58:
    437          if ((active0 & 0x400L) != 0L)
    438          {
    439             jjmatchedKind = 10;
    440             jjmatchedPos = 10;
    441          }
    442          break;
    443       default :
    444          break;
    445    }
    446    return jjMoveNfa_0(0, 10);
    447 }
    448 private final void jjCheckNAdd(int state)
    449 {
    450    if (jjrounds[state] != jjround)
    451    {
    452       jjstateSet[jjnewStateCnt++] = state;
    453       jjrounds[state] = jjround;
    454    }
    455 }
    456 private final void jjAddStates(int start, int end)
    457 {
    458    do {
    459       jjstateSet[jjnewStateCnt++] = jjnextStates[start];
    460    } while (start++ != end);
    461 }
    462 private final void jjCheckNAddTwoStates(int state1, int state2)
    463 {
    464    jjCheckNAdd(state1);
    465    jjCheckNAdd(state2);
    466 }
    467 private final void jjCheckNAddStates(int start, int end)
    468 {
    469    do {
    470       jjCheckNAdd(jjnextStates[start]);
    471    } while (start++ != end);
    472 }
    473 private final void jjCheckNAddStates(int start)
    474 {
    475    jjCheckNAdd(jjnextStates[start]);
    476    jjCheckNAdd(jjnextStates[start + 1]);
    477 }
    478 static final long[] jjbitVec0 = {
    479    0x0L, 0x0L, 0xffffffffffffffffL, 0xffffffffffffffffL
    480 };
    481 private final int jjMoveNfa_0(int startState, int curPos)
    482 {
    483    int strKind = jjmatchedKind;
    484    int strPos = jjmatchedPos;
    485    int seenUpto;
    486    input_stream.backup(seenUpto = curPos + 1);
    487    try { curChar = input_stream.readChar(); }
    488    catch(java.io.IOException e) { throw new Error("Internal Error"); }
    489    curPos = 0;
    490    int[] nextStates;
    491    int startsAt = 0;
    492    jjnewStateCnt = 53;
    493    int i = 1;
    494    jjstateSet[0] = startState;
    495    int j, kind = 0x7fffffff;
    496    for (;;)
    497    {
    498       if (++jjround == 0x7fffffff)
    499          ReInitRounds();
    500       if (curChar < 64)
    501       {
    502          long l = 1L << curChar;
    503          MatchLoop: do
    504          {
    505             switch(jjstateSet[--i])
    506             {
    507                case 0:
    508                   if ((0x3ff000000000000L & l) != 0L)
    509                   {
    510                      if (kind > 27)
    511                         kind = 27;
    512                      jjCheckNAddStates(0, 7);
    513                   }
    514                   else if ((0x100003600L & l) != 0L)
    515                   {
    516                      if (kind > 51)
    517                         kind = 51;
    518                      jjCheckNAdd(17);
    519                   }
    520                   else if ((0x80000c0000000000L & l) != 0L)
    521                   {
    522                      if (kind > 26)
    523                         kind = 26;
    524                   }
    525                   else if (curChar == 47)
    526                      jjAddStates(8, 9);
    527                   else if (curChar == 35)
    528                      jjstateSet[jjnewStateCnt++] = 26;
    529                   else if (curChar == 59)
    530                      jjstateSet[jjnewStateCnt++] = 18;
    531                   else if (curChar == 46)
    532                      jjCheckNAdd(12);
    533                   break;
    534                case 10:
    535                   if ((0x3ff200000000000L & l) == 0L)
    536                      break;
    537                   if (kind > 36)
    538                      kind = 36;
    539                   jjstateSet[jjnewStateCnt++] = 10;
    540                   break;
    541                case 11:
    542                   if (curChar == 46)
    543                      jjCheckNAdd(12);
    544                   break;
    545                case 12:
    546                   if ((0x3ff000000000000L & l) == 0L)
    547                      break;
    548                   if (kind > 37)
    549                      kind = 37;
    550                   jjCheckNAddStates(10, 12);
    551                   break;
    552                case 14:
    553                   if ((0x280000000000L & l) != 0L)
    554                      jjCheckNAdd(15);
    555                   break;
    556                case 15:
    557                   if ((0x3ff000000000000L & l) == 0L)
    558                      break;
    559                   if (kind > 37)
    560                      kind = 37;
    561                   jjCheckNAddTwoStates(15, 16);
    562                   break;
    563                case 17:
    564                   if ((0x100003600L & l) == 0L)
    565                      break;
    566                   if (kind > 51)
    567                      kind = 51;
    568                   jjCheckNAdd(17);
    569                   break;
    570                case 18:
    571                   if (curChar == 59)
    572                      jjCheckNAddStates(13, 16);
    573                   break;
    574                case 19:
    575                   if ((0xffffffffffffdbffL & l) != 0L)
    576                      jjCheckNAddStates(13, 16);
    577                   break;
    578                case 20:
    579                   if ((0x2400L & l) != 0L && kind > 53)
    580                      kind = 53;
    581                   break;
    582                case 21:
    583                   if (curChar == 13 && kind > 53)
    584                      kind = 53;
    585                   break;
    586                case 22:
    587                   if (curChar == 10)
    588                      jjstateSet[jjnewStateCnt++] = 21;
    589                   break;
    590                case 23:
    591                   if (curChar == 10 && kind > 53)
    592                      kind = 53;
    593                   break;
    594                case 24:
    595                   if (curChar == 13)
    596                      jjstateSet[jjnewStateCnt++] = 23;
    597                   break;
    598                case 25:
    599                   if (curChar == 59)
    600                      jjstateSet[jjnewStateCnt++] = 18;
    601                   break;
    602                case 27:
    603                   if (curChar == 35)
    604                      jjstateSet[jjnewStateCnt++] = 26;
    605                   break;
    606                case 28:
    607                   if ((0x3ff000000000000L & l) == 0L)
    608                      break;
    609                   if (kind > 27)
    610                      kind = 27;
    611                   jjCheckNAddStates(0, 7);
    612                   break;
    613                case 29:
    614                   if ((0x3ff000000000000L & l) == 0L)
    615                      break;
    616                   if (kind > 27)
    617                      kind = 27;
    618                   jjCheckNAdd(29);
    619                   break;
    620                case 30:
    621                   if ((0x3ff000000000000L & l) != 0L)
    622                      jjCheckNAddTwoStates(30, 31);
    623                   break;
    624                case 31:
    625                   if (curChar != 46)
    626                      break;
    627                   if (kind > 37)
    628                      kind = 37;
    629                   jjCheckNAddStates(17, 19);
    630                   break;
    631                case 32:
    632                   if ((0x3ff000000000000L & l) == 0L)
    633                      break;
    634                   if (kind > 37)
    635                      kind = 37;
    636                   jjCheckNAddStates(17, 19);
    637                   break;
    638                case 34:
    639                   if ((0x280000000000L & l) != 0L)
    640                      jjCheckNAdd(35);
    641                   break;
    642                case 35:
    643                   if ((0x3ff000000000000L & l) == 0L)
    644                      break;
    645                   if (kind > 37)
    646                      kind = 37;
    647                   jjCheckNAddTwoStates(35, 16);
    648                   break;
    649                case 36:
    650                   if ((0x3ff000000000000L & l) != 0L)
    651                      jjCheckNAddTwoStates(36, 37);
    652                   break;
    653                case 38:
    654                   if ((0x280000000000L & l) != 0L)
    655                      jjCheckNAdd(39);
    656                   break;
    657                case 39:
    658                   if ((0x3ff000000000000L & l) == 0L)
    659                      break;
    660                   if (kind > 37)
    661                      kind = 37;
    662                   jjCheckNAddTwoStates(39, 16);
    663                   break;
    664                case 40:
    665                   if ((0x3ff000000000000L & l) != 0L)
    666                      jjCheckNAddStates(20, 22);
    667                   break;
    668                case 42:
    669                   if ((0x280000000000L & l) != 0L)
    670                      jjCheckNAdd(43);
    671                   break;
    672                case 43:
    673                   if ((0x3ff000000000000L & l) != 0L)
    674                      jjCheckNAddTwoStates(43, 16);
    675                   break;
    676                case 44:
    677                   if (curChar == 47)
    678                      jjAddStates(8, 9);
    679                   break;
    680                case 45:
    681                   if (curChar == 47)
    682                      jjCheckNAddStates(23, 26);
    683                   break;
    684                case 46:
    685                   if ((0xffffffffffffdbffL & l) != 0L)
    686                      jjCheckNAddStates(23, 26);
    687                   break;
    688                case 47:
    689                   if ((0x2400L & l) != 0L && kind > 52)
    690                      kind = 52;
    691                   break;
    692                case 48:
    693                   if (curChar == 13 && kind > 52)
    694                      kind = 52;
    695                   break;
    696                case 49:
    697                   if (curChar == 10)
    698                      jjstateSet[jjnewStateCnt++] = 48;
    699                   break;
    700                case 50:
    701                   if (curChar == 10 && kind > 52)
    702                      kind = 52;
    703                   break;
    704                case 51:
    705                   if (curChar == 13)
    706                      jjstateSet[jjnewStateCnt++] = 50;
    707                   break;
    708                case 52:
    709                   if (curChar == 42 && kind > 54)
    710                      kind = 54;
    711                   break;
    712                default : break;
    713             }
    714          } while(i != startsAt);
    715       }
    716       else if (curChar < 128)
    717       {
    718          long l = 1L << (curChar & 077);
    719          MatchLoop: do
    720          {
    721             switch(jjstateSet[--i])
    722             {
    723                case 0:
    724                   if ((0x7fffffe07fffffeL & l) != 0L)
    725                   {
    726                      if (kind > 36)
    727                         kind = 36;
    728                      jjCheckNAdd(10);
    729                   }
    730                   if (curChar == 102)
    731                      jjstateSet[jjnewStateCnt++] = 7;
    732                   else if (curChar == 116)
    733                      jjstateSet[jjnewStateCnt++] = 3;
    734                   break;
    735                case 1:
    736                   if (curChar == 101 && kind > 35)
    737                      kind = 35;
    738                   break;
    739                case 2:
    740                   if (curChar == 117)
    741                      jjCheckNAdd(1);
    742                   break;
    743                case 3:
    744                   if (curChar == 114)
    745                      jjstateSet[jjnewStateCnt++] = 2;
    746                   break;
    747                case 4:
    748                   if (curChar == 116)
    749                      jjstateSet[jjnewStateCnt++] = 3;
    750                   break;
    751                case 5:
    752                   if (curChar == 115)
    753                      jjCheckNAdd(1);
    754                   break;
    755                case 6:
    756                   if (curChar == 108)
    757                      jjstateSet[jjnewStateCnt++] = 5;
    758                   break;
    759                case 7:
    760                   if (curChar == 97)
    761                      jjstateSet[jjnewStateCnt++] = 6;
    762                   break;
    763                case 8:
    764                   if (curChar == 102)
    765                      jjstateSet[jjnewStateCnt++] = 7;
    766                   break;
    767                case 9:
    768                   if ((0x7fffffe07fffffeL & l) == 0L)
    769                      break;
    770                   if (kind > 36)
    771                      kind = 36;
    772                   jjCheckNAdd(10);
    773                   break;
    774                case 10:
    775                   if ((0x7fffffe87fffffeL & l) == 0L)
    776                      break;
    777                   if (kind > 36)
    778                      kind = 36;
    779                   jjCheckNAdd(10);
    780                   break;
    781                case 13:
    782                   if ((0x2000000020L & l) != 0L)
    783                      jjAddStates(27, 28);
    784                   break;
    785                case 16:
    786                   if ((0x5000000050L & l) != 0L && kind > 37)
    787                      kind = 37;
    788                   break;
    789                case 19:
    790                   jjAddStates(13, 16);
    791                   break;
    792                case 26:
    793                   if (curChar == 124 && kind > 54)
    794                      kind = 54;
    795                   break;
    796                case 33:
    797                   if ((0x2000000020L & l) != 0L)
    798                      jjAddStates(29, 30);
    799                   break;
    800                case 37:
    801                   if ((0x2000000020L & l) != 0L)
    802                      jjAddStates(31, 32);
    803                   break;
    804                case 41:
    805                   if ((0x2000000020L & l) != 0L)
    806                      jjAddStates(33, 34);
    807                   break;
    808                case 46:
    809                   jjAddStates(23, 26);
    810                   break;
    811                default : break;
    812             }
    813          } while(i != startsAt);
    814       }
    815       else
    816       {
    817          int i2 = (curChar & 0xff) >> 6;
    818          long l2 = 1L << (curChar & 077);
    819          MatchLoop: do
    820          {
    821             switch(jjstateSet[--i])
    822             {
    823                case 19:
    824                   if ((jjbitVec0[i2] & l2) != 0L)
    825                      jjAddStates(13, 16);
    826                   break;
    827                case 46:
    828                   if ((jjbitVec0[i2] & l2) != 0L)
    829                      jjAddStates(23, 26);
    830                   break;
    831                default : break;
    832             }
    833          } while(i != startsAt);
    834       }
    835       if (kind != 0x7fffffff)
    836       {
    837          jjmatchedKind = kind;
    838          jjmatchedPos = curPos;
    839          kind = 0x7fffffff;
    840       }
    841       ++curPos;
    842       if ((i = jjnewStateCnt) == (startsAt = 53 - (jjnewStateCnt = startsAt)))
    843          break;
    844       try { curChar = input_stream.readChar(); }
    845       catch(java.io.IOException e) { break; }
    846    }
    847    if (jjmatchedPos > strPos)
    848       return curPos;
    849
    850    int toRet = Math.max(curPos, seenUpto);
    851
    852    if (curPos < toRet)
    853       for (i = toRet - Math.min(curPos, seenUpto); i-- > 0; )
    854          try { curChar = input_stream.readChar(); }
    855          catch(java.io.IOException e) { throw new Error("Internal Error : Please send a bug report."); }
    856
    857    if (jjmatchedPos < strPos)
    858    {
    859       jjmatchedKind = strKind;
    860       jjmatchedPos = strPos;
    861    }
    862    else if (jjmatchedPos == strPos && jjmatchedKind > strKind)
    863       jjmatchedKind = strKind;
    864
    865    return toRet;
    866 }
    867 private final int jjStopStringLiteralDfa_3(int pos, long active0)
    868 {
    869    switch (pos)
    870    {
    871       case 0:
    872          if ((active0 & 0x1e0000000L) != 0L)
    873          {
    874             jjmatchedKind = 33;
    875             return -1;
    876          }
    877          return -1;
    878       default :
    879          return -1;
    880    }
    881 }
    882 private final int jjStartNfa_3(int pos, long active0)
    883 {
    884    return jjMoveNfa_3(jjStopStringLiteralDfa_3(pos, active0), pos + 1);
    885 }
    886 private final int jjStartNfaWithStates_3(int pos, int kind, int state)
    887 {
    888    jjmatchedKind = kind;
    889    jjmatchedPos = pos;
    890    try { curChar = input_stream.readChar(); }
    891    catch(java.io.IOException e) { return pos + 1; }
    892    return jjMoveNfa_3(state, pos + 1);
    893 }
    894 private final int jjMoveStringLiteralDfa0_3()
    895 {
    896    switch(curChar)
    897    {
    898       case 34:
    899          return jjStopAtPos(0, 34);
    900       case 92:
    901          return jjMoveStringLiteralDfa1_3(0x1e0000000L);
    902       default :
    903          return jjMoveNfa_3(0, 0);
    904    }
    905 }
    906 private final int jjMoveStringLiteralDfa1_3(long active0)
    907 {
    908    try { curChar = input_stream.readChar(); }
    909    catch(java.io.IOException e) {
    910       jjStopStringLiteralDfa_3(0, active0);
    911       return 1;
    912    }
    913    switch(curChar)
    914    {
    915       case 34:
    916          if ((active0 & 0x100000000L) != 0L)
    917             return jjStopAtPos(1, 32);
    918          break;
    919       case 110:
    920          if ((active0 & 0x20000000L) != 0L)
    921             return jjStopAtPos(1, 29);
    922          break;
    923       case 114:
    924          if ((active0 & 0x40000000L) != 0L)
    925             return jjStopAtPos(1, 30);
    926          break;
    927       case 116:
    928          if ((active0 & 0x80000000L) != 0L)
    929             return jjStopAtPos(1, 31);
    930          break;
    931       default :
    932          break;
    933    }
    934    return jjStartNfa_3(0, active0);
    935 }
    936 private final int jjMoveNfa_3(int startState, int curPos)
    937 {
    938    int[] nextStates;
    939    int startsAt = 0;
    940    jjnewStateCnt = 1;
    941    int i = 1;
    942    jjstateSet[0] = startState;
    943    int j, kind = 0x7fffffff;
    944    for (;;)
    945    {
    946       if (++jjround == 0x7fffffff)
    947          ReInitRounds();
    948       if (curChar < 64)
    949       {
    950          long l = 1L << curChar;
    951          MatchLoop: do
    952          {
    953             switch(jjstateSet[--i])
    954             {
    955                case 0:
    956                   if ((0xfffffffbffffffffL & l) != 0L)
    957                      kind = 33;
    958                   break;
    959                default : break;
    960             }
    961          } while(i != startsAt);
    962       }
    963       else if (curChar < 128)
    964       {
    965          long l = 1L << (curChar & 077);
    966          MatchLoop: do
    967          {
    968             switch(jjstateSet[--i])
    969             {
    970                case 0:
    971                   kind = 33;
    972                   break;
    973                default : break;
    974             }
    975          } while(i != startsAt);
    976       }
    977       else
    978       {
    979          int i2 = (curChar & 0xff) >> 6;
    980          long l2 = 1L << (curChar & 077);
    981          MatchLoop: do
    982          {
    983             switch(jjstateSet[--i])
    984             {
    985                case 0:
    986                   if ((jjbitVec0[i2] & l2) != 0L && kind > 33)
    987                      kind = 33;
    988                   break;
    989                default : break;
    990             }
    991          } while(i != startsAt);
    992       }
    993       if (kind != 0x7fffffff)
    994       {
    995          jjmatchedKind = kind;
    996          jjmatchedPos = curPos;
    997          kind = 0x7fffffff;
    998       }
    999       ++curPos;
    1000      if ((i = jjnewStateCnt) == (startsAt = 1 - (jjnewStateCnt = startsAt)))
    1001         return curPos;
    1002      try { curChar = input_stream.readChar(); }
    1003      catch(java.io.IOException e) { return curPos; }
    1004   }
    1005}
    1006private final int jjMoveStringLiteralDfa0_1()
    1007{
    1008   return jjMoveNfa_1(9, 0);
    1009}
    1010private final int jjMoveNfa_1(int startState, int curPos)
    1011{
    1012   int[] nextStates;
    1013   int startsAt = 0;
    1014   jjnewStateCnt = 21;
    1015   int i = 1;
    1016   jjstateSet[0] = startState;
    1017   int j, kind = 0x7fffffff;
    1018   for (;;)
    1019   {
    1020      if (++jjround == 0x7fffffff)
    1021         ReInitRounds();
    1022      if (curChar < 64)
    1023      {
    1024         long l = 1L << curChar;
    1025         MatchLoop: do
    1026         {
    1027            switch(jjstateSet[--i])
    1028            {
    1029               case 9:
    1030                  if ((0x3ffe00000000000L & l) != 0L)
    1031                  {
    1032                     if (kind > 12)
    1033                        kind = 12;
    1034                     jjCheckNAdd(0);
    1035                  }
    1036                  else if ((0x100003600L & l) != 0L)
    1037                  {
    1038                     if (kind > 13)
    1039                        kind = 13;
    1040                     jjCheckNAdd(1);
    1041                  }
    1042                  else if (curChar == 35)
    1043                     jjstateSet[jjnewStateCnt++] = 10;
    1044                  else if (curChar == 59)
    1045                     jjstateSet[jjnewStateCnt++] = 2;
    1046                  if (curChar == 47)
    1047                     jjAddStates(35, 36);
    1048                  break;
    1049               case 0:
    1050                  if ((0x3ffe00000000000L & l) == 0L)
    1051                     break;
    1052                  if (kind > 12)
    1053                     kind = 12;
    1054                  jjCheckNAdd(0);
    1055                  break;
    1056               case 1:
    1057                  if ((0x100003600L & l) == 0L)
    1058                     break;
    1059                  if (kind > 13)
    1060                     kind = 13;
    1061                  jjCheckNAdd(1);
    1062                  break;
    1063               case 2:
    1064                  if (curChar == 59)
    1065                     jjCheckNAddStates(37, 40);
    1066                  break;
    1067               case 3:
    1068                  if ((0xffffffffffffdbffL & l) != 0L)
    1069                     jjCheckNAddStates(37, 40);
    1070                  break;
    1071               case 4:
    1072                  if ((0x2400L & l) != 0L && kind > 15)
    1073                     kind = 15;
    1074                  break;
    1075               case 5:
    1076                  if (curChar == 13 && kind > 15)
    1077                     kind = 15;
    1078                  break;
    1079               case 6:
    1080                  if (curChar == 10)
    1081                     jjstateSet[jjnewStateCnt++] = 5;
    1082                  break;
    1083               case 7:
    1084                  if (curChar == 10 && kind > 15)
    1085                     kind = 15;
    1086                  break;
    1087               case 8:
    1088                  if (curChar == 13)
    1089                     jjstateSet[jjnewStateCnt++] = 7;
    1090                  break;
    1091               case 11:
    1092                  if (curChar == 35)
    1093                     jjstateSet[jjnewStateCnt++] = 10;
    1094                  break;
    1095               case 12:
    1096                  if (curChar == 47)
    1097                     jjAddStates(35, 36);
    1098                  break;
    1099               case 13:
    1100                  if (curChar == 47)
    1101                     jjCheckNAddStates(41, 44);
    1102                  break;
    1103               case 14:
    1104                  if ((0xffffffffffffdbffL & l) != 0L)
    1105                     jjCheckNAddStates(41, 44);
    1106                  break;
    1107               case 15:
    1108                  if ((0x2400L & l) != 0L && kind > 14)
    1109                     kind = 14;
    1110                  break;
    1111               case 16:
    1112                  if (curChar == 13 && kind > 14)
    1113                     kind = 14;
    1114                  break;
    1115               case 17:
    1116                  if (curChar == 10)
    1117                     jjstateSet[jjnewStateCnt++] = 16;
    1118                  break;
    1119               case 18:
    1120                  if (curChar == 10 && kind > 14)
    1121                     kind = 14;
    1122                  break;
    1123               case 19:
    1124                  if (curChar == 13)
    1125                     jjstateSet[jjnewStateCnt++] = 18;
    1126                  break;
    1127               case 20:
    1128                  if (curChar == 42 && kind > 16)
    1129                     kind = 16;
    1130                  break;
    1131               default : break;
    1132            }
    1133         } while(i != startsAt);
    1134      }
    1135      else if (curChar < 128)
    1136      {
    1137         long l = 1L << (curChar & 077);
    1138         MatchLoop: do
    1139         {
    1140            switch(jjstateSet[--i])
    1141            {
    1142               case 9:
    1143               case 0:
    1144                  if ((0x7fffffe97fffffeL & l) == 0L)
    1145                     break;
    1146                  if (kind > 12)
    1147                     kind = 12;
    1148                  jjCheckNAdd(0);
    1149                  break;
    1150               case 3:
    1151                  jjAddStates(37, 40);
    1152                  break;
    1153               case 10:
    1154                  if (curChar == 124 && kind > 16)
    1155                     kind = 16;
    1156                  break;
    1157               case 14:
    1158                  jjAddStates(41, 44);
    1159                  break;
    1160               default : break;
    1161            }
    1162         } while(i != startsAt);
    1163      }
    1164      else
    1165      {
    1166         int i2 = (curChar & 0xff) >> 6;
    1167         long l2 = 1L << (curChar & 077);
    1168         MatchLoop: do
    1169         {
    1170            switch(jjstateSet[--i])
    1171            {
    1172               case 3:
    1173                  if ((jjbitVec0[i2] & l2) != 0L)
    1174                     jjAddStates(37, 40);
    1175                  break;
    1176               case 14:
    1177                  if ((jjbitVec0[i2] & l2) != 0L)
    1178                     jjAddStates(41, 44);
    1179                  break;
    1180               default : break;
    1181            }
    1182         } while(i != startsAt);
    1183      }
    1184      if (kind != 0x7fffffff)
    1185      {
    1186         jjmatchedKind = kind;
    1187         jjmatchedPos = curPos;
    1188         kind = 0x7fffffff;
    1189      }
    1190      ++curPos;
    1191      if ((i = jjnewStateCnt) == (startsAt = 21 - (jjnewStateCnt = startsAt)))
    1192         return curPos;
    1193      try { curChar = input_stream.readChar(); }
    1194      catch(java.io.IOException e) { return curPos; }
    1195   }
    1196}
    1197private final int jjMoveStringLiteralDfa0_4()
    1198{
    1199   return jjMoveNfa_4(1, 0);
    1200}
    1201private final int jjMoveNfa_4(int startState, int curPos)
    1202{
    1203   int[] nextStates;
    1204   int startsAt = 0;
    1205   jjnewStateCnt = 4;
    1206   int i = 1;
    1207   jjstateSet[0] = startState;
    1208   int j, kind = 0x7fffffff;
    1209   for (;;)
    1210   {
    1211      if (++jjround == 0x7fffffff)
    1212         ReInitRounds();
    1213      if (curChar < 64)
    1214      {
    1215         long l = 1L << curChar;
    1216         MatchLoop: do
    1217         {
    1218            switch(jjstateSet[--i])
    1219            {
    1220               case 1:
    1221                  if (curChar == 42)
    1222                     jjstateSet[jjnewStateCnt++] = 0;
    1223                  break;
    1224               case 0:
    1225                  if (curChar == 47)
    1226                     kind = 56;
    1227                  break;
    1228               case 2:
    1229                  if (curChar == 35)
    1230                     kind = 56;
    1231                  break;
    1232               default : break;
    1233            }
    1234         } while(i != startsAt);
    1235      }
    1236      else if (curChar < 128)
    1237      {
    1238         long l = 1L << (curChar & 077);
    1239         MatchLoop: do
    1240         {
    1241            switch(jjstateSet[--i])
    1242            {
    1243               case 1:
    1244                  if (curChar == 124)
    1245                     jjstateSet[jjnewStateCnt++] = 2;
    1246                  break;
    1247               default : break;
    1248            }
    1249         } while(i != startsAt);
    1250      }
    1251      else
    1252      {
    1253         int i2 = (curChar & 0xff) >> 6;
    1254         long l2 = 1L << (curChar & 077);
    1255         MatchLoop: do
    1256         {
    1257            switch(jjstateSet[--i])
    1258            {
    1259               default : break;
    1260            }
    1261         } while(i != startsAt);
    1262      }
    1263      if (kind != 0x7fffffff)
    1264      {
    1265         jjmatchedKind = kind;
    1266         jjmatchedPos = curPos;
    1267         kind = 0x7fffffff;
    1268      }
    1269      ++curPos;
    1270      if ((i = jjnewStateCnt) == (startsAt = 4 - (jjnewStateCnt = startsAt)))
    1271         return curPos;
    1272      try { curChar = input_stream.readChar(); }
    1273      catch(java.io.IOException e) { return curPos; }
    1274   }
    1275}
    1276private final int jjMoveStringLiteralDfa0_2()
    1277{
    1278   return jjMoveNfa_2(1, 0);
    1279}
    1280private final int jjMoveNfa_2(int startState, int curPos)
    1281{
    1282   int[] nextStates;
    1283   int startsAt = 0;
    1284   jjnewStateCnt = 4;
    1285   int i = 1;
    1286   jjstateSet[0] = startState;
    1287   int j, kind = 0x7fffffff;
    1288   for (;;)
    1289   {
    1290      if (++jjround == 0x7fffffff)
    1291         ReInitRounds();
    1292      if (curChar < 64)
    1293      {
    1294         long l = 1L << curChar;
    1295         MatchLoop: do
    1296         {
    1297            switch(jjstateSet[--i])
    1298            {
    1299               case 1:
    1300                  if (curChar == 42)
    1301                     jjstateSet[jjnewStateCnt++] = 0;
    1302                  break;
    1303               case 0:
    1304                  if (curChar == 47)
    1305                     kind = 18;
    1306                  break;
    1307               case 2:
    1308                  if (curChar == 35)
    1309                     kind = 18;
    1310                  break;
    1311               default : break;
    1312            }
    1313         } while(i != startsAt);
    1314      }
    1315      else if (curChar < 128)
    1316      {
    1317         long l = 1L << (curChar & 077);
    1318         MatchLoop: do
    1319         {
    1320            switch(jjstateSet[--i])
    1321            {
    1322               case 1:
    1323                  if (curChar == 124)
    1324                     jjstateSet[jjnewStateCnt++] = 2;
    1325                  break;
    1326               default : break;
    1327            }
    1328         } while(i != startsAt);
    1329      }
    1330      else
    1331      {
    1332         int i2 = (curChar & 0xff) >> 6;
    1333         long l2 = 1L << (curChar & 077);
    1334         MatchLoop: do
    1335         {
    1336            switch(jjstateSet[--i])
    1337            {
    1338               default : break;
    1339            }
    1340         } while(i != startsAt);
    1341      }
    1342      if (kind != 0x7fffffff)
    1343      {
    1344         jjmatchedKind = kind;
    1345         jjmatchedPos = curPos;
    1346         kind = 0x7fffffff;
    1347      }
    1348      ++curPos;
    1349      if ((i = jjnewStateCnt) == (startsAt = 4 - (jjnewStateCnt = startsAt)))
    1350         return curPos;
    1351      try { curChar = input_stream.readChar(); }
    1352      catch(java.io.IOException e) { return curPos; }
    1353   }
    1354}
    1355static final int[] jjnextStates = {
    1356   29, 30, 31, 36, 37, 40, 41, 16, 45, 52, 12, 13, 16, 19, 20, 22,
    1357   24, 32, 33, 16, 40, 41, 16, 46, 47, 49, 51, 14, 15, 34, 35, 38,
    1358   39, 42, 43, 13, 20, 3, 4, 6, 8, 14, 15, 17, 19,
    1359};
    1360public static final String[] jjstrLiteralImages = {
    1361"", null, null, null, null, null, null, null, null, null, null, null, null,
    1362null, null, null, null, null, null, null, null, null, null, null, null, "\41", null,
    1363null, null, null, null, null, null, null, null, null, null, null, null, "\72",
    1364"\73", "\56", "\174", "\54", "\173", "\175", "\50", "\51", "\75", "\75\75", "\72\53",
    1365null, null, null, null, null, null, null, "\55\55\76", };
    1366public static final String[] lexStateNames = {
    1367   "DEFAULT",
    1368   "IN_PHASES",
    1369   "PHASES_WITHIN_COMMENT",
    1370   "IN_STRING",
    1371   "WITHIN_COMMENT",
    1372};
    1373public static final int[] jjnewLexState = {
    1374   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 1, -1, -1, -1, -1, 2, -1, 1, -1, -1, -1, -1, -1, -1,
    1375   -1, -1, -1, 3, -1, -1, -1, -1, -1, 0, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
    1376   -1, -1, -1, -1, 4, -1, 0, -1, -1,
    1377};
    1378static final long[] jjtoToken = {
    1379   0x607ffbc0ff81c01L,
    1380};
    1381static final long[] jjtoSkip = {
    1382   0x17800000005e000L,
    1383};
    1384static final long[] jjtoSpecial = {
    1385   0x17800000005e000L,
    1386};
    1387static final long[] jjtoMore = {
    1388   0x800003f0020000L,
    1389};
    1390private ASCII_CharStream input_stream;
    1391private final int[] jjrounds = new int[53];
    1392private final int[] jjstateSet = new int[106];
    1393StringBuffer image;
    1394int jjimageLen;
    1395int lengthOfMatch;
    1396protected char curChar;
    1397public ParseCpslTokenManager(ASCII_CharStream stream)
    1398{
    1399   if (ASCII_CharStream.staticFlag)
    1400      throw new Error("ERROR: Cannot use a static CharStream class with a non-static lexical analyzer.");
    1401   input_stream = stream;
    1402}
    1403public ParseCpslTokenManager(ASCII_CharStream stream, int lexState)
    1404{
    1405   this(stream);
    1406   SwitchTo(lexState);
    1407}
    1408public void ReInit(ASCII_CharStream stream)
    1409{
    1410   jjmatchedPos = jjnewStateCnt = 0;
    1411   curLexState = defaultLexState;
    1412   input_stream = stream;
    1413   ReInitRounds();
    1414}
    1415private final void ReInitRounds()
    1416{
    1417   int i;
    1418   jjround = 0x80000001;
    1419   for (i = 53; i-- > 0;)
    1420      jjrounds[i] = 0x80000000;
    1421}
    1422public void ReInit(ASCII_CharStream stream, int lexState)
    1423{
    1424   ReInit(stream);
    1425   SwitchTo(lexState);
    1426}
    1427public void SwitchTo(int lexState)
    1428{
    1429   if (lexState >= 5 || lexState < 0)
    1430      throw new TokenMgrError("Error: Ignoring invalid lexical state : " + lexState + ". State unchanged.", TokenMgrError.INVALID_LEXICAL_STATE);
    1431   else
    1432      curLexState = lexState;
    1433}
    1434
    1435private final Token jjFillToken()
    1436{
    1437   Token t = Token.newToken(jjmatchedKind);
    1438   t.kind = jjmatchedKind;
    1439   String im = jjstrLiteralImages[jjmatchedKind];
    1440   t.image = (im == null) ? input_stream.GetImage() : im;
    1441   t.beginLine = input_stream.getBeginLine();
    1442   t.beginColumn = input_stream.getBeginColumn();
    1443   t.endLine = input_stream.getEndLine();
    1444   t.endColumn = input_stream.getEndColumn();
    1445   return t;
    1446}
    1447
    1448int curLexState = 0;
    1449int defaultLexState = 0;
    1450int jjnewStateCnt;
    1451int jjround;
    1452int jjmatchedPos;
    1453int jjmatchedKind;
    1454
    1455public final Token getNextToken()
    1456{
    1457  int kind;
    1458  Token specialToken = null;
    1459  Token matchedToken;
    1460  int curPos = 0;
    1461
    1462  EOFLoop :
    1463  for (;;)
    1464  {
    1465   try
    1466   {
    1467      curChar = input_stream.BeginToken();
    1468   }
    1469   catch(java.io.IOException e)
    1470   {
    1471      jjmatchedKind = 0;
    1472      matchedToken = jjFillToken();
    1473      matchedToken.specialToken = specialToken;
    1474      return matchedToken;
    1475   }
    1476   image = null;
    1477   jjimageLen = 0;
    1478
    1479   for (;;)
    1480   {
    1481     switch(curLexState)
    1482     {
    1483       case 0:
    1484         jjmatchedKind = 0x7fffffff;
    1485         jjmatchedPos = 0;
    1486         curPos = jjMoveStringLiteralDfa0_0();
    1487         if (jjmatchedPos == 0 && jjmatchedKind > 57)
    1488         {
    1489            jjmatchedKind = 57;
    1490         }
    1491         break;
    1492       case 1:
    1493         jjmatchedKind = 0x7fffffff;
    1494         jjmatchedPos = 0;
    1495         curPos = jjMoveStringLiteralDfa0_1();
    1496         break;
    1497       case 2:
    1498         jjmatchedKind = 0x7fffffff;
    1499         jjmatchedPos = 0;
    1500         curPos = jjMoveStringLiteralDfa0_2();
    1501         if (jjmatchedPos == 0 && jjmatchedKind > 17)
    1502         {
    1503            jjmatchedKind = 17;
    1504         }
    1505         break;
    1506       case 3:
    1507         jjmatchedKind = 0x7fffffff;
    1508         jjmatchedPos = 0;
    1509         curPos = jjMoveStringLiteralDfa0_3();
    1510         break;
    1511       case 4:
    1512         jjmatchedKind = 0x7fffffff;
    1513         jjmatchedPos = 0;
    1514         curPos = jjMoveStringLiteralDfa0_4();
    1515         if (jjmatchedPos == 0 && jjmatchedKind > 55)
    1516         {
    1517            jjmatchedKind = 55;
    1518         }
    1519         break;
    1520     }
    1521     if (jjmatchedKind != 0x7fffffff)
    1522     {
    1523        if (jjmatchedPos + 1 < curPos)
    1524           input_stream.backup(curPos - jjmatchedPos - 1);
    1525        if ((jjtoToken[jjmatchedKind >> 6] & (1L << (jjmatchedKind & 077))) != 0L)
    1526        {
    1527           matchedToken = jjFillToken();
    1528           matchedToken.specialToken = specialToken;
    1529           TokenLexicalActions(matchedToken);
    1530       if (jjnewLexState[jjmatchedKind] != -1)
    1531         curLexState = jjnewLexState[jjmatchedKind];
    1532           return matchedToken;
    1533        }
    1534        else if ((jjtoSkip[jjmatchedKind >> 6] & (1L << (jjmatchedKind & 077))) != 0L)
    1535        {
    1536           if ((jjtoSpecial[jjmatchedKind >> 6] & (1L << (jjmatchedKind & 077))) != 0L)
    1537           {
    1538              matchedToken = jjFillToken();
    1539              if (specialToken == null)
    1540                 specialToken = matchedToken;
    1541              else
    1542              {
    1543                 matchedToken.specialToken = specialToken;
    1544                 specialToken = (specialToken.next = matchedToken);
    1545              }
    1546              SkipLexicalActions(matchedToken);
    1547           }
    1548           else
    1549              SkipLexicalActions(null);
    1550         if (jjnewLexState[jjmatchedKind] != -1)
    1551           curLexState = jjnewLexState[jjmatchedKind];
    1552           continue EOFLoop;
    1553        }
    1554        MoreLexicalActions();
    1555      if (jjnewLexState[jjmatchedKind] != -1)
    1556        curLexState = jjnewLexState[jjmatchedKind];
    1557        curPos = 0;
    1558        jjmatchedKind = 0x7fffffff;
    1559        try {
    1560           curChar = input_stream.readChar();
    1561           continue;
    1562        }
    1563        catch (java.io.IOException e1) { }
    1564     }
    1565     int error_line = input_stream.getEndLine();
    1566     int error_column = input_stream.getEndColumn();
    1567     String error_after = null;
    1568     boolean EOFSeen = false;
    1569     try { input_stream.readChar(); input_stream.backup(1); }
    1570     catch (java.io.IOException e1) {
    1571        EOFSeen = true;
    1572        error_after = curPos <= 1 ? "" : input_stream.GetImage();
    1573        if (curChar == '\n' || curChar == '\r') {
    1574           error_line++;
    1575           error_column = 0;
    1576        }
    1577        else
    1578           error_column++;
    1579     }
    1580     if (!EOFSeen) {
    1581        input_stream.backup(1);
    1582        error_after = curPos <= 1 ? "" : input_stream.GetImage();
    1583     }
    1584     throw new TokenMgrError(EOFSeen, curLexState, error_line, error_column, error_after, curChar, TokenMgrError.LEXICAL_ERROR);
    1585   }
    1586  }
    1587}
    1588
    1589final void SkipLexicalActions(Token matchedToken)
    1590{
    1591   switch(jjmatchedKind)
    1592   {
    1593      default :
    1594         break;
    1595   }
    1596}
    1597final void MoreLexicalActions()
    1598{
    1599   jjimageLen += (lengthOfMatch = jjmatchedPos + 1);
    1600   switch(jjmatchedKind)
    1601   {
    1602      case 29 :
    1603         if (image == null)
    1604              image = new StringBuffer(new String(input_stream.GetSuffix(jjimageLen)));
    1605         else
    1606            image.append(new String(input_stream.GetSuffix(jjimageLen)));
    1607         jjimageLen = 0;
    1608               image.setLength(image.length() - 2); image.append("\n");
    1609         break;
    1610      case 30 :
    1611         if (image == null)
    1612              image = new StringBuffer(new String(input_stream.GetSuffix(jjimageLen)));
    1613         else
    1614            image.append(new String(input_stream.GetSuffix(jjimageLen)));
    1615         jjimageLen = 0;
    1616               image.setLength(image.length() - 2); image.append("\r");
    1617         break;
    1618      case 31 :
    1619         if (image == null)
    1620              image = new StringBuffer(new String(input_stream.GetSuffix(jjimageLen)));
    1621         else
    1622            image.append(new String(input_stream.GetSuffix(jjimageLen)));
    1623         jjimageLen = 0;
    1624               image.setLength(image.length() - 2); image.append("\t");
    1625         break;
    1626      case 32 :
    1627         if (image == null)
    1628              image = new StringBuffer(new String(input_stream.GetSuffix(jjimageLen)));
    1629         else
    1630            image.append(new String(input_stream.GetSuffix(jjimageLen)));
    1631         jjimageLen = 0;
    1632                image.setLength(image.length() - 2); image.append("\"");
    1633         break;
    1634      default :
    1635         break;
    1636   }
    1637}
    1638final void TokenLexicalActions(Token matchedToken)
    1639{
    1640   switch(jjmatchedKind)
    1641   {
    1642      case 34 :
    1643        if (image == null)
    1644            image = new StringBuffer(new String(input_stream.GetSuffix(jjimageLen + (lengthOfMatch = jjmatchedPos + 1))));
    1645         else
    1646            image.append(new String(input_stream.GetSuffix(jjimageLen + (lengthOfMatch = jjmatchedPos + 1))));
    1647        // image.setLength(image.length() - 1);
    1648         matchedToken.image = image.toString();
    1649         break;
    1650      default :
    1651         break;
    1652   }
    1653}
    1654}
    1655

| ParseCpslTokenManager |