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