View Javadoc

    1   /* Generated By:JavaCC: Do not edit this line. SelectorParserTokenManager.java */
    2   package org.codehaus.activemq.selector;
    3
    4
    5   public class SelectorParserTokenManager implements SelectorParserConstants {
    6       public java.io.PrintStream debugStream = System.out;
    7
    8       public void setDebugStream(java.io.PrintStream ds) {
    9           debugStream = ds;
    10      }
    11
    12      private final int jjStopAtPos(int pos, int kind) {
    13          jjmatchedKind = kind;
    14          jjmatchedPos = pos;
    15          return pos + 1;
    16      }
    17
    18      private final int jjMoveStringLiteralDfa0_0() {
    19          switch (curChar) {
    20              case 9:
    21                  jjmatchedKind = 2;
    22                  return jjMoveNfa_0(5, 0);
    23              case 10:
    24                  jjmatchedKind = 3;
    25                  return jjMoveNfa_0(5, 0);
    26              case 12:
    27                  jjmatchedKind = 5;
    28                  return jjMoveNfa_0(5, 0);
    29              case 13:
    30                  jjmatchedKind = 4;
    31                  return jjMoveNfa_0(5, 0);
    32              case 32:
    33                  jjmatchedKind = 1;
    34                  return jjMoveNfa_0(5, 0);
    35              case 37:
    36                  jjmatchedKind = 37;
    37                  return jjMoveNfa_0(5, 0);
    38              case 40:
    39                  jjmatchedKind = 30;
    40                  return jjMoveNfa_0(5, 0);
    41              case 41:
    42                  jjmatchedKind = 32;
    43                  return jjMoveNfa_0(5, 0);
    44              case 42:
    45                  jjmatchedKind = 35;
    46                  return jjMoveNfa_0(5, 0);
    47              case 43:
    48                  jjmatchedKind = 33;
    49                  return jjMoveNfa_0(5, 0);
    50              case 44:
    51                  jjmatchedKind = 31;
    52                  return jjMoveNfa_0(5, 0);
    53              case 45:
    54                  jjmatchedKind = 34;
    55                  return jjMoveNfa_0(5, 0);
    56              case 47:
    57                  jjmatchedKind = 36;
    58                  return jjMoveNfa_0(5, 0);
    59              case 60:
    60                  jjmatchedKind = 28;
    61                  return jjMoveStringLiteralDfa1_0(0x22000000L);
    62              case 61:
    63                  jjmatchedKind = 24;
    64                  return jjMoveNfa_0(5, 0);
    65              case 62:
    66                  jjmatchedKind = 26;
    67                  return jjMoveStringLiteralDfa1_0(0x8000000L);
    68              case 65:
    69                  return jjMoveStringLiteralDfa1_0(0x200L);
    70              case 66:
    71                  return jjMoveStringLiteralDfa1_0(0x800L);
    72              case 69:
    73                  return jjMoveStringLiteralDfa1_0(0x2000L);
    74              case 70:
    75                  return jjMoveStringLiteralDfa1_0(0x20000L);
    76              case 73:
    77                  return jjMoveStringLiteralDfa1_0(0xc000L);
    78              case 76:
    79                  return jjMoveStringLiteralDfa1_0(0x1000L);
    80              case 78:
    81                  return jjMoveStringLiteralDfa1_0(0x40100L);
    82              case 79:
    83                  return jjMoveStringLiteralDfa1_0(0x400L);
    84              case 84:
    85                  return jjMoveStringLiteralDfa1_0(0x10000L);
    86              case 97:
    87                  return jjMoveStringLiteralDfa1_0(0x200L);
    88              case 98:
    89                  return jjMoveStringLiteralDfa1_0(0x800L);
    90              case 101:
    91                  return jjMoveStringLiteralDfa1_0(0x2000L);
    92              case 102:
    93                  return jjMoveStringLiteralDfa1_0(0x20000L);
    94              case 105:
    95                  return jjMoveStringLiteralDfa1_0(0xc000L);
    96              case 108:
    97                  return jjMoveStringLiteralDfa1_0(0x1000L);
    98              case 110:
    99                  return jjMoveStringLiteralDfa1_0(0x40100L);
    100             case 111:
    101                 return jjMoveStringLiteralDfa1_0(0x400L);
    102             case 116:
    103                 return jjMoveStringLiteralDfa1_0(0x10000L);
    104             default :
    105                 return jjMoveNfa_0(5, 0);
    106         }
    107     }
    108
    109     private final int jjMoveStringLiteralDfa1_0(long active0) {
    110         try {
    111             curChar = input_stream.readChar();
    112         }
    113         catch (java.io.IOException e) {
    114             return jjMoveNfa_0(5, 0);
    115         }
    116         switch (curChar) {
    117             case 61:
    118                 if ((active0 & 0x8000000L) != 0L) {
    119                     jjmatchedKind = 27;
    120                     jjmatchedPos = 1;
    121                 }
    122                 else if ((active0 & 0x20000000L) != 0L) {
    123                     jjmatchedKind = 29;
    124                     jjmatchedPos = 1;
    125                 }
    126                 break;
    127             case 62:
    128                 if ((active0 & 0x2000000L) != 0L) {
    129                     jjmatchedKind = 25;
    130                     jjmatchedPos = 1;
    131                 }
    132                 break;
    133             case 65:
    134                 return jjMoveStringLiteralDfa2_0(active0, 0x20000L);
    135             case 69:
    136                 return jjMoveStringLiteralDfa2_0(active0, 0x800L);
    137             case 73:
    138                 return jjMoveStringLiteralDfa2_0(active0, 0x1000L);
    139             case 78:
    140                 if ((active0 & 0x4000L) != 0L) {
    141                     jjmatchedKind = 14;
    142                     jjmatchedPos = 1;
    143                 }
    144                 return jjMoveStringLiteralDfa2_0(active0, 0x200L);
    145             case 79:
    146                 return jjMoveStringLiteralDfa2_0(active0, 0x100L);
    147             case 82:
    148                 if ((active0 & 0x400L) != 0L) {
    149                     jjmatchedKind = 10;
    150                     jjmatchedPos = 1;
    151                 }
    152                 return jjMoveStringLiteralDfa2_0(active0, 0x10000L);
    153             case 83:
    154                 if ((active0 & 0x8000L) != 0L) {
    155                     jjmatchedKind = 15;
    156                     jjmatchedPos = 1;
    157                 }
    158                 return jjMoveStringLiteralDfa2_0(active0, 0x2000L);
    159             case 85:
    160                 return jjMoveStringLiteralDfa2_0(active0, 0x40000L);
    161             case 97:
    162                 return jjMoveStringLiteralDfa2_0(active0, 0x20000L);
    163             case 101:
    164                 return jjMoveStringLiteralDfa2_0(active0, 0x800L);
    165             case 105:
    166                 return jjMoveStringLiteralDfa2_0(active0, 0x1000L);
    167             case 110:
    168                 if ((active0 & 0x4000L) != 0L) {
    169                     jjmatchedKind = 14;
    170                     jjmatchedPos = 1;
    171                 }
    172                 return jjMoveStringLiteralDfa2_0(active0, 0x200L);
    173             case 111:
    174                 return jjMoveStringLiteralDfa2_0(active0, 0x100L);
    175             case 114:
    176                 if ((active0 & 0x400L) != 0L) {
    177                     jjmatchedKind = 10;
    178                     jjmatchedPos = 1;
    179                 }
    180                 return jjMoveStringLiteralDfa2_0(active0, 0x10000L);
    181             case 115:
    182                 if ((active0 & 0x8000L) != 0L) {
    183                     jjmatchedKind = 15;
    184                     jjmatchedPos = 1;
    185                 }
    186                 return jjMoveStringLiteralDfa2_0(active0, 0x2000L);
    187             case 117:
    188                 return jjMoveStringLiteralDfa2_0(active0, 0x40000L);
    189             default :
    190                 break;
    191         }
    192         return jjMoveNfa_0(5, 1);
    193     }
    194
    195     private final int jjMoveStringLiteralDfa2_0(long old0, long active0) {
    196         if (((active0 &= old0)) == 0L) {
    197             return jjMoveNfa_0(5, 1);
    198         }
    199         try {
    200             curChar = input_stream.readChar();
    201         }
    202         catch (java.io.IOException e) {
    203             return jjMoveNfa_0(5, 1);
    204         }
    205         switch (curChar) {
    206             case 67:
    207                 return jjMoveStringLiteralDfa3_0(active0, 0x2000L);
    208             case 68:
    209                 if ((active0 & 0x200L) != 0L) {
    210                     jjmatchedKind = 9;
    211                     jjmatchedPos = 2;
    212                 }
    213                 break;
    214             case 75:
    215                 return jjMoveStringLiteralDfa3_0(active0, 0x1000L);
    216             case 76:
    217                 return jjMoveStringLiteralDfa3_0(active0, 0x60000L);
    218             case 84:
    219                 if ((active0 & 0x100L) != 0L) {
    220                     jjmatchedKind = 8;
    221                     jjmatchedPos = 2;
    222                 }
    223                 return jjMoveStringLiteralDfa3_0(active0, 0x800L);
    224             case 85:
    225                 return jjMoveStringLiteralDfa3_0(active0, 0x10000L);
    226             case 99:
    227                 return jjMoveStringLiteralDfa3_0(active0, 0x2000L);
    228             case 100:
    229                 if ((active0 & 0x200L) != 0L) {
    230                     jjmatchedKind = 9;
    231                     jjmatchedPos = 2;
    232                 }
    233                 break;
    234             case 107:
    235                 return jjMoveStringLiteralDfa3_0(active0, 0x1000L);
    236             case 108:
    237                 return jjMoveStringLiteralDfa3_0(active0, 0x60000L);
    238             case 116:
    239                 if ((active0 & 0x100L) != 0L) {
    240                     jjmatchedKind = 8;
    241                     jjmatchedPos = 2;
    242                 }
    243                 return jjMoveStringLiteralDfa3_0(active0, 0x800L);
    244             case 117:
    245                 return jjMoveStringLiteralDfa3_0(active0, 0x10000L);
    246             default :
    247                 break;
    248         }
    249         return jjMoveNfa_0(5, 2);
    250     }
    251
    252     private final int jjMoveStringLiteralDfa3_0(long old0, long active0) {
    253         if (((active0 &= old0)) == 0L) {
    254             return jjMoveNfa_0(5, 2);
    255         }
    256         try {
    257             curChar = input_stream.readChar();
    258         }
    259         catch (java.io.IOException e) {
    260             return jjMoveNfa_0(5, 2);
    261         }
    262         switch (curChar) {
    263             case 65:
    264                 return jjMoveStringLiteralDfa4_0(active0, 0x2000L);
    265             case 69:
    266                 if ((active0 & 0x1000L) != 0L) {
    267                     jjmatchedKind = 12;
    268                     jjmatchedPos = 3;
    269                 }
    270                 else if ((active0 & 0x10000L) != 0L) {
    271                     jjmatchedKind = 16;
    272                     jjmatchedPos = 3;
    273                 }
    274                 break;
    275             case 76:
    276                 if ((active0 & 0x40000L) != 0L) {
    277                     jjmatchedKind = 18;
    278                     jjmatchedPos = 3;
    279                 }
    280                 break;
    281             case 83:
    282                 return jjMoveStringLiteralDfa4_0(active0, 0x20000L);
    283             case 87:
    284                 return jjMoveStringLiteralDfa4_0(active0, 0x800L);
    285             case 97:
    286                 return jjMoveStringLiteralDfa4_0(active0, 0x2000L);
    287             case 101:
    288                 if ((active0 & 0x1000L) != 0L) {
    289                     jjmatchedKind = 12;
    290                     jjmatchedPos = 3;
    291                 }
    292                 else if ((active0 & 0x10000L) != 0L) {
    293                     jjmatchedKind = 16;
    294                     jjmatchedPos = 3;
    295                 }
    296                 break;
    297             case 108:
    298                 if ((active0 & 0x40000L) != 0L) {
    299                     jjmatchedKind = 18;
    300                     jjmatchedPos = 3;
    301                 }
    302                 break;
    303             case 115:
    304                 return jjMoveStringLiteralDfa4_0(active0, 0x20000L);
    305             case 119:
    306                 return jjMoveStringLiteralDfa4_0(active0, 0x800L);
    307             default :
    308                 break;
    309         }
    310         return jjMoveNfa_0(5, 3);
    311     }
    312
    313     private final int jjMoveStringLiteralDfa4_0(long old0, long active0) {
    314         if (((active0 &= old0)) == 0L) {
    315             return jjMoveNfa_0(5, 3);
    316         }
    317         try {
    318             curChar = input_stream.readChar();
    319         }
    320         catch (java.io.IOException e) {
    321             return jjMoveNfa_0(5, 3);
    322         }
    323         switch (curChar) {
    324             case 69:
    325                 if ((active0 & 0x20000L) != 0L) {
    326                     jjmatchedKind = 17;
    327                     jjmatchedPos = 4;
    328                 }
    329                 return jjMoveStringLiteralDfa5_0(active0, 0x800L);
    330             case 80:
    331                 return jjMoveStringLiteralDfa5_0(active0, 0x2000L);
    332             case 101:
    333                 if ((active0 & 0x20000L) != 0L) {
    334                     jjmatchedKind = 17;
    335                     jjmatchedPos = 4;
    336                 }
    337                 return jjMoveStringLiteralDfa5_0(active0, 0x800L);
    338             case 112:
    339                 return jjMoveStringLiteralDfa5_0(active0, 0x2000L);
    340             default :
    341                 break;
    342         }
    343         return jjMoveNfa_0(5, 4);
    344     }
    345
    346     private final int jjMoveStringLiteralDfa5_0(long old0, long active0) {
    347         if (((active0 &= old0)) == 0L) {
    348             return jjMoveNfa_0(5, 4);
    349         }
    350         try {
    351             curChar = input_stream.readChar();
    352         }
    353         catch (java.io.IOException e) {
    354             return jjMoveNfa_0(5, 4);
    355         }
    356         switch (curChar) {
    357             case 69:
    358                 if ((active0 & 0x2000L) != 0L) {
    359                     jjmatchedKind = 13;
    360                     jjmatchedPos = 5;
    361                 }
    362                 return jjMoveStringLiteralDfa6_0(active0, 0x800L);
    363             case 101:
    364                 if ((active0 & 0x2000L) != 0L) {
    365                     jjmatchedKind = 13;
    366                     jjmatchedPos = 5;
    367                 }
    368                 return jjMoveStringLiteralDfa6_0(active0, 0x800L);
    369             default :
    370                 break;
    371         }
    372         return jjMoveNfa_0(5, 5);
    373     }
    374
    375     private final int jjMoveStringLiteralDfa6_0(long old0, long active0) {
    376         if (((active0 &= old0)) == 0L) {
    377             return jjMoveNfa_0(5, 5);
    378         }
    379         try {
    380             curChar = input_stream.readChar();
    381         }
    382         catch (java.io.IOException e) {
    383             return jjMoveNfa_0(5, 5);
    384         }
    385         switch (curChar) {
    386             case 78:
    387                 if ((active0 & 0x800L) != 0L) {
    388                     jjmatchedKind = 11;
    389                     jjmatchedPos = 6;
    390                 }
    391                 break;
    392             case 110:
    393                 if ((active0 & 0x800L) != 0L) {
    394                     jjmatchedKind = 11;
    395                     jjmatchedPos = 6;
    396                 }
    397                 break;
    398             default :
    399                 break;
    400         }
    401         return jjMoveNfa_0(5, 6);
    402     }
    403
    404     private final void jjCheckNAdd(int state) {
    405         if (jjrounds[state] != jjround) {
    406             jjstateSet[jjnewStateCnt++] = state;
    407             jjrounds[state] = jjround;
    408         }
    409     }
    410
    411     private final void jjAddStates(int start, int end) {
    412         do {
    413             jjstateSet[jjnewStateCnt++] = jjnextStates[start];
    414         }
    415         while (start++ != end);
    416     }
    417
    418     private final void jjCheckNAddTwoStates(int state1, int state2) {
    419         jjCheckNAdd(state1);
    420         jjCheckNAdd(state2);
    421     }
    422
    423     private final void jjCheckNAddStates(int start, int end) {
    424         do {
    425             jjCheckNAdd(jjnextStates[start]);
    426         }
    427         while (start++ != end);
    428     }
    429
    430     private final void jjCheckNAddStates(int start) {
    431         jjCheckNAdd(jjnextStates[start]);
    432         jjCheckNAdd(jjnextStates[start + 1]);
    433     }
    434
    435     static final long[] jjbitVec0 = {
    436         0xfffffffffffffffeL, 0xffffffffffffffffL, 0xffffffffffffffffL, 0xffffffffffffffffL
    437     };
    438     static final long[] jjbitVec2 = {
    439         0x0L, 0x0L, 0xffffffffffffffffL, 0xffffffffffffffffL
    440     };
    441
    442     private final int jjMoveNfa_0(int startState, int curPos) {
    443         int strKind = jjmatchedKind;
    444         int strPos = jjmatchedPos;
    445         int seenUpto;
    446         input_stream.backup(seenUpto = curPos + 1);
    447         try {
    448             curChar = input_stream.readChar();
    449         }
    450         catch (java.io.IOException e) {
    451             throw new Error("Internal Error");
    452         }
    453         curPos = 0;
    454         int[] nextStates;
    455         int startsAt = 0;
    456         jjnewStateCnt = 37;
    457         int i = 1;
    458         jjstateSet[0] = startState;
    459         int j, kind = 0x7fffffff;
    460         for (; ;) {
    461             if (++jjround == 0x7fffffff) {
    462                 ReInitRounds();
    463             }
    464             if (curChar < 64) {
    465                 long l = 1L << curChar;
    466                 MatchLoop: do {
    467                     switch (jjstateSet[--i]) {
    468                         case 5:
    469                             if ((0x3ff000000000000L & l) != 0L) {
    470                                 if (kind > 19) {
    471                                     kind = 19;
    472                                 }
    473                                 jjCheckNAddStates(0, 4);
    474                             }
    475                             else if (curChar == 36) {
    476                                 if (kind > 23) {
    477                                     kind = 23;
    478                                 }
    479                                 jjCheckNAdd(24);
    480                             }
    481                             else if (curChar == 39) {
    482                                 jjCheckNAddStates(5, 7);
    483                             }
    484                             else if (curChar == 46) {
    485                                 jjCheckNAdd(14);
    486                             }
    487                             else if (curChar == 47) {
    488                                 jjstateSet[jjnewStateCnt++] = 6;
    489                             }
    490                             else if (curChar == 45) {
    491                                 jjstateSet[jjnewStateCnt++] = 0;
    492                             }
    493                             break;
    494                         case 0:
    495                             if (curChar == 45) {
    496                                 jjCheckNAddStates(8, 10);
    497                             }
    498                             break;
    499                         case 1:
    500                             if ((0xffffffffffffdbffL & l) != 0L) {
    501                                 jjCheckNAddStates(8, 10);
    502                             }
    503                             break;
    504                         case 2:
    505                             if ((0x2400L & l) != 0L && kind > 6) {
    506                                 kind = 6;
    507                             }
    508                             break;
    509                         case 3:
    510                             if (curChar == 10 && kind > 6) {
    511                                 kind = 6;
    512                             }
    513                             break;
    514                         case 4:
    515                             if (curChar == 13) {
    516                                 jjstateSet[jjnewStateCnt++] = 3;
    517                             }
    518                             break;
    519                         case 6:
    520                             if (curChar == 42) {
    521                                 jjCheckNAddTwoStates(7, 8);
    522                             }
    523                             break;
    524                         case 7:
    525                             if ((0xfffffbffffffffffL & l) != 0L) {
    526                                 jjCheckNAddTwoStates(7, 8);
    527                             }
    528                             break;
    529                         case 8:
    530                             if (curChar == 42) {
    531                                 jjCheckNAddStates(11, 13);
    532                             }
    533                             break;
    534                         case 9:
    535                             if ((0xffff7bffffffffffL & l) != 0L) {
    536                                 jjCheckNAddTwoStates(10, 8);
    537                             }
    538                             break;
    539                         case 10:
    540                             if ((0xfffffbffffffffffL & l) != 0L) {
    541                                 jjCheckNAddTwoStates(10, 8);
    542                             }
    543                             break;
    544                         case 11:
    545                             if (curChar == 47 && kind > 7) {
    546                                 kind = 7;
    547                             }
    548                             break;
    549                         case 12:
    550                             if (curChar == 47) {
    551                                 jjstateSet[jjnewStateCnt++] = 6;
    552                             }
    553                             break;
    554                         case 13:
    555                             if (curChar == 46) {
    556                                 jjCheckNAdd(14);
    557                             }
    558                             break;
    559                         case 14:
    560                             if ((0x3ff000000000000L & l) == 0L) {
    561                                 break;
    562                             }
    563                             if (kind > 20) {
    564                                 kind = 20;
    565                             }
    566                             jjCheckNAddTwoStates(14, 15);
    567                             break;
    568                         case 16:
    569                             if ((0x280000000000L & l) != 0L) {
    570                                 jjCheckNAdd(17);
    571                             }
    572                             break;
    573                         case 17:
    574                             if ((0x3ff000000000000L & l) == 0L) {
    575                                 break;
    576                             }
    577                             if (kind > 20) {
    578                                 kind = 20;
    579                             }
    580                             jjCheckNAdd(17);
    581                             break;
    582                         case 18:
    583                         case 19:
    584                             if (curChar == 39) {
    585                                 jjCheckNAddStates(5, 7);
    586                             }
    587                             break;
    588                         case 20:
    589                             if (curChar == 39) {
    590                                 jjstateSet[jjnewStateCnt++] = 19;
    591                             }
    592                             break;
    593                         case 21:
    594                             if ((0xffffff7fffffffffL & l) != 0L) {
    595                                 jjCheckNAddStates(5, 7);
    596                             }
    597                             break;
    598                         case 22:
    599                             if (curChar == 39 && kind > 22) {
    600                                 kind = 22;
    601                             }
    602                             break;
    603                         case 23:
    604                             if (curChar != 36) {
    605                                 break;
    606                             }
    607                             if (kind > 23) {
    608                                 kind = 23;
    609                             }
    610                             jjCheckNAdd(24);
    611                             break;
    612                         case 24:
    613                             if ((0x3ff001000000000L & l) == 0L) {
    614                                 break;
    615                             }
    616                             if (kind > 23) {
    617                                 kind = 23;
    618                             }
    619                             jjCheckNAdd(24);
    620                             break;
    621                         case 25:
    622                             if ((0x3ff000000000000L & l) == 0L) {
    623                                 break;
    624                             }
    625                             if (kind > 19) {
    626                                 kind = 19;
    627                             }
    628                             jjCheckNAddStates(0, 4);
    629                             break;
    630                         case 26:
    631                             if ((0x3ff000000000000L & l) == 0L) {
    632                                 break;
    633                             }
    634                             if (kind > 19) {
    635                                 kind = 19;
    636                             }
    637                             jjCheckNAdd(26);
    638                             break;
    639                         case 27:
    640                             if ((0x3ff000000000000L & l) != 0L) {
    641                                 jjCheckNAddTwoStates(27, 28);
    642                             }
    643                             break;
    644                         case 28:
    645                             if (curChar != 46) {
    646                                 break;
    647                             }
    648                             if (kind > 20) {
    649                                 kind = 20;
    650                             }
    651                             jjCheckNAddTwoStates(29, 30);
    652                             break;
    653                         case 29:
    654                             if ((0x3ff000000000000L & l) == 0L) {
    655                                 break;
    656                             }
    657                             if (kind > 20) {
    658                                 kind = 20;
    659                             }
    660                             jjCheckNAddTwoStates(29, 30);
    661                             break;
    662                         case 31:
    663                             if ((0x280000000000L & l) != 0L) {
    664                                 jjCheckNAdd(32);
    665                             }
    666                             break;
    667                         case 32:
    668                             if ((0x3ff000000000000L & l) == 0L) {
    669                                 break;
    670                             }
    671                             if (kind > 20) {
    672                                 kind = 20;
    673                             }
    674                             jjCheckNAdd(32);
    675                             break;
    676                         case 33:
    677                             if ((0x3ff000000000000L & l) != 0L) {
    678                                 jjCheckNAddTwoStates(33, 34);
    679                             }
    680                             break;
    681                         case 35:
    682                             if ((0x280000000000L & l) != 0L) {
    683                                 jjCheckNAdd(36);
    684                             }
    685                             break;
    686                         case 36:
    687                             if ((0x3ff000000000000L & l) == 0L) {
    688                                 break;
    689                             }
    690                             if (kind > 20) {
    691                                 kind = 20;
    692                             }
    693                             jjCheckNAdd(36);
    694                             break;
    695                         default :
    696                             break;
    697                     }
    698                 }
    699                 while (i != startsAt);
    700             }
    701             else if (curChar < 128) {
    702                 long l = 1L << (curChar & 077);
    703                 MatchLoop: do {
    704                     switch (jjstateSet[--i]) {
    705                         case 5:
    706                         case 24:
    707                             if ((0x7fffffe87fffffeL & l) == 0L) {
    708                                 break;
    709                             }
    710                             if (kind > 23) {
    711                                 kind = 23;
    712                             }
    713                             jjCheckNAdd(24);
    714                             break;
    715                         case 1:
    716                             jjAddStates(8, 10);
    717                             break;
    718                         case 7:
    719                             jjCheckNAddTwoStates(7, 8);
    720                             break;
    721                         case 9:
    722                         case 10:
    723                             jjCheckNAddTwoStates(10, 8);
    724                             break;
    725                         case 15:
    726                             if ((0x2000000020L & l) != 0L) {
    727                                 jjAddStates(14, 15);
    728                             }
    729                             break;
    730                         case 21:
    731                             jjAddStates(5, 7);
    732                             break;
    733                         case 30:
    734                             if ((0x2000000020L & l) != 0L) {
    735                                 jjAddStates(16, 17);
    736                             }
    737                             break;
    738                         case 34:
    739                             if ((0x2000000020L & l) != 0L) {
    740                                 jjAddStates(18, 19);
    741                             }
    742                             break;
    743                         default :
    744                             break;
    745                     }
    746                 }
    747                 while (i != startsAt);
    748             }
    749             else {
    750                 int hiByte = (int) (curChar >> 8);
    751                 int i1 = hiByte >> 6;
    752                 long l1 = 1L << (hiByte & 077);
    753                 int i2 = (curChar & 0xff) >> 6;
    754                 long l2 = 1L << (curChar & 077);
    755                 MatchLoop: do {
    756                     switch (jjstateSet[--i]) {
    757                         case 1:
    758                             if (jjCanMove_0(hiByte, i1, i2, l1, l2)) {
    759                                 jjAddStates(8, 10);
    760                             }
    761                             break;
    762                         case 7:
    763                             if (jjCanMove_0(hiByte, i1, i2, l1, l2)) {
    764                                 jjCheckNAddTwoStates(7, 8);
    765                             }
    766                             break;
    767                         case 9:
    768                         case 10:
    769                             if (jjCanMove_0(hiByte, i1, i2, l1, l2)) {
    770                                 jjCheckNAddTwoStates(10, 8);
    771                             }
    772                             break;
    773                         case 21:
    774                             if (jjCanMove_0(hiByte, i1, i2, l1, l2)) {
    775                                 jjAddStates(5, 7);
    776                             }
    777                             break;
    778                         default :
    779                             break;
    780                     }
    781                 }
    782                 while (i != startsAt);
    783             }
    784             if (kind != 0x7fffffff) {
    785                 jjmatchedKind = kind;
    786                 jjmatchedPos = curPos;
    787                 kind = 0x7fffffff;
    788             }
    789             ++curPos;
    790             if ((i = jjnewStateCnt) == (startsAt = 37 - (jjnewStateCnt = startsAt))) {
    791                 break;
    792             }
    793             try {
    794                 curChar = input_stream.readChar();
    795             }
    796             catch (java.io.IOException e) {
    797                 break;
    798             }
    799         }
    800         if (jjmatchedPos > strPos) {
    801             return curPos;
    802         }
    803
    804         int toRet = Math.max(curPos, seenUpto);
    805
    806         if (curPos < toRet) {
    807             for (i = toRet - Math.min(curPos, seenUpto); i-- > 0;) {
    808                 try {
    809                     curChar = input_stream.readChar();
    810                 }
    811                 catch (java.io.IOException e) {
    812                     throw new Error("Internal Error : Please send a bug report.");
    813                 }
    814             }
    815         }
    816
    817         if (jjmatchedPos < strPos) {
    818             jjmatchedKind = strKind;
    819             jjmatchedPos = strPos;
    820         }
    821         else if (jjmatchedPos == strPos && jjmatchedKind > strKind) {
    822             jjmatchedKind = strKind;
    823         }
    824
    825         return toRet;
    826     }
    827
    828     static final int[] jjnextStates = {
    829         26, 27, 28, 33, 34, 20, 21, 22, 1, 2, 4, 8, 9, 11, 16, 17,
    830         31, 32, 35, 36,
    831     };
    832
    833     private static final boolean jjCanMove_0(int hiByte, int i1, int i2, long l1, long l2) {
    834         switch (hiByte) {
    835             case 0:
    836                 return ((jjbitVec2[i2] & l2) != 0L);
    837             default :
    838                 if ((jjbitVec0[i1] & l1) != 0L) {
    839                     return true;
    840                 }
    841                 return false;
    842         }
    843     }
    844
    845     public static final String[] jjstrLiteralImages = {
    846         "", null, null, null, null, null, null, null, null, null, null, null, null,
    847         null, null, null, null, null, null, null, null, null, null, null, "\75", "\74\76",
    848         "\76", "\76\75", "\74", "\74\75", "\50", "\54", "\51", "\53", "\55", "\52", "\57",
    849         "\45", };
    850     public static final String[] lexStateNames = {
    851         "DEFAULT",
    852     };
    853     static final long[] jjtoToken = {
    854         0x3fffdfff01L,
    855     };
    856     static final long[] jjtoSkip = {
    857         0xfeL,
    858     };
    859     static final long[] jjtoSpecial = {
    860         0x3eL,
    861     };
    862     private SimpleCharStream input_stream;
    863     private final int[] jjrounds = new int[37];
    864     private final int[] jjstateSet = new int[74];
    865     protected char curChar;
    866
    867     public SelectorParserTokenManager(SimpleCharStream stream) {
    868         if (SimpleCharStream.staticFlag) {
    869             throw new Error("ERROR: Cannot use a static CharStream class with a non-static lexical analyzer.");
    870         }
    871         input_stream = stream;
    872     }
    873
    874     public SelectorParserTokenManager(SimpleCharStream stream, int lexState) {
    875         this(stream);
    876         SwitchTo(lexState);
    877     }
    878
    879     public void ReInit(SimpleCharStream stream) {
    880         jjmatchedPos = jjnewStateCnt = 0;
    881         curLexState = defaultLexState;
    882         input_stream = stream;
    883         ReInitRounds();
    884     }
    885
    886     private final void ReInitRounds() {
    887         int i;
    888         jjround = 0x80000001;
    889         for (i = 37; i-- > 0;) {
    890             jjrounds[i] = 0x80000000;
    891         }
    892     }
    893
    894     public void ReInit(SimpleCharStream stream, int lexState) {
    895         ReInit(stream);
    896         SwitchTo(lexState);
    897     }
    898
    899     public void SwitchTo(int lexState) {
    900         if (lexState >= 1 || lexState < 0) {
    901             throw new TokenMgrError("Error: Ignoring invalid lexical state : " + lexState + ". State unchanged.", TokenMgrError.INVALID_LEXICAL_STATE);
    902         }
    903         else {
    904             curLexState = lexState;
    905         }
    906     }
    907
    908     private final Token jjFillToken() {
    909         Token t = Token.newToken(jjmatchedKind);
    910         t.kind = jjmatchedKind;
    911         String im = jjstrLiteralImages[jjmatchedKind];
    912         t.image = (im == null) ? input_stream.GetImage() : im;
    913         t.beginLine = input_stream.getBeginLine();
    914         t.beginColumn = input_stream.getBeginColumn();
    915         t.endLine = input_stream.getEndLine();
    916         t.endColumn = input_stream.getEndColumn();
    917         return t;
    918     }
    919
    920     int curLexState = 0;
    921     int defaultLexState = 0;
    922     int jjnewStateCnt;
    923     int jjround;
    924     int jjmatchedPos;
    925     int jjmatchedKind;
    926
    927     public final Token getNextToken() {
    928         int kind;
    929         Token specialToken = null;
    930         Token matchedToken;
    931         int curPos = 0;
    932
    933         EOFLoop :
    934         for (; ;) {
    935             try {
    936                 curChar = input_stream.BeginToken();
    937             }
    938             catch (java.io.IOException e) {
    939                 jjmatchedKind = 0;
    940                 matchedToken = jjFillToken();
    941                 matchedToken.specialToken = specialToken;
    942                 return matchedToken;
    943             }
    944
    945             jjmatchedKind = 0x7fffffff;
    946             jjmatchedPos = 0;
    947             curPos = jjMoveStringLiteralDfa0_0();
    948             if (jjmatchedKind != 0x7fffffff) {
    949                 if (jjmatchedPos + 1 < curPos) {
    950                     input_stream.backup(curPos - jjmatchedPos - 1);
    951                 }
    952                 if ((jjtoToken[jjmatchedKind >> 6] & (1L << (jjmatchedKind & 077))) != 0L) {
    953                     matchedToken = jjFillToken();
    954                     matchedToken.specialToken = specialToken;
    955                     return matchedToken;
    956                 }
    957                 else {
    958                     if ((jjtoSpecial[jjmatchedKind >> 6] & (1L << (jjmatchedKind & 077))) != 0L) {
    959                         matchedToken = jjFillToken();
    960                         if (specialToken == null) {
    961                             specialToken = matchedToken;
    962                         }
    963                         else {
    964                             matchedToken.specialToken = specialToken;
    965                             specialToken = (specialToken.next = matchedToken);
    966                         }
    967                     }
    968                     continue EOFLoop;
    969                 }
    970             }
    971             int error_line = input_stream.getEndLine();
    972             int error_column = input_stream.getEndColumn();
    973             String error_after = null;
    974             boolean EOFSeen = false;
    975             try {
    976                 input_stream.readChar();
    977                 input_stream.backup(1);
    978             }
    979             catch (java.io.IOException e1) {
    980                 EOFSeen = true;
    981                 error_after = curPos <= 1 ? "" : input_stream.GetImage();
    982                 if (curChar == '\n' || curChar == '\r') {
    983                     error_line++;
    984                     error_column = 0;
    985                 }
    986                 else {
    987                     error_column++;
    988                 }
    989             }
    990             if (!EOFSeen) {
    991                 input_stream.backup(1);
    992                 error_after = curPos <= 1 ? "" : input_stream.GetImage();
    993             }
    994             throw new TokenMgrError(EOFSeen, curLexState, error_line, error_column, error_after, curChar, TokenMgrError.LEXICAL_ERROR);
    995         }
    996     }
    997
    998 }