gate/yam/parse/YamParserTokenManager.java


YamParserTokenManager.java


0001 /* Generated By:JJTree&JavaCC: Do not edit this line. YamParserTokenManager.java */

0002 package gate.yam.parse;

0003 import java.io.*;

0004 import java.net.*;

0005 import java.util.*;

0006 import org.apache.log4j.Logger;

0007 import gate.util.*;

0008 import gate.yam.*;

0009 

0010 public class YamParserTokenManager implements YamParserConstants

0011 {

0012   public  java.io.PrintStream debugStream = System.out;

0013   public  void setDebugStream(java.io.PrintStream ds) { debugStream = ds; }

0014   public YamParser parser = null;

0015 private final int jjMoveStringLiteralDfa0_5()

0016 {

0017    return jjMoveNfa_5(3, 0);

0018 }

0019 private final void jjCheckNAdd(int state)

0020 {

0021    if (jjrounds[state] != jjround)

0022    {

0023       jjstateSet[jjnewStateCnt++] = state;

0024       jjrounds[state] = jjround;

0025    }

0026 }

0027 private final void jjAddStates(int start, int end)

0028 {

0029    do {

0030       jjstateSet[jjnewStateCnt++] = jjnextStates[start];

0031    } while (start++ != end);

0032 }

0033 private final void jjCheckNAddTwoStates(int state1, int state2)

0034 {

0035    jjCheckNAdd(state1);

0036    jjCheckNAdd(state2);

0037 }

0038 private final void jjCheckNAddStates(int start, int end)

0039 {

0040    do {

0041       jjCheckNAdd(jjnextStates[start]);

0042    } while (start++ != end);

0043 }

0044 private final void jjCheckNAddStates(int start)

0045 {

0046    jjCheckNAdd(jjnextStates[start]);

0047    jjCheckNAdd(jjnextStates[start + 1]);

0048 }

0049 static final long[] jjbitVec0 = {

0050    0xfffffffffffffffeL, 0xffffffffffffffffL, 0xffffffffffffffffL, 0xffffffffffffffffL

0051 };

0052 static final long[] jjbitVec2 = {

0053    0x0L, 0x0L, 0xffffffffffffffffL, 0xffffffffffffffffL

0054 };

0055 private final int jjMoveNfa_5(int startState, int curPos)

0056 {

0057    int[] nextStates;

0058    int startsAt = 0;

0059    jjnewStateCnt = 3;

0060    int i = 1;

0061    jjstateSet[0] = startState;

0062    int j, kind = 0x7fffffff;

0063    for (;;)

0064    {

0065       if (++jjround == 0x7fffffff)

0066          ReInitRounds();

0067       if (curChar < 64)

0068       {

0069          long l = 1L << curChar;

0070          MatchLoop: do

0071          {

0072             switch(jjstateSet[--i])

0073             {

0074                case 3:

0075                case 0:

0076                   if ((0xfffffffeffffd9ffL & l) == 0L)

0077                      break;

0078                   kind = 43;

0079                   jjCheckNAddTwoStates(0, 2);

0080                   break;

0081                case 1:

0082                   if (curChar != 32)

0083                      break;

0084                   kind = 43;

0085                   jjCheckNAddTwoStates(0, 2);

0086                   break;

0087                default : break;

0088             }

0089          } while(i != startsAt);

0090       }

0091       else if (curChar < 128)

0092       {

0093          long l = 1L << (curChar & 077);

0094          MatchLoop: do

0095          {

0096             switch(jjstateSet[--i])

0097             {

0098                case 3:

0099                   if (kind > 43)

0100                      kind = 43;

0101                   jjCheckNAddTwoStates(0, 2);

0102                   if (curChar == 92)

0103                      jjstateSet[jjnewStateCnt++] = 1;

0104                   break;

0105                case 0:

0106                   if (kind > 43)

0107                      kind = 43;

0108                   jjCheckNAddTwoStates(0, 2);

0109                   break;

0110                case 2:

0111                   if (curChar == 92)

0112                      jjstateSet[jjnewStateCnt++] = 1;

0113                   break;

0114                default : break;

0115             }

0116          } while(i != startsAt);

0117       }

0118       else

0119       {

0120          int hiByte = (int)(curChar >> 8);

0121          int i1 = hiByte >> 6;

0122          long l1 = 1L << (hiByte & 077);

0123          int i2 = (curChar & 0xff) >> 6;

0124          long l2 = 1L << (curChar & 077);

0125          MatchLoop: do

0126          {

0127             switch(jjstateSet[--i])

0128             {

0129                case 3:

0130                case 0:

0131                   if (!jjCanMove_0(hiByte, i1, i2, l1, l2))

0132                      break;

0133                   if (kind > 43)

0134                      kind = 43;

0135                   jjCheckNAddTwoStates(0, 2);

0136                   break;

0137                default : break;

0138             }

0139          } while(i != startsAt);

0140       }

0141       if (kind != 0x7fffffff)

0142       {

0143          jjmatchedKind = kind;

0144          jjmatchedPos = curPos;

0145          kind = 0x7fffffff;

0146       }

0147       ++curPos;

0148       if ((i = jjnewStateCnt) == (startsAt = 3 - (jjnewStateCnt = startsAt)))

0149          return curPos;

0150       try { curChar = input_stream.readChar(); }

0151       catch(java.io.IOException e) { return curPos; }

0152    }

0153 }

0154 private final int jjStopAtPos(int pos, int kind)

0155 {

0156    jjmatchedKind = kind;

0157    jjmatchedPos = pos;

0158    return pos + 1;

0159 }

0160 private final int jjMoveStringLiteralDfa0_0()

0161 {

0162    switch(curChar)

0163    {

0164       case 37:

0165          return jjMoveStringLiteralDfa1_0(0x240105400200L);

0166       case 38:

0167          jjmatchedKind = 10;

0168          return jjMoveNfa_0(0, 0);

0169       case 42:

0170          jjmatchedKind = 5;

0171          return jjMoveNfa_0(0, 0);

0172       case 60:

0173          jjmatchedKind = 11;

0174          return jjMoveNfa_0(0, 0);

0175       case 90:

0176          return jjMoveStringLiteralDfa1_0(0x4000L);

0177       case 94:

0178          jjmatchedKind = 6;

0179          return jjMoveNfa_0(0, 0);

0180       case 95:

0181          jjmatchedKind = 7;

0182          return jjMoveStringLiteralDfa1_0(0x100L);

0183       default :

0184          return jjMoveNfa_0(0, 0);

0185    }

0186 }

0187 private final int jjMoveStringLiteralDfa1_0(long active0)

0188 {

0189    try { curChar = input_stream.readChar(); }

0190    catch(java.io.IOException e) {

0191    return jjMoveNfa_0(0, 0);

0192    }

0193    switch(curChar)

0194    {

0195       case 34:

0196          if ((active0 & 0x200L) != 0L)

0197          {

0198             jjmatchedKind = 9;

0199             jjmatchedPos = 1;

0200          }

0201          break;

0202       case 35:

0203          if ((active0 & 0x40000000000L) != 0L)

0204          {

0205             jjmatchedKind = 42;

0206             jjmatchedPos = 1;

0207          }

0208          break;

0209       case 40:

0210          if ((active0 & 0x100000000L) != 0L)

0211          {

0212             jjmatchedKind = 32;

0213             jjmatchedPos = 1;

0214          }

0215          break;

0216       case 47:

0217          return jjMoveStringLiteralDfa2_0(active0, 0x200000000000L);

0218       case 60:

0219          if ((active0 & 0x400000L) != 0L)

0220          {

0221             jjmatchedKind = 22;

0222             jjmatchedPos = 1;

0223          }

0224          break;

0225       case 90:

0226          return jjMoveStringLiteralDfa2_0(active0, 0x4000L);

0227       case 95:

0228          if ((active0 & 0x100L) != 0L)

0229          {

0230             jjmatchedKind = 8;

0231             jjmatchedPos = 1;

0232          }

0233          break;

0234       case 98:

0235          return jjMoveStringLiteralDfa2_0(active0, 0x1000000L);

0236       case 99:

0237          return jjMoveStringLiteralDfa2_0(active0, 0x4000000L);

0238       default :

0239          break;

0240    }

0241    return jjMoveNfa_0(0, 1);

0242 }

0243 private final int jjMoveStringLiteralDfa2_0(long old0, long active0)

0244 {

0245    if (((active0 &= old0)) == 0L)

0246       return jjMoveNfa_0(0, 1);

0247    try { curChar = input_stream.readChar(); }

0248    catch(java.io.IOException e) {

0249    return jjMoveNfa_0(0, 1);

0250    }

0251    switch(curChar)

0252    {

0253       case 42:

0254          if ((active0 & 0x200000000000L) != 0L)

0255          {

0256             jjmatchedKind = 45;

0257             jjmatchedPos = 2;

0258          }

0259          break;

0260       case 90:

0261          return jjMoveStringLiteralDfa3_0(active0, 0x4000L);

0262       case 111:

0263          return jjMoveStringLiteralDfa3_0(active0, 0x4000000L);

0264       case 114:

0265          if ((active0 & 0x1000000L) != 0L)

0266          {

0267             jjmatchedKind = 24;

0268             jjmatchedPos = 2;

0269          }

0270          break;

0271       default :

0272          break;

0273    }

0274    return jjMoveNfa_0(0, 2);

0275 }

0276 private final int jjMoveStringLiteralDfa3_0(long old0, long active0)

0277 {

0278    if (((active0 &= old0)) == 0L)

0279       return jjMoveNfa_0(0, 2);

0280    try { curChar = input_stream.readChar(); }

0281    catch(java.io.IOException e) {

0282    return jjMoveNfa_0(0, 2);

0283    }

0284    switch(curChar)

0285    {

0286       case 81:

0287          return jjMoveStringLiteralDfa4_0(active0, 0x4000L);

0288       case 110:

0289          return jjMoveStringLiteralDfa4_0(active0, 0x4000000L);

0290       default :

0291          break;

0292    }

0293    return jjMoveNfa_0(0, 3);

0294 }

0295 private final int jjMoveStringLiteralDfa4_0(long old0, long active0)

0296 {

0297    if (((active0 &= old0)) == 0L)

0298       return jjMoveNfa_0(0, 3);

0299    try { curChar = input_stream.readChar(); }

0300    catch(java.io.IOException e) {

0301    return jjMoveNfa_0(0, 3);

0302    }

0303    switch(curChar)

0304    {

0305       case 90:

0306          return jjMoveStringLiteralDfa5_0(active0, 0x4000L);

0307       case 116:

0308          return jjMoveStringLiteralDfa5_0(active0, 0x4000000L);

0309       default :

0310          break;

0311    }

0312    return jjMoveNfa_0(0, 4);

0313 }

0314 private final int jjMoveStringLiteralDfa5_0(long old0, long active0)

0315 {

0316    if (((active0 &= old0)) == 0L)

0317       return jjMoveNfa_0(0, 4);

0318    try { curChar = input_stream.readChar(); }

0319    catch(java.io.IOException e) {

0320    return jjMoveNfa_0(0, 4);

0321    }

0322    switch(curChar)

0323    {

0324       case 33:

0325          return jjMoveStringLiteralDfa6_0(active0, 0x4000L);

0326       case 101:

0327          return jjMoveStringLiteralDfa6_0(active0, 0x4000000L);

0328       default :

0329          break;

0330    }

0331    return jjMoveNfa_0(0, 5);

0332 }

0333 private final int jjMoveStringLiteralDfa6_0(long old0, long active0)

0334 {

0335    if (((active0 &= old0)) == 0L)

0336       return jjMoveNfa_0(0, 5);

0337    try { curChar = input_stream.readChar(); }

0338    catch(java.io.IOException e) {

0339    return jjMoveNfa_0(0, 5);

0340    }

0341    switch(curChar)

0342    {

0343       case 108:

0344          return jjMoveStringLiteralDfa7_0(active0, 0x4000L);

0345       case 110:

0346          return jjMoveStringLiteralDfa7_0(active0, 0x4000000L);

0347       default :

0348          break;

0349    }

0350    return jjMoveNfa_0(0, 6);

0351 }

0352 private final int jjMoveStringLiteralDfa7_0(long old0, long active0)

0353 {

0354    if (((active0 &= old0)) == 0L)

0355       return jjMoveNfa_0(0, 6);

0356    try { curChar = input_stream.readChar(); }

0357    catch(java.io.IOException e) {

0358    return jjMoveNfa_0(0, 6);

0359    }

0360    switch(curChar)

0361    {

0362       case 115:

0363          return jjMoveStringLiteralDfa8_0(active0, 0x4000L);

0364       case 116:

0365          return jjMoveStringLiteralDfa8_0(active0, 0x4000000L);

0366       default :

0367          break;

0368    }

0369    return jjMoveNfa_0(0, 7);

0370 }

0371 private final int jjMoveStringLiteralDfa8_0(long old0, long active0)

0372 {

0373    if (((active0 &= old0)) == 0L)

0374       return jjMoveNfa_0(0, 7);

0375    try { curChar = input_stream.readChar(); }

0376    catch(java.io.IOException e) {

0377    return jjMoveNfa_0(0, 7);

0378    }

0379    switch(curChar)

0380    {

0381       case 107:

0382          return jjMoveStringLiteralDfa9_0(active0, 0x4000L);

0383       case 115:

0384          if ((active0 & 0x4000000L) != 0L)

0385          {

0386             jjmatchedKind = 26;

0387             jjmatchedPos = 8;

0388          }

0389          break;

0390       default :

0391          break;

0392    }

0393    return jjMoveNfa_0(0, 8);

0394 }

0395 private final int jjMoveStringLiteralDfa9_0(long old0, long active0)

0396 {

0397    if (((active0 &= old0)) == 0L)

0398       return jjMoveNfa_0(0, 8);

0399    try { curChar = input_stream.readChar(); }

0400    catch(java.io.IOException e) {

0401    return jjMoveNfa_0(0, 8);

0402    }

0403    switch(curChar)

0404    {

0405       case 100:

0406          return jjMoveStringLiteralDfa10_0(active0, 0x4000L);

0407       default :

0408          break;

0409    }

0410    return jjMoveNfa_0(0, 9);

0411 }

0412 private final int jjMoveStringLiteralDfa10_0(long old0, long active0)

0413 {

0414    if (((active0 &= old0)) == 0L)

0415       return jjMoveNfa_0(0, 9);

0416    try { curChar = input_stream.readChar(); }

0417    catch(java.io.IOException e) {

0418    return jjMoveNfa_0(0, 9);

0419    }

0420    switch(curChar)

0421    {

0422       case 106:

0423          return jjMoveStringLiteralDfa11_0(active0, 0x4000L);

0424       default :

0425          break;

0426    }

0427    return jjMoveNfa_0(0, 10);

0428 }

0429 private final int jjMoveStringLiteralDfa11_0(long old0, long active0)

0430 {

0431    if (((active0 &= old0)) == 0L)

0432       return jjMoveNfa_0(0, 10);

0433    try { curChar = input_stream.readChar(); }

0434    catch(java.io.IOException e) {

0435    return jjMoveNfa_0(0, 10);

0436    }

0437    switch(curChar)

0438    {

0439       case 102:

0440          return jjMoveStringLiteralDfa12_0(active0, 0x4000L);

0441       default :

0442          break;

0443    }

0444    return jjMoveNfa_0(0, 11);

0445 }

0446 private final int jjMoveStringLiteralDfa12_0(long old0, long active0)

0447 {

0448    if (((active0 &= old0)) == 0L)

0449       return jjMoveNfa_0(0, 11);

0450    try { curChar = input_stream.readChar(); }

0451    catch(java.io.IOException e) {

0452    return jjMoveNfa_0(0, 11);

0453    }

0454    switch(curChar)

0455    {

0456       case 108:

0457          return jjMoveStringLiteralDfa13_0(active0, 0x4000L);

0458       default :

0459          break;

0460    }

0461    return jjMoveNfa_0(0, 12);

0462 }

0463 private final int jjMoveStringLiteralDfa13_0(long old0, long active0)

0464 {

0465    if (((active0 &= old0)) == 0L)

0466       return jjMoveNfa_0(0, 12);

0467    try { curChar = input_stream.readChar(); }

0468    catch(java.io.IOException e) {

0469    return jjMoveNfa_0(0, 12);

0470    }

0471    switch(curChar)

0472    {

0473       case 115:

0474          return jjMoveStringLiteralDfa14_0(active0, 0x4000L);

0475       default :

0476          break;

0477    }

0478    return jjMoveNfa_0(0, 13);

0479 }

0480 private final int jjMoveStringLiteralDfa14_0(long old0, long active0)

0481 {

0482    if (((active0 &= old0)) == 0L)

0483       return jjMoveNfa_0(0, 13);

0484    try { curChar = input_stream.readChar(); }

0485    catch(java.io.IOException e) {

0486    return jjMoveNfa_0(0, 13);

0487    }

0488    switch(curChar)

0489    {

0490       case 100:

0491          return jjMoveStringLiteralDfa15_0(active0, 0x4000L);

0492       default :

0493          break;

0494    }

0495    return jjMoveNfa_0(0, 14);

0496 }

0497 private final int jjMoveStringLiteralDfa15_0(long old0, long active0)

0498 {

0499    if (((active0 &= old0)) == 0L)

0500       return jjMoveNfa_0(0, 14);

0501    try { curChar = input_stream.readChar(); }

0502    catch(java.io.IOException e) {

0503    return jjMoveNfa_0(0, 14);

0504    }

0505    switch(curChar)

0506    {

0507       case 106:

0508          return jjMoveStringLiteralDfa16_0(active0, 0x4000L);

0509       default :

0510          break;

0511    }

0512    return jjMoveNfa_0(0, 15);

0513 }

0514 private final int jjMoveStringLiteralDfa16_0(long old0, long active0)

0515 {

0516    if (((active0 &= old0)) == 0L)

0517       return jjMoveNfa_0(0, 15);

0518    try { curChar = input_stream.readChar(); }

0519    catch(java.io.IOException e) {

0520    return jjMoveNfa_0(0, 15);

0521    }

0522    switch(curChar)

0523    {

0524       case 102:

0525          return jjMoveStringLiteralDfa17_0(active0, 0x4000L);

0526       default :

0527          break;

0528    }

0529    return jjMoveNfa_0(0, 16);

0530 }

0531 private final int jjMoveStringLiteralDfa17_0(long old0, long active0)

0532 {

0533    if (((active0 &= old0)) == 0L)

0534       return jjMoveNfa_0(0, 16);

0535    try { curChar = input_stream.readChar(); }

0536    catch(java.io.IOException e) {

0537    return jjMoveNfa_0(0, 16);

0538    }

0539    switch(curChar)

0540    {

0541       case 108:

0542          return jjMoveStringLiteralDfa18_0(active0, 0x4000L);

0543       default :

0544          break;

0545    }

0546    return jjMoveNfa_0(0, 17);

0547 }

0548 private final int jjMoveStringLiteralDfa18_0(long old0, long active0)

0549 {

0550    if (((active0 &= old0)) == 0L)

0551       return jjMoveNfa_0(0, 17);

0552    try { curChar = input_stream.readChar(); }

0553    catch(java.io.IOException e) {

0554    return jjMoveNfa_0(0, 17);

0555    }

0556    switch(curChar)

0557    {

0558       case 107:

0559          return jjMoveStringLiteralDfa19_0(active0, 0x4000L);

0560       default :

0561          break;

0562    }

0563    return jjMoveNfa_0(0, 18);

0564 }

0565 private final int jjMoveStringLiteralDfa19_0(long old0, long active0)

0566 {

0567    if (((active0 &= old0)) == 0L)

0568       return jjMoveNfa_0(0, 18);

0569    try { curChar = input_stream.readChar(); }

0570    catch(java.io.IOException e) {

0571    return jjMoveNfa_0(0, 18);

0572    }

0573    switch(curChar)

0574    {

0575       case 115:

0576          return jjMoveStringLiteralDfa20_0(active0, 0x4000L);

0577       default :

0578          break;

0579    }

0580    return jjMoveNfa_0(0, 19);

0581 }

0582 private final int jjMoveStringLiteralDfa20_0(long old0, long active0)

0583 {

0584    if (((active0 &= old0)) == 0L)

0585       return jjMoveNfa_0(0, 19);

0586    try { curChar = input_stream.readChar(); }

0587    catch(java.io.IOException e) {

0588    return jjMoveNfa_0(0, 19);

0589    }

0590    switch(curChar)

0591    {

0592       case 100:

0593          return jjMoveStringLiteralDfa21_0(active0, 0x4000L);

0594       default :

0595          break;

0596    }

0597    return jjMoveNfa_0(0, 20);

0598 }

0599 private final int jjMoveStringLiteralDfa21_0(long old0, long active0)

0600 {

0601    if (((active0 &= old0)) == 0L)

0602       return jjMoveNfa_0(0, 20);

0603    try { curChar = input_stream.readChar(); }

0604    catch(java.io.IOException e) {

0605    return jjMoveNfa_0(0, 20);

0606    }

0607    switch(curChar)

0608    {

0609       case 106:

0610          return jjMoveStringLiteralDfa22_0(active0, 0x4000L);

0611       default :

0612          break;

0613    }

0614    return jjMoveNfa_0(0, 21);

0615 }

0616 private final int jjMoveStringLiteralDfa22_0(long old0, long active0)

0617 {

0618    if (((active0 &= old0)) == 0L)

0619       return jjMoveNfa_0(0, 21);

0620    try { curChar = input_stream.readChar(); }

0621    catch(java.io.IOException e) {

0622    return jjMoveNfa_0(0, 21);

0623    }

0624    switch(curChar)

0625    {

0626       case 102:

0627          return jjMoveStringLiteralDfa23_0(active0, 0x4000L);

0628       default :

0629          break;

0630    }

0631    return jjMoveNfa_0(0, 22);

0632 }

0633 private final int jjMoveStringLiteralDfa23_0(long old0, long active0)

0634 {

0635    if (((active0 &= old0)) == 0L)

0636       return jjMoveNfa_0(0, 22);

0637    try { curChar = input_stream.readChar(); }

0638    catch(java.io.IOException e) {

0639    return jjMoveNfa_0(0, 22);

0640    }

0641    switch(curChar)

0642    {

0643       case 108:

0644          return jjMoveStringLiteralDfa24_0(active0, 0x4000L);

0645       default :

0646          break;

0647    }

0648    return jjMoveNfa_0(0, 23);

0649 }

0650 private final int jjMoveStringLiteralDfa24_0(long old0, long active0)

0651 {

0652    if (((active0 &= old0)) == 0L)

0653       return jjMoveNfa_0(0, 23);

0654    try { curChar = input_stream.readChar(); }

0655    catch(java.io.IOException e) {

0656    return jjMoveNfa_0(0, 23);

0657    }

0658    switch(curChar)

0659    {

0660       case 115:

0661          return jjMoveStringLiteralDfa25_0(active0, 0x4000L);

0662       default :

0663          break;

0664    }

0665    return jjMoveNfa_0(0, 24);

0666 }

0667 private final int jjMoveStringLiteralDfa25_0(long old0, long active0)

0668 {

0669    if (((active0 &= old0)) == 0L)

0670       return jjMoveNfa_0(0, 24);

0671    try { curChar = input_stream.readChar(); }

0672    catch(java.io.IOException e) {

0673    return jjMoveNfa_0(0, 24);

0674    }

0675    switch(curChar)

0676    {

0677       case 107:

0678          return jjMoveStringLiteralDfa26_0(active0, 0x4000L);

0679       default :

0680          break;

0681    }

0682    return jjMoveNfa_0(0, 25);

0683 }

0684 private final int jjMoveStringLiteralDfa26_0(long old0, long active0)

0685 {

0686    if (((active0 &= old0)) == 0L)

0687       return jjMoveNfa_0(0, 25);

0688    try { curChar = input_stream.readChar(); }

0689    catch(java.io.IOException e) {

0690    return jjMoveNfa_0(0, 25);

0691    }

0692    switch(curChar)

0693    {

0694       case 106:

0695          return jjMoveStringLiteralDfa27_0(active0, 0x4000L);

0696       default :

0697          break;

0698    }

0699    return jjMoveNfa_0(0, 26);

0700 }

0701 private final int jjMoveStringLiteralDfa27_0(long old0, long active0)

0702 {

0703    if (((active0 &= old0)) == 0L)

0704       return jjMoveNfa_0(0, 26);

0705    try { curChar = input_stream.readChar(); }

0706    catch(java.io.IOException e) {

0707    return jjMoveNfa_0(0, 26);

0708    }

0709    switch(curChar)

0710    {

0711       case 102:

0712          return jjMoveStringLiteralDfa28_0(active0, 0x4000L);

0713       default :

0714          break;

0715    }

0716    return jjMoveNfa_0(0, 27);

0717 }

0718 private final int jjMoveStringLiteralDfa28_0(long old0, long active0)

0719 {

0720    if (((active0 &= old0)) == 0L)

0721       return jjMoveNfa_0(0, 27);

0722    try { curChar = input_stream.readChar(); }

0723    catch(java.io.IOException e) {

0724    return jjMoveNfa_0(0, 27);

0725    }

0726    switch(curChar)

0727    {

0728       case 108:

0729          return jjMoveStringLiteralDfa29_0(active0, 0x4000L);

0730       default :

0731          break;

0732    }

0733    return jjMoveNfa_0(0, 28);

0734 }

0735 private final int jjMoveStringLiteralDfa29_0(long old0, long active0)

0736 {

0737    if (((active0 &= old0)) == 0L)

0738       return jjMoveNfa_0(0, 28);

0739    try { curChar = input_stream.readChar(); }

0740    catch(java.io.IOException e) {

0741    return jjMoveNfa_0(0, 28);

0742    }

0743    switch(curChar)

0744    {

0745       case 115:

0746          return jjMoveStringLiteralDfa30_0(active0, 0x4000L);

0747       default :

0748          break;

0749    }

0750    return jjMoveNfa_0(0, 29);

0751 }

0752 private final int jjMoveStringLiteralDfa30_0(long old0, long active0)

0753 {

0754    if (((active0 &= old0)) == 0L)

0755       return jjMoveNfa_0(0, 29);

0756    try { curChar = input_stream.readChar(); }

0757    catch(java.io.IOException e) {

0758    return jjMoveNfa_0(0, 29);

0759    }

0760    switch(curChar)

0761    {

0762       case 107:

0763          return jjMoveStringLiteralDfa31_0(active0, 0x4000L);

0764       default :

0765          break;

0766    }

0767    return jjMoveNfa_0(0, 30);

0768 }

0769 private final int jjMoveStringLiteralDfa31_0(long old0, long active0)

0770 {

0771    if (((active0 &= old0)) == 0L)

0772       return jjMoveNfa_0(0, 30);

0773    try { curChar = input_stream.readChar(); }

0774    catch(java.io.IOException e) {

0775    return jjMoveNfa_0(0, 30);

0776    }

0777    switch(curChar)

0778    {

0779       case 100:

0780          return jjMoveStringLiteralDfa32_0(active0, 0x4000L);

0781       default :

0782          break;

0783    }

0784    return jjMoveNfa_0(0, 31);

0785 }

0786 private final int jjMoveStringLiteralDfa32_0(long old0, long active0)

0787 {

0788    if (((active0 &= old0)) == 0L)

0789       return jjMoveNfa_0(0, 31);

0790    try { curChar = input_stream.readChar(); }

0791    catch(java.io.IOException e) {

0792    return jjMoveNfa_0(0, 31);

0793    }

0794    switch(curChar)

0795    {

0796       case 106:

0797          return jjMoveStringLiteralDfa33_0(active0, 0x4000L);

0798       default :

0799          break;

0800    }

0801    return jjMoveNfa_0(0, 32);

0802 }

0803 private final int jjMoveStringLiteralDfa33_0(long old0, long active0)

0804 {

0805    if (((active0 &= old0)) == 0L)

0806       return jjMoveNfa_0(0, 32);

0807    try { curChar = input_stream.readChar(); }

0808    catch(java.io.IOException e) {

0809    return jjMoveNfa_0(0, 32);

0810    }

0811    switch(curChar)

0812    {

0813       case 102:

0814          return jjMoveStringLiteralDfa34_0(active0, 0x4000L);

0815       default :

0816          break;

0817    }

0818    return jjMoveNfa_0(0, 33);

0819 }

0820 private final int jjMoveStringLiteralDfa34_0(long old0, long active0)

0821 {

0822    if (((active0 &= old0)) == 0L)

0823       return jjMoveNfa_0(0, 33);

0824    try { curChar = input_stream.readChar(); }

0825    catch(java.io.IOException e) {

0826    return jjMoveNfa_0(0, 33);

0827    }

0828    switch(curChar)

0829    {

0830       case 108:

0831          return jjMoveStringLiteralDfa35_0(active0, 0x4000L);

0832       default :

0833          break;

0834    }

0835    return jjMoveNfa_0(0, 34);

0836 }

0837 private final int jjMoveStringLiteralDfa35_0(long old0, long active0)

0838 {

0839    if (((active0 &= old0)) == 0L)

0840       return jjMoveNfa_0(0, 34);

0841    try { curChar = input_stream.readChar(); }

0842    catch(java.io.IOException e) {

0843    return jjMoveNfa_0(0, 34);

0844    }

0845    switch(curChar)

0846    {

0847       case 107:

0848          return jjMoveStringLiteralDfa36_0(active0, 0x4000L);

0849       default :

0850          break;

0851    }

0852    return jjMoveNfa_0(0, 35);

0853 }

0854 private final int jjMoveStringLiteralDfa36_0(long old0, long active0)

0855 {

0856    if (((active0 &= old0)) == 0L)

0857       return jjMoveNfa_0(0, 35);

0858    try { curChar = input_stream.readChar(); }

0859    catch(java.io.IOException e) {

0860    return jjMoveNfa_0(0, 35);

0861    }

0862    switch(curChar)

0863    {

0864       case 100:

0865          return jjMoveStringLiteralDfa37_0(active0, 0x4000L);

0866       default :

0867          break;

0868    }

0869    return jjMoveNfa_0(0, 36);

0870 }

0871 private final int jjMoveStringLiteralDfa37_0(long old0, long active0)

0872 {

0873    if (((active0 &= old0)) == 0L)

0874       return jjMoveNfa_0(0, 36);

0875    try { curChar = input_stream.readChar(); }

0876    catch(java.io.IOException e) {

0877    return jjMoveNfa_0(0, 36);

0878    }

0879    switch(curChar)

0880    {

0881       case 106:

0882          return jjMoveStringLiteralDfa38_0(active0, 0x4000L);

0883       default :

0884          break;

0885    }

0886    return jjMoveNfa_0(0, 37);

0887 }

0888 private final int jjMoveStringLiteralDfa38_0(long old0, long active0)

0889 {

0890    if (((active0 &= old0)) == 0L)

0891       return jjMoveNfa_0(0, 37);

0892    try { curChar = input_stream.readChar(); }

0893    catch(java.io.IOException e) {

0894    return jjMoveNfa_0(0, 37);

0895    }

0896    switch(curChar)

0897    {

0898       case 115:

0899          if ((active0 & 0x4000L) != 0L)

0900          {

0901             jjmatchedKind = 14;

0902             jjmatchedPos = 38;

0903          }

0904          break;

0905       default :

0906          break;

0907    }

0908    return jjMoveNfa_0(0, 38);

0909 }

0910 private final int jjMoveNfa_0(int startState, int curPos)

0911 {

0912    int strKind = jjmatchedKind;

0913    int strPos = jjmatchedPos;

0914    int seenUpto;

0915    input_stream.backup(seenUpto = curPos + 1);

0916    try { curChar = input_stream.readChar(); }

0917    catch(java.io.IOException e) { throw new Error("Internal Error"); }

0918    curPos = 0;

0919    int[] nextStates;

0920    int startsAt = 0;

0921    jjnewStateCnt = 108;

0922    int i = 1;

0923    jjstateSet[0] = startState;

0924    int j, kind = 0x7fffffff;

0925    for (;;)

0926    {

0927       if (++jjround == 0x7fffffff)

0928          ReInitRounds();

0929       if (curChar < 64)

0930       {

0931          long l = 1L << curChar;

0932          MatchLoop: do

0933          {

0934             switch(jjstateSet[--i])

0935             {

0936                case 0:

0937                   if ((0x100002600L & l) != 0L)

0938                      jjCheckNAddStates(0, 7);

0939                   else if (curChar == 37)

0940                      jjCheckNAddTwoStates(104, 106);

0941                   else if (curChar == 45)

0942                      jjCheckNAddTwoStates(76, 102);

0943                   if ((0x2400L & l) != 0L)

0944                   {

0945                      if (kind > 4)

0946                         kind = 4;

0947                      jjCheckNAddStates(8, 12);

0948                   }

0949                   else if ((0x100000200L & l) != 0L)

0950                   {

0951                      if (kind > 1)

0952                         kind = 1;

0953                      jjCheckNAddTwoStates(35, 37);

0954                   }

0955                   else if (curChar == 37)

0956                      jjCheckNAddStates(13, 15);

0957                   if (curChar == 13)

0958                      jjCheckNAddStates(16, 20);

0959                   else if (curChar == 10)

0960                      jjCheckNAddStates(21, 25);

0961                   break;

0962                case 1:

0963                   if (kind > 13)

0964                      kind = 13;

0965                   break;

0966                case 3:

0967                   if ((0x100002600L & l) == 0L)

0968                      break;

0969                   if (kind > 20)

0970                      kind = 20;

0971                   jjCheckNAddStates(26, 29);

0972                   break;

0973                case 4:

0974                   if (curChar != 10)

0975                      break;

0976                   if (kind > 20)

0977                      kind = 20;

0978                   jjCheckNAddStates(26, 29);

0979                   break;

0980                case 5:

0981                   if (curChar == 13)

0982                      jjstateSet[jjnewStateCnt++] = 4;

0983                   break;

0984                case 6:

0985                   if (curChar != 13)

0986                      break;

0987                   if (kind > 20)

0988                      kind = 20;

0989                   jjCheckNAddStates(26, 29);

0990                   break;

0991                case 7:

0992                   if (curChar == 10)

0993                      jjstateSet[jjnewStateCnt++] = 6;

0994                   break;

0995                case 8:

0996                   if ((0x200800000000L & l) != 0L && kind > 20)

0997                      kind = 20;

0998                   break;

0999                case 9:

1000                   if (curChar == 47 && kind > 31)

1001                      kind = 31;

1002                   break;

1003                case 10:

1004                case 23:

1005                case 28:

1006                   if (curChar == 47)

1007                      jjCheckNAdd(9);

1008                   break;

1009                case 11:

1010                   if (curChar == 58)

1011                      jjstateSet[jjnewStateCnt++] = 10;

1012                   break;

1013                case 15:

1014                   if (curChar == 58 && kind > 31)

1015                      kind = 31;

1016                   break;

1017                case 24:

1018                   if (curChar == 58)

1019                      jjstateSet[jjnewStateCnt++] = 23;

1020                   break;

1021                case 29:

1022                   if (curChar == 58)

1023                      jjstateSet[jjnewStateCnt++] = 28;

1024                   break;

1025                case 34:

1026                   if ((0x100000200L & l) == 0L)

1027                      break;

1028                   if (kind > 1)

1029                      kind = 1;

1030                   jjCheckNAddTwoStates(35, 37);

1031                   break;

1032                case 35:

1033                   if ((0x100000200L & l) != 0L)

1034                      jjCheckNAddTwoStates(35, 37);

1035                   break;

1036                case 37:

1037                   if (curChar == 37)

1038                      jjCheckNAdd(36);

1039                   break;

1040                case 38:

1041                   if ((0x2400L & l) == 0L)

1042                      break;

1043                   if (kind > 4)

1044                      kind = 4;

1045                   jjCheckNAddStates(8, 12);

1046                   break;

1047                case 39:

1048                   if ((0x100000200L & l) == 0L)

1049                      break;

1050                   if (kind > 4)

1051                      kind = 4;

1052                   jjCheckNAdd(39);

1053                   break;

1054                case 40:

1055                   if ((0x100000200L & l) != 0L)

1056                      jjCheckNAddTwoStates(40, 41);

1057                   break;

1058                case 41:

1059                   if (curChar == 37)

1060                      jjstateSet[jjnewStateCnt++] = 42;

1061                   break;

1062                case 42:

1063                   if ((0x3ff000000000000L & l) == 0L)

1064                      break;

1065                   if (kind > 17)

1066                      kind = 17;

1067                   jjCheckNAddTwoStates(43, 44);

1068                   break;

1069                case 43:

1070                   if (curChar != 42)

1071                      break;

1072                   if (kind > 17)

1073                      kind = 17;

1074                   jjCheckNAdd(44);

1075                   break;

1076                case 44:

1077                   if ((0x100000200L & l) == 0L)

1078                      break;

1079                   if (kind > 17)

1080                      kind = 17;

1081                   jjCheckNAdd(44);

1082                   break;

1083                case 45:

1084                   if ((0x100000200L & l) != 0L)

1085                      jjCheckNAddTwoStates(45, 46);

1086                   break;

1087                case 46:

1088                   if ((0x200800000000L & l) != 0L)

1089                      jjCheckNAdd(47);

1090                   break;

1091                case 47:

1092                   if ((0x100000200L & l) == 0L)

1093                      break;

1094                   if (kind > 19)

1095                      kind = 19;

1096                   jjCheckNAdd(47);

1097                   break;

1098                case 48:

1099                   if (curChar == 10)

1100                      jjCheckNAddStates(21, 25);

1101                   break;

1102                case 49:

1103                   if (curChar != 13)

1104                      break;

1105                   if (kind > 4)

1106                      kind = 4;

1107                   jjCheckNAdd(39);

1108                   break;

1109                case 50:

1110                   if (curChar == 13)

1111                      jjCheckNAddTwoStates(40, 41);

1112                   break;

1113                case 51:

1114                   if (curChar == 13)

1115                      jjCheckNAddTwoStates(45, 46);

1116                   break;

1117                case 52:

1118                   if (curChar == 13)

1119                      jjCheckNAddStates(30, 33);

1120                   break;

1121                case 53:

1122                   if ((0x100002600L & l) != 0L)

1123                      jjCheckNAddStates(30, 33);

1124                   break;

1125                case 54:

1126                   if (curChar == 10)

1127                      jjCheckNAddStates(30, 33);

1128                   break;

1129                case 55:

1130                   if (curChar == 13)

1131                      jjCheckNAdd(54);

1132                   break;

1133                case 56:

1134                   if (curChar == 10)

1135                      jjCheckNAdd(52);

1136                   break;

1137                case 57:

1138                   if (curChar == 13)

1139                      jjCheckNAddStates(34, 37);

1140                   break;

1141                case 58:

1142                   if ((0x100002600L & l) != 0L)

1143                      jjCheckNAddStates(34, 37);

1144                   break;

1145                case 59:

1146                   if (curChar == 10)

1147                      jjCheckNAddStates(34, 37);

1148                   break;

1149                case 60:

1150                   if (curChar == 13)

1151                      jjCheckNAdd(59);

1152                   break;

1153                case 61:

1154                   if (curChar == 10)

1155                      jjCheckNAdd(57);

1156                   break;

1157                case 62:

1158                case 63:

1159                   if (curChar == 45)

1160                      jjCheckNAddStates(38, 42);

1161                   break;

1162                case 64:

1163                   if ((0x100002600L & l) != 0L)

1164                      jjCheckNAddStates(43, 46);

1165                   break;

1166                case 65:

1167                   if (curChar == 10)

1168                      jjCheckNAddStates(43, 46);

1169                   break;

1170                case 66:

1171                   if (curChar == 13)

1172                      jjstateSet[jjnewStateCnt++] = 65;

1173                   break;

1174                case 67:

1175                   if (curChar == 13)

1176                      jjCheckNAddStates(43, 46);

1177                   break;

1178                case 68:

1179                   if (curChar == 10)

1180                      jjstateSet[jjnewStateCnt++] = 67;

1181                   break;

1182                case 70:

1183                   if ((0x100002600L & l) == 0L)

1184                      break;

1185                   if (kind > 21)

1186                      kind = 21;

1187                   jjCheckNAddStates(47, 50);

1188                   break;

1189                case 71:

1190                   if (curChar != 10)

1191                      break;

1192                   if (kind > 21)

1193                      kind = 21;

1194                   jjCheckNAddStates(47, 50);

1195                   break;

1196                case 72:

1197                   if (curChar == 13)

1198                      jjstateSet[jjnewStateCnt++] = 71;

1199                   break;

1200                case 73:

1201                   if (curChar != 13)

1202                      break;

1203                   if (kind > 21)

1204                      kind = 21;

1205                   jjCheckNAddStates(47, 50);

1206                   break;

1207                case 74:

1208                   if (curChar == 10)

1209                      jjstateSet[jjnewStateCnt++] = 73;

1210                   break;

1211                case 75:

1212                   if ((0x200800000000L & l) != 0L && kind > 21)

1213                      kind = 21;

1214                   break;

1215                case 76:

1216                   if (curChar == 45)

1217                      jjstateSet[jjnewStateCnt++] = 62;

1218                   break;

1219                case 77:

1220                   if (curChar == 45)

1221                      jjCheckNAdd(76);

1222                   break;

1223                case 78:

1224                   if (curChar == 13)

1225                      jjCheckNAddStates(16, 20);

1226                   break;

1227                case 79:

1228                   if (curChar != 10)

1229                      break;

1230                   if (kind > 4)

1231                      kind = 4;

1232                   jjCheckNAdd(39);

1233                   break;

1234                case 80:

1235                   if (curChar == 10)

1236                      jjCheckNAddTwoStates(40, 41);

1237                   break;

1238                case 81:

1239                   if (curChar == 10)

1240                      jjCheckNAddTwoStates(45, 46);

1241                   break;

1242                case 82:

1243                   if (curChar == 37)

1244                      jjCheckNAddStates(13, 15);

1245                   break;

1246                case 84:

1247                   if ((0x100002600L & l) == 0L)

1248                      break;

1249                   if (kind > 15)

1250                      kind = 15;

1251                   jjCheckNAddStates(51, 54);

1252                   break;

1253                case 85:

1254                   if (curChar != 10)

1255                      break;

1256                   if (kind > 15)

1257                      kind = 15;

1258                   jjCheckNAddStates(51, 54);

1259                   break;

1260                case 86:

1261                   if (curChar == 13)

1262                      jjstateSet[jjnewStateCnt++] = 85;

1263                   break;

1264                case 87:

1265                   if (curChar != 13)

1266                      break;

1267                   if (kind > 15)

1268                      kind = 15;

1269                   jjCheckNAddStates(51, 54);

1270                   break;

1271                case 88:

1272                   if (curChar == 10)

1273                      jjstateSet[jjnewStateCnt++] = 87;

1274                   break;

1275                case 90:

1276                   if ((0x100002600L & l) == 0L)

1277                      break;

1278                   if (kind > 15)

1279                      kind = 15;

1280                   jjCheckNAddStates(55, 58);

1281                   break;

1282                case 91:

1283                   if (curChar != 10)

1284                      break;

1285                   if (kind > 15)

1286                      kind = 15;

1287                   jjCheckNAddStates(55, 58);

1288                   break;

1289                case 92:

1290                   if (curChar == 13)

1291                      jjstateSet[jjnewStateCnt++] = 91;

1292                   break;

1293                case 93:

1294                   if (curChar != 13)

1295                      break;

1296                   if (kind > 15)

1297                      kind = 15;

1298                   jjCheckNAddStates(55, 58);

1299                   break;

1300                case 94:

1301                   if (curChar == 10)

1302                      jjstateSet[jjnewStateCnt++] = 93;

1303                   break;

1304                case 95:

1305                   if ((0x200800000000L & l) != 0L && kind > 15)

1306                      kind = 15;

1307                   break;

1308                case 96:

1309                   if (curChar != 37)

1310                      break;

1311                   if (kind > 44)

1312                      kind = 44;

1313                   jjCheckNAdd(97);

1314                   break;

1315                case 97:

1316                   if ((0xffffffffffffdbffL & l) == 0L)

1317                      break;

1318                   if (kind > 44)

1319                      kind = 44;

1320                   jjCheckNAdd(97);

1321                   break;

1322                case 98:

1323                   if ((0x100002600L & l) != 0L)

1324                      jjCheckNAddStates(0, 7);

1325                   break;

1326                case 99:

1327                   if (curChar == 45)

1328                      jjCheckNAddTwoStates(76, 102);

1329                   break;

1330                case 100:

1331                case 101:

1332                   if (curChar != 45)

1333                      break;

1334                   if (kind > 23)

1335                      kind = 23;

1336                   jjCheckNAdd(101);

1337                   break;

1338                case 102:

1339                   if (curChar == 45)

1340                      jjstateSet[jjnewStateCnt++] = 100;

1341                   break;

1342                case 103:

1343                   if (curChar == 37)

1344                      jjCheckNAddTwoStates(104, 106);

1345                   break;

1346                case 105:

1347                   if ((0x100000200L & l) != 0L && kind > 25)

1348                      kind = 25;

1349                   break;

1350                case 106:

1351                   if ((0x3ff200000000000L & l) != 0L)

1352                      jjCheckNAddTwoStates(106, 107);

1353                   break;

1354                case 107:

1355                   if (curChar == 40 && kind > 38)

1356                      kind = 38;

1357                   break;

1358                default : break;

1359             }

1360          } while(i != startsAt);

1361       }

1362       else if (curChar < 128)

1363       {

1364          long l = 1L << (curChar & 077);

1365          MatchLoop: do

1366          {

1367             switch(jjstateSet[--i])

1368             {

1369                case 0:

1370                   if ((0x10000000100L & l) != 0L)

1371                      jjAddStates(59, 60);

1372                   else if ((0x200000002000L & l) != 0L)

1373                      jjstateSet[jjnewStateCnt++] = 20;

1374                   else if ((0x4000000040L & l) != 0L)

1375                      jjstateSet[jjnewStateCnt++] = 13;

1376                   else if (curChar == 124)

1377                   {

1378                      if (kind > 20)

1379                         kind = 20;

1380                      jjAddStates(26, 29);

1381                   }

1382                   else if (curChar == 92)

1383                      jjstateSet[jjnewStateCnt++] = 1;

1384                   break;

1385                case 1:

1386                   if (kind > 13)

1387                      kind = 13;

1388                   break;

1389                case 2:

1390                   if (curChar != 124)

1391                      break;

1392                   if (kind > 20)

1393                      kind = 20;

1394                   jjAddStates(26, 29);

1395                   break;

1396                case 12:

1397                   if ((0x1000000010000L & l) != 0L)

1398                      jjstateSet[jjnewStateCnt++] = 11;

1399                   break;

1400                case 13:

1401                   if ((0x10000000100000L & l) != 0L)

1402                      jjstateSet[jjnewStateCnt++] = 12;

1403                   break;

1404                case 14:

1405                   if ((0x4000000040L & l) != 0L)

1406                      jjstateSet[jjnewStateCnt++] = 13;

1407                   break;

1408                case 16:

1409                   if ((0x800000008000L & l) != 0L)

1410                      jjstateSet[jjnewStateCnt++] = 15;

1411                   break;

1412                case 17:

1413                   if ((0x10000000100000L & l) != 0L)

1414                      jjstateSet[jjnewStateCnt++] = 16;

1415                   break;

1416                case 18:

1417                   if ((0x100000001000L & l) != 0L)

1418                      jjstateSet[jjnewStateCnt++] = 17;

1419                   break;

1420                case 19:

1421                   if ((0x20000000200L & l) != 0L)

1422                      jjstateSet[jjnewStateCnt++] = 18;

1423                   break;

1424                case 20:

1425                   if ((0x200000002L & l) != 0L)

1426                      jjstateSet[jjnewStateCnt++] = 19;

1427                   break;

1428                case 21:

1429                   if ((0x200000002000L & l) != 0L)

1430                      jjstateSet[jjnewStateCnt++] = 20;

1431                   break;

1432                case 22:

1433                   if ((0x10000000100L & l) != 0L)

1434                      jjAddStates(59, 60);

1435                   break;

1436                case 25:

1437                   if ((0x1000000010000L & l) != 0L)

1438                      jjstateSet[jjnewStateCnt++] = 24;

1439                   break;

1440                case 26:

1441                   if ((0x10000000100000L & l) != 0L)

1442                      jjstateSet[jjnewStateCnt++] = 25;

1443                   break;

1444                case 27:

1445                   if ((0x10000000100000L & l) != 0L)

1446                      jjstateSet[jjnewStateCnt++] = 26;

1447                   break;

1448                case 30:

1449                   if ((0x8000000080000L & l) != 0L)

1450                      jjstateSet[jjnewStateCnt++] = 29;

1451                   break;

1452                case 31:

1453                   if ((0x1000000010000L & l) != 0L)

1454                      jjstateSet[jjnewStateCnt++] = 30;

1455                   break;

1456                case 32:

1457                   if ((0x10000000100000L & l) != 0L)

1458                      jjstateSet[jjnewStateCnt++] = 31;

1459                   break;

1460                case 33:

1461                   if ((0x10000000100000L & l) != 0L)

1462                      jjstateSet[jjnewStateCnt++] = 32;

1463                   break;

1464                case 36:

1465                   if (curChar == 93 && kind > 16)

1466                      kind = 16;

1467                   break;

1468                case 69:

1469                   if (curChar != 124)

1470                      break;

1471                   if (kind > 21)

1472                      kind = 21;

1473                   jjAddStates(47, 50);

1474                   break;

1475                case 83:

1476                   if (curChar != 91)

1477                      break;

1478                   if (kind > 15)

1479                      kind = 15;

1480                   jjAddStates(51, 54);

1481                   break;

1482                case 89:

1483                   if (curChar != 124)

1484                      break;

1485                   if (kind > 15)

1486                      kind = 15;

1487                   jjAddStates(55, 58);

1488                   break;

1489                case 97:

1490                   if (kind > 44)

1491                      kind = 44;

1492                   jjstateSet[jjnewStateCnt++] = 97;

1493                   break;

1494                case 104:

1495                   if (curChar == 92)

1496                      jjstateSet[jjnewStateCnt++] = 105;

1497                   break;

1498                case 106:

1499                   if ((0x7fffffe87fffffeL & l) != 0L)

1500                      jjAddStates(61, 62);

1501                   break;

1502                default : break;

1503             }

1504          } while(i != startsAt);

1505       }

1506       else

1507       {

1508          int hiByte = (int)(curChar >> 8);

1509          int i1 = hiByte >> 6;

1510          long l1 = 1L << (hiByte & 077);

1511          int i2 = (curChar & 0xff) >> 6;

1512          long l2 = 1L << (curChar & 077);

1513          MatchLoop: do

1514          {

1515             switch(jjstateSet[--i])

1516             {

1517                case 1:

1518                   if (jjCanMove_0(hiByte, i1, i2, l1, l2) && kind > 13)

1519                      kind = 13;

1520                   break;

1521                case 97:

1522                   if (!jjCanMove_0(hiByte, i1, i2, l1, l2))

1523                      break;

1524                   if (kind > 44)

1525                      kind = 44;

1526                   jjstateSet[jjnewStateCnt++] = 97;

1527                   break;

1528                default : break;

1529             }

1530          } while(i != startsAt);

1531       }

1532       if (kind != 0x7fffffff)

1533       {

1534          jjmatchedKind = kind;

1535          jjmatchedPos = curPos;

1536          kind = 0x7fffffff;

1537       }

1538       ++curPos;

1539       if ((i = jjnewStateCnt) == (startsAt = 108 - (jjnewStateCnt = startsAt)))

1540          break;

1541       try { curChar = input_stream.readChar(); }

1542       catch(java.io.IOException e) { break; }

1543    }

1544    if (jjmatchedPos > strPos)

1545       return curPos;

1546 

1547    int toRet = Math.max(curPos, seenUpto);

1548 

1549    if (curPos < toRet)

1550       for (i = toRet - Math.min(curPos, seenUpto); i-- > 0; )

1551          try { curChar = input_stream.readChar(); }

1552          catch(java.io.IOException e) { throw new Error("Internal Error : Please send a bug report."); }

1553 

1554    if (jjmatchedPos < strPos)

1555    {

1556       jjmatchedKind = strKind;

1557       jjmatchedPos = strPos;

1558    }

1559    else if (jjmatchedPos == strPos && jjmatchedKind > strKind)

1560       jjmatchedKind = strKind;

1561 

1562    return toRet;

1563 }

1564 private final int jjMoveStringLiteralDfa0_1()

1565 {

1566    switch(curChar)

1567    {

1568       case 37:

1569          return jjMoveStringLiteralDfa1_1(0x20000000L);

1570       case 92:

1571          return jjMoveStringLiteralDfa1_1(0x10000000L);

1572       default :

1573          return 1;

1574    }

1575 }

1576 private final int jjMoveStringLiteralDfa1_1(long active0)

1577 {

1578    try { curChar = input_stream.readChar(); }

1579    catch(java.io.IOException e) {

1580       return 1;

1581    }

1582    switch(curChar)

1583    {

1584       case 37:

1585          return jjMoveStringLiteralDfa2_1(active0, 0x10000000L);

1586       case 62:

1587          if ((active0 & 0x20000000L) != 0L)

1588             return jjStopAtPos(1, 29);

1589          break;

1590       default :

1591          return 2;

1592    }

1593    return 2;

1594 }

1595 private final int jjMoveStringLiteralDfa2_1(long old0, long active0)

1596 {

1597    if (((active0 &= old0)) == 0L)

1598       return 2;

1599    try { curChar = input_stream.readChar(); }

1600    catch(java.io.IOException e) {

1601       return 2;

1602    }

1603    switch(curChar)

1604    {

1605       case 62:

1606          if ((active0 & 0x10000000L) != 0L)

1607             return jjStopAtPos(2, 28);

1608          break;

1609       default :

1610          return 3;

1611    }

1612    return 3;

1613 }

1614 private final int jjMoveStringLiteralDfa0_6()

1615 {

1616    switch(curChar)

1617    {

1618       case 37:

1619          return jjMoveStringLiteralDfa1_6(0x800000000000L);

1620       default :

1621          return 1;

1622    }

1623 }

1624 private final int jjMoveStringLiteralDfa1_6(long active0)

1625 {

1626    try { curChar = input_stream.readChar(); }

1627    catch(java.io.IOException e) {

1628       return 1;

1629    }

1630    switch(curChar)

1631    {

1632       case 42:

1633          return jjMoveStringLiteralDfa2_6(active0, 0x800000000000L);

1634       default :

1635          return 2;

1636    }

1637 }

1638 private final int jjMoveStringLiteralDfa2_6(long old0, long active0)

1639 {

1640    if (((active0 &= old0)) == 0L)

1641       return 2;

1642    try { curChar = input_stream.readChar(); }

1643    catch(java.io.IOException e) {

1644       return 2;

1645    }

1646    switch(curChar)

1647    {

1648       case 47:

1649          if ((active0 & 0x800000000000L) != 0L)

1650             return jjStopAtPos(2, 47);

1651          break;

1652       default :

1653          return 3;

1654    }

1655    return 3;

1656 }

1657 private final int jjStopStringLiteralDfa_4(int pos, long active0)

1658 {

1659    switch (pos)

1660    {

1661       default :

1662          return -1;

1663    }

1664 }

1665 private final int jjStartNfa_4(int pos, long active0)

1666 {

1667    return jjMoveNfa_4(jjStopStringLiteralDfa_4(pos, active0), pos + 1);

1668 }

1669 private final int jjStartNfaWithStates_4(int pos, int kind, int state)

1670 {

1671    jjmatchedKind = kind;

1672    jjmatchedPos = pos;

1673    try { curChar = input_stream.readChar(); }

1674    catch(java.io.IOException e) { return pos + 1; }

1675    return jjMoveNfa_4(state, pos + 1);

1676 }

1677 private final int jjMoveStringLiteralDfa0_4()

1678 {

1679    switch(curChar)

1680    {

1681       case 41:

1682          return jjStopAtPos(0, 41);

1683       case 44:

1684          return jjStopAtPos(0, 40);

1685       default :

1686          return jjMoveNfa_4(3, 0);

1687    }

1688 }

1689 private final int jjMoveNfa_4(int startState, int curPos)

1690 {

1691    int[] nextStates;

1692    int startsAt = 0;

1693    jjnewStateCnt = 3;

1694    int i = 1;

1695    jjstateSet[0] = startState;

1696    int j, kind = 0x7fffffff;

1697    for (;;)

1698    {

1699       if (++jjround == 0x7fffffff)

1700          ReInitRounds();

1701       if (curChar < 64)

1702       {

1703          long l = 1L << curChar;

1704          MatchLoop: do

1705          {

1706             switch(jjstateSet[--i])

1707             {

1708                case 3:

1709                case 0:

1710                   if ((0xffffedffffffffffL & l) == 0L)

1711                      break;

1712                   kind = 39;

1713                   jjCheckNAddTwoStates(0, 2);

1714                   break;

1715                case 1:

1716                   if (curChar != 44)

1717                      break;

1718                   kind = 39;

1719                   jjCheckNAddTwoStates(0, 2);

1720                   break;

1721                default : break;

1722             }

1723          } while(i != startsAt);

1724       }

1725       else if (curChar < 128)

1726       {

1727          long l = 1L << (curChar & 077);

1728          MatchLoop: do

1729          {

1730             switch(jjstateSet[--i])

1731             {

1732                case 3:

1733                   if (kind > 39)

1734                      kind = 39;

1735                   jjCheckNAddTwoStates(0, 2);

1736                   if (curChar == 92)

1737                      jjstateSet[jjnewStateCnt++] = 1;

1738                   break;

1739                case 0:

1740                   if (kind > 39)

1741                      kind = 39;

1742                   jjCheckNAddTwoStates(0, 2);

1743                   break;

1744                case 2:

1745                   if (curChar == 92)

1746                      jjstateSet[jjnewStateCnt++] = 1;

1747                   break;

1748                default : break;

1749             }

1750          } while(i != startsAt);

1751       }

1752       else

1753       {

1754          int hiByte = (int)(curChar >> 8);

1755          int i1 = hiByte >> 6;

1756          long l1 = 1L << (hiByte & 077);

1757          int i2 = (curChar & 0xff) >> 6;

1758          long l2 = 1L << (curChar & 077);

1759          MatchLoop: do

1760          {

1761             switch(jjstateSet[--i])

1762             {

1763                case 3:

1764                case 0:

1765                   if (!jjCanMove_0(hiByte, i1, i2, l1, l2))

1766                      break;

1767                   if (kind > 39)

1768                      kind = 39;

1769                   jjCheckNAddTwoStates(0, 2);

1770                   break;

1771                default : break;

1772             }

1773          } while(i != startsAt);

1774       }

1775       if (kind != 0x7fffffff)

1776       {

1777          jjmatchedKind = kind;

1778          jjmatchedPos = curPos;

1779          kind = 0x7fffffff;

1780       }

1781       ++curPos;

1782       if ((i = jjnewStateCnt) == (startsAt = 3 - (jjnewStateCnt = startsAt)))

1783          return curPos;

1784       try { curChar = input_stream.readChar(); }

1785       catch(java.io.IOException e) { return curPos; }

1786    }

1787 }

1788 private final int jjMoveStringLiteralDfa0_2()

1789 {

1790    return jjMoveNfa_2(3, 0);

1791 }

1792 private final int jjMoveNfa_2(int startState, int curPos)

1793 {

1794    int[] nextStates;

1795    int startsAt = 0;

1796    jjnewStateCnt = 3;

1797    int i = 1;

1798    jjstateSet[0] = startState;

1799    int j, kind = 0x7fffffff;

1800    for (;;)

1801    {

1802       if (++jjround == 0x7fffffff)

1803          ReInitRounds();

1804       if (curChar < 64)

1805       {

1806          long l = 1L << curChar;

1807          MatchLoop: do

1808          {

1809             switch(jjstateSet[--i])

1810             {

1811                case 3:

1812                case 0:

1813                   if ((0xfffffffeffffd9ffL & l) == 0L)

1814                      break;

1815                   kind = 33;

1816                   jjCheckNAddTwoStates(0, 2);

1817                   break;

1818                case 1:

1819                   if (curChar != 32)

1820                      break;

1821                   kind = 33;

1822                   jjCheckNAddTwoStates(0, 2);

1823                   break;

1824                default : break;

1825             }

1826          } while(i != startsAt);

1827       }

1828       else if (curChar < 128)

1829       {

1830          long l = 1L << (curChar & 077);

1831          MatchLoop: do

1832          {

1833             switch(jjstateSet[--i])

1834             {

1835                case 3:

1836                   if (kind > 33)

1837                      kind = 33;

1838                   jjCheckNAddTwoStates(0, 2);

1839                   if (curChar == 92)

1840                      jjstateSet[jjnewStateCnt++] = 1;

1841                   break;

1842                case 0:

1843                   if (kind > 33)

1844                      kind = 33;

1845                   jjCheckNAddTwoStates(0, 2);

1846                   break;

1847                case 2:

1848                   if (curChar == 92)

1849                      jjstateSet[jjnewStateCnt++] = 1;

1850                   break;

1851                default : break;

1852             }

1853          } while(i != startsAt);

1854       }

1855       else

1856       {

1857          int hiByte = (int)(curChar >> 8);

1858          int i1 = hiByte >> 6;

1859          long l1 = 1L << (hiByte & 077);

1860          int i2 = (curChar & 0xff) >> 6;

1861          long l2 = 1L << (curChar & 077);

1862          MatchLoop: do

1863          {

1864             switch(jjstateSet[--i])

1865             {

1866                case 3:

1867                case 0:

1868                   if (!jjCanMove_0(hiByte, i1, i2, l1, l2))

1869                      break;

1870                   if (kind > 33)

1871                      kind = 33;

1872                   jjCheckNAddTwoStates(0, 2);

1873                   break;

1874                default : break;

1875             }

1876          } while(i != startsAt);

1877       }

1878       if (kind != 0x7fffffff)

1879       {

1880          jjmatchedKind = kind;

1881          jjmatchedPos = curPos;

1882          kind = 0x7fffffff;

1883       }

1884       ++curPos;

1885       if ((i = jjnewStateCnt) == (startsAt = 3 - (jjnewStateCnt = startsAt)))

1886          return curPos;

1887       try { curChar = input_stream.readChar(); }

1888       catch(java.io.IOException e) { return curPos; }

1889    }

1890 }

1891 private final int jjStopStringLiteralDfa_3(int pos, long active0)

1892 {

1893    switch (pos)

1894    {

1895       default :

1896          return -1;

1897    }

1898 }

1899 private final int jjStartNfa_3(int pos, long active0)

1900 {

1901    return jjMoveNfa_3(jjStopStringLiteralDfa_3(pos, active0), pos + 1);

1902 }

1903 private final int jjStartNfaWithStates_3(int pos, int kind, int state)

1904 {

1905    jjmatchedKind = kind;

1906    jjmatchedPos = pos;

1907    try { curChar = input_stream.readChar(); }

1908    catch(java.io.IOException e) { return pos + 1; }

1909    return jjMoveNfa_3(state, pos + 1);

1910 }

1911 private final int jjMoveStringLiteralDfa0_3()

1912 {

1913    switch(curChar)

1914    {

1915       case 41:

1916          return jjStopAtPos(0, 37);

1917       default :

1918          return jjMoveNfa_3(3, 0);

1919    }

1920 }

1921 private final int jjMoveNfa_3(int startState, int curPos)

1922 {

1923    int[] nextStates;

1924    int startsAt = 0;

1925    jjnewStateCnt = 5;

1926    int i = 1;

1927    jjstateSet[0] = startState;

1928    int j, kind = 0x7fffffff;

1929    for (;;)

1930    {

1931       if (++jjround == 0x7fffffff)

1932          ReInitRounds();

1933       if (curChar < 64)

1934       {

1935          long l = 1L << curChar;

1936          MatchLoop: do

1937          {

1938             switch(jjstateSet[--i])

1939             {

1940                case 3:

1941                   if ((0xffffedffffffffffL & l) != 0L)

1942                   {

1943                      if (kind > 34)

1944                         kind = 34;

1945                      jjCheckNAddTwoStates(0, 2);

1946                   }

1947                   else if (curChar == 44)

1948                   {

1949                      if (kind > 36)

1950                         kind = 36;

1951                      jjCheckNAdd(4);

1952                   }

1953                   break;

1954                case 0:

1955                   if ((0xffffedffffffffffL & l) == 0L)

1956                      break;

1957                   if (kind > 34)

1958                      kind = 34;

1959                   jjCheckNAddTwoStates(0, 2);

1960                   break;

1961                case 1:

1962                   if (curChar != 44)

1963                      break;

1964                   if (kind > 34)

1965                      kind = 34;

1966                   jjCheckNAddTwoStates(0, 2);

1967                   break;

1968                case 4:

1969                   if ((0xfffffdffffffffffL & l) == 0L)

1970                      break;

1971                   if (kind > 36)

1972                      kind = 36;

1973                   jjCheckNAdd(4);

1974                   break;

1975                default : break;

1976             }

1977          } while(i != startsAt);

1978       }

1979       else if (curChar < 128)

1980       {

1981          long l = 1L << (curChar & 077);

1982          MatchLoop: do

1983          {

1984             switch(jjstateSet[--i])

1985             {

1986                case 3:

1987                   if (kind > 34)

1988                      kind = 34;

1989                   jjCheckNAddTwoStates(0, 2);

1990                   if (curChar == 92)

1991                      jjstateSet[jjnewStateCnt++] = 1;

1992                   break;

1993                case 0:

1994                   if (kind > 34)

1995                      kind = 34;

1996                   jjCheckNAddTwoStates(0, 2);

1997                   break;

1998                case 2:

1999                   if (curChar == 92)

2000                      jjstateSet[jjnewStateCnt++] = 1;

2001                   break;

2002                case 4:

2003                   if (kind > 36)

2004                      kind = 36;

2005                   jjstateSet[jjnewStateCnt++] = 4;

2006                   break;

2007                default : break;

2008             }

2009          } while(i != startsAt);

2010       }

2011       else

2012       {

2013          int hiByte = (int)(curChar >> 8);

2014          int i1 = hiByte >> 6;

2015          long l1 = 1L << (hiByte & 077);

2016          int i2 = (curChar & 0xff) >> 6;

2017          long l2 = 1L << (curChar & 077);

2018          MatchLoop: do

2019          {

2020             switch(jjstateSet[--i])

2021             {

2022                case 3:

2023                case 0:

2024                   if (!jjCanMove_0(hiByte, i1, i2, l1, l2))

2025                      break;

2026                   if (kind > 34)

2027                      kind = 34;

2028                   jjCheckNAddTwoStates(0, 2);

2029                   break;

2030                case 4:

2031                   if (!jjCanMove_0(hiByte, i1, i2, l1, l2))

2032                      break;

2033                   if (kind > 36)

2034                      kind = 36;

2035                   jjstateSet[jjnewStateCnt++] = 4;

2036                   break;

2037                default : break;

2038             }

2039          } while(i != startsAt);

2040       }

2041       if (kind != 0x7fffffff)

2042       {

2043          jjmatchedKind = kind;

2044          jjmatchedPos = curPos;

2045          kind = 0x7fffffff;

2046       }

2047       ++curPos;

2048       if ((i = jjnewStateCnt) == (startsAt = 5 - (jjnewStateCnt = startsAt)))

2049          return curPos;

2050       try { curChar = input_stream.readChar(); }

2051       catch(java.io.IOException e) { return curPos; }

2052    }

2053 }

2054 static final int[] jjnextStates = {

2055    53, 55, 56, 2, 58, 60, 61, 77, 39, 40, 41, 45, 46, 83, 36, 96, 

2056    79, 80, 81, 54, 59, 49, 50, 51, 52, 57, 3, 5, 7, 8, 53, 55, 

2057    56, 2, 58, 60, 61, 77, 63, 64, 66, 68, 69, 64, 66, 68, 69, 70, 

2058    72, 74, 75, 84, 86, 88, 89, 90, 92, 94, 95, 27, 33, 106, 107, 

2059 };

2060 private static final boolean jjCanMove_0(int hiByte, int i1, int i2, long l1, long l2)

2061 {

2062    switch(hiByte)

2063    {

2064       case 0:

2065          return ((jjbitVec2[i2] & l2) != 0L);

2066       default : 

2067          if ((jjbitVec0[i1] & l1) != 0L)

2068             return true;

2069          return false;

2070    }

2071 }

2072 public static final String[] jjstrLiteralImages = {

2073 "", null, null, null, null, "\52", "\136", "\137", "\137\137", "\45\42", 

2074 "\46", "\74", null, null, 

2075 "\132\132\132\121\132\41\154\163\153\144\152\146\154\163\144\152\146\154\153\163\144\152\146\154\163\153\152\146\154\163\153\144\152\146\154\153\144\152\163", null, null, null, null, null, null, null, "\45\74", null, "\45\142\162", null, 

2076 "\45\143\157\156\164\145\156\164\163", null, "\134\45\76", "\45\76", null, null, "\45\50", null, null, null, null, 

2077 "\51", null, null, "\54", "\51", "\45\43", null, null, null, null, null, };

2078 public static final String[] lexStateNames = {

2079    "DEFAULT", 

2080    "VERBATIM", 

2081    "URLPLAIN", 

2082    "URLPERCENT", 

2083    "PRED", 

2084    "ANCHOR", 

2085    "COMMENT", 

2086 };

2087 public static final int[] jjnewLexState = {

2088    -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, 

2089    -1, -1, -1, -1, 0, -1, 2, 3, 0, -1, -1, -1, 0, 4, -1, -1, 0, 5, 0, -1, 6, -1, 0, 

2090 };

2091 static final long[] jjtoToken = {

2092    0xff7fffbeff3L, 

2093 };

2094 static final long[] jjtoSkip = {

2095    0xf00000000000L, 

2096 };

2097 static final long[] jjtoSpecial = {

2098    0xf00000000000L, 

2099 };

2100 protected SimpleCharStream input_stream;

2101 private final int[] jjrounds = new int[108];

2102 private final int[] jjstateSet = new int[216];

2103 StringBuffer image;

2104 int jjimageLen;

2105 int lengthOfMatch;

2106 protected char curChar;

2107 public YamParserTokenManager(YamParser parserArg, SimpleCharStream stream){

2108    parser = parserArg;

2109    if (SimpleCharStream.staticFlag)

2110       throw new Error("ERROR: Cannot use a static CharStream class with a non-static lexical analyzer.");

2111    input_stream = stream;

2112 }

2113 public YamParserTokenManager(YamParser parserArg, SimpleCharStream stream, int lexState){

2114    this(parserArg, stream);

2115    SwitchTo(lexState);

2116 }

2117 public void ReInit(SimpleCharStream stream)

2118 {

2119    jjmatchedPos = jjnewStateCnt = 0;

2120    curLexState = defaultLexState;

2121    input_stream = stream;

2122    ReInitRounds();

2123 }

2124 private final void ReInitRounds()

2125 {

2126    int i;

2127    jjround = 0x80000001;

2128    for (i = 108; i-- > 0;)

2129       jjrounds[i] = 0x80000000;

2130 }

2131 public void ReInit(SimpleCharStream stream, int lexState)

2132 {

2133    ReInit(stream);

2134    SwitchTo(lexState);

2135 }

2136 public void SwitchTo(int lexState)

2137 {

2138    if (lexState >= 7 || lexState < 0)

2139       throw new TokenMgrError("Error: Ignoring invalid lexical state : " + lexState + ". State unchanged.", TokenMgrError.INVALID_LEXICAL_STATE);

2140    else

2141       curLexState = lexState;

2142 }

2143 

2144 protected Token jjFillToken()

2145 {

2146    Token t = Token.newToken(jjmatchedKind);

2147    t.kind = jjmatchedKind;

2148    if (jjmatchedPos < 0)

2149    {

2150       if (image == null)

2151          t.image = "";

2152       else

2153          t.image = image.toString();

2154       t.beginLine = t.endLine = input_stream.getBeginLine();

2155       t.beginColumn = t.endColumn = input_stream.getBeginColumn();

2156    }

2157    else

2158    {

2159       String im = jjstrLiteralImages[jjmatchedKind];

2160       t.image = (im == null) ? input_stream.GetImage() : im;

2161       t.beginLine = input_stream.getBeginLine();

2162       t.beginColumn = input_stream.getBeginColumn();

2163       t.endLine = input_stream.getEndLine();

2164       t.endColumn = input_stream.getEndColumn();

2165    }

2166    return t;

2167 }

2168 

2169 int curLexState = 0;

2170 int defaultLexState = 0;

2171 int jjnewStateCnt;

2172 int jjround;

2173 int jjmatchedPos;

2174 int jjmatchedKind;

2175 

2176 public Token getNextToken() 

2177 {

2178   int kind;

2179   Token specialToken = null;

2180   Token matchedToken;

2181   int curPos = 0;

2182 

2183   EOFLoop :

2184   for (;;)

2185   {   

2186    try   

2187    {     

2188       curChar = input_stream.BeginToken();

2189    }     

2190    catch(java.io.IOException e)

2191    {        

2192       jjmatchedKind = 0;

2193       matchedToken = jjFillToken();

2194       matchedToken.specialToken = specialToken;

2195       return matchedToken;

2196    }

2197    image = null;

2198    jjimageLen = 0;

2199 

2200    switch(curLexState)

2201    {

2202      case 0:

2203        jjmatchedKind = 0x7fffffff;

2204        jjmatchedPos = 0;

2205        curPos = jjMoveStringLiteralDfa0_0();

2206        if (jjmatchedPos == 0 && jjmatchedKind > 27)

2207        {

2208           jjmatchedKind = 27;

2209        }

2210        break;

2211      case 1:

2212        jjmatchedKind = 0x7fffffff;

2213        jjmatchedPos = 0;

2214        curPos = jjMoveStringLiteralDfa0_1();

2215        if (jjmatchedPos == 0 && jjmatchedKind > 30)

2216        {

2217           jjmatchedKind = 30;

2218        }

2219        break;

2220      case 2:

2221        jjmatchedKind = 33;

2222        jjmatchedPos = -1;

2223        curPos = 0;

2224        curPos = jjMoveStringLiteralDfa0_2();

2225        break;

2226      case 3:

2227        jjmatchedKind = 34;

2228        jjmatchedPos = -1;

2229        curPos = 0;

2230        curPos = jjMoveStringLiteralDfa0_3();

2231        break;

2232      case 4:

2233        jjmatchedKind = 0x7fffffff;

2234        jjmatchedPos = 0;

2235        curPos = jjMoveStringLiteralDfa0_4();

2236        break;

2237      case 5:

2238        jjmatchedKind = 43;

2239        jjmatchedPos = -1;

2240        curPos = 0;

2241        curPos = jjMoveStringLiteralDfa0_5();

2242        break;

2243      case 6:

2244        jjmatchedKind = 0x7fffffff;

2245        jjmatchedPos = 0;

2246        curPos = jjMoveStringLiteralDfa0_6();

2247        if (jjmatchedPos == 0 && jjmatchedKind > 46)

2248        {

2249           jjmatchedKind = 46;

2250        }

2251        break;

2252    }

2253      if (jjmatchedKind != 0x7fffffff)

2254      {

2255         if (jjmatchedPos + 1 < curPos)

2256            input_stream.backup(curPos - jjmatchedPos - 1);

2257         if ((jjtoToken[jjmatchedKind >> 6] & (1L << (jjmatchedKind & 077))) != 0L)

2258         {

2259            matchedToken = jjFillToken();

2260            matchedToken.specialToken = specialToken;

2261            TokenLexicalActions(matchedToken);

2262        if (jjnewLexState[jjmatchedKind] != -1)

2263          curLexState = jjnewLexState[jjmatchedKind];

2264            return matchedToken;

2265         }

2266         else

2267         {

2268            if ((jjtoSpecial[jjmatchedKind >> 6] & (1L << (jjmatchedKind & 077))) != 0L)

2269            {

2270               matchedToken = jjFillToken();

2271               if (specialToken == null)

2272                  specialToken = matchedToken;

2273               else

2274               {

2275                  matchedToken.specialToken = specialToken;

2276                  specialToken = (specialToken.next = matchedToken);

2277               }

2278               SkipLexicalActions(matchedToken);

2279            }

2280            else 

2281               SkipLexicalActions(null);

2282          if (jjnewLexState[jjmatchedKind] != -1)

2283            curLexState = jjnewLexState[jjmatchedKind];

2284            continue EOFLoop;

2285         }

2286      }

2287      int error_line = input_stream.getEndLine();

2288      int error_column = input_stream.getEndColumn();

2289      String error_after = null;

2290      boolean EOFSeen = false;

2291      try { input_stream.readChar(); input_stream.backup(1); }

2292      catch (java.io.IOException e1) {

2293         EOFSeen = true;

2294         error_after = curPos <= 1 ? "" : input_stream.GetImage();

2295         if (curChar == '\n' || curChar == '\r') {

2296            error_line++;

2297            error_column = 0;

2298         }

2299         else

2300            error_column++;

2301      }

2302      if (!EOFSeen) {

2303         input_stream.backup(1);

2304         error_after = curPos <= 1 ? "" : input_stream.GetImage();

2305      }

2306      throw new TokenMgrError(EOFSeen, curLexState, error_line, error_column, error_after, curChar, TokenMgrError.LEXICAL_ERROR);

2307   }

2308 }

2309 

2310 int[] jjemptyLineNo = new int[7];

2311 int[] jjemptyColNo = new int[7];

2312 boolean[] jjbeenHere = new boolean[7];

2313 void SkipLexicalActions(Token matchedToken)

2314 {

2315    switch(jjmatchedKind)

2316    {

2317       default :

2318          break;

2319    }

2320 }

2321 void TokenLexicalActions(Token matchedToken)

2322 {

2323    switch(jjmatchedKind)

2324    {

2325       case 15 :

2326         if (image == null)

2327             image = new StringBuffer();

2328             image.append(input_stream.GetSuffix(jjimageLen + (lengthOfMatch = jjmatchedPos + 1)));

2329   parser.pushBackListStart(image, input_stream, matchedToken);

2330          break;

2331       case 20 :

2332         if (image == null)

2333             image = new StringBuffer();

2334             image.append(input_stream.GetSuffix(jjimageLen + (lengthOfMatch = jjmatchedPos + 1)));

2335   parser.pushBackListStart(image, input_stream, matchedToken);

2336          break;

2337       case 21 :

2338         if (image == null)

2339             image = new StringBuffer();

2340             image.append(input_stream.GetSuffix(jjimageLen + (lengthOfMatch = jjmatchedPos + 1)));

2341   parser.pushBackListStart(image, input_stream, matchedToken);

2342          break;

2343       case 28 :

2344         if (image == null)

2345             image = new StringBuffer();

2346             image.append(jjstrLiteralImages[28]);

2347                          matchedToken.image = "%>";

2348          break;

2349       case 34 :

2350          if (jjmatchedPos == -1)

2351          {

2352             if (jjbeenHere[3] &&

2353                 jjemptyLineNo[3] == input_stream.getBeginLine() && 

2354                 jjemptyColNo[3] == input_stream.getBeginColumn())

2355                throw new TokenMgrError(("Error: Bailing out of infinite loop caused by repeated empty string matches at line " + input_stream.getBeginLine() + ", column " + input_stream.getBeginColumn() + "."), TokenMgrError.LOOP_DETECTED);

2356             jjemptyLineNo[3] = input_stream.getBeginLine();

2357             jjemptyColNo[3] = input_stream.getBeginColumn();

2358             jjbeenHere[3] = true;

2359          }

2360          break;

2361       case 36 :

2362          break;

2363       case 37 :

2364          break;

2365       default : 

2366          break;

2367    }

2368 }

2369 }