View Javadoc

    1   /* Generated By:JJTree&JavaCC: Do not edit this line. JavaParserTokenManager.java */
    2   package net.sourceforge.pmd.lang.java.ast;
    3   import java.util.*;
    4   import net.sourceforge.pmd.PMD;
    5   import net.sourceforge.pmd.lang.ast.CharStream;
    6   import net.sourceforge.pmd.lang.ast.TokenMgrError;
    7
    8   /** Token Manager. */
    9   public class JavaParserTokenManager extends net.sourceforge.pmd.lang.ast.AbstractTokenManager implements JavaParserConstants
    10  {
    11      protected List<Comment> comments = new ArrayList<Comment>();
    12
    13    /** Debug output. */
    14    public  java.io.PrintStream debugStream = System.out;
    15    /** Set debug output. */
    16    public  void setDebugStream(java.io.PrintStream ds) { debugStream = ds; }
    17  private final int jjStopStringLiteralDfa_0(int pos, long active0, long active1)
    18  {
    19     switch (pos)
    20     {
    21        case 0:
    22           if ((active0 & 0x100L) != 0L || (active1 & 0x1008000000000L) != 0L)
    23              return 31;
    24           if ((active1 & 0x100000000100000L) != 0L)
    25              return 1;
    26           if ((active0 & 0x7ffffffffffff000L) != 0L)
    27           {
    28              jjmatchedKind = 73;
    29              return 29;
    30           }
    31           return -1;
    32        case 1:
    33           if ((active0 & 0x7ffffffdfe7ff000L) != 0L)
    34           {
    35              if (jjmatchedPos != 1)
    36              {
    37                 jjmatchedKind = 73;
    38                 jjmatchedPos = 1;
    39              }
    40              return 29;
    41           }
    42           if ((active0 & 0x100L) != 0L)
    43              return 36;
    44           if ((active0 & 0x201800000L) != 0L)
    45              return 29;
    46           return -1;
    47        case 2:
    48           if ((active0 & 0x7bfffd9d7f7ff000L) != 0L)
    49           {
    50              if (jjmatchedPos != 2)
    51              {
    52                 jjmatchedKind = 73;
    53                 jjmatchedPos = 2;
    54              }
    55              return 29;
    56           }
    57           if ((active0 & 0x400026080000000L) != 0L)
    58              return 29;
    59           return -1;
    60        case 3:
    61           if ((active0 & 0x71dff95c7d7a7000L) != 0L)
    62           {
    63              jjmatchedKind = 73;
    64              jjmatchedPos = 3;
    65              return 29;
    66           }
    67           if ((active0 & 0xa20048102058000L) != 0L)
    68              return 29;
    69           return -1;
    70        case 4:
    71           if ((active0 & 0x20c50000781a4000L) != 0L)
    72              return 29;
    73           if ((active0 & 0x511af95c05603000L) != 0L)
    74           {
    75              if (jjmatchedPos != 4)
    76              {
    77                 jjmatchedKind = 73;
    78                 jjmatchedPos = 4;
    79              }
    80              return 29;
    81           }
    82           return -1;
    83        case 5:
    84           if ((active0 & 0x5110385424603000L) != 0L)
    85           {
    86              jjmatchedKind = 73;
    87              jjmatchedPos = 5;
    88              return 29;
    89           }
    90           if ((active0 & 0x8ac10801000000L) != 0L)
    91              return 29;
    92           return -1;
    93        case 6:
    94           if ((active0 & 0x5110205400201000L) != 0L)
    95           {
    96              jjmatchedKind = 73;
    97              jjmatchedPos = 6;
    98              return 29;
    99           }
    100          if ((active0 & 0x180024402000L) != 0L)
    101             return 29;
    102          return -1;
    103       case 7:
    104          if ((active0 & 0x5000000000201000L) != 0L)
    105             return 29;
    106          if ((active0 & 0x110205400000000L) != 0L)
    107          {
    108             jjmatchedKind = 73;
    109             jjmatchedPos = 7;
    110             return 29;
    111          }
    112          return -1;
    113       case 8:
    114          if ((active0 & 0x10001400000000L) != 0L)
    115          {
    116             jjmatchedKind = 73;
    117             jjmatchedPos = 8;
    118             return 29;
    119          }
    120          if ((active0 & 0x100204000000000L) != 0L)
    121             return 29;
    122          return -1;
    123       case 9:
    124          if ((active0 & 0x10000000000000L) != 0L)
    125          {
    126             jjmatchedKind = 73;
    127             jjmatchedPos = 9;
    128             return 29;
    129          }
    130          if ((active0 & 0x1400000000L) != 0L)
    131             return 29;
    132          return -1;
    133       case 10:
    134          if ((active0 & 0x10000000000000L) != 0L)
    135          {
    136             jjmatchedKind = 73;
    137             jjmatchedPos = 10;
    138             return 29;
    139          }
    140          return -1;
    141       default :
    142          return -1;
    143    }
    144 }
    145 private final int jjStartNfa_0(int pos, long active0, long active1)
    146 {
    147    return jjMoveNfa_0(jjStopStringLiteralDfa_0(pos, active0, active1), pos + 1);
    148 }
    149 private int jjStopAtPos(int pos, int kind)
    150 {
    151    jjmatchedKind = kind;
    152    jjmatchedPos = pos;
    153    return pos + 1;
    154 }
    155 private int jjMoveStringLiteralDfa0_0()
    156 {
    157    switch(curChar)
    158    {
    159       case 9:
    160          return jjStopAtPos(0, 2);
    161       case 10:
    162          return jjStopAtPos(0, 3);
    163       case 12:
    164          return jjStopAtPos(0, 5);
    165       case 13:
    166          return jjStopAtPos(0, 4);
    167       case 26:
    168          return jjStopAtPos(0, 124);
    169       case 32:
    170          return jjStopAtPos(0, 1);
    171       case 33:
    172          jjmatchedKind = 88;
    173          return jjMoveStringLiteralDfa1_0(0x0L, 0x80000000L);
    174       case 37:
    175          jjmatchedKind = 107;
    176          return jjMoveStringLiteralDfa1_0(0x0L, 0x10000000000000L);
    177       case 38:
    178          jjmatchedKind = 104;
    179          return jjMoveStringLiteralDfa1_0(0x0L, 0x2000200000000L);
    180       case 40:
    181          return jjStopAtPos(0, 76);
    182       case 41:
    183          return jjStopAtPos(0, 77);
    184       case 42:
    185          jjmatchedKind = 102;
    186          return jjMoveStringLiteralDfa1_0(0x0L, 0x800000000000L);
    187       case 43:
    188          jjmatchedKind = 100;
    189          return jjMoveStringLiteralDfa1_0(0x0L, 0x200400000000L);
    190       case 44:
    191          return jjStopAtPos(0, 83);
    192       case 45:
    193          jjmatchedKind = 101;
    194          return jjMoveStringLiteralDfa1_0(0x0L, 0x400800000000L);
    195       case 46:
    196          jjmatchedKind = 84;
    197          return jjMoveStringLiteralDfa1_0(0x0L, 0x100000000000000L);
    198       case 47:
    199          jjmatchedKind = 103;
    200          return jjMoveStringLiteralDfa1_0(0x100L, 0x1000000000000L);
    201       case 58:
    202          return jjStopAtPos(0, 91);
    203       case 59:
    204          return jjStopAtPos(0, 82);
    205       case 60:
    206          jjmatchedKind = 87;
    207          return jjMoveStringLiteralDfa1_0(0x0L, 0x20100020000000L);
    208       case 61:
    209          jjmatchedKind = 86;
    210          return jjMoveStringLiteralDfa1_0(0x0L, 0x10000000L);
    211       case 62:
    212          jjmatchedKind = 123;
    213          return jjMoveStringLiteralDfa1_0(0x0L, 0x6c0000040000000L);
    214       case 63:
    215          return jjStopAtPos(0, 90);
    216       case 64:
    217          return jjStopAtPos(0, 85);
    218       case 91:
    219          return jjStopAtPos(0, 80);
    220       case 93:
    221          return jjStopAtPos(0, 81);
    222       case 94:
    223          jjmatchedKind = 106;
    224          return jjMoveStringLiteralDfa1_0(0x0L, 0x8000000000000L);
    225       case 97:
    226          return jjMoveStringLiteralDfa1_0(0x1000L, 0x0L);
    227       case 98:
    228          return jjMoveStringLiteralDfa1_0(0xe000L, 0x0L);
    229       case 99:
    230          return jjMoveStringLiteralDfa1_0(0x3f0000L, 0x0L);
    231       case 100:
    232          return jjMoveStringLiteralDfa1_0(0x1c00000L, 0x0L);
    233       case 101:
    234          return jjMoveStringLiteralDfa1_0(0x6000000L, 0x0L);
    235       case 102:
    236          return jjMoveStringLiteralDfa1_0(0xf8000000L, 0x0L);
    237       case 103:
    238          return jjMoveStringLiteralDfa1_0(0x100000000L, 0x0L);
    239       case 105:
    240          return jjMoveStringLiteralDfa1_0(0x7e00000000L, 0x0L);
    241       case 108:
    242          return jjMoveStringLiteralDfa1_0(0x8000000000L, 0x0L);
    243       case 110:
    244          return jjMoveStringLiteralDfa1_0(0x70000000000L, 0x0L);
    245       case 112:
    246          return jjMoveStringLiteralDfa1_0(0x780000000000L, 0x0L);
    247       case 114:
    248          return jjMoveStringLiteralDfa1_0(0x800000000000L, 0x0L);
    249       case 115:
    250          return jjMoveStringLiteralDfa1_0(0x401f000000000000L, 0x0L);
    251       case 116:
    252          return jjMoveStringLiteralDfa1_0(0x7e0000000000000L, 0x0L);
    253       case 118:
    254          return jjMoveStringLiteralDfa1_0(0x1800000000000000L, 0x0L);
    255       case 119:
    256          return jjMoveStringLiteralDfa1_0(0x2000000000000000L, 0x0L);
    257       case 123:
    258          return jjStopAtPos(0, 78);
    259       case 124:
    260          jjmatchedKind = 105;
    261          return jjMoveStringLiteralDfa1_0(0x0L, 0x4000100000000L);
    262       case 125:
    263          return jjStopAtPos(0, 79);
    264       case 126:
    265          jjmatchedKind = 89;
    266          return jjMoveStringLiteralDfa1_0(0x0L, 0x2000000000000000L);
    267       default :
    268          return jjMoveNfa_0(0, 0);
    269    }
    270 }
    271 private int jjMoveStringLiteralDfa1_0(long active0, long active1)
    272 {
    273    try { curChar = input_stream.readChar(); }
    274    catch(java.io.IOException e) {
    275       jjStopStringLiteralDfa_0(0, active0, active1);
    276       return 1;
    277    }
    278    switch(curChar)
    279    {
    280       case 38:
    281          if ((active1 & 0x200000000L) != 0L)
    282             return jjStopAtPos(1, 97);
    283          break;
    284       case 42:
    285          if ((active0 & 0x100L) != 0L)
    286             return jjStartNfaWithStates_0(1, 8, 36);
    287          break;
    288       case 43:
    289          if ((active1 & 0x400000000L) != 0L)
    290             return jjStopAtPos(1, 98);
    291          break;
    292       case 45:
    293          if ((active1 & 0x800000000L) != 0L)
    294             return jjStopAtPos(1, 99);
    295          break;
    296       case 46:
    297          return jjMoveStringLiteralDfa2_0(active0, 0L, active1, 0x100000000000000L);
    298       case 60:
    299          if ((active1 & 0x100000000000L) != 0L)
    300          {
    301             jjmatchedKind = 108;
    302             jjmatchedPos = 1;
    303          }
    304          return jjMoveStringLiteralDfa2_0(active0, 0L, active1, 0x20000000000000L);
    305       case 61:
    306          if ((active1 & 0x10000000L) != 0L)
    307             return jjStopAtPos(1, 92);
    308          else if ((active1 & 0x20000000L) != 0L)
    309             return jjStopAtPos(1, 93);
    310          else if ((active1 & 0x40000000L) != 0L)
    311             return jjStopAtPos(1, 94);
    312          else if ((active1 & 0x80000000L) != 0L)
    313             return jjStopAtPos(1, 95);
    314          else if ((active1 & 0x200000000000L) != 0L)
    315             return jjStopAtPos(1, 109);
    316          else if ((active1 & 0x400000000000L) != 0L)
    317             return jjStopAtPos(1, 110);
    318          else if ((active1 & 0x800000000000L) != 0L)
    319             return jjStopAtPos(1, 111);
    320          else if ((active1 & 0x1000000000000L) != 0L)
    321             return jjStopAtPos(1, 112);
    322          else if ((active1 & 0x2000000000000L) != 0L)
    323             return jjStopAtPos(1, 113);
    324          else if ((active1 & 0x4000000000000L) != 0L)
    325             return jjStopAtPos(1, 114);
    326          else if ((active1 & 0x8000000000000L) != 0L)
    327             return jjStopAtPos(1, 115);
    328          else if ((active1 & 0x10000000000000L) != 0L)
    329             return jjStopAtPos(1, 116);
    330          break;
    331       case 62:
    332          if ((active1 & 0x400000000000000L) != 0L)
    333          {
    334             jjmatchedKind = 122;
    335             jjmatchedPos = 1;
    336          }
    337          return jjMoveStringLiteralDfa2_0(active0, 0L, active1, 0x2c0000000000000L);
    338       case 91:
    339          return jjMoveStringLiteralDfa2_0(active0, 0L, active1, 0x2000000000000000L);
    340       case 97:
    341          return jjMoveStringLiteralDfa2_0(active0, 0x90008030000L, active1, 0L);
    342       case 98:
    343          return jjMoveStringLiteralDfa2_0(active0, 0x1000L, active1, 0L);
    344       case 101:
    345          return jjMoveStringLiteralDfa2_0(active0, 0x820000400000L, active1, 0L);
    346       case 102:
    347          if ((active0 & 0x200000000L) != 0L)
    348             return jjStartNfaWithStates_0(1, 33, 29);
    349          break;
    350       case 104:
    351          return jjMoveStringLiteralDfa2_0(active0, 0x20e1000000040000L, active1, 0L);
    352       case 105:
    353          return jjMoveStringLiteralDfa2_0(active0, 0x30000000L, active1, 0L);
    354       case 108:
    355          return jjMoveStringLiteralDfa2_0(active0, 0x42080000L, active1, 0L);
    356       case 109:
    357          return jjMoveStringLiteralDfa2_0(active0, 0xc00000000L, active1, 0L);
    358       case 110:
    359          return jjMoveStringLiteralDfa2_0(active0, 0x7000000000L, active1, 0L);
    360       case 111:
    361          if ((active0 & 0x800000L) != 0L)
    362          {
    363             jjmatchedKind = 23;
    364             jjmatchedPos = 1;
    365          }
    366          return jjMoveStringLiteralDfa2_0(active0, 0x1800008181302000L, active1, 0L);
    367       case 114:
    368          return jjMoveStringLiteralDfa2_0(active0, 0x700300000004000L, active1, 0L);
    369       case 116:
    370          return jjMoveStringLiteralDfa2_0(active0, 0x4002000000000000L, active1, 0L);
    371       case 117:
    372          return jjMoveStringLiteralDfa2_0(active0, 0x4440000000000L, active1, 0L);
    373       case 119:
    374          return jjMoveStringLiteralDfa2_0(active0, 0x8000000000000L, active1, 0L);
    375       case 120:
    376          return jjMoveStringLiteralDfa2_0(active0, 0x4000000L, active1, 0L);
    377       case 121:
    378          return jjMoveStringLiteralDfa2_0(active0, 0x10000000008000L, active1, 0L);
    379       case 124:
    380          if ((active1 & 0x100000000L) != 0L)
    381             return jjStopAtPos(1, 96);
    382          break;
    383       default :
    384          break;
    385    }
    386    return jjStartNfa_0(0, active0, active1);
    387 }
    388 private int jjMoveStringLiteralDfa2_0(long old0, long active0, long old1, long active1)
    389 {
    390    if (((active0 &= old0) | (active1 &= old1)) == 0L)
    391       return jjStartNfa_0(0, old0, old1);
    392    try { curChar = input_stream.readChar(); }
    393    catch(java.io.IOException e) {
    394       jjStopStringLiteralDfa_0(1, active0, active1);
    395       return 2;
    396    }
    397    switch(curChar)
    398    {
    399       case 46:
    400          if ((active1 & 0x100000000000000L) != 0L)
    401             return jjStopAtPos(2, 120);
    402          break;
    403       case 61:
    404          if ((active1 & 0x20000000000000L) != 0L)
    405             return jjStopAtPos(2, 117);
    406          else if ((active1 & 0x40000000000000L) != 0L)
    407             return jjStopAtPos(2, 118);
    408          break;
    409       case 62:
    410          if ((active1 & 0x200000000000000L) != 0L)
    411          {
    412             jjmatchedKind = 121;
    413             jjmatchedPos = 2;
    414          }
    415          return jjMoveStringLiteralDfa3_0(active0, 0L, active1, 0x80000000000000L);
    416       case 93:
    417          if ((active1 & 0x2000000000000000L) != 0L)
    418             return jjStopAtPos(2, 125);
    419          break;
    420       case 97:
    421          return jjMoveStringLiteralDfa3_0(active0, 0x1020000000c0000L, active1, 0L);
    422       case 98:
    423          return jjMoveStringLiteralDfa3_0(active0, 0x400000000000L, active1, 0L);
    424       case 99:
    425          return jjMoveStringLiteralDfa3_0(active0, 0x80000000000L, active1, 0L);
    426       case 101:
    427          return jjMoveStringLiteralDfa3_0(active0, 0x4000L, active1, 0L);
    428       case 102:
    429          return jjMoveStringLiteralDfa3_0(active0, 0x400000L, active1, 0L);
    430       case 105:
    431          return jjMoveStringLiteralDfa3_0(active0, 0x2828100000000000L, active1, 0L);
    432       case 108:
    433          return jjMoveStringLiteralDfa3_0(active0, 0x1000040008000000L, active1, 0L);
    434       case 110:
    435          return jjMoveStringLiteralDfa3_0(active0, 0x10008030300000L, active1, 0L);
    436       case 111:
    437          return jjMoveStringLiteralDfa3_0(active0, 0x1200040002000L, active1, 0L);
    438       case 112:
    439          return jjMoveStringLiteralDfa3_0(active0, 0x4000c00000000L, active1, 0L);
    440       case 114:
    441          if ((active0 & 0x80000000L) != 0L)
    442             return jjStartNfaWithStates_0(2, 31, 29);
    443          return jjMoveStringLiteralDfa3_0(active0, 0x40c0000000000000L, active1, 0L);
    444       case 115:
    445          return jjMoveStringLiteralDfa3_0(active0, 0x1002011000L, active1, 0L);
    446       case 116:
    447          if ((active0 & 0x2000000000L) != 0L)
    448          {
    449             jjmatchedKind = 37;
    450             jjmatchedPos = 2;
    451          }
    452          return jjMoveStringLiteralDfa3_0(active0, 0x814104028000L, active1, 0L);
    453       case 117:
    454          return jjMoveStringLiteralDfa3_0(active0, 0x200000001000000L, active1, 0L);
    455       case 119:
    456          if ((active0 & 0x20000000000L) != 0L)
    457             return jjStartNfaWithStates_0(2, 41, 29);
    458          break;
    459       case 121:
    460          if ((active0 & 0x400000000000000L) != 0L)
    461             return jjStartNfaWithStates_0(2, 58, 29);
    462          break;
    463       default :
    464          break;
    465    }
    466    return jjStartNfa_0(1, active0, active1);
    467 }
    468 private int jjMoveStringLiteralDfa3_0(long old0, long active0, long old1, long active1)
    469 {
    470    if (((active0 &= old0) | (active1 &= old1)) == 0L)
    471       return jjStartNfa_0(1, old0, old1);
    472    try { curChar = input_stream.readChar(); }
    473    catch(java.io.IOException e) {
    474       jjStopStringLiteralDfa_0(2, active0, active1);
    475       return 3;
    476    }
    477    switch(curChar)
    478    {
    479       case 61:
    480          if ((active1 & 0x80000000000000L) != 0L)
    481             return jjStopAtPos(3, 119);
    482          break;
    483       case 97:
    484          return jjMoveStringLiteralDfa4_0(active0, 0x1000000070404000L, active1, 0L);
    485       case 98:
    486          return jjMoveStringLiteralDfa4_0(active0, 0x1000000L, active1, 0L);
    487       case 99:
    488          return jjMoveStringLiteralDfa4_0(active0, 0x10000000020000L, active1, 0L);
    489       case 100:
    490          if ((active0 & 0x800000000000000L) != 0L)
    491             return jjStartNfaWithStates_0(3, 59, 29);
    492          break;
    493       case 101:
    494          if ((active0 & 0x8000L) != 0L)
    495             return jjStartNfaWithStates_0(3, 15, 29);
    496          else if ((active0 & 0x10000L) != 0L)
    497             return jjStartNfaWithStates_0(3, 16, 29);
    498          else if ((active0 & 0x2000000L) != 0L)
    499             return jjStartNfaWithStates_0(3, 25, 29);
    500          else if ((active0 & 0x200000000000000L) != 0L)
    501             return jjStartNfaWithStates_0(3, 57, 29);
    502          return jjMoveStringLiteralDfa4_0(active0, 0x4004004000000L, active1, 0L);
    503       case 103:
    504          if ((active0 & 0x8000000000L) != 0L)
    505             return jjStartNfaWithStates_0(3, 39, 29);
    506          break;
    507       case 105:
    508          return jjMoveStringLiteralDfa4_0(active0, 0x4000010000000000L, active1, 0L);
    509       case 107:
    510          return jjMoveStringLiteralDfa4_0(active0, 0x80000000000L, active1, 0L);
    511       case 108:
    512          if ((active0 & 0x40000000000L) != 0L)
    513             return jjStartNfaWithStates_0(3, 42, 29);
    514          return jjMoveStringLiteralDfa4_0(active0, 0x2000400400002000L, active1, 0L);
    515       case 110:
    516          return jjMoveStringLiteralDfa4_0(active0, 0x100000000000000L, active1, 0L);
    517       case 111:
    518          if ((active0 & 0x100000000L) != 0L)
    519             return jjStartNfaWithStates_0(3, 32, 29);
    520          return jjMoveStringLiteralDfa4_0(active0, 0xc0000800000000L, active1, 0L);
    521       case 114:
    522          if ((active0 & 0x40000L) != 0L)
    523             return jjStartNfaWithStates_0(3, 18, 29);
    524          return jjMoveStringLiteralDfa4_0(active0, 0x1000000000000L, active1, 0L);
    525       case 115:
    526          if ((active0 & 0x20000000000000L) != 0L)
    527             return jjStartNfaWithStates_0(3, 53, 29);
    528          return jjMoveStringLiteralDfa4_0(active0, 0x8180000L, active1, 0L);
    529       case 116:
    530          return jjMoveStringLiteralDfa4_0(active0, 0xa201000201000L, active1, 0L);
    531       case 117:
    532          return jjMoveStringLiteralDfa4_0(active0, 0x800000000000L, active1, 0L);
    533       case 118:
    534          return jjMoveStringLiteralDfa4_0(active0, 0x100000000000L, active1, 0L);
    535       default :
    536          break;
    537    }
    538    return jjStartNfa_0(2, active0, active1);
    539 }
    540 private int jjMoveStringLiteralDfa4_0(long old0, long active0, long old1, long active1)
    541 {
    542    if (((active0 &= old0) | (active1 &= old1)) == 0L)
    543       return jjStartNfa_0(2, old0, old1);
    544    try { curChar = input_stream.readChar(); }
    545    catch(java.io.IOException e) {
    546       jjStopStringLiteralDfa_0(3, active0, 0L);
    547       return 4;
    548    }
    549    switch(curChar)
    550    {
    551       case 97:
    552          return jjMoveStringLiteralDfa5_0(active0, 0x181000000000L);
    553       case 99:
    554          return jjMoveStringLiteralDfa5_0(active0, 0x4008000000000000L);
    555       case 101:
    556          if ((active0 & 0x8000000L) != 0L)
    557             return jjStartNfaWithStates_0(4, 27, 29);
    558          else if ((active0 & 0x2000000000000000L) != 0L)
    559             return jjStartNfaWithStates_0(4, 61, 29);
    560          return jjMoveStringLiteralDfa5_0(active0, 0x200400002000L);
    561       case 104:
    562          if ((active0 & 0x20000L) != 0L)
    563             return jjStartNfaWithStates_0(4, 17, 29);
    564          return jjMoveStringLiteralDfa5_0(active0, 0x10000000000000L);
    565       case 105:
    566          return jjMoveStringLiteralDfa5_0(active0, 0x2400000200000L);
    567       case 107:
    568          if ((active0 & 0x4000L) != 0L)
    569             return jjStartNfaWithStates_0(4, 14, 29);
    570          break;
    571       case 108:
    572          if ((active0 & 0x10000000L) != 0L)
    573          {
    574             jjmatchedKind = 28;
    575             jjmatchedPos = 4;
    576          }
    577          return jjMoveStringLiteralDfa5_0(active0, 0x21000000L);
    578       case 110:
    579          return jjMoveStringLiteralDfa5_0(active0, 0x4000000L);
    580       case 114:
    581          if ((active0 & 0x4000000000000L) != 0L)
    582             return jjStartNfaWithStates_0(4, 50, 29);
    583          return jjMoveStringLiteralDfa5_0(active0, 0x804800001000L);
    584       case 115:
    585          if ((active0 & 0x80000L) != 0L)
    586             return jjStartNfaWithStates_0(4, 19, 29);
    587          return jjMoveStringLiteralDfa5_0(active0, 0x100000000000000L);
    588       case 116:
    589          if ((active0 & 0x100000L) != 0L)
    590             return jjStartNfaWithStates_0(4, 20, 29);
    591          else if ((active0 & 0x40000000L) != 0L)
    592             return jjStartNfaWithStates_0(4, 30, 29);
    593          else if ((active0 & 0x1000000000000L) != 0L)
    594             return jjStartNfaWithStates_0(4, 48, 29);
    595          return jjMoveStringLiteralDfa5_0(active0, 0x1000000000000000L);
    596       case 117:
    597          return jjMoveStringLiteralDfa5_0(active0, 0x400000L);
    598       case 118:
    599          return jjMoveStringLiteralDfa5_0(active0, 0x10000000000L);
    600       case 119:
    601          if ((active0 & 0x40000000000000L) != 0L)
    602          {
    603             jjmatchedKind = 54;
    604             jjmatchedPos = 4;
    605          }
    606          return jjMoveStringLiteralDfa5_0(active0, 0x80000000000000L);
    607       default :
    608          break;
    609    }
    610    return jjStartNfa_0(3, active0, 0L);
    611 }
    612 private int jjMoveStringLiteralDfa5_0(long old0, long active0)
    613 {
    614    if (((active0 &= old0)) == 0L)
    615       return jjStartNfa_0(3, old0, 0L);
    616    try { curChar = input_stream.readChar(); }
    617    catch(java.io.IOException e) {
    618       jjStopStringLiteralDfa_0(4, active0, 0L);
    619       return 5;
    620    }
    621    switch(curChar)
    622    {
    623       case 97:
    624          return jjMoveStringLiteralDfa6_0(active0, 0x3000L);
    625       case 99:
    626          if ((active0 & 0x400000000000L) != 0L)
    627             return jjStartNfaWithStates_0(5, 46, 29);
    628          else if ((active0 & 0x2000000000000L) != 0L)
    629             return jjStartNfaWithStates_0(5, 49, 29);
    630          return jjMoveStringLiteralDfa6_0(active0, 0x200000000000L);
    631       case 100:
    632          return jjMoveStringLiteralDfa6_0(active0, 0x4000000L);
    633       case 101:
    634          if ((active0 & 0x1000000L) != 0L)
    635             return jjStartNfaWithStates_0(5, 24, 29);
    636          else if ((active0 & 0x10000000000L) != 0L)
    637             return jjStartNfaWithStates_0(5, 40, 29);
    638          break;
    639       case 102:
    640          return jjMoveStringLiteralDfa6_0(active0, 0x4000000000L);
    641       case 103:
    642          return jjMoveStringLiteralDfa6_0(active0, 0x80000000000L);
    643       case 104:
    644          if ((active0 & 0x8000000000000L) != 0L)
    645             return jjStartNfaWithStates_0(5, 51, 29);
    646          break;
    647       case 105:
    648          return jjMoveStringLiteralDfa6_0(active0, 0x1100000000000000L);
    649       case 108:
    650          return jjMoveStringLiteralDfa6_0(active0, 0x20400000L);
    651       case 109:
    652          return jjMoveStringLiteralDfa6_0(active0, 0x400000000L);
    653       case 110:
    654          if ((active0 & 0x800000000000L) != 0L)
    655             return jjStartNfaWithStates_0(5, 47, 29);
    656          return jjMoveStringLiteralDfa6_0(active0, 0x1000200000L);
    657       case 114:
    658          return jjMoveStringLiteralDfa6_0(active0, 0x10000000000000L);
    659       case 115:
    660          if ((active0 & 0x80000000000000L) != 0L)
    661             return jjStartNfaWithStates_0(5, 55, 29);
    662          break;
    663       case 116:
    664          if ((active0 & 0x800000000L) != 0L)
    665             return jjStartNfaWithStates_0(5, 35, 29);
    666          return jjMoveStringLiteralDfa6_0(active0, 0x4000100000000000L);
    667       default :
    668          break;
    669    }
    670    return jjStartNfa_0(4, active0, 0L);
    671 }
    672 private int jjMoveStringLiteralDfa6_0(long old0, long active0)
    673 {
    674    if (((active0 &= old0)) == 0L)
    675       return jjStartNfa_0(4, old0, 0L);
    676    try { curChar = input_stream.readChar(); }
    677    catch(java.io.IOException e) {
    678       jjStopStringLiteralDfa_0(5, active0, 0L);
    679       return 6;
    680    }
    681    switch(curChar)
    682    {
    683       case 97:
    684          return jjMoveStringLiteralDfa7_0(active0, 0x4000000000L);
    685       case 99:
    686          return jjMoveStringLiteralDfa7_0(active0, 0x1000001000L);
    687       case 101:
    688          if ((active0 & 0x80000000000L) != 0L)
    689             return jjStartNfaWithStates_0(6, 43, 29);
    690          else if ((active0 & 0x100000000000L) != 0L)
    691             return jjStartNfaWithStates_0(6, 44, 29);
    692          return jjMoveStringLiteralDfa7_0(active0, 0x100000400000000L);
    693       case 102:
    694          return jjMoveStringLiteralDfa7_0(active0, 0x4000000000000000L);
    695       case 108:
    696          return jjMoveStringLiteralDfa7_0(active0, 0x1000000000000000L);
    697       case 110:
    698          if ((active0 & 0x2000L) != 0L)
    699             return jjStartNfaWithStates_0(6, 13, 29);
    700          break;
    701       case 111:
    702          return jjMoveStringLiteralDfa7_0(active0, 0x10000000000000L);
    703       case 115:
    704          if ((active0 & 0x4000000L) != 0L)
    705             return jjStartNfaWithStates_0(6, 26, 29);
    706          break;
    707       case 116:
    708          if ((active0 & 0x400000L) != 0L)
    709             return jjStartNfaWithStates_0(6, 22, 29);
    710          return jjMoveStringLiteralDfa7_0(active0, 0x200000000000L);
    711       case 117:
    712          return jjMoveStringLiteralDfa7_0(active0, 0x200000L);
    713       case 121:
    714          if ((active0 & 0x20000000L) != 0L)
    715             return jjStartNfaWithStates_0(6, 29, 29);
    716          break;
    717       default :
    718          break;
    719    }
    720    return jjStartNfa_0(5, active0, 0L);
    721 }
    722 private int jjMoveStringLiteralDfa7_0(long old0, long active0)
    723 {
    724    if (((active0 &= old0)) == 0L)
    725       return jjStartNfa_0(5, old0, 0L);
    726    try { curChar = input_stream.readChar(); }
    727    catch(java.io.IOException e) {
    728       jjStopStringLiteralDfa_0(6, active0, 0L);
    729       return 7;
    730    }
    731    switch(curChar)
    732    {
    733       case 99:
    734          return jjMoveStringLiteralDfa8_0(active0, 0x4000000000L);
    735       case 101:
    736          if ((active0 & 0x200000L) != 0L)
    737             return jjStartNfaWithStates_0(7, 21, 29);
    738          else if ((active0 & 0x1000000000000000L) != 0L)
    739             return jjStartNfaWithStates_0(7, 60, 29);
    740          return jjMoveStringLiteralDfa8_0(active0, 0x201000000000L);
    741       case 110:
    742          return jjMoveStringLiteralDfa8_0(active0, 0x110000400000000L);
    743       case 112:
    744          if ((active0 & 0x4000000000000000L) != 0L)
    745             return jjStartNfaWithStates_0(7, 62, 29);
    746          break;
    747       case 116:
    748          if ((active0 & 0x1000L) != 0L)
    749             return jjStartNfaWithStates_0(7, 12, 29);
    750          break;
    751       default :
    752          break;
    753    }
    754    return jjStartNfa_0(6, active0, 0L);
    755 }
    756 private int jjMoveStringLiteralDfa8_0(long old0, long active0)
    757 {
    758    if (((active0 &= old0)) == 0L)
    759       return jjStartNfa_0(6, old0, 0L);
    760    try { curChar = input_stream.readChar(); }
    761    catch(java.io.IOException e) {
    762       jjStopStringLiteralDfa_0(7, active0, 0L);
    763       return 8;
    764    }
    765    switch(curChar)
    766    {
    767       case 100:
    768          if ((active0 & 0x200000000000L) != 0L)
    769             return jjStartNfaWithStates_0(8, 45, 29);
    770          break;
    771       case 101:
    772          if ((active0 & 0x4000000000L) != 0L)
    773             return jjStartNfaWithStates_0(8, 38, 29);
    774          break;
    775       case 105:
    776          return jjMoveStringLiteralDfa9_0(active0, 0x10000000000000L);
    777       case 111:
    778          return jjMoveStringLiteralDfa9_0(active0, 0x1000000000L);
    779       case 116:
    780          if ((active0 & 0x100000000000000L) != 0L)
    781             return jjStartNfaWithStates_0(8, 56, 29);
    782          return jjMoveStringLiteralDfa9_0(active0, 0x400000000L);
    783       default :
    784          break;
    785    }
    786    return jjStartNfa_0(7, active0, 0L);
    787 }
    788 private int jjMoveStringLiteralDfa9_0(long old0, long active0)
    789 {
    790    if (((active0 &= old0)) == 0L)
    791       return jjStartNfa_0(7, old0, 0L);
    792    try { curChar = input_stream.readChar(); }
    793    catch(java.io.IOException e) {
    794       jjStopStringLiteralDfa_0(8, active0, 0L);
    795       return 9;
    796    }
    797    switch(curChar)
    798    {
    799       case 102:
    800          if ((active0 & 0x1000000000L) != 0L)
    801             return jjStartNfaWithStates_0(9, 36, 29);
    802          break;
    803       case 115:
    804          if ((active0 & 0x400000000L) != 0L)
    805             return jjStartNfaWithStates_0(9, 34, 29);
    806          break;
    807       case 122:
    808          return jjMoveStringLiteralDfa10_0(active0, 0x10000000000000L);
    809       default :
    810          break;
    811    }
    812    return jjStartNfa_0(8, active0, 0L);
    813 }
    814 private int jjMoveStringLiteralDfa10_0(long old0, long active0)
    815 {
    816    if (((active0 &= old0)) == 0L)
    817       return jjStartNfa_0(8, old0, 0L);
    818    try { curChar = input_stream.readChar(); }
    819    catch(java.io.IOException e) {
    820       jjStopStringLiteralDfa_0(9, active0, 0L);
    821       return 10;
    822    }
    823    switch(curChar)
    824    {
    825       case 101:
    826          return jjMoveStringLiteralDfa11_0(active0, 0x10000000000000L);
    827       default :
    828          break;
    829    }
    830    return jjStartNfa_0(9, active0, 0L);
    831 }
    832 private int jjMoveStringLiteralDfa11_0(long old0, long active0)
    833 {
    834    if (((active0 &= old0)) == 0L)
    835       return jjStartNfa_0(9, old0, 0L);
    836    try { curChar = input_stream.readChar(); }
    837    catch(java.io.IOException e) {
    838       jjStopStringLiteralDfa_0(10, active0, 0L);
    839       return 11;
    840    }
    841    switch(curChar)
    842    {
    843       case 100:
    844          if ((active0 & 0x10000000000000L) != 0L)
    845             return jjStartNfaWithStates_0(11, 52, 29);
    846          break;
    847       default :
    848          break;
    849    }
    850    return jjStartNfa_0(10, active0, 0L);
    851 }
    852 private int jjStartNfaWithStates_0(int pos, int kind, int state)
    853 {
    854    jjmatchedKind = kind;
    855    jjmatchedPos = pos;
    856    try { curChar = input_stream.readChar(); }
    857    catch(java.io.IOException e) { return pos + 1; }
    858    return jjMoveNfa_0(state, pos + 1);
    859 }
    860 static final long[] jjbitVec0 = {
    861    0xfffffffffffffffeL, 0xffffffffffffffffL, 0xffffffffffffffffL, 0xffffffffffffffffL
    862 };
    863 static final long[] jjbitVec2 = {
    864    0x0L, 0x0L, 0xffffffffffffffffL, 0xffffffffffffffffL
    865 };
    866 static final long[] jjbitVec3 = {
    867    0xfff0000000200002L, 0xffffffffffffdfffL, 0xfffff00f7fffffffL, 0x12000000007fffffL
    868 };
    869 static final long[] jjbitVec4 = {
    870    0x0L, 0x0L, 0x420043c00000000L, 0xff7fffffff7fffffL
    871 };
    872 static final long[] jjbitVec5 = {
    873    0xffffcffffffffL, 0xffffffffffff0000L, 0xf9ff3fffffffffffL, 0x401f00030003L
    874 };
    875 static final long[] jjbitVec6 = {
    876    0x0L, 0x400000000000000L, 0xfffffffbffffd740L, 0xffffffcff7fffL
    877 };
    878 static final long[] jjbitVec7 = {
    879    0xffffffffffffffffL, 0xffffffffffffffffL, 0xfffffffffffff003L, 0x33fffffffff199fL
    880 };
    881 static final long[] jjbitVec8 = {
    882    0xfffe000000000000L, 0xfffffffe027fffffL, 0xffL, 0x707ffffff0000L
    883 };
    884 static final long[] jjbitVec9 = {
    885    0x7fffffe00000000L, 0xfffe0000000007ffL, 0xffffffffffffffffL, 0x1c000060002fffffL
    886 };
    887 static final long[] jjbitVec10 = {
    888    0x1ffffffd0000L, 0x0L, 0x3fffffffffL, 0x0L
    889 };
    890 static final long[] jjbitVec11 = {
    891    0x23ffffffffffffe0L, 0x3ff010000L, 0x3c5fdfffff99fe0L, 0xf0003b0000000L
    892 };
    893 static final long[] jjbitVec12 = {
    894    0x36dfdfffff987e0L, 0x1c00005e000000L, 0x23edfdfffffbafe0L, 0x100010000L
    895 };
    896 static final long[] jjbitVec13 = {
    897    0x23cdfdfffff99fe0L, 0x3b0000000L, 0x3bfc718d63dc7e0L, 0x0L
    898 };
    899 static final long[] jjbitVec14 = {
    900    0x3effdfffffddfe0L, 0x300000000L, 0x3effdfffffddfe0L, 0x340000000L
    901 };
    902 static final long[] jjbitVec15 = {
    903    0x3fffdfffffddfe0L, 0x300000000L, 0x2ffbfffffc7fffe0L, 0x7fL
    904 };
    905 static final long[] jjbitVec16 = {
    906    0x800dfffffffffffeL, 0x7fL, 0x200decaefef02596L, 0x3000005fL
    907 };
    908 static final long[] jjbitVec17 = {
    909    0x1L, 0x7fffffffeffL, 0xf00L, 0x0L
    910 };
    911 static final long[] jjbitVec18 = {
    912    0x6fbffffffffL, 0x3f0000L, 0xffffffff00000000L, 0x7fffffffff003fL
    913 };
    914 static final long[] jjbitVec19 = {
    915    0xffffffffffffffffL, 0xffffffff83ffffffL, 0xffffff07ffffffffL, 0x3ffffffffffffffL
    916 };
    917 static final long[] jjbitVec20 = {
    918    0xffffffffffffff7fL, 0xffffffff3d7f3d7fL, 0x7f3d7fffffff3d7fL, 0xffff7fffff7f7f3dL
    919 };
    920 static final long[] jjbitVec21 = {
    921    0xffffffff7f3d7fffL, 0x7ffff7fL, 0xffffffff00000000L, 0x1fffffffffffffL
    922 };
    923 static final long[] jjbitVec22 = {
    924    0xffffffffffffffffL, 0x7f9fffffffffffL, 0xffffffff07fffffeL, 0x7ffffffffffL
    925 };
    926 static final long[] jjbitVec23 = {
    927    0x0L, 0x0L, 0xfffffffffffffL, 0x8000000L
    928 };
    929 static final long[] jjbitVec24 = {
    930    0xffffffff00000000L, 0xffffffffffffffL, 0x1ffffffffffL, 0x0L
    931 };
    932 static final long[] jjbitVec25 = {
    933    0xffffffffffffffffL, 0xffffffffffffffffL, 0xffffffff0fffffffL, 0x3ffffffffffffffL
    934 };
    935 static final long[] jjbitVec26 = {
    936    0xffffffff3f3fffffL, 0x3fffffffaaff3f3fL, 0x5fdfffffffffffffL, 0x1fdc1fff0fcf1fdcL
    937 };
    938 static final long[] jjbitVec27 = {
    939    0x8000000000000000L, 0x8000000000000001L, 0xffff00000000L, 0x0L
    940 };
    941 static final long[] jjbitVec28 = {
    942    0x3fbbd503e2ffc84L, 0xffffffff00000000L, 0xfL, 0x0L
    943 };
    944 static final long[] jjbitVec29 = {
    945    0x73e03fe000000e0L, 0xfffffffffffffffeL, 0xfffffffe601fffffL, 0x7fffffffffffffffL
    946 };
    947 static final long[] jjbitVec30 = {
    948    0xfffe1fffffffffe0L, 0xffffffffffffffffL, 0xffffff00007fffL, 0x0L
    949 };
    950 static final long[] jjbitVec31 = {
    951    0xffffffffffffffffL, 0xffffffffffffffffL, 0x3fffffffffffffL, 0x0L
    952 };
    953 static final long[] jjbitVec32 = {
    954    0xffffffffffffffffL, 0xffffffffffffffffL, 0x3fffffffffL, 0x0L
    955 };
    956 static final long[] jjbitVec33 = {
    957    0xffffffffffffffffL, 0xffffffffffffffffL, 0x1fffL, 0x0L
    958 };
    959 static final long[] jjbitVec34 = {
    960    0xffffffffffffffffL, 0xffffffffffffffffL, 0xfffffffffL, 0x0L
    961 };
    962 static final long[] jjbitVec35 = {
    963    0x3fffffffffffL, 0x0L, 0x0L, 0x0L
    964 };
    965 static final long[] jjbitVec36 = {
    966    0x5f7ffdffa0f8007fL, 0xffffffffffffffdbL, 0x3ffffffffffffL, 0xfffffffffff80000L
    967 };
    968 static final long[] jjbitVec37 = {
    969    0x3fffffffffffffffL, 0xffffffffffff0000L, 0xfffffffffffcffffL, 0xfff0000000000ffL
    970 };
    971 static final long[] jjbitVec38 = {
    972    0x18000000000000L, 0xffd702000000e000L, 0xffffffffffffffffL, 0x1fffffffffffffffL
    973 };
    974 static final long[] jjbitVec39 = {
    975    0x87fffffe00000010L, 0xffffffe007fffffeL, 0x7fffffffffffffffL, 0x631cfcfcfcL
    976 };
    977 static final long[] jjbitVec40 = {
    978    0x0L, 0x0L, 0x420043cffffffffL, 0xff7fffffff7fffffL
    979 };
    980 static final long[] jjbitVec41 = {
    981    0xffffffffffffffffL, 0x400000700007fffL, 0xfffffffbffffd740L, 0xffffffcff7fffL
    982 };
    983 static final long[] jjbitVec42 = {
    984    0xffffffffffffffffL, 0xffffffffffffffffL, 0xfffffffffffff07bL, 0x33fffffffff199fL
    985 };
    986 static final long[] jjbitVec43 = {
    987    0xfffe000000000000L, 0xfffffffe027fffffL, 0xbbfffffbfffe00ffL, 0x707ffffff0016L
    988 };
    989 static final long[] jjbitVec44 = {
    990    0x7fffffe00000000L, 0xffff03ff003fffffL, 0xffffffffffffffffL, 0x1fff3dff9fefffffL
    991 };
    992 static final long[] jjbitVec45 = {
    993    0xffff1fffffff8000L, 0x7ffL, 0x1ffffffffffffL, 0x0L
    994 };
    995 static final long[] jjbitVec46 = {
    996    0xf3ffffffffffffeeL, 0xffcfff1f3fffL, 0xd3c5fdfffff99feeL, 0xfffcfb080399fL
    997 };
    998 static final long[] jjbitVec47 = {
    999    0xd36dfdfffff987e4L, 0x1fffc05e003987L, 0xf3edfdfffffbafeeL, 0xffc100013bbfL
    1000 };
    1001 static final long[] jjbitVec48 = {
    1002    0xf3cdfdfffff99feeL, 0xffc3b0c0398fL, 0xc3bfc718d63dc7ecL, 0xff8000803dc7L
    1003 };
    1004 static final long[] jjbitVec49 = {
    1005    0xc3effdfffffddfeeL, 0xffc300603ddfL, 0xc3effdfffffddfecL, 0xffc340603ddfL
    1006 };
    1007 static final long[] jjbitVec50 = {
    1008    0xc3fffdfffffddfecL, 0xffc300803dcfL, 0x2ffbfffffc7fffecL, 0xc0000ff5f847fL
    1009 };
    1010 static final long[] jjbitVec51 = {
    1011    0x87fffffffffffffeL, 0x3ff7fffL, 0x3bffecaefef02596L, 0x33ff3f5fL
    1012 };
    1013 static final long[] jjbitVec52 = {
    1014    0xc2a003ff03000001L, 0xfffe07fffffffeffL, 0x1ffffffffeff0fdfL, 0x40L
    1015 };
    1016 static final long[] jjbitVec53 = {
    1017    0x3c7f6fbffffffffL, 0x3ff03ffL, 0xffffffff00000000L, 0x7fffffffff003fL
    1018 };
    1019 static final long[] jjbitVec54 = {
    1020    0xffffffff7f3d7fffL, 0x3fe0007ffff7fL, 0xffffffff00000000L, 0x1fffffffffffffL
    1021 };
    1022 static final long[] jjbitVec55 = {
    1023    0x0L, 0x0L, 0xffffffffffffffffL, 0x3ff080fffffL
    1024 };
    1025 static final long[] jjbitVec56 = {
    1026    0xffffffff03ff7800L, 0xffffffffffffffL, 0x3ffffffffffL, 0x0L
    1027 };
    1028 static final long[] jjbitVec57 = {
    1029    0x80007c000000f000L, 0x8000fc0000000001L, 0xffff00000000L, 0x21fff0000L
    1030 };
    1031 static final long[] jjbitVec58 = {
    1032    0x73efffe000000e0L, 0xfffffffffffffffeL, 0xfffffffe661fffffL, 0x7fffffffffffffffL
    1033 };
    1034 static final long[] jjbitVec59 = {
    1035    0x5f7ffdffe0f8007fL, 0xffffffffffffffdbL, 0x3ffffffffffffL, 0xfffffffffff80000L
    1036 };
    1037 static final long[] jjbitVec60 = {
    1038    0x18000f00000000L, 0xffd702000000e000L, 0xffffffffffffffffL, 0x9fffffffffffffffL
    1039 };
    1040 static final long[] jjbitVec61 = {
    1041    0x87fffffe03ff0010L, 0xffffffe007fffffeL, 0x7fffffffffffffffL, 0xe0000631cfcfcfcL
    1042 };
    1043 private int jjMoveNfa_0(int startState, int curPos)
    1044 {
    1045    int startsAt = 0;
    1046    jjnewStateCnt = 99;
    1047    int i = 1;
    1048    jjstateSet[0] = startState;
    1049    int kind = 0x7fffffff;
    1050    for (;;)
    1051    {
    1052       if (++jjround == 0x7fffffff)
    1053          ReInitRounds();
    1054       if (curChar < 64)
    1055       {
    1056          long l = 1L << curChar;
    1057          do
    1058          {
    1059             switch(jjstateSet[--i])
    1060             {
    1061                case 31:
    1062                   if (curChar == 42)
    1063                      jjstateSet[jjnewStateCnt++] = 36;
    1064                   else if (curChar == 47)
    1065                   {
    1066                      if (kind > 6)
    1067                         kind = 6;
    1068                      jjCheckNAddStates(0, 2);
    1069                   }
    1070                   break;
    1071                case 0:
    1072                   if ((0x3ff000000000000L & l) != 0L)
    1073                   {
    1074                      if (kind > 63)
    1075                         kind = 63;
    1076                      jjCheckNAddStates(3, 15);
    1077                   }
    1078                   else if (curChar == 47)
    1079                      jjAddStates(16, 17);
    1080                   else if (curChar == 36)
    1081                   {
    1082                      if (kind > 73)
    1083                         kind = 73;
    1084                      jjCheckNAdd(29);
    1085                   }
    1086                   else if (curChar == 34)
    1087                      jjCheckNAddStates(18, 20);
    1088                   else if (curChar == 39)
    1089                      jjAddStates(21, 22);
    1090                   else if (curChar == 46)
    1091                      jjstateSet[jjnewStateCnt++] = 1;
    1092                   if (curChar == 48)
    1093                      jjAddStates(23, 27);
    1094                   break;
    1095                case 1:
    1096                   if ((0x3ff000000000000L & l) == 0L)
    1097                      break;
    1098                   if (kind > 68)
    1099                      kind = 68;
    1100                   jjCheckNAddStates(28, 31);
    1101                   break;
    1102                case 2:
    1103                   if ((0x3ff000000000000L & l) != 0L)
    1104                      jjCheckNAddTwoStates(2, 3);
    1105                   break;
    1106                case 3:
    1107                   if ((0x3ff000000000000L & l) == 0L)
    1108                      break;
    1109                   if (kind > 68)
    1110                      kind = 68;
    1111                   jjCheckNAddTwoStates(4, 9);
    1112                   break;
    1113                case 5:
    1114                   if ((0x280000000000L & l) != 0L)
    1115                      jjstateSet[jjnewStateCnt++] = 6;
    1116                   break;
    1117                case 6:
    1118                   if ((0x3ff000000000000L & l) == 0L)
    1119                      break;
    1120                   if (kind > 68)
    1121                      kind = 68;
    1122                   jjCheckNAddStates(32, 34);
    1123                   break;
    1124                case 7:
    1125                   if ((0x3ff000000000000L & l) != 0L)
    1126                      jjCheckNAddTwoStates(7, 8);
    1127                   break;
    1128                case 8:
    1129                case 53:
    1130                case 60:
    1131                   if ((0x3ff000000000000L & l) == 0L)
    1132                      break;
    1133                   if (kind > 68)
    1134                      kind = 68;
    1135                   jjCheckNAdd(9);
    1136                   break;
    1137                case 10:
    1138                   if (curChar == 39)
    1139                      jjAddStates(21, 22);
    1140                   break;
    1141                case 11:
    1142                   if ((0xffffff7fffffdbffL & l) != 0L)
    1143                      jjCheckNAdd(12);
    1144                   break;
    1145                case 12:
    1146                   if (curChar == 39 && kind > 71)
    1147                      kind = 71;
    1148                   break;
    1149                case 14:
    1150                   if ((0x8400000000L & l) != 0L)
    1151                      jjCheckNAdd(12);
    1152                   break;
    1153                case 15:
    1154                   if ((0xff000000000000L & l) != 0L)
    1155                      jjCheckNAddTwoStates(16, 12);
    1156                   break;
    1157                case 16:
    1158                   if ((0xff000000000000L & l) != 0L)
    1159                      jjCheckNAdd(12);
    1160                   break;
    1161                case 17:
    1162                   if ((0xf000000000000L & l) != 0L)
    1163                      jjstateSet[jjnewStateCnt++] = 18;
    1164                   break;
    1165                case 18:
    1166                   if ((0xff000000000000L & l) != 0L)
    1167                      jjCheckNAdd(16);
    1168                   break;
    1169                case 19:
    1170                   if (curChar == 34)
    1171                      jjCheckNAddStates(18, 20);
    1172                   break;
    1173                case 20:
    1174                   if ((0xfffffffbffffdbffL & l) != 0L)
    1175                      jjCheckNAddStates(18, 20);
    1176                   break;
    1177                case 22:
    1178                   if ((0x8400000000L & l) != 0L)
    1179                      jjCheckNAddStates(18, 20);
    1180                   break;
    1181                case 23:
    1182                   if (curChar == 34 && kind > 72)
    1183                      kind = 72;
    1184                   break;
    1185                case 24:
    1186                   if ((0xff000000000000L & l) != 0L)
    1187                      jjCheckNAddStates(35, 38);
    1188                   break;
    1189                case 25:
    1190                   if ((0xff000000000000L & l) != 0L)
    1191                      jjCheckNAddStates(18, 20);
    1192                   break;
    1193                case 26:
    1194                   if ((0xf000000000000L & l) != 0L)
    1195                      jjstateSet[jjnewStateCnt++] = 27;
    1196                   break;
    1197                case 27:
    1198                   if ((0xff000000000000L & l) != 0L)
    1199                      jjCheckNAdd(25);
    1200                   break;
    1201                case 28:
    1202                   if (curChar != 36)
    1203                      break;
    1204                   if (kind > 73)
    1205                      kind = 73;
    1206                   jjCheckNAdd(29);
    1207                   break;
    1208                case 29:
    1209                   if ((0x3ff00100fffc1ffL & l) == 0L)
    1210                      break;
    1211                   if (kind > 73)
    1212                      kind = 73;
    1213                   jjCheckNAdd(29);
    1214                   break;
    1215                case 30:
    1216                   if (curChar == 47)
    1217                      jjAddStates(16, 17);
    1218                   break;
    1219                case 32:
    1220                   if ((0xffffffffffffdbffL & l) == 0L)
    1221                      break;
    1222                   if (kind > 6)
    1223                      kind = 6;
    1224                   jjCheckNAddStates(0, 2);
    1225                   break;
    1226                case 33:
    1227                   if ((0x2400L & l) != 0L && kind > 6)
    1228                      kind = 6;
    1229                   break;
    1230                case 34:
    1231                   if (curChar == 10 && kind > 6)
    1232                      kind = 6;
    1233                   break;
    1234                case 35:
    1235                   if (curChar == 13)
    1236                      jjstateSet[jjnewStateCnt++] = 34;
    1237                   break;
    1238                case 36:
    1239                   if (curChar == 42)
    1240                      jjstateSet[jjnewStateCnt++] = 37;
    1241                   break;
    1242                case 37:
    1243                   if ((0xffff7fffffffffffL & l) != 0L && kind > 7)
    1244                      kind = 7;
    1245                   break;
    1246                case 38:
    1247                   if (curChar == 42)
    1248                      jjstateSet[jjnewStateCnt++] = 36;
    1249                   break;
    1250                case 39:
    1251                   if ((0x3ff000000000000L & l) == 0L)
    1252                      break;
    1253                   if (kind > 63)
    1254                      kind = 63;
    1255                   jjCheckNAddStates(3, 15);
    1256                   break;
    1257                case 40:
    1258                   if ((0x3ff000000000000L & l) != 0L)
    1259                      jjCheckNAddTwoStates(40, 41);
    1260                   break;
    1261                case 41:
    1262                case 72:
    1263                   if ((0x3ff000000000000L & l) == 0L)
    1264                      break;
    1265                   if (kind > 63)
    1266                      kind = 63;
    1267                   jjCheckNAdd(42);
    1268                   break;
    1269                case 43:
    1270                   if ((0x3ff000000000000L & l) != 0L)
    1271                      jjCheckNAddTwoStates(43, 44);
    1272                   break;
    1273                case 44:
    1274                   if ((0x3ff000000000000L & l) != 0L)
    1275                      jjCheckNAdd(45);
    1276                   break;
    1277                case 45:
    1278                   if (curChar != 46)
    1279                      break;
    1280                   if (kind > 68)
    1281                      kind = 68;
    1282                   jjCheckNAddStates(39, 41);
    1283                   break;
    1284                case 46:
    1285                   if ((0x3ff000000000000L & l) == 0L)
    1286                      break;
    1287                   if (kind > 68)
    1288                      kind = 68;
    1289                   jjCheckNAddStates(42, 45);
    1290                   break;
    1291                case 47:
    1292                   if ((0x3ff000000000000L & l) != 0L)
    1293                      jjCheckNAddTwoStates(47, 48);
    1294                   break;
    1295                case 48:
    1296                   if ((0x3ff000000000000L & l) == 0L)
    1297                      break;
    1298                   if (kind > 68)
    1299                      kind = 68;
    1300                   jjCheckNAddTwoStates(49, 9);
    1301                   break;
    1302                case 50:
    1303                   if ((0x280000000000L & l) != 0L)
    1304                      jjstateSet[jjnewStateCnt++] = 51;
    1305                   break;
    1306                case 51:
    1307                   if ((0x3ff000000000000L & l) == 0L)
    1308                      break;
    1309                   if (kind > 68)
    1310                      kind = 68;
    1311                   jjCheckNAddStates(46, 48);
    1312                   break;
    1313                case 52:
    1314                   if ((0x3ff000000000000L & l) != 0L)
    1315                      jjCheckNAddTwoStates(52, 53);
    1316                   break;
    1317                case 54:
    1318                   if ((0x3ff000000000000L & l) != 0L)
    1319                      jjCheckNAddTwoStates(54, 55);
    1320                   break;
    1321                case 55:
    1322                   if ((0x3ff000000000000L & l) != 0L)
    1323                      jjCheckNAdd(56);
    1324                   break;
    1325                case 57:
    1326                   if ((0x280000000000L & l) != 0L)
    1327                      jjstateSet[jjnewStateCnt++] = 58;
    1328                   break;
    1329                case 58:
    1330                   if ((0x3ff000000000000L & l) == 0L)
    1331                      break;
    1332                   if (kind > 68)
    1333                      kind = 68;
    1334                   jjCheckNAddStates(49, 51);
    1335                   break;
    1336                case 59:
    1337                   if ((0x3ff000000000000L & l) != 0L)
    1338                      jjCheckNAddTwoStates(59, 60);
    1339                   break;
    1340                case 61:
    1341                   if ((0x3ff000000000000L & l) != 0L)
    1342                      jjCheckNAddTwoStates(61, 62);
    1343                   break;
    1344                case 62:
    1345                   if ((0x3ff000000000000L & l) != 0L)
    1346                      jjCheckNAddTwoStates(63, 9);
    1347                   break;
    1348                case 64:
    1349                   if ((0x280000000000L & l) != 0L)
    1350                      jjstateSet[jjnewStateCnt++] = 65;
    1351                   break;
    1352                case 65:
    1353                   if ((0x3ff000000000000L & l) != 0L)
    1354                      jjCheckNAddStates(52, 54);
    1355                   break;
    1356                case 66:
    1357                   if ((0x3ff000000000000L & l) != 0L)
    1358                      jjCheckNAddTwoStates(66, 67);
    1359                   break;
    1360                case 67:
    1361                   if ((0x3ff000000000000L & l) != 0L)
    1362                      jjCheckNAdd(9);
    1363                   break;
    1364                case 68:
    1365                   if (curChar == 48)
    1366                      jjAddStates(23, 27);
    1367                   break;
    1368                case 70:
    1369                   if ((0x3ff000000000000L & l) == 0L)
    1370                      break;
    1371                   if (kind > 63)
    1372                      kind = 63;
    1373                   jjCheckNAddStates(55, 57);
    1374                   break;
    1375                case 71:
    1376                   if ((0x3ff000000000000L & l) != 0L)
    1377                      jjCheckNAddTwoStates(71, 72);
    1378                   break;
    1379                case 74:
    1380                   if ((0x3000000000000L & l) == 0L)
    1381                      break;
    1382                   if (kind > 63)
    1383                      kind = 63;
    1384                   jjCheckNAddStates(58, 60);
    1385                   break;
    1386                case 75:
    1387                   if ((0x3000000000000L & l) != 0L)
    1388                      jjCheckNAddTwoStates(75, 76);
    1389                   break;
    1390                case 76:
    1391                   if ((0x3000000000000L & l) == 0L)
    1392                      break;
    1393                   if (kind > 63)
    1394                      kind = 63;
    1395                   jjCheckNAdd(42);
    1396                   break;
    1397                case 77:
    1398                   if ((0xff000000000000L & l) == 0L)
    1399                      break;
    1400                   if (kind > 63)
    1401                      kind = 63;
    1402                   jjCheckNAddStates(61, 63);
    1403                   break;
    1404                case 78:
    1405                   if ((0xff000000000000L & l) != 0L)
    1406                      jjCheckNAddTwoStates(78, 79);
    1407                   break;
    1408                case 79:
    1409                   if ((0xff000000000000L & l) == 0L)
    1410                      break;
    1411                   if (kind > 63)
    1412                      kind = 63;
    1413                   jjCheckNAdd(42);
    1414                   break;
    1415                case 81:
    1416                   if ((0x3ff000000000000L & l) != 0L)
    1417                      jjCheckNAddStates(64, 67);
    1418                   break;
    1419                case 82:
    1420                   if ((0x3ff000000000000L & l) != 0L)
    1421                      jjCheckNAddTwoStates(82, 83);
    1422                   break;
    1423                case 83:
    1424                   if ((0x3ff000000000000L & l) != 0L)
    1425                      jjCheckNAddTwoStates(84, 85);
    1426                   break;
    1427                case 84:
    1428                   if (curChar == 46)
    1429                      jjCheckNAdd(85);
    1430                   break;
    1431                case 86:
    1432                   if ((0x280000000000L & l) != 0L)
    1433                      jjstateSet[jjnewStateCnt++] = 87;
    1434                   break;
    1435                case 87:
    1436                   if ((0x3ff000000000000L & l) == 0L)
    1437                      break;
    1438                   if (kind > 69)
    1439                      kind = 69;
    1440                   jjCheckNAddStates(68, 70);
    1441                   break;
    1442                case 88:
    1443                   if ((0x3ff000000000000L & l) != 0L)
    1444                      jjCheckNAddTwoStates(88, 89);
    1445                   break;
    1446                case 89:
    1447                   if ((0x3ff000000000000L & l) == 0L)
    1448                      break;
    1449                   if (kind > 69)
    1450                      kind = 69;
    1451                   jjCheckNAdd(90);
    1452                   break;
    1453                case 92:
    1454                   if ((0x3ff000000000000L & l) != 0L)
    1455                      jjCheckNAddStates(71, 73);
    1456                   break;
    1457                case 93:
    1458                   if ((0x3ff000000000000L & l) != 0L)
    1459                      jjCheckNAddTwoStates(93, 94);
    1460                   break;
    1461                case 94:
    1462                   if ((0x3ff000000000000L & l) != 0L)
    1463                      jjCheckNAdd(95);
    1464                   break;
    1465                case 95:
    1466                   if (curChar == 46)
    1467                      jjstateSet[jjnewStateCnt++] = 96;
    1468                   break;
    1469                case 96:
    1470                   if ((0x3ff000000000000L & l) != 0L)
    1471                      jjCheckNAddStates(74, 76);
    1472                   break;
    1473                case 97:
    1474                   if ((0x3ff000000000000L & l) != 0L)
    1475                      jjCheckNAddTwoStates(97, 98);
    1476                   break;
    1477                case 98:
    1478                   if ((0x3ff000000000000L & l) != 0L)
    1479                      jjCheckNAdd(85);
    1480                   break;
    1481                default : break;
    1482             }
    1483          } while(i != startsAt);
    1484       }
    1485       else if (curChar < 128)
    1486       {
    1487          long l = 1L << (curChar & 077);
    1488          do
    1489          {
    1490             switch(jjstateSet[--i])
    1491             {
    1492                case 0:
    1493                   if ((0x7fffffe87fffffeL & l) == 0L)
    1494                      break;
    1495                   if (kind > 73)
    1496                      kind = 73;
    1497                   jjCheckNAdd(29);
    1498                   break;
    1499                case 2:
    1500                   if (curChar == 95)
    1501                      jjAddStates(77, 78);
    1502                   break;
    1503                case 4:
    1504                   if ((0x2000000020L & l) != 0L)
    1505                      jjAddStates(79, 80);
    1506                   break;
    1507                case 7:
    1508                   if (curChar == 95)
    1509                      jjAddStates(81, 82);
    1510                   break;
    1511                case 9:
    1512                   if ((0x5000000050L & l) != 0L && kind > 68)
    1513                      kind = 68;
    1514                   break;
    1515                case 11:
    1516                   if ((0xffffffffefffffffL & l) != 0L)
    1517                      jjCheckNAdd(12);
    1518                   break;
    1519                case 13:
    1520                   if (curChar == 92)
    1521                      jjAddStates(83, 85);
    1522                   break;
    1523                case 14:
    1524                   if ((0x14404410000000L & l) != 0L)
    1525                      jjCheckNAdd(12);
    1526                   break;
    1527                case 20:
    1528                   if ((0xffffffffefffffffL & l) != 0L)
    1529                      jjCheckNAddStates(18, 20);
    1530                   break;
    1531                case 21:
    1532                   if (curChar == 92)
    1533                      jjAddStates(86, 88);
    1534                   break;
    1535                case 22:
    1536                   if ((0x14404410000000L & l) != 0L)
    1537                      jjCheckNAddStates(18, 20);
    1538                   break;
    1539                case 29:
    1540                   if ((0x87fffffe87fffffeL & l) == 0L)
    1541                      break;
    1542                   if (kind > 73)
    1543                      kind = 73;
    1544                   jjCheckNAdd(29);
    1545                   break;
    1546                case 32:
    1547                   if (kind > 6)
    1548                      kind = 6;
    1549                   jjAddStates(0, 2);
    1550                   break;
    1551                case 37:
    1552                   if (kind > 7)
    1553                      kind = 7;
    1554                   break;
    1555                case 40:
    1556                   if (curChar == 95)
    1557                      jjAddStates(89, 90);
    1558                   break;
    1559                case 42:
    1560                   if ((0x100000001000L & l) != 0L && kind > 63)
    1561                      kind = 63;
    1562                   break;
    1563                case 43:
    1564                   if (curChar == 95)
    1565                      jjAddStates(91, 92);
    1566                   break;
    1567                case 47:
    1568                   if (curChar == 95)
    1569                      jjAddStates(93, 94);
    1570                   break;
    1571                case 49:
    1572                   if ((0x2000000020L & l) != 0L)
    1573                      jjAddStates(95, 96);
    1574                   break;
    1575                case 52:
    1576                   if (curChar == 95)
    1577                      jjAddStates(97, 98);
    1578                   break;
    1579                case 54:
    1580                   if (curChar == 95)
    1581                      jjAddStates(99, 100);
    1582                   break;
    1583                case 56:
    1584                   if ((0x2000000020L & l) != 0L)
    1585                      jjAddStates(101, 102);
    1586                   break;
    1587                case 59:
    1588                   if (curChar == 95)
    1589                      jjAddStates(103, 104);
    1590                   break;
    1591                case 61:
    1592                   if (curChar == 95)
    1593                      jjAddStates(105, 106);
    1594                   break;
    1595                case 63:
    1596                   if ((0x2000000020L & l) != 0L)
    1597                      jjAddStates(107, 108);
    1598                   break;
    1599                case 66:
    1600                   if (curChar == 95)
    1601                      jjAddStates(109, 110);
    1602                   break;
    1603                case 69:
    1604                   if ((0x100000001000000L & l) != 0L)
    1605                      jjstateSet[jjnewStateCnt++] = 70;
    1606                   break;
    1607                case 70:
    1608                   if ((0x7e0000007eL & l) == 0L)
    1609                      break;
    1610                   if (kind > 63)
    1611                      kind = 63;
    1612                   jjCheckNAddStates(55, 57);
    1613                   break;
    1614                case 71:
    1615                   if ((0x7e8000007eL & l) != 0L)
    1616                      jjCheckNAddTwoStates(71, 72);
    1617                   break;
    1618                case 72:
    1619                   if ((0x7e0000007eL & l) == 0L)
    1620                      break;
    1621                   if (kind > 63)
    1622                      kind = 63;
    1623                   jjCheckNAdd(42);
    1624                   break;
    1625                case 73:
    1626                   if ((0x400000004L & l) != 0L)
    1627                      jjstateSet[jjnewStateCnt++] = 74;
    1628                   break;
    1629                case 75:
    1630                   if (curChar == 95)
    1631                      jjAddStates(111, 112);
    1632                   break;
    1633                case 78:
    1634                   if (curChar == 95)
    1635                      jjAddStates(113, 114);
    1636                   break;
    1637                case 80:
    1638                   if ((0x100000001000000L & l) != 0L)
    1639                      jjstateSet[jjnewStateCnt++] = 81;
    1640                   break;
    1641                case 81:
    1642                   if ((0x7e0000007eL & l) != 0L)
    1643                      jjCheckNAddStates(64, 67);
    1644                   break;
    1645                case 82:
    1646                   if ((0x7e8000007eL & l) != 0L)
    1647                      jjCheckNAddTwoStates(82, 83);
    1648                   break;
    1649                case 83:
    1650                   if ((0x7e0000007eL & l) != 0L)
    1651                      jjCheckNAddTwoStates(84, 85);
    1652                   break;
    1653                case 85:
    1654                   if ((0x1000000010000L & l) != 0L)
    1655                      jjAddStates(115, 116);
    1656                   break;
    1657                case 88:
    1658                   if (curChar == 95)
    1659                      jjAddStates(117, 118);
    1660                   break;
    1661                case 90:
    1662                   if ((0x5000000050L & l) != 0L && kind > 69)
    1663                      kind = 69;
    1664                   break;
    1665                case 91:
    1666                   if ((0x100000001000000L & l) != 0L)
    1667                      jjCheckNAddTwoStates(92, 95);
    1668                   break;
    1669                case 92:
    1670                   if ((0x7e0000007eL & l) != 0L)
    1671                      jjCheckNAddStates(71, 73);
    1672                   break;
    1673                case 93:
    1674                   if ((0x7e8000007eL & l) != 0L)
    1675                      jjCheckNAddTwoStates(93, 94);
    1676                   break;
    1677                case 94:
    1678                   if ((0x7e0000007eL & l) != 0L)
    1679                      jjCheckNAdd(95);
    1680                   break;
    1681                case 96:
    1682                   if ((0x7e0000007eL & l) != 0L)
    1683                      jjCheckNAddStates(74, 76);
    1684                   break;
    1685                case 97:
    1686                   if ((0x7e8000007eL & l) != 0L)
    1687                      jjCheckNAddTwoStates(97, 98);
    1688                   break;
    1689                case 98:
    1690                   if ((0x7e0000007eL & l) != 0L)
    1691                      jjCheckNAdd(85);
    1692                   break;
    1693                default : break;
    1694             }
    1695          } while(i != startsAt);
    1696       }
    1697       else
    1698       {
    1699          int hiByte = (int)(curChar >> 8);
    1700          int i1 = hiByte >> 6;
    1701          long l1 = 1L << (hiByte & 077);
    1702          int i2 = (curChar & 0xff) >> 6;
    1703          long l2 = 1L << (curChar & 077);
    1704          do
    1705          {
    1706             switch(jjstateSet[--i])
    1707             {
    1708                case 0:
    1709                   if (!jjCanMove_1(hiByte, i1, i2, l1, l2))
    1710                      break;
    1711                   if (kind > 73)
    1712                      kind = 73;
    1713                   jjCheckNAdd(29);
    1714                   break;
    1715                case 11:
    1716                   if (jjCanMove_0(hiByte, i1, i2, l1, l2))
    1717                      jjstateSet[jjnewStateCnt++] = 12;
    1718                   break;
    1719                case 20:
    1720                   if (jjCanMove_0(hiByte, i1, i2, l1, l2))
    1721                      jjAddStates(18, 20);
    1722                   break;
    1723                case 29:
    1724                   if (!jjCanMove_2(hiByte, i1, i2, l1, l2))
    1725                      break;
    1726                   if (kind > 73)
    1727                      kind = 73;
    1728                   jjCheckNAdd(29);
    1729                   break;
    1730                case 32:
    1731                   if (!jjCanMove_0(hiByte, i1, i2, l1, l2))
    1732                      break;
    1733                   if (kind > 6)
    1734                      kind = 6;
    1735                   jjAddStates(0, 2);
    1736                   break;
    1737                case 37:
    1738                   if (jjCanMove_0(hiByte, i1, i2, l1, l2) && kind > 7)
    1739                      kind = 7;
    1740                   break;
    1741                default : break;
    1742             }
    1743          } while(i != startsAt);
    1744       }
    1745       if (kind != 0x7fffffff)
    1746       {
    1747          jjmatchedKind = kind;
    1748          jjmatchedPos = curPos;
    1749          kind = 0x7fffffff;
    1750       }
    1751       ++curPos;
    1752       if ((i = jjnewStateCnt) == (startsAt = 99 - (jjnewStateCnt = startsAt)))
    1753          return curPos;
    1754       try { curChar = input_stream.readChar(); }
    1755       catch(java.io.IOException e) { return curPos; }
    1756    }
    1757 }
    1758 private int jjMoveStringLiteralDfa0_2()
    1759 {
    1760    switch(curChar)
    1761    {
    1762       case 42:
    1763          return jjMoveStringLiteralDfa1_2(0x400L);
    1764       default :
    1765          return 1;
    1766    }
    1767 }
    1768 private int jjMoveStringLiteralDfa1_2(long active0)
    1769 {
    1770    try { curChar = input_stream.readChar(); }
    1771    catch(java.io.IOException e) {
    1772       return 1;
    1773    }
    1774    switch(curChar)
    1775    {
    1776       case 47:
    1777          if ((active0 & 0x400L) != 0L)
    1778             return jjStopAtPos(1, 10);
    1779          break;
    1780       default :
    1781          return 2;
    1782    }
    1783    return 2;
    1784 }
    1785 private int jjMoveStringLiteralDfa0_1()
    1786 {
    1787    switch(curChar)
    1788    {
    1789       case 42:
    1790          return jjMoveStringLiteralDfa1_1(0x200L);
    1791       default :
    1792          return 1;
    1793    }
    1794 }
    1795 private int jjMoveStringLiteralDfa1_1(long active0)
    1796 {
    1797    try { curChar = input_stream.readChar(); }
    1798    catch(java.io.IOException e) {
    1799       return 1;
    1800    }
    1801    switch(curChar)
    1802    {
    1803       case 47:
    1804          if ((active0 & 0x200L) != 0L)
    1805             return jjStopAtPos(1, 9);
    1806          break;
    1807       default :
    1808          return 2;
    1809    }
    1810    return 2;
    1811 }
    1812 static final int[] jjnextStates = {
    1813    32, 33, 35, 40, 41, 42, 43, 44, 45, 54, 55, 56, 61, 62, 63, 9,
    1814    31, 38, 20, 21, 23, 11, 13, 69, 73, 77, 80, 91, 2, 3, 4, 9,
    1815    7, 8, 9, 20, 21, 25, 23, 46, 49, 9, 47, 48, 49, 9, 52, 53,
    1816    9, 59, 60, 9, 66, 67, 9, 71, 72, 42, 75, 76, 42, 78, 79, 42,
    1817    82, 83, 84, 85, 88, 89, 90, 93, 94, 95, 97, 98, 85, 2, 3, 5,
    1818    6, 7, 8, 14, 15, 17, 22, 24, 26, 40, 41, 43, 44, 47, 48, 50,
    1819    51, 52, 53, 54, 55, 57, 58, 59, 60, 61, 62, 64, 65, 66, 67, 75,
    1820    76, 78, 79, 86, 87, 88, 89,
    1821 };
    1822 private static final boolean jjCanMove_0(int hiByte, int i1, int i2, long l1, long l2)
    1823 {
    1824    switch(hiByte)
    1825    {
    1826       case 0:
    1827          return ((jjbitVec2[i2] & l2) != 0L);
    1828       default :
    1829          if ((jjbitVec0[i1] & l1) != 0L)
    1830             return true;
    1831          return false;
    1832    }
    1833 }
    1834 private static final boolean jjCanMove_1(int hiByte, int i1, int i2, long l1, long l2)
    1835 {
    1836    switch(hiByte)
    1837    {
    1838       case 0:
    1839          return ((jjbitVec4[i2] & l2) != 0L);
    1840       case 2:
    1841          return ((jjbitVec5[i2] & l2) != 0L);
    1842       case 3:
    1843          return ((jjbitVec6[i2] & l2) != 0L);
    1844       case 4:
    1845          return ((jjbitVec7[i2] & l2) != 0L);
    1846       case 5:
    1847          return ((jjbitVec8[i2] & l2) != 0L);
    1848       case 6:
    1849          return ((jjbitVec9[i2] & l2) != 0L);
    1850       case 7:
    1851          return ((jjbitVec10[i2] & l2) != 0L);
    1852       case 9:
    1853          return ((jjbitVec11[i2] & l2) != 0L);
    1854       case 10:
    1855          return ((jjbitVec12[i2] & l2) != 0L);
    1856       case 11:
    1857          return ((jjbitVec13[i2] & l2) != 0L);
    1858       case 12:
    1859          return ((jjbitVec14[i2] & l2) != 0L);
    1860       case 13:
    1861          return ((jjbitVec15[i2] & l2) != 0L);
    1862       case 14:
    1863          return ((jjbitVec16[i2] & l2) != 0L);
    1864       case 15:
    1865          return ((jjbitVec17[i2] & l2) != 0L);
    1866       case 16:
    1867          return ((jjbitVec18[i2] & l2) != 0L);
    1868       case 17:
    1869          return ((jjbitVec19[i2] & l2) != 0L);
    1870       case 18:
    1871          return ((jjbitVec20[i2] & l2) != 0L);
    1872       case 19:
    1873          return ((jjbitVec21[i2] & l2) != 0L);
    1874       case 20:
    1875          return ((jjbitVec0[i2] & l2) != 0L);
    1876       case 22:
    1877          return ((jjbitVec22[i2] & l2) != 0L);
    1878       case 23:
    1879          return ((jjbitVec23[i2] & l2) != 0L);
    1880       case 24:
    1881          return ((jjbitVec24[i2] & l2) != 0L);
    1882       case 30:
    1883          return ((jjbitVec25[i2] & l2) != 0L);
    1884       case 31:
    1885          return ((jjbitVec26[i2] & l2) != 0L);
    1886       case 32:
    1887          return ((jjbitVec27[i2] & l2) != 0L);
    1888       case 33:
    1889          return ((jjbitVec28[i2] & l2) != 0L);
    1890       case 48:
    1891          return ((jjbitVec29[i2] & l2) != 0L);
    1892       case 49:
    1893          return ((jjbitVec30[i2] & l2) != 0L);
    1894       case 77:
    1895          return ((jjbitVec31[i2] & l2) != 0L);
    1896       case 159:
    1897          return ((jjbitVec32[i2] & l2) != 0L);
    1898       case 164:
    1899          return ((jjbitVec33[i2] & l2) != 0L);
    1900       case 215:
    1901          return ((jjbitVec34[i2] & l2) != 0L);
    1902       case 250:
    1903          return ((jjbitVec35[i2] & l2) != 0L);
    1904       case 251:
    1905          return ((jjbitVec36[i2] & l2) != 0L);
    1906       case 253:
    1907          return ((jjbitVec37[i2] & l2) != 0L);
    1908       case 254:
    1909          return ((jjbitVec38[i2] & l2) != 0L);
    1910       case 255:
    1911          return ((jjbitVec39[i2] & l2) != 0L);
    1912       default :
    1913          if ((jjbitVec3[i1] & l1) != 0L)
    1914             return true;
    1915          return false;
    1916    }
    1917 }
    1918 private static final boolean jjCanMove_2(int hiByte, int i1, int i2, long l1, long l2)
    1919 {
    1920    switch(hiByte)
    1921    {
    1922       case 0:
    1923          return ((jjbitVec40[i2] & l2) != 0L);
    1924       case 2:
    1925          return ((jjbitVec5[i2] & l2) != 0L);
    1926       case 3:
    1927          return ((jjbitVec41[i2] & l2) != 0L);
    1928       case 4:
    1929          return ((jjbitVec42[i2] & l2) != 0L);
    1930       case 5:
    1931          return ((jjbitVec43[i2] & l2) != 0L);
    1932       case 6:
    1933          return ((jjbitVec44[i2] & l2) != 0L);
    1934       case 7:
    1935          return ((jjbitVec45[i2] & l2) != 0L);
    1936       case 9:
    1937          return ((jjbitVec46[i2] & l2) != 0L);
    1938       case 10:
    1939          return ((jjbitVec47[i2] & l2) != 0L);
    1940       case 11:
    1941          return ((jjbitVec48[i2] & l2) != 0L);
    1942       case 12:
    1943          return ((jjbitVec49[i2] & l2) != 0L);
    1944       case 13:
    1945          return ((jjbitVec50[i2] & l2) != 0L);
    1946       case 14:
    1947          return ((jjbitVec51[i2] & l2) != 0L);
    1948       case 15:
    1949          return ((jjbitVec52[i2] & l2) != 0L);
    1950       case 16:
    1951          return ((jjbitVec53[i2] & l2) != 0L);
    1952       case 17:
    1953          return ((jjbitVec19[i2] & l2) != 0L);
    1954       case 18:
    1955          return ((jjbitVec20[i2] & l2) != 0L);
    1956       case 19:
    1957          return ((jjbitVec54[i2] & l2) != 0L);
    1958       case 20:
    1959          return ((jjbitVec0[i2] & l2) != 0L);
    1960       case 22:
    1961          return ((jjbitVec22[i2] & l2) != 0L);
    1962       case 23:
    1963          return ((jjbitVec55[i2] & l2) != 0L);
    1964       case 24:
    1965          return ((jjbitVec56[i2] & l2) != 0L);
    1966       case 30:
    1967          return ((jjbitVec25[i2] & l2) != 0L);
    1968       case 31:
    1969          return ((jjbitVec26[i2] & l2) != 0L);
    1970       case 32:
    1971          return ((jjbitVec57[i2] & l2) != 0L);
    1972       case 33:
    1973          return ((jjbitVec28[i2] & l2) != 0L);
    1974       case 48:
    1975          return ((jjbitVec58[i2] & l2) != 0L);
    1976       case 49:
    1977          return ((jjbitVec30[i2] & l2) != 0L);
    1978       case 77:
    1979          return ((jjbitVec31[i2] & l2) != 0L);
    1980       case 159:
    1981          return ((jjbitVec32[i2] & l2) != 0L);
    1982       case 164:
    1983          return ((jjbitVec33[i2] & l2) != 0L);
    1984       case 215:
    1985          return ((jjbitVec34[i2] & l2) != 0L);
    1986       case 250:
    1987          return ((jjbitVec35[i2] & l2) != 0L);
    1988       case 251:
    1989          return ((jjbitVec59[i2] & l2) != 0L);
    1990       case 253:
    1991          return ((jjbitVec37[i2] & l2) != 0L);
    1992       case 254:
    1993          return ((jjbitVec60[i2] & l2) != 0L);
    1994       case 255:
    1995          return ((jjbitVec61[i2] & l2) != 0L);
    1996       default :
    1997          if ((jjbitVec3[i1] & l1) != 0L)
    1998             return true;
    1999          return false;
    2000    }
    2001 }
    2002
    2003 /** Token literal values. */
    2004 public static final String[] jjstrLiteralImages = {
    2005 "", null, null, null, null, null, null, null, null, null, null, null,
    2006 "\141\142\163\164\162\141\143\164", "\142\157\157\154\145\141\156", "\142\162\145\141\153", "\142\171\164\145",
    2007 "\143\141\163\145", "\143\141\164\143\150", "\143\150\141\162", "\143\154\141\163\163",
    2008 "\143\157\156\163\164", "\143\157\156\164\151\156\165\145", "\144\145\146\141\165\154\164",
    2009 "\144\157", "\144\157\165\142\154\145", "\145\154\163\145",
    2010 "\145\170\164\145\156\144\163", "\146\141\154\163\145", "\146\151\156\141\154",
    2011 "\146\151\156\141\154\154\171", "\146\154\157\141\164", "\146\157\162", "\147\157\164\157", "\151\146",
    2012 "\151\155\160\154\145\155\145\156\164\163", "\151\155\160\157\162\164", "\151\156\163\164\141\156\143\145\157\146",
    2013 "\151\156\164", "\151\156\164\145\162\146\141\143\145", "\154\157\156\147",
    2014 "\156\141\164\151\166\145", "\156\145\167", "\156\165\154\154", "\160\141\143\153\141\147\145",
    2015 "\160\162\151\166\141\164\145", "\160\162\157\164\145\143\164\145\144", "\160\165\142\154\151\143",
    2016 "\162\145\164\165\162\156", "\163\150\157\162\164", "\163\164\141\164\151\143", "\163\165\160\145\162",
    2017 "\163\167\151\164\143\150", "\163\171\156\143\150\162\157\156\151\172\145\144", "\164\150\151\163",
    2018 "\164\150\162\157\167", "\164\150\162\157\167\163", "\164\162\141\156\163\151\145\156\164",
    2019 "\164\162\165\145", "\164\162\171", "\166\157\151\144", "\166\157\154\141\164\151\154\145",
    2020 "\167\150\151\154\145", "\163\164\162\151\143\164\146\160", null, null, null, null, null, null, null,
    2021 null, null, null, null, null, null, "\50", "\51", "\173", "\175", "\133", "\135",
    2022 "\73", "\54", "\56", "\100", "\75", "\74", "\41", "\176", "\77", "\72", "\75\75",
    2023 "\74\75", "\76\75", "\41\75", "\174\174", "\46\46", "\53\53", "\55\55", "\53", "\55",
    2024 "\52", "\57", "\46", "\174", "\136", "\45", "\74\74", "\53\75", "\55\75", "\52\75",
    2025 "\57\75", "\46\75", "\174\75", "\136\75", "\45\75", "\74\74\75", "\76\76\75",
    2026 "\76\76\76\75", "\56\56\56", "\76\76\76", "\76\76", "\76", "\32", "\176\133\135", };
    2027
    2028 /** Lexer state names. */
    2029 public static final String[] lexStateNames = {
    2030    "DEFAULT",
    2031    "IN_FORMAL_COMMENT",
    2032    "IN_MULTI_LINE_COMMENT",
    2033 };
    2034
    2035 /** Lex State array. */
    2036 public static final int[] jjnewLexState = {
    2037    -1, -1, -1, -1, -1, -1, -1, 1, 2, 0, 0, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
    2038    -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,
    2039    -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,
    2040    -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,
    2041    -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,
    2042    -1,
    2043 };
    2044 static final long[] jjtoToken = {
    2045    0xfffffffffffff001L, 0x3ffffffffffff3b0L,
    2046 };
    2047 static final long[] jjtoSkip = {
    2048    0x67eL, 0x0L,
    2049 };
    2050 static final long[] jjtoSpecial = {
    2051    0x67eL, 0x0L,
    2052 };
    2053 static final long[] jjtoMore = {
    2054    0x980L, 0x0L,
    2055 };
    2056 protected CharStream input_stream;
    2057 private final int[] jjrounds = new int[99];
    2058 private final int[] jjstateSet = new int[198];
    2059 private final StringBuilder jjimage = new StringBuilder();
    2060 private StringBuilder image = jjimage;
    2061 private int jjimageLen;
    2062 private int lengthOfMatch;
    2063 protected char curChar;
    2064 /** Constructor. */
    2065 public JavaParserTokenManager(CharStream stream){
    2066    input_stream = stream;
    2067 }
    2068
    2069 /** Constructor. */
    2070 public JavaParserTokenManager(CharStream stream, int lexState){
    2071    this(stream);
    2072    SwitchTo(lexState);
    2073 }
    2074
    2075 /** Reinitialise parser. */
    2076 public void ReInit(CharStream stream)
    2077 {
    2078    jjmatchedPos = jjnewStateCnt = 0;
    2079    curLexState = defaultLexState;
    2080    input_stream = stream;
    2081    ReInitRounds();
    2082 }
    2083 private void ReInitRounds()
    2084 {
    2085    int i;
    2086    jjround = 0x80000001;
    2087    for (i = 99; i-- > 0;)
    2088       jjrounds[i] = 0x80000000;
    2089 }
    2090
    2091 /** Reinitialise parser. */
    2092 public void ReInit(CharStream stream, int lexState)
    2093 {
    2094    ReInit(stream);
    2095    SwitchTo(lexState);
    2096 }
    2097
    2098 /** Switch to specified lex state. */
    2099 public void SwitchTo(int lexState)
    2100 {
    2101    if (lexState >= 3 || lexState < 0)
    2102       throw new TokenMgrError("Error: Ignoring invalid lexical state : " + lexState + ". State unchanged.", TokenMgrError.INVALID_LEXICAL_STATE);
    2103    else
    2104       curLexState = lexState;
    2105 }
    2106
    2107 protected Token jjFillToken()
    2108 {
    2109    final Token t;
    2110    final String curTokenImage;
    2111    final int beginLine;
    2112    final int endLine;
    2113    final int beginColumn;
    2114    final int endColumn;
    2115    String im = jjstrLiteralImages[jjmatchedKind];
    2116    curTokenImage = (im == null) ? input_stream.GetImage() : im;
    2117    beginLine = input_stream.getBeginLine();
    2118    beginColumn = input_stream.getBeginColumn();
    2119    endLine = input_stream.getEndLine();
    2120    endColumn = input_stream.getEndColumn();
    2121    t = Token.newToken(jjmatchedKind, curTokenImage);
    2122
    2123    t.beginLine = beginLine;
    2124    t.endLine = endLine;
    2125    t.beginColumn = beginColumn;
    2126    t.endColumn = endColumn;
    2127
    2128    return t;
    2129 }
    2130
    2131 int curLexState = 0;
    2132 int defaultLexState = 0;
    2133 int jjnewStateCnt;
    2134 int jjround;
    2135 int jjmatchedPos;
    2136 int jjmatchedKind;
    2137
    2138 /** Get the next Token. */
    2139 public Token getNextToken()
    2140 {
    2141   Token specialToken = null;
    2142   Token matchedToken;
    2143   int curPos = 0;
    2144
    2145   EOFLoop :
    2146   for (;;)
    2147   {
    2148    try
    2149    {
    2150       curChar = input_stream.BeginToken();
    2151    }
    2152    catch(java.io.IOException e)
    2153    {
    2154       jjmatchedKind = 0;
    2155       matchedToken = jjFillToken();
    2156       matchedToken.specialToken = specialToken;
    2157       return matchedToken;
    2158    }
    2159    image = jjimage;
    2160    image.setLength(0);
    2161    jjimageLen = 0;
    2162
    2163    for (;;)
    2164    {
    2165      switch(curLexState)
    2166      {
    2167        case 0:
    2168          jjmatchedKind = 0x7fffffff;
    2169          jjmatchedPos = 0;
    2170          curPos = jjMoveStringLiteralDfa0_0();
    2171          break;
    2172        case 1:
    2173          jjmatchedKind = 0x7fffffff;
    2174          jjmatchedPos = 0;
    2175          curPos = jjMoveStringLiteralDfa0_1();
    2176          if (jjmatchedPos == 0 && jjmatchedKind > 11)
    2177          {
    2178             jjmatchedKind = 11;
    2179          }
    2180          break;
    2181        case 2:
    2182          jjmatchedKind = 0x7fffffff;
    2183          jjmatchedPos = 0;
    2184          curPos = jjMoveStringLiteralDfa0_2();
    2185          if (jjmatchedPos == 0 && jjmatchedKind > 11)
    2186          {
    2187             jjmatchedKind = 11;
    2188          }
    2189          break;
    2190      }
    2191      if (jjmatchedKind != 0x7fffffff)
    2192      {
    2193         if (jjmatchedPos + 1 < curPos)
    2194            input_stream.backup(curPos - jjmatchedPos - 1);
    2195         if ((jjtoToken[jjmatchedKind >> 6] & (1L << (jjmatchedKind & 077))) != 0L)
    2196         {
    2197            matchedToken = jjFillToken();
    2198            matchedToken.specialToken = specialToken;
    2199            TokenLexicalActions(matchedToken);
    2200        if (jjnewLexState[jjmatchedKind] != -1)
    2201          curLexState = jjnewLexState[jjmatchedKind];
    2202            return matchedToken;
    2203         }
    2204         else if ((jjtoSkip[jjmatchedKind >> 6] & (1L << (jjmatchedKind & 077))) != 0L)
    2205         {
    2206            if ((jjtoSpecial[jjmatchedKind >> 6] & (1L << (jjmatchedKind & 077))) != 0L)
    2207            {
    2208               matchedToken = jjFillToken();
    2209               if (specialToken == null)
    2210                  specialToken = matchedToken;
    2211               else
    2212               {
    2213                  matchedToken.specialToken = specialToken;
    2214                  specialToken = (specialToken.next = matchedToken);
    2215               }
    2216               SkipLexicalActions(matchedToken);
    2217            }
    2218            else
    2219               SkipLexicalActions(null);
    2220          if (jjnewLexState[jjmatchedKind] != -1)
    2221            curLexState = jjnewLexState[jjmatchedKind];
    2222            continue EOFLoop;
    2223         }
    2224         MoreLexicalActions();
    2225       if (jjnewLexState[jjmatchedKind] != -1)
    2226         curLexState = jjnewLexState[jjmatchedKind];
    2227         curPos = 0;
    2228         jjmatchedKind = 0x7fffffff;
    2229         try {
    2230            curChar = input_stream.readChar();
    2231            continue;
    2232         }
    2233         catch (java.io.IOException e1) { }
    2234      }
    2235      int error_line = input_stream.getEndLine();
    2236      int error_column = input_stream.getEndColumn();
    2237      String error_after = null;
    2238      boolean EOFSeen = false;
    2239      try { input_stream.readChar(); input_stream.backup(1); }
    2240      catch (java.io.IOException e1) {
    2241         EOFSeen = true;
    2242         error_after = curPos <= 1 ? "" : input_stream.GetImage();
    2243         if (curChar == '\n' || curChar == '\r') {
    2244            error_line++;
    2245            error_column = 0;
    2246         }
    2247         else
    2248            error_column++;
    2249      }
    2250      if (!EOFSeen) {
    2251         input_stream.backup(1);
    2252         error_after = curPos <= 1 ? "" : input_stream.GetImage();
    2253      }
    2254      throw new TokenMgrError(EOFSeen, curLexState, error_line, error_column, error_after, curChar, TokenMgrError.LEXICAL_ERROR);
    2255    }
    2256   }
    2257 }
    2258
    2259 void SkipLexicalActions(Token matchedToken)
    2260 {
    2261    switch(jjmatchedKind)
    2262    {
    2263       case 6 :
    2264          image.append(input_stream.GetSuffix(jjimageLen + (lengthOfMatch = jjmatchedPos + 1)));
    2265         int startOfNOPMD = matchedToken.image.indexOf(suppressMarker);
    2266         if (startOfNOPMD != -1) {
    2267             suppressMap.put(matchedToken.beginLine, matchedToken.image.substring(startOfNOPMD + suppressMarker.length()));
    2268         }
    2269         comments.add(new SingleLineComment(matchedToken));
    2270          break;
    2271       case 9 :
    2272          image.append(input_stream.GetSuffix(jjimageLen + (lengthOfMatch = jjmatchedPos + 1)));
    2273                             comments.add(new FormalComment(matchedToken));
    2274          break;
    2275       case 10 :
    2276          image.append(input_stream.GetSuffix(jjimageLen + (lengthOfMatch = jjmatchedPos + 1)));
    2277                                 comments.add(new MultiLineComment(matchedToken));
    2278          break;
    2279       default :
    2280          break;
    2281    }
    2282 }
    2283 void MoreLexicalActions()
    2284 {
    2285    jjimageLen += (lengthOfMatch = jjmatchedPos + 1);
    2286    switch(jjmatchedKind)
    2287    {
    2288       case 7 :
    2289          image.append(input_stream.GetSuffix(jjimageLen));
    2290          jjimageLen = 0;
    2291                    input_stream.backup(1);
    2292          break;
    2293       default :
    2294          break;
    2295    }
    2296 }
    2297 void TokenLexicalActions(Token matchedToken)
    2298 {
    2299    switch(jjmatchedKind)
    2300    {
    2301       case 121 :
    2302         image.append(jjstrLiteralImages[121]);
    2303         lengthOfMatch = jjstrLiteralImages[121].length();
    2304      matchedToken.kind = GT;
    2305      ((Token.GTToken)matchedToken).realKind = RUNSIGNEDSHIFT;
    2306      input_stream.backup(2);
    2307      matchedToken.image = ">";
    2308          break;
    2309       case 122 :
    2310         image.append(jjstrLiteralImages[122]);
    2311         lengthOfMatch = jjstrLiteralImages[122].length();
    2312      matchedToken.kind = GT;
    2313      ((Token.GTToken)matchedToken).realKind = RSIGNEDSHIFT;
    2314      input_stream.backup(1);
    2315      matchedToken.image = ">";
    2316          break;
    2317       default :
    2318          break;
    2319    }
    2320 }
    2321 private void jjCheckNAdd(int state)
    2322 {
    2323    if (jjrounds[state] != jjround)
    2324    {
    2325       jjstateSet[jjnewStateCnt++] = state;
    2326       jjrounds[state] = jjround;
    2327    }
    2328 }
    2329 private void jjAddStates(int start, int end)
    2330 {
    2331    do {
    2332       jjstateSet[jjnewStateCnt++] = jjnextStates[start];
    2333    } while (start++ != end);
    2334 }
    2335 private void jjCheckNAddTwoStates(int state1, int state2)
    2336 {
    2337    jjCheckNAdd(state1);
    2338    jjCheckNAdd(state2);
    2339 }
    2340
    2341 private void jjCheckNAddStates(int start, int end)
    2342 {
    2343    do {
    2344       jjCheckNAdd(jjnextStates[start]);
    2345    } while (start++ != end);
    2346 }
    2347
    2348 }