View Javadoc

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