View Javadoc

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