View Javadoc

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