0001: /* Generated By:JJTree&JavaCC: Do not edit this line. JspParserTokenManager.java */
0002: /**
0003: * JSP Parser for PMD.
0004: * @author Pieter � Application Engineers NV/SA � http://www.ae.be
0005: */package net.sourceforge.pmd.jsp.ast;
0006:
0007: public class JspParserTokenManager implements JspParserConstants {
0008: public java.io.PrintStream debugStream = System.out;
0009:
0010: public void setDebugStream(java.io.PrintStream ds) {
0011: debugStream = ds;
0012: }
0013:
0014: private final int jjStopStringLiteralDfa_9(int pos, long active0) {
0015: switch (pos) {
0016: case 0:
0017: if ((active0 & 0x40000000000L) != 0L)
0018: return 2;
0019: return -1;
0020: default:
0021: return -1;
0022: }
0023: }
0024:
0025: private final int jjStartNfa_9(int pos, long active0) {
0026: return jjMoveNfa_9(jjStopStringLiteralDfa_9(pos, active0),
0027: pos + 1);
0028: }
0029:
0030: private final int jjStopAtPos(int pos, int kind) {
0031: jjmatchedKind = kind;
0032: jjmatchedPos = pos;
0033: return pos + 1;
0034: }
0035:
0036: private final int jjStartNfaWithStates_9(int pos, int kind,
0037: int state) {
0038: jjmatchedKind = kind;
0039: jjmatchedPos = pos;
0040: try {
0041: curChar = input_stream.readChar();
0042: } catch (java.io.IOException e) {
0043: return pos + 1;
0044: }
0045: return jjMoveNfa_9(state, pos + 1);
0046: }
0047:
0048: private final int jjMoveStringLiteralDfa0_9() {
0049: switch (curChar) {
0050: case 37:
0051: return jjMoveStringLiteralDfa1_9(0x40000000000L);
0052: default:
0053: return jjMoveNfa_9(3, 0);
0054: }
0055: }
0056:
0057: private final int jjMoveStringLiteralDfa1_9(long active0) {
0058: try {
0059: curChar = input_stream.readChar();
0060: } catch (java.io.IOException e) {
0061: jjStopStringLiteralDfa_9(0, active0);
0062: return 1;
0063: }
0064: switch (curChar) {
0065: case 62:
0066: if ((active0 & 0x40000000000L) != 0L)
0067: return jjStopAtPos(1, 42);
0068: break;
0069: default:
0070: break;
0071: }
0072: return jjStartNfa_9(0, active0);
0073: }
0074:
0075: private final void jjCheckNAdd(int state) {
0076: if (jjrounds[state] != jjround) {
0077: jjstateSet[jjnewStateCnt++] = state;
0078: jjrounds[state] = jjround;
0079: }
0080: }
0081:
0082: private final void jjAddStates(int start, int end) {
0083: do {
0084: jjstateSet[jjnewStateCnt++] = jjnextStates[start];
0085: } while (start++ != end);
0086: }
0087:
0088: private final void jjCheckNAddTwoStates(int state1, int state2) {
0089: jjCheckNAdd(state1);
0090: jjCheckNAdd(state2);
0091: }
0092:
0093: private final void jjCheckNAddStates(int start, int end) {
0094: do {
0095: jjCheckNAdd(jjnextStates[start]);
0096: } while (start++ != end);
0097: }
0098:
0099: private final void jjCheckNAddStates(int start) {
0100: jjCheckNAdd(jjnextStates[start]);
0101: jjCheckNAdd(jjnextStates[start + 1]);
0102: }
0103:
0104: static final long[] jjbitVec0 = { 0x0L, 0x0L, 0xffffffffffffffffL,
0105: 0xffffffffffffffffL };
0106:
0107: private final int jjMoveNfa_9(int startState, int curPos) {
0108: int[] nextStates;
0109: int startsAt = 0;
0110: jjnewStateCnt = 3;
0111: int i = 1;
0112: jjstateSet[0] = startState;
0113: int j, kind = 0x7fffffff;
0114: for (;;) {
0115: if (++jjround == 0x7fffffff)
0116: ReInitRounds();
0117: if (curChar < 64) {
0118: long l = 1L << curChar;
0119: MatchLoop: do {
0120: switch (jjstateSet[--i]) {
0121: case 3:
0122: if ((0xffffffdfffffffffL & l) != 0L) {
0123: if (kind > 43)
0124: kind = 43;
0125: jjCheckNAddTwoStates(0, 1);
0126: } else if (curChar == 37)
0127: jjstateSet[jjnewStateCnt++] = 2;
0128: break;
0129: case 0:
0130: if ((0xffffffdfffffffffL & l) == 0L)
0131: break;
0132: if (kind > 43)
0133: kind = 43;
0134: jjCheckNAddTwoStates(0, 1);
0135: break;
0136: case 1:
0137: if (curChar == 37)
0138: jjstateSet[jjnewStateCnt++] = 2;
0139: break;
0140: case 2:
0141: if ((0xbfffffffffffffffL & l) == 0L)
0142: break;
0143: if (kind > 43)
0144: kind = 43;
0145: jjCheckNAddTwoStates(0, 1);
0146: break;
0147: default:
0148: break;
0149: }
0150: } while (i != startsAt);
0151: } else if (curChar < 128) {
0152: long l = 1L << (curChar & 077);
0153: MatchLoop: do {
0154: switch (jjstateSet[--i]) {
0155: case 3:
0156: case 0:
0157: case 2:
0158: if (kind > 43)
0159: kind = 43;
0160: jjCheckNAddTwoStates(0, 1);
0161: break;
0162: default:
0163: break;
0164: }
0165: } while (i != startsAt);
0166: } else {
0167: int i2 = (curChar & 0xff) >> 6;
0168: long l2 = 1L << (curChar & 077);
0169: MatchLoop: do {
0170: switch (jjstateSet[--i]) {
0171: case 3:
0172: case 0:
0173: case 2:
0174: if ((jjbitVec0[i2] & l2) == 0L)
0175: break;
0176: if (kind > 43)
0177: kind = 43;
0178: jjCheckNAddTwoStates(0, 1);
0179: break;
0180: default:
0181: break;
0182: }
0183: } while (i != startsAt);
0184: }
0185: if (kind != 0x7fffffff) {
0186: jjmatchedKind = kind;
0187: jjmatchedPos = curPos;
0188: kind = 0x7fffffff;
0189: }
0190: ++curPos;
0191: if ((i = jjnewStateCnt) == (startsAt = 3 - (jjnewStateCnt = startsAt)))
0192: return curPos;
0193: try {
0194: curChar = input_stream.readChar();
0195: } catch (java.io.IOException e) {
0196: return curPos;
0197: }
0198: }
0199: }
0200:
0201: private final int jjMoveStringLiteralDfa0_4() {
0202: switch (curChar) {
0203: case 93:
0204: return jjMoveStringLiteralDfa1_4(0x80000000000000L);
0205: default:
0206: return 1;
0207: }
0208: }
0209:
0210: private final int jjMoveStringLiteralDfa1_4(long active0) {
0211: try {
0212: curChar = input_stream.readChar();
0213: } catch (java.io.IOException e) {
0214: return 1;
0215: }
0216: switch (curChar) {
0217: case 93:
0218: return jjMoveStringLiteralDfa2_4(active0, 0x80000000000000L);
0219: default:
0220: return 2;
0221: }
0222: }
0223:
0224: private final int jjMoveStringLiteralDfa2_4(long old0, long active0) {
0225: if (((active0 &= old0)) == 0L)
0226: return 2;
0227: try {
0228: curChar = input_stream.readChar();
0229: } catch (java.io.IOException e) {
0230: return 2;
0231: }
0232: switch (curChar) {
0233: case 62:
0234: if ((active0 & 0x80000000000000L) != 0L)
0235: return jjStopAtPos(2, 55);
0236: break;
0237: default:
0238: return 3;
0239: }
0240: return 3;
0241: }
0242:
0243: private final int jjMoveStringLiteralDfa0_6() {
0244: return jjMoveNfa_6(1, 0);
0245: }
0246:
0247: static final long[] jjbitVec1 = { 0x0L, 0x0L, 0x0L,
0248: 0xff7fffffff7fffffL };
0249:
0250: private final int jjMoveNfa_6(int startState, int curPos) {
0251: int[] nextStates;
0252: int startsAt = 0;
0253: jjnewStateCnt = 3;
0254: int i = 1;
0255: jjstateSet[0] = startState;
0256: int j, kind = 0x7fffffff;
0257: for (;;) {
0258: if (++jjround == 0x7fffffff)
0259: ReInitRounds();
0260: if (curChar < 64) {
0261: long l = 1L << curChar;
0262: MatchLoop: do {
0263: switch (jjstateSet[--i]) {
0264: case 1:
0265: if ((0x100002600L & l) != 0L) {
0266: if (kind > 48)
0267: kind = 48;
0268: jjCheckNAdd(0);
0269: } else if ((0x400001000000000L & l) != 0L) {
0270: if (kind > 49)
0271: kind = 49;
0272: jjCheckNAdd(2);
0273: }
0274: break;
0275: case 0:
0276: if ((0x100002600L & l) == 0L)
0277: break;
0278: kind = 48;
0279: jjCheckNAdd(0);
0280: break;
0281: case 2:
0282: if ((0x7ff601000000000L & l) == 0L)
0283: break;
0284: if (kind > 49)
0285: kind = 49;
0286: jjCheckNAdd(2);
0287: break;
0288: default:
0289: break;
0290: }
0291: } while (i != startsAt);
0292: } else if (curChar < 128) {
0293: long l = 1L << (curChar & 077);
0294: MatchLoop: do {
0295: switch (jjstateSet[--i]) {
0296: case 1:
0297: case 2:
0298: if ((0x7fffffe87fffffeL & l) == 0L)
0299: break;
0300: if (kind > 49)
0301: kind = 49;
0302: jjCheckNAdd(2);
0303: break;
0304: default:
0305: break;
0306: }
0307: } while (i != startsAt);
0308: } else {
0309: int i2 = (curChar & 0xff) >> 6;
0310: long l2 = 1L << (curChar & 077);
0311: MatchLoop: do {
0312: switch (jjstateSet[--i]) {
0313: case 1:
0314: case 2:
0315: if ((jjbitVec1[i2] & l2) == 0L)
0316: break;
0317: if (kind > 49)
0318: kind = 49;
0319: jjCheckNAdd(2);
0320: break;
0321: default:
0322: break;
0323: }
0324: } while (i != startsAt);
0325: }
0326: if (kind != 0x7fffffff) {
0327: jjmatchedKind = kind;
0328: jjmatchedPos = curPos;
0329: kind = 0x7fffffff;
0330: }
0331: ++curPos;
0332: if ((i = jjnewStateCnt) == (startsAt = 3 - (jjnewStateCnt = startsAt)))
0333: return curPos;
0334: try {
0335: curChar = input_stream.readChar();
0336: } catch (java.io.IOException e) {
0337: return curPos;
0338: }
0339: }
0340: }
0341:
0342: private final int jjMoveStringLiteralDfa0_3() {
0343: return jjMoveNfa_3(0, 0);
0344: }
0345:
0346: private final int jjMoveNfa_3(int startState, int curPos) {
0347: int[] nextStates;
0348: int startsAt = 0;
0349: jjnewStateCnt = 2;
0350: int i = 1;
0351: jjstateSet[0] = startState;
0352: int j, kind = 0x7fffffff;
0353: for (;;) {
0354: if (++jjround == 0x7fffffff)
0355: ReInitRounds();
0356: if (curChar < 64) {
0357: long l = 1L << curChar;
0358: MatchLoop: do {
0359: switch (jjstateSet[--i]) {
0360: case 0:
0361: if (curChar != 36)
0362: break;
0363: if (kind > 56)
0364: kind = 56;
0365: jjCheckNAdd(1);
0366: break;
0367: case 1:
0368: if ((0x7ff601000000000L & l) == 0L)
0369: break;
0370: if (kind > 56)
0371: kind = 56;
0372: jjCheckNAdd(1);
0373: break;
0374: default:
0375: break;
0376: }
0377: } while (i != startsAt);
0378: } else if (curChar < 128) {
0379: long l = 1L << (curChar & 077);
0380: MatchLoop: do {
0381: switch (jjstateSet[--i]) {
0382: case 0:
0383: case 1:
0384: if ((0x7fffffe87fffffeL & l) == 0L)
0385: break;
0386: if (kind > 56)
0387: kind = 56;
0388: jjCheckNAdd(1);
0389: break;
0390: default:
0391: break;
0392: }
0393: } while (i != startsAt);
0394: } else {
0395: int i2 = (curChar & 0xff) >> 6;
0396: long l2 = 1L << (curChar & 077);
0397: MatchLoop: do {
0398: switch (jjstateSet[--i]) {
0399: case 0:
0400: case 1:
0401: if ((jjbitVec1[i2] & l2) == 0L)
0402: break;
0403: if (kind > 56)
0404: kind = 56;
0405: jjCheckNAdd(1);
0406: break;
0407: default:
0408: break;
0409: }
0410: } while (i != startsAt);
0411: }
0412: if (kind != 0x7fffffff) {
0413: jjmatchedKind = kind;
0414: jjmatchedPos = curPos;
0415: kind = 0x7fffffff;
0416: }
0417: ++curPos;
0418: if ((i = jjnewStateCnt) == (startsAt = 2 - (jjnewStateCnt = startsAt)))
0419: return curPos;
0420: try {
0421: curChar = input_stream.readChar();
0422: } catch (java.io.IOException e) {
0423: return curPos;
0424: }
0425: }
0426: }
0427:
0428: private final int jjMoveStringLiteralDfa0_0() {
0429: return jjMoveNfa_0(0, 0);
0430: }
0431:
0432: private final int jjMoveNfa_0(int startState, int curPos) {
0433: int[] nextStates;
0434: int startsAt = 0;
0435: jjnewStateCnt = 5;
0436: int i = 1;
0437: jjstateSet[0] = startState;
0438: int j, kind = 0x7fffffff;
0439: for (;;) {
0440: if (++jjround == 0x7fffffff)
0441: ReInitRounds();
0442: if (curChar < 64) {
0443: long l = 1L << curChar;
0444: MatchLoop: do {
0445: switch (jjstateSet[--i]) {
0446: case 0:
0447: if (curChar == 45)
0448: jjAddStates(0, 1);
0449: break;
0450: case 1:
0451: if (curChar == 45)
0452: jjCheckNAddTwoStates(2, 3);
0453: break;
0454: case 2:
0455: if (curChar == 32)
0456: jjCheckNAddTwoStates(2, 3);
0457: break;
0458: case 3:
0459: case 4:
0460: if (curChar == 62 && kind > 75)
0461: kind = 75;
0462: break;
0463: default:
0464: break;
0465: }
0466: } while (i != startsAt);
0467: } else if (curChar < 128) {
0468: long l = 1L << (curChar & 077);
0469: MatchLoop: do {
0470: switch (jjstateSet[--i]) {
0471: default:
0472: break;
0473: }
0474: } while (i != startsAt);
0475: } else {
0476: int i2 = (curChar & 0xff) >> 6;
0477: long l2 = 1L << (curChar & 077);
0478: MatchLoop: do {
0479: switch (jjstateSet[--i]) {
0480: default:
0481: break;
0482: }
0483: } while (i != startsAt);
0484: }
0485: if (kind != 0x7fffffff) {
0486: jjmatchedKind = kind;
0487: jjmatchedPos = curPos;
0488: kind = 0x7fffffff;
0489: }
0490: ++curPos;
0491: if ((i = jjnewStateCnt) == (startsAt = 5 - (jjnewStateCnt = startsAt)))
0492: return curPos;
0493: try {
0494: curChar = input_stream.readChar();
0495: } catch (java.io.IOException e) {
0496: return curPos;
0497: }
0498: }
0499: }
0500:
0501: private final int jjStopStringLiteralDfa_2(int pos, long active0,
0502: long active1) {
0503: switch (pos) {
0504: default:
0505: return -1;
0506: }
0507: }
0508:
0509: private final int jjStartNfa_2(int pos, long active0, long active1) {
0510: return jjMoveNfa_2(jjStopStringLiteralDfa_2(pos, active0,
0511: active1), pos + 1);
0512: }
0513:
0514: private final int jjStartNfaWithStates_2(int pos, int kind,
0515: int state) {
0516: jjmatchedKind = kind;
0517: jjmatchedPos = pos;
0518: try {
0519: curChar = input_stream.readChar();
0520: } catch (java.io.IOException e) {
0521: return pos + 1;
0522: }
0523: return jjMoveNfa_2(state, pos + 1);
0524: }
0525:
0526: private final int jjMoveStringLiteralDfa0_2() {
0527: switch (curChar) {
0528: case 39:
0529: return jjStopAtPos(0, 69);
0530: default:
0531: return jjMoveNfa_2(9, 0);
0532: }
0533: }
0534:
0535: private final int jjMoveNfa_2(int startState, int curPos) {
0536: int[] nextStates;
0537: int startsAt = 0;
0538: jjnewStateCnt = 37;
0539: int i = 1;
0540: jjstateSet[0] = startState;
0541: int j, kind = 0x7fffffff;
0542: for (;;) {
0543: if (++jjround == 0x7fffffff)
0544: ReInitRounds();
0545: if (curChar < 64) {
0546: long l = 1L << curChar;
0547: MatchLoop: do {
0548: switch (jjstateSet[--i]) {
0549: case 9:
0550: if ((0xffffff67ffffffffL & l) != 0L) {
0551: if (kind > 70)
0552: kind = 70;
0553: jjCheckNAddStates(2, 4);
0554: } else if ((0x1800000000L & l) != 0L)
0555: jjCheckNAddTwoStates(30, 36);
0556: if (curChar == 60)
0557: jjstateSet[jjnewStateCnt++] = 26;
0558: else if (curChar == 35)
0559: jjstateSet[jjnewStateCnt++] = 10;
0560: else if (curChar == 36)
0561: jjstateSet[jjnewStateCnt++] = 0;
0562: break;
0563: case 1:
0564: if ((0xffffff7bffffffffL & l) != 0L)
0565: jjCheckNAddStates(5, 8);
0566: break;
0567: case 2:
0568: if (curChar == 34)
0569: jjCheckNAddTwoStates(3, 4);
0570: break;
0571: case 3:
0572: if ((0xfffffffbffffffffL & l) != 0L)
0573: jjCheckNAddTwoStates(3, 4);
0574: break;
0575: case 4:
0576: if (curChar == 34)
0577: jjCheckNAddStates(5, 8);
0578: break;
0579: case 5:
0580: if (curChar == 39)
0581: jjCheckNAddTwoStates(6, 7);
0582: break;
0583: case 6:
0584: if ((0xffffff7fffffffffL & l) != 0L)
0585: jjCheckNAddTwoStates(6, 7);
0586: break;
0587: case 7:
0588: if (curChar == 39)
0589: jjCheckNAddStates(5, 8);
0590: break;
0591: case 11:
0592: if ((0xffffff7bffffffffL & l) != 0L)
0593: jjCheckNAddStates(9, 12);
0594: break;
0595: case 12:
0596: if (curChar == 34)
0597: jjCheckNAddTwoStates(13, 14);
0598: break;
0599: case 13:
0600: if ((0xfffffffbffffffffL & l) != 0L)
0601: jjCheckNAddTwoStates(13, 14);
0602: break;
0603: case 14:
0604: if (curChar == 34)
0605: jjCheckNAddStates(9, 12);
0606: break;
0607: case 15:
0608: if (curChar == 39)
0609: jjCheckNAddTwoStates(16, 17);
0610: break;
0611: case 16:
0612: if ((0xffffff7fffffffffL & l) != 0L)
0613: jjCheckNAddTwoStates(16, 17);
0614: break;
0615: case 17:
0616: if (curChar == 39)
0617: jjCheckNAddStates(9, 12);
0618: break;
0619: case 19:
0620: if (curChar == 35)
0621: jjstateSet[jjnewStateCnt++] = 10;
0622: break;
0623: case 20:
0624: if (curChar == 61)
0625: jjCheckNAddTwoStates(21, 22);
0626: break;
0627: case 21:
0628: if ((0xffffffdfffffffffL & l) != 0L)
0629: jjCheckNAddStates(13, 15);
0630: break;
0631: case 22:
0632: if (curChar == 37)
0633: jjstateSet[jjnewStateCnt++] = 23;
0634: break;
0635: case 23:
0636: if ((0xbfffffffffffffffL & l) != 0L)
0637: jjCheckNAddStates(13, 15);
0638: break;
0639: case 24:
0640: if (curChar == 62 && kind > 68)
0641: kind = 68;
0642: break;
0643: case 25:
0644: if (curChar == 37)
0645: jjstateSet[jjnewStateCnt++] = 24;
0646: break;
0647: case 26:
0648: if (curChar == 37)
0649: jjstateSet[jjnewStateCnt++] = 20;
0650: break;
0651: case 27:
0652: if (curChar == 60)
0653: jjstateSet[jjnewStateCnt++] = 26;
0654: break;
0655: case 28:
0656: if ((0xffffff67ffffffffL & l) == 0L)
0657: break;
0658: if (kind > 70)
0659: kind = 70;
0660: jjCheckNAddStates(2, 4);
0661: break;
0662: case 29:
0663: if ((0x1800000000L & l) != 0L)
0664: jjCheckNAdd(30);
0665: break;
0666: case 30:
0667: if ((0xffffff7fffffffffL & l) == 0L)
0668: break;
0669: if (kind > 70)
0670: kind = 70;
0671: jjCheckNAddStates(2, 4);
0672: break;
0673: case 33:
0674: if (curChar == 35)
0675: jjCheckNAdd(32);
0676: break;
0677: case 34:
0678: if (curChar == 36)
0679: jjCheckNAdd(32);
0680: break;
0681: case 35:
0682: if ((0x1800000000L & l) != 0L)
0683: jjCheckNAddTwoStates(30, 36);
0684: break;
0685: case 36:
0686: if (curChar == 39 && kind > 71)
0687: kind = 71;
0688: break;
0689: default:
0690: break;
0691: }
0692: } while (i != startsAt);
0693: } else if (curChar < 128) {
0694: long l = 1L << (curChar & 077);
0695: MatchLoop: do {
0696: switch (jjstateSet[--i]) {
0697: case 9:
0698: if (kind > 70)
0699: kind = 70;
0700: jjCheckNAddStates(2, 4);
0701: if (curChar == 92)
0702: jjAddStates(16, 17);
0703: break;
0704: case 0:
0705: if (curChar == 123)
0706: jjCheckNAddStates(5, 8);
0707: break;
0708: case 1:
0709: if ((0xdfffffffffffffffL & l) != 0L)
0710: jjCheckNAddStates(5, 8);
0711: break;
0712: case 3:
0713: jjAddStates(18, 19);
0714: break;
0715: case 6:
0716: jjAddStates(20, 21);
0717: break;
0718: case 8:
0719: if (curChar == 125 && kind > 66)
0720: kind = 66;
0721: break;
0722: case 10:
0723: if (curChar == 123)
0724: jjCheckNAddStates(9, 12);
0725: break;
0726: case 11:
0727: if ((0xdfffffffffffffffL & l) != 0L)
0728: jjCheckNAddStates(9, 12);
0729: break;
0730: case 13:
0731: jjAddStates(22, 23);
0732: break;
0733: case 16:
0734: jjAddStates(24, 25);
0735: break;
0736: case 18:
0737: if (curChar == 125 && kind > 67)
0738: kind = 67;
0739: break;
0740: case 21:
0741: case 23:
0742: jjCheckNAddStates(13, 15);
0743: break;
0744: case 28:
0745: if (kind > 70)
0746: kind = 70;
0747: jjCheckNAddStates(2, 4);
0748: break;
0749: case 30:
0750: if ((0xf7ffffffffffffffL & l) == 0L)
0751: break;
0752: if (kind > 70)
0753: kind = 70;
0754: jjCheckNAddStates(2, 4);
0755: break;
0756: case 31:
0757: if (curChar == 92)
0758: jjAddStates(16, 17);
0759: break;
0760: case 32:
0761: if (curChar != 123)
0762: break;
0763: if (kind > 70)
0764: kind = 70;
0765: jjCheckNAddStates(2, 4);
0766: break;
0767: default:
0768: break;
0769: }
0770: } while (i != startsAt);
0771: } else {
0772: int i2 = (curChar & 0xff) >> 6;
0773: long l2 = 1L << (curChar & 077);
0774: MatchLoop: do {
0775: switch (jjstateSet[--i]) {
0776: case 9:
0777: case 28:
0778: case 30:
0779: if ((jjbitVec0[i2] & l2) == 0L)
0780: break;
0781: if (kind > 70)
0782: kind = 70;
0783: jjCheckNAddStates(2, 4);
0784: break;
0785: case 1:
0786: if ((jjbitVec0[i2] & l2) != 0L)
0787: jjAddStates(5, 8);
0788: break;
0789: case 3:
0790: if ((jjbitVec0[i2] & l2) != 0L)
0791: jjAddStates(18, 19);
0792: break;
0793: case 6:
0794: if ((jjbitVec0[i2] & l2) != 0L)
0795: jjAddStates(20, 21);
0796: break;
0797: case 11:
0798: if ((jjbitVec0[i2] & l2) != 0L)
0799: jjAddStates(9, 12);
0800: break;
0801: case 13:
0802: if ((jjbitVec0[i2] & l2) != 0L)
0803: jjAddStates(22, 23);
0804: break;
0805: case 16:
0806: if ((jjbitVec0[i2] & l2) != 0L)
0807: jjAddStates(24, 25);
0808: break;
0809: case 21:
0810: case 23:
0811: if ((jjbitVec0[i2] & l2) != 0L)
0812: jjCheckNAddStates(13, 15);
0813: break;
0814: default:
0815: break;
0816: }
0817: } while (i != startsAt);
0818: }
0819: if (kind != 0x7fffffff) {
0820: jjmatchedKind = kind;
0821: jjmatchedPos = curPos;
0822: kind = 0x7fffffff;
0823: }
0824: ++curPos;
0825: if ((i = jjnewStateCnt) == (startsAt = 37 - (jjnewStateCnt = startsAt)))
0826: return curPos;
0827: try {
0828: curChar = input_stream.readChar();
0829: } catch (java.io.IOException e) {
0830: return curPos;
0831: }
0832: }
0833: }
0834:
0835: private final int jjStopStringLiteralDfa_7(int pos, long active0) {
0836: switch (pos) {
0837: case 0:
0838: if ((active0 & 0x400000000000L) != 0L)
0839: return 3;
0840: return -1;
0841: case 1:
0842: if ((active0 & 0x400000000000L) != 0L)
0843: return 4;
0844: return -1;
0845: case 2:
0846: if ((active0 & 0x400000000000L) != 0L)
0847: return 6;
0848: return -1;
0849: default:
0850: return -1;
0851: }
0852: }
0853:
0854: private final int jjStartNfa_7(int pos, long active0) {
0855: return jjMoveNfa_7(jjStopStringLiteralDfa_7(pos, active0),
0856: pos + 1);
0857: }
0858:
0859: private final int jjStartNfaWithStates_7(int pos, int kind,
0860: int state) {
0861: jjmatchedKind = kind;
0862: jjmatchedPos = pos;
0863: try {
0864: curChar = input_stream.readChar();
0865: } catch (java.io.IOException e) {
0866: return pos + 1;
0867: }
0868: return jjMoveNfa_7(state, pos + 1);
0869: }
0870:
0871: private final int jjMoveStringLiteralDfa0_7() {
0872: switch (curChar) {
0873: case 45:
0874: return jjMoveStringLiteralDfa1_7(0x400000000000L);
0875: default:
0876: return jjMoveNfa_7(8, 0);
0877: }
0878: }
0879:
0880: private final int jjMoveStringLiteralDfa1_7(long active0) {
0881: try {
0882: curChar = input_stream.readChar();
0883: } catch (java.io.IOException e) {
0884: jjStopStringLiteralDfa_7(0, active0);
0885: return 1;
0886: }
0887: switch (curChar) {
0888: case 45:
0889: return jjMoveStringLiteralDfa2_7(active0, 0x400000000000L);
0890: default:
0891: break;
0892: }
0893: return jjStartNfa_7(0, active0);
0894: }
0895:
0896: private final int jjMoveStringLiteralDfa2_7(long old0, long active0) {
0897: if (((active0 &= old0)) == 0L)
0898: return jjStartNfa_7(0, old0);
0899: try {
0900: curChar = input_stream.readChar();
0901: } catch (java.io.IOException e) {
0902: jjStopStringLiteralDfa_7(1, active0);
0903: return 2;
0904: }
0905: switch (curChar) {
0906: case 37:
0907: return jjMoveStringLiteralDfa3_7(active0, 0x400000000000L);
0908: default:
0909: break;
0910: }
0911: return jjStartNfa_7(1, active0);
0912: }
0913:
0914: private final int jjMoveStringLiteralDfa3_7(long old0, long active0) {
0915: if (((active0 &= old0)) == 0L)
0916: return jjStartNfa_7(1, old0);
0917: try {
0918: curChar = input_stream.readChar();
0919: } catch (java.io.IOException e) {
0920: jjStopStringLiteralDfa_7(2, active0);
0921: return 3;
0922: }
0923: switch (curChar) {
0924: case 62:
0925: if ((active0 & 0x400000000000L) != 0L)
0926: return jjStopAtPos(3, 46);
0927: break;
0928: default:
0929: break;
0930: }
0931: return jjStartNfa_7(2, active0);
0932: }
0933:
0934: private final int jjMoveNfa_7(int startState, int curPos) {
0935: int[] nextStates;
0936: int startsAt = 0;
0937: jjnewStateCnt = 8;
0938: int i = 1;
0939: jjstateSet[0] = startState;
0940: int j, kind = 0x7fffffff;
0941: for (;;) {
0942: if (++jjround == 0x7fffffff)
0943: ReInitRounds();
0944: if (curChar < 64) {
0945: long l = 1L << curChar;
0946: MatchLoop: do {
0947: switch (jjstateSet[--i]) {
0948: case 4:
0949: if ((0xffffffdfffffffffL & l) != 0L) {
0950: if (kind > 47)
0951: kind = 47;
0952: jjCheckNAddStates(26, 28);
0953: } else if (curChar == 37)
0954: jjstateSet[jjnewStateCnt++] = 6;
0955: break;
0956: case 3:
0957: if ((0xffffdfffffffffffL & l) != 0L) {
0958: if (kind > 47)
0959: kind = 47;
0960: jjCheckNAddStates(26, 28);
0961: } else if (curChar == 45)
0962: jjstateSet[jjnewStateCnt++] = 5;
0963: if (curChar == 45)
0964: jjstateSet[jjnewStateCnt++] = 4;
0965: break;
0966: case 8:
0967: if ((0xffffdfffffffffffL & l) != 0L) {
0968: if (kind > 47)
0969: kind = 47;
0970: jjCheckNAddStates(26, 28);
0971: } else if (curChar == 45)
0972: jjAddStates(29, 30);
0973: if (curChar == 45)
0974: jjCheckNAdd(0);
0975: break;
0976: case 0:
0977: if ((0xffffdfffffffffffL & l) == 0L)
0978: break;
0979: if (kind > 47)
0980: kind = 47;
0981: jjCheckNAddStates(26, 28);
0982: break;
0983: case 1:
0984: if (curChar == 45)
0985: jjCheckNAdd(0);
0986: break;
0987: case 2:
0988: if (curChar == 45)
0989: jjAddStates(29, 30);
0990: break;
0991: case 5:
0992: if (curChar == 37)
0993: jjstateSet[jjnewStateCnt++] = 6;
0994: break;
0995: case 6:
0996: if ((0xbfffffffffffffffL & l) == 0L)
0997: break;
0998: if (kind > 47)
0999: kind = 47;
1000: jjCheckNAddStates(26, 28);
1001: break;
1002: case 7:
1003: if (curChar == 45)
1004: jjstateSet[jjnewStateCnt++] = 5;
1005: break;
1006: default:
1007: break;
1008: }
1009: } while (i != startsAt);
1010: } else if (curChar < 128) {
1011: long l = 1L << (curChar & 077);
1012: MatchLoop: do {
1013: switch (jjstateSet[--i]) {
1014: case 4:
1015: case 6:
1016: if (kind > 47)
1017: kind = 47;
1018: jjCheckNAddStates(26, 28);
1019: break;
1020: case 3:
1021: case 0:
1022: if (kind > 47)
1023: kind = 47;
1024: jjCheckNAddStates(26, 28);
1025: break;
1026: case 8:
1027: if (kind > 47)
1028: kind = 47;
1029: jjCheckNAddStates(26, 28);
1030: break;
1031: default:
1032: break;
1033: }
1034: } while (i != startsAt);
1035: } else {
1036: int i2 = (curChar & 0xff) >> 6;
1037: long l2 = 1L << (curChar & 077);
1038: MatchLoop: do {
1039: switch (jjstateSet[--i]) {
1040: case 4:
1041: case 6:
1042: if ((jjbitVec0[i2] & l2) == 0L)
1043: break;
1044: if (kind > 47)
1045: kind = 47;
1046: jjCheckNAddStates(26, 28);
1047: break;
1048: case 3:
1049: case 0:
1050: if ((jjbitVec0[i2] & l2) == 0L)
1051: break;
1052: if (kind > 47)
1053: kind = 47;
1054: jjCheckNAddStates(26, 28);
1055: break;
1056: case 8:
1057: if ((jjbitVec0[i2] & l2) == 0L)
1058: break;
1059: if (kind > 47)
1060: kind = 47;
1061: jjCheckNAddStates(26, 28);
1062: break;
1063: default:
1064: break;
1065: }
1066: } while (i != startsAt);
1067: }
1068: if (kind != 0x7fffffff) {
1069: jjmatchedKind = kind;
1070: jjmatchedPos = curPos;
1071: kind = 0x7fffffff;
1072: }
1073: ++curPos;
1074: if ((i = jjnewStateCnt) == (startsAt = 8 - (jjnewStateCnt = startsAt)))
1075: return curPos;
1076: try {
1077: curChar = input_stream.readChar();
1078: } catch (java.io.IOException e) {
1079: return curPos;
1080: }
1081: }
1082: }
1083:
1084: private final int jjStopStringLiteralDfa_13(int pos, long active0,
1085: long active1) {
1086: switch (pos) {
1087: default:
1088: return -1;
1089: }
1090: }
1091:
1092: private final int jjStartNfa_13(int pos, long active0, long active1) {
1093: return jjMoveNfa_13(jjStopStringLiteralDfa_13(pos, active0,
1094: active1), pos + 1);
1095: }
1096:
1097: private final int jjStartNfaWithStates_13(int pos, int kind,
1098: int state) {
1099: jjmatchedKind = kind;
1100: jjmatchedPos = pos;
1101: try {
1102: curChar = input_stream.readChar();
1103: } catch (java.io.IOException e) {
1104: return pos + 1;
1105: }
1106: return jjMoveNfa_13(state, pos + 1);
1107: }
1108:
1109: private final int jjMoveStringLiteralDfa0_13() {
1110: switch (curChar) {
1111: case 34:
1112: return jjStopAtPos(0, 65);
1113: case 39:
1114: return jjStopAtPos(0, 64);
1115: default:
1116: return jjMoveNfa_13(0, 0);
1117: }
1118: }
1119:
1120: private final int jjMoveNfa_13(int startState, int curPos) {
1121: int[] nextStates;
1122: int startsAt = 0;
1123: jjnewStateCnt = 1;
1124: int i = 1;
1125: jjstateSet[0] = startState;
1126: int j, kind = 0x7fffffff;
1127: for (;;) {
1128: if (++jjround == 0x7fffffff)
1129: ReInitRounds();
1130: if (curChar < 64) {
1131: long l = 1L << curChar;
1132: MatchLoop: do {
1133: switch (jjstateSet[--i]) {
1134: case 0:
1135: if ((0x100002600L & l) == 0L)
1136: break;
1137: kind = 21;
1138: jjstateSet[jjnewStateCnt++] = 0;
1139: break;
1140: default:
1141: break;
1142: }
1143: } while (i != startsAt);
1144: } else if (curChar < 128) {
1145: long l = 1L << (curChar & 077);
1146: MatchLoop: do {
1147: switch (jjstateSet[--i]) {
1148: default:
1149: break;
1150: }
1151: } while (i != startsAt);
1152: } else {
1153: int i2 = (curChar & 0xff) >> 6;
1154: long l2 = 1L << (curChar & 077);
1155: MatchLoop: do {
1156: switch (jjstateSet[--i]) {
1157: default:
1158: break;
1159: }
1160: } while (i != startsAt);
1161: }
1162: if (kind != 0x7fffffff) {
1163: jjmatchedKind = kind;
1164: jjmatchedPos = curPos;
1165: kind = 0x7fffffff;
1166: }
1167: ++curPos;
1168: if ((i = jjnewStateCnt) == (startsAt = 1 - (jjnewStateCnt = startsAt)))
1169: return curPos;
1170: try {
1171: curChar = input_stream.readChar();
1172: } catch (java.io.IOException e) {
1173: return curPos;
1174: }
1175: }
1176: }
1177:
1178: private final int jjStopStringLiteralDfa_16(int pos, long active0) {
1179: switch (pos) {
1180: default:
1181: return -1;
1182: }
1183: }
1184:
1185: private final int jjStartNfa_16(int pos, long active0) {
1186: return jjMoveNfa_16(jjStopStringLiteralDfa_16(pos, active0),
1187: pos + 1);
1188: }
1189:
1190: private final int jjStartNfaWithStates_16(int pos, int kind,
1191: int state) {
1192: jjmatchedKind = kind;
1193: jjmatchedPos = pos;
1194: try {
1195: curChar = input_stream.readChar();
1196: } catch (java.io.IOException e) {
1197: return pos + 1;
1198: }
1199: return jjMoveNfa_16(state, pos + 1);
1200: }
1201:
1202: private final int jjMoveStringLiteralDfa0_16() {
1203: switch (curChar) {
1204: case 60:
1205: jjmatchedKind = 22;
1206: return jjMoveStringLiteralDfa1_16(0x1ff800000L);
1207: default:
1208: return jjMoveNfa_16(0, 0);
1209: }
1210: }
1211:
1212: private final int jjMoveStringLiteralDfa1_16(long active0) {
1213: try {
1214: curChar = input_stream.readChar();
1215: } catch (java.io.IOException e) {
1216: jjStopStringLiteralDfa_16(0, active0);
1217: return 1;
1218: }
1219: switch (curChar) {
1220: case 33:
1221: return jjMoveStringLiteralDfa2_16(active0, 0xd000000L);
1222: case 37:
1223: if ((active0 & 0x80000000L) != 0L) {
1224: jjmatchedKind = 31;
1225: jjmatchedPos = 1;
1226: }
1227: return jjMoveStringLiteralDfa2_16(active0, 0x170000000L);
1228: case 47:
1229: if ((active0 & 0x800000L) != 0L)
1230: return jjStopAtPos(1, 23);
1231: break;
1232: case 63:
1233: if ((active0 & 0x2000000L) != 0L)
1234: return jjStopAtPos(1, 25);
1235: break;
1236: default:
1237: break;
1238: }
1239: return jjStartNfa_16(0, active0);
1240: }
1241:
1242: private final int jjMoveStringLiteralDfa2_16(long old0, long active0) {
1243: if (((active0 &= old0)) == 0L)
1244: return jjStartNfa_16(0, old0);
1245: try {
1246: curChar = input_stream.readChar();
1247: } catch (java.io.IOException e) {
1248: jjStopStringLiteralDfa_16(1, active0);
1249: return 2;
1250: }
1251: switch (curChar) {
1252: case 33:
1253: if ((active0 & 0x20000000L) != 0L)
1254: return jjStopAtPos(2, 29);
1255: break;
1256: case 45:
1257: return jjMoveStringLiteralDfa3_16(active0, 0x11000000L);
1258: case 61:
1259: if ((active0 & 0x40000000L) != 0L)
1260: return jjStopAtPos(2, 30);
1261: break;
1262: case 64:
1263: if ((active0 & 0x100000000L) != 0L)
1264: return jjStopAtPos(2, 32);
1265: break;
1266: case 91:
1267: return jjMoveStringLiteralDfa3_16(active0, 0x8000000L);
1268: case 68:
1269: case 100:
1270: return jjMoveStringLiteralDfa3_16(active0, 0x4000000L);
1271: default:
1272: break;
1273: }
1274: return jjStartNfa_16(1, active0);
1275: }
1276:
1277: private final int jjMoveStringLiteralDfa3_16(long old0, long active0) {
1278: if (((active0 &= old0)) == 0L)
1279: return jjStartNfa_16(1, old0);
1280: try {
1281: curChar = input_stream.readChar();
1282: } catch (java.io.IOException e) {
1283: jjStopStringLiteralDfa_16(2, active0);
1284: return 3;
1285: }
1286: switch (curChar) {
1287: case 45:
1288: if ((active0 & 0x1000000L) != 0L)
1289: return jjStopAtPos(3, 24);
1290: else if ((active0 & 0x10000000L) != 0L)
1291: return jjStopAtPos(3, 28);
1292: break;
1293: case 67:
1294: case 99:
1295: return jjMoveStringLiteralDfa4_16(active0, 0x8000000L);
1296: case 79:
1297: case 111:
1298: return jjMoveStringLiteralDfa4_16(active0, 0x4000000L);
1299: default:
1300: break;
1301: }
1302: return jjStartNfa_16(2, active0);
1303: }
1304:
1305: private final int jjMoveStringLiteralDfa4_16(long old0, long active0) {
1306: if (((active0 &= old0)) == 0L)
1307: return jjStartNfa_16(2, old0);
1308: try {
1309: curChar = input_stream.readChar();
1310: } catch (java.io.IOException e) {
1311: jjStopStringLiteralDfa_16(3, active0);
1312: return 4;
1313: }
1314: switch (curChar) {
1315: case 67:
1316: case 99:
1317: return jjMoveStringLiteralDfa5_16(active0, 0x4000000L);
1318: case 68:
1319: case 100:
1320: return jjMoveStringLiteralDfa5_16(active0, 0x8000000L);
1321: default:
1322: break;
1323: }
1324: return jjStartNfa_16(3, active0);
1325: }
1326:
1327: private final int jjMoveStringLiteralDfa5_16(long old0, long active0) {
1328: if (((active0 &= old0)) == 0L)
1329: return jjStartNfa_16(3, old0);
1330: try {
1331: curChar = input_stream.readChar();
1332: } catch (java.io.IOException e) {
1333: jjStopStringLiteralDfa_16(4, active0);
1334: return 5;
1335: }
1336: switch (curChar) {
1337: case 65:
1338: case 97:
1339: return jjMoveStringLiteralDfa6_16(active0, 0x8000000L);
1340: case 84:
1341: case 116:
1342: return jjMoveStringLiteralDfa6_16(active0, 0x4000000L);
1343: default:
1344: break;
1345: }
1346: return jjStartNfa_16(4, active0);
1347: }
1348:
1349: private final int jjMoveStringLiteralDfa6_16(long old0, long active0) {
1350: if (((active0 &= old0)) == 0L)
1351: return jjStartNfa_16(4, old0);
1352: try {
1353: curChar = input_stream.readChar();
1354: } catch (java.io.IOException e) {
1355: jjStopStringLiteralDfa_16(5, active0);
1356: return 6;
1357: }
1358: switch (curChar) {
1359: case 84:
1360: case 116:
1361: return jjMoveStringLiteralDfa7_16(active0, 0x8000000L);
1362: case 89:
1363: case 121:
1364: return jjMoveStringLiteralDfa7_16(active0, 0x4000000L);
1365: default:
1366: break;
1367: }
1368: return jjStartNfa_16(5, active0);
1369: }
1370:
1371: private final int jjMoveStringLiteralDfa7_16(long old0, long active0) {
1372: if (((active0 &= old0)) == 0L)
1373: return jjStartNfa_16(5, old0);
1374: try {
1375: curChar = input_stream.readChar();
1376: } catch (java.io.IOException e) {
1377: jjStopStringLiteralDfa_16(6, active0);
1378: return 7;
1379: }
1380: switch (curChar) {
1381: case 65:
1382: case 97:
1383: return jjMoveStringLiteralDfa8_16(active0, 0x8000000L);
1384: case 80:
1385: case 112:
1386: return jjMoveStringLiteralDfa8_16(active0, 0x4000000L);
1387: default:
1388: break;
1389: }
1390: return jjStartNfa_16(6, active0);
1391: }
1392:
1393: private final int jjMoveStringLiteralDfa8_16(long old0, long active0) {
1394: if (((active0 &= old0)) == 0L)
1395: return jjStartNfa_16(6, old0);
1396: try {
1397: curChar = input_stream.readChar();
1398: } catch (java.io.IOException e) {
1399: jjStopStringLiteralDfa_16(7, active0);
1400: return 8;
1401: }
1402: switch (curChar) {
1403: case 91:
1404: if ((active0 & 0x8000000L) != 0L)
1405: return jjStopAtPos(8, 27);
1406: break;
1407: case 69:
1408: case 101:
1409: if ((active0 & 0x4000000L) != 0L)
1410: return jjStopAtPos(8, 26);
1411: break;
1412: default:
1413: break;
1414: }
1415: return jjStartNfa_16(7, active0);
1416: }
1417:
1418: private final int jjMoveNfa_16(int startState, int curPos) {
1419: int[] nextStates;
1420: int startsAt = 0;
1421: jjnewStateCnt = 1;
1422: int i = 1;
1423: jjstateSet[0] = startState;
1424: int j, kind = 0x7fffffff;
1425: for (;;) {
1426: if (++jjround == 0x7fffffff)
1427: ReInitRounds();
1428: if (curChar < 64) {
1429: long l = 1L << curChar;
1430: MatchLoop: do {
1431: switch (jjstateSet[--i]) {
1432: case 0:
1433: if ((0x100002600L & l) == 0L)
1434: break;
1435: kind = 20;
1436: jjstateSet[jjnewStateCnt++] = 0;
1437: break;
1438: default:
1439: break;
1440: }
1441: } while (i != startsAt);
1442: } else if (curChar < 128) {
1443: long l = 1L << (curChar & 077);
1444: MatchLoop: do {
1445: switch (jjstateSet[--i]) {
1446: default:
1447: break;
1448: }
1449: } while (i != startsAt);
1450: } else {
1451: int i2 = (curChar & 0xff) >> 6;
1452: long l2 = 1L << (curChar & 077);
1453: MatchLoop: do {
1454: switch (jjstateSet[--i]) {
1455: default:
1456: break;
1457: }
1458: } while (i != startsAt);
1459: }
1460: if (kind != 0x7fffffff) {
1461: jjmatchedKind = kind;
1462: jjmatchedPos = curPos;
1463: kind = 0x7fffffff;
1464: }
1465: ++curPos;
1466: if ((i = jjnewStateCnt) == (startsAt = 1 - (jjnewStateCnt = startsAt)))
1467: return curPos;
1468: try {
1469: curChar = input_stream.readChar();
1470: } catch (java.io.IOException e) {
1471: return curPos;
1472: }
1473: }
1474: }
1475:
1476: private final int jjStopStringLiteralDfa_12(int pos, long active0) {
1477: switch (pos) {
1478: default:
1479: return -1;
1480: }
1481: }
1482:
1483: private final int jjStartNfa_12(int pos, long active0) {
1484: return jjMoveNfa_12(jjStopStringLiteralDfa_12(pos, active0),
1485: pos + 1);
1486: }
1487:
1488: private final int jjStartNfaWithStates_12(int pos, int kind,
1489: int state) {
1490: jjmatchedKind = kind;
1491: jjmatchedPos = pos;
1492: try {
1493: curChar = input_stream.readChar();
1494: } catch (java.io.IOException e) {
1495: return pos + 1;
1496: }
1497: return jjMoveNfa_12(state, pos + 1);
1498: }
1499:
1500: private final int jjMoveStringLiteralDfa0_12() {
1501: switch (curChar) {
1502: case 60:
1503: jjmatchedKind = 22;
1504: return jjMoveStringLiteralDfa1_12(0x1ff800000L);
1505: default:
1506: return jjMoveNfa_12(10, 0);
1507: }
1508: }
1509:
1510: private final int jjMoveStringLiteralDfa1_12(long active0) {
1511: try {
1512: curChar = input_stream.readChar();
1513: } catch (java.io.IOException e) {
1514: jjStopStringLiteralDfa_12(0, active0);
1515: return 1;
1516: }
1517: switch (curChar) {
1518: case 33:
1519: return jjMoveStringLiteralDfa2_12(active0, 0xd000000L);
1520: case 37:
1521: if ((active0 & 0x80000000L) != 0L) {
1522: jjmatchedKind = 31;
1523: jjmatchedPos = 1;
1524: }
1525: return jjMoveStringLiteralDfa2_12(active0, 0x170000000L);
1526: case 47:
1527: if ((active0 & 0x800000L) != 0L)
1528: return jjStopAtPos(1, 23);
1529: break;
1530: case 63:
1531: if ((active0 & 0x2000000L) != 0L)
1532: return jjStopAtPos(1, 25);
1533: break;
1534: default:
1535: break;
1536: }
1537: return jjStartNfa_12(0, active0);
1538: }
1539:
1540: private final int jjMoveStringLiteralDfa2_12(long old0, long active0) {
1541: if (((active0 &= old0)) == 0L)
1542: return jjStartNfa_12(0, old0);
1543: try {
1544: curChar = input_stream.readChar();
1545: } catch (java.io.IOException e) {
1546: jjStopStringLiteralDfa_12(1, active0);
1547: return 2;
1548: }
1549: switch (curChar) {
1550: case 33:
1551: if ((active0 & 0x20000000L) != 0L)
1552: return jjStopAtPos(2, 29);
1553: break;
1554: case 45:
1555: return jjMoveStringLiteralDfa3_12(active0, 0x11000000L);
1556: case 61:
1557: if ((active0 & 0x40000000L) != 0L)
1558: return jjStopAtPos(2, 30);
1559: break;
1560: case 64:
1561: if ((active0 & 0x100000000L) != 0L)
1562: return jjStopAtPos(2, 32);
1563: break;
1564: case 91:
1565: return jjMoveStringLiteralDfa3_12(active0, 0x8000000L);
1566: case 68:
1567: case 100:
1568: return jjMoveStringLiteralDfa3_12(active0, 0x4000000L);
1569: default:
1570: break;
1571: }
1572: return jjStartNfa_12(1, active0);
1573: }
1574:
1575: private final int jjMoveStringLiteralDfa3_12(long old0, long active0) {
1576: if (((active0 &= old0)) == 0L)
1577: return jjStartNfa_12(1, old0);
1578: try {
1579: curChar = input_stream.readChar();
1580: } catch (java.io.IOException e) {
1581: jjStopStringLiteralDfa_12(2, active0);
1582: return 3;
1583: }
1584: switch (curChar) {
1585: case 45:
1586: if ((active0 & 0x1000000L) != 0L)
1587: return jjStopAtPos(3, 24);
1588: else if ((active0 & 0x10000000L) != 0L)
1589: return jjStopAtPos(3, 28);
1590: break;
1591: case 67:
1592: case 99:
1593: return jjMoveStringLiteralDfa4_12(active0, 0x8000000L);
1594: case 79:
1595: case 111:
1596: return jjMoveStringLiteralDfa4_12(active0, 0x4000000L);
1597: default:
1598: break;
1599: }
1600: return jjStartNfa_12(2, active0);
1601: }
1602:
1603: private final int jjMoveStringLiteralDfa4_12(long old0, long active0) {
1604: if (((active0 &= old0)) == 0L)
1605: return jjStartNfa_12(2, old0);
1606: try {
1607: curChar = input_stream.readChar();
1608: } catch (java.io.IOException e) {
1609: jjStopStringLiteralDfa_12(3, active0);
1610: return 4;
1611: }
1612: switch (curChar) {
1613: case 67:
1614: case 99:
1615: return jjMoveStringLiteralDfa5_12(active0, 0x4000000L);
1616: case 68:
1617: case 100:
1618: return jjMoveStringLiteralDfa5_12(active0, 0x8000000L);
1619: default:
1620: break;
1621: }
1622: return jjStartNfa_12(3, active0);
1623: }
1624:
1625: private final int jjMoveStringLiteralDfa5_12(long old0, long active0) {
1626: if (((active0 &= old0)) == 0L)
1627: return jjStartNfa_12(3, old0);
1628: try {
1629: curChar = input_stream.readChar();
1630: } catch (java.io.IOException e) {
1631: jjStopStringLiteralDfa_12(4, active0);
1632: return 5;
1633: }
1634: switch (curChar) {
1635: case 65:
1636: case 97:
1637: return jjMoveStringLiteralDfa6_12(active0, 0x8000000L);
1638: case 84:
1639: case 116:
1640: return jjMoveStringLiteralDfa6_12(active0, 0x4000000L);
1641: default:
1642: break;
1643: }
1644: return jjStartNfa_12(4, active0);
1645: }
1646:
1647: private final int jjMoveStringLiteralDfa6_12(long old0, long active0) {
1648: if (((active0 &= old0)) == 0L)
1649: return jjStartNfa_12(4, old0);
1650: try {
1651: curChar = input_stream.readChar();
1652: } catch (java.io.IOException e) {
1653: jjStopStringLiteralDfa_12(5, active0);
1654: return 6;
1655: }
1656: switch (curChar) {
1657: case 84:
1658: case 116:
1659: return jjMoveStringLiteralDfa7_12(active0, 0x8000000L);
1660: case 89:
1661: case 121:
1662: return jjMoveStringLiteralDfa7_12(active0, 0x4000000L);
1663: default:
1664: break;
1665: }
1666: return jjStartNfa_12(5, active0);
1667: }
1668:
1669: private final int jjMoveStringLiteralDfa7_12(long old0, long active0) {
1670: if (((active0 &= old0)) == 0L)
1671: return jjStartNfa_12(5, old0);
1672: try {
1673: curChar = input_stream.readChar();
1674: } catch (java.io.IOException e) {
1675: jjStopStringLiteralDfa_12(6, active0);
1676: return 7;
1677: }
1678: switch (curChar) {
1679: case 65:
1680: case 97:
1681: return jjMoveStringLiteralDfa8_12(active0, 0x8000000L);
1682: case 80:
1683: case 112:
1684: return jjMoveStringLiteralDfa8_12(active0, 0x4000000L);
1685: default:
1686: break;
1687: }
1688: return jjStartNfa_12(6, active0);
1689: }
1690:
1691: private final int jjMoveStringLiteralDfa8_12(long old0, long active0) {
1692: if (((active0 &= old0)) == 0L)
1693: return jjStartNfa_12(6, old0);
1694: try {
1695: curChar = input_stream.readChar();
1696: } catch (java.io.IOException e) {
1697: jjStopStringLiteralDfa_12(7, active0);
1698: return 8;
1699: }
1700: switch (curChar) {
1701: case 91:
1702: if ((active0 & 0x8000000L) != 0L)
1703: return jjStopAtPos(8, 27);
1704: break;
1705: case 69:
1706: case 101:
1707: if ((active0 & 0x4000000L) != 0L)
1708: return jjStopAtPos(8, 26);
1709: break;
1710: default:
1711: break;
1712: }
1713: return jjStartNfa_12(7, active0);
1714: }
1715:
1716: private final int jjMoveNfa_12(int startState, int curPos) {
1717: int[] nextStates;
1718: int startsAt = 0;
1719: jjnewStateCnt = 18;
1720: int i = 1;
1721: jjstateSet[0] = startState;
1722: int j, kind = 0x7fffffff;
1723: for (;;) {
1724: if (++jjround == 0x7fffffff)
1725: ReInitRounds();
1726: if (curChar < 64) {
1727: long l = 1L << curChar;
1728: MatchLoop: do {
1729: switch (jjstateSet[--i]) {
1730: case 10:
1731: if ((0xefffffefffffffffL & l) != 0L) {
1732: if (kind > 34)
1733: kind = 34;
1734: jjCheckNAddStates(31, 33);
1735: } else if (curChar == 36)
1736: jjstateSet[jjnewStateCnt++] = 13;
1737: if ((0x100002600L & l) != 0L) {
1738: if (kind > 21)
1739: kind = 21;
1740: jjCheckNAdd(0);
1741: } else if (curChar == 36)
1742: jjstateSet[jjnewStateCnt++] = 1;
1743: break;
1744: case 0:
1745: if ((0x100002600L & l) == 0L)
1746: break;
1747: if (kind > 21)
1748: kind = 21;
1749: jjCheckNAdd(0);
1750: break;
1751: case 2:
1752: if ((0xffffff7bffffffffL & l) != 0L)
1753: jjCheckNAddStates(34, 37);
1754: break;
1755: case 3:
1756: if (curChar == 34)
1757: jjCheckNAddTwoStates(4, 5);
1758: break;
1759: case 4:
1760: if ((0xfffffffbffffffffL & l) != 0L)
1761: jjCheckNAddTwoStates(4, 5);
1762: break;
1763: case 5:
1764: if (curChar == 34)
1765: jjCheckNAddStates(34, 37);
1766: break;
1767: case 6:
1768: if (curChar == 39)
1769: jjCheckNAddTwoStates(7, 8);
1770: break;
1771: case 7:
1772: if ((0xffffff7fffffffffL & l) != 0L)
1773: jjCheckNAddTwoStates(7, 8);
1774: break;
1775: case 8:
1776: if (curChar == 39)
1777: jjCheckNAddStates(34, 37);
1778: break;
1779: case 11:
1780: if ((0xefffffefffffffffL & l) == 0L)
1781: break;
1782: if (kind > 34)
1783: kind = 34;
1784: jjCheckNAddStates(31, 33);
1785: break;
1786: case 12:
1787: if (curChar == 36)
1788: jjstateSet[jjnewStateCnt++] = 13;
1789: break;
1790: case 13:
1791: if ((0xefffffffffffffffL & l) == 0L)
1792: break;
1793: if (kind > 34)
1794: kind = 34;
1795: jjCheckNAddStates(31, 33);
1796: break;
1797: case 16:
1798: if (curChar == 35)
1799: jjCheckNAdd(15);
1800: break;
1801: case 17:
1802: if (curChar == 36)
1803: jjCheckNAdd(15);
1804: break;
1805: default:
1806: break;
1807: }
1808: } while (i != startsAt);
1809: } else if (curChar < 128) {
1810: long l = 1L << (curChar & 077);
1811: MatchLoop: do {
1812: switch (jjstateSet[--i]) {
1813: case 10:
1814: if (kind > 34)
1815: kind = 34;
1816: jjCheckNAddStates(31, 33);
1817: if (curChar == 92)
1818: jjAddStates(24, 25);
1819: break;
1820: case 1:
1821: if (curChar == 123)
1822: jjCheckNAddStates(34, 37);
1823: break;
1824: case 2:
1825: if ((0xdfffffffffffffffL & l) != 0L)
1826: jjCheckNAddStates(34, 37);
1827: break;
1828: case 4:
1829: jjAddStates(38, 39);
1830: break;
1831: case 7:
1832: jjAddStates(40, 41);
1833: break;
1834: case 9:
1835: if (curChar == 125 && kind > 33)
1836: kind = 33;
1837: break;
1838: case 11:
1839: if (kind > 34)
1840: kind = 34;
1841: jjCheckNAddStates(31, 33);
1842: break;
1843: case 13:
1844: if ((0xf7ffffffffffffffL & l) == 0L)
1845: break;
1846: if (kind > 34)
1847: kind = 34;
1848: jjCheckNAddStates(31, 33);
1849: break;
1850: case 14:
1851: if (curChar == 92)
1852: jjAddStates(24, 25);
1853: break;
1854: case 15:
1855: if (curChar != 123)
1856: break;
1857: if (kind > 34)
1858: kind = 34;
1859: jjCheckNAddStates(31, 33);
1860: break;
1861: default:
1862: break;
1863: }
1864: } while (i != startsAt);
1865: } else {
1866: int i2 = (curChar & 0xff) >> 6;
1867: long l2 = 1L << (curChar & 077);
1868: MatchLoop: do {
1869: switch (jjstateSet[--i]) {
1870: case 10:
1871: case 11:
1872: case 13:
1873: if ((jjbitVec0[i2] & l2) == 0L)
1874: break;
1875: if (kind > 34)
1876: kind = 34;
1877: jjCheckNAddStates(31, 33);
1878: break;
1879: case 2:
1880: if ((jjbitVec0[i2] & l2) != 0L)
1881: jjAddStates(34, 37);
1882: break;
1883: case 4:
1884: if ((jjbitVec0[i2] & l2) != 0L)
1885: jjAddStates(38, 39);
1886: break;
1887: case 7:
1888: if ((jjbitVec0[i2] & l2) != 0L)
1889: jjAddStates(40, 41);
1890: break;
1891: default:
1892: break;
1893: }
1894: } while (i != startsAt);
1895: }
1896: if (kind != 0x7fffffff) {
1897: jjmatchedKind = kind;
1898: jjmatchedPos = curPos;
1899: kind = 0x7fffffff;
1900: }
1901: ++curPos;
1902: if ((i = jjnewStateCnt) == (startsAt = 18 - (jjnewStateCnt = startsAt)))
1903: return curPos;
1904: try {
1905: curChar = input_stream.readChar();
1906: } catch (java.io.IOException e) {
1907: return curPos;
1908: }
1909: }
1910: }
1911:
1912: private final int jjStopStringLiteralDfa_8(int pos, long active0) {
1913: switch (pos) {
1914: case 0:
1915: if ((active0 & 0x100000000000L) != 0L)
1916: return 2;
1917: return -1;
1918: default:
1919: return -1;
1920: }
1921: }
1922:
1923: private final int jjStartNfa_8(int pos, long active0) {
1924: return jjMoveNfa_8(jjStopStringLiteralDfa_8(pos, active0),
1925: pos + 1);
1926: }
1927:
1928: private final int jjStartNfaWithStates_8(int pos, int kind,
1929: int state) {
1930: jjmatchedKind = kind;
1931: jjmatchedPos = pos;
1932: try {
1933: curChar = input_stream.readChar();
1934: } catch (java.io.IOException e) {
1935: return pos + 1;
1936: }
1937: return jjMoveNfa_8(state, pos + 1);
1938: }
1939:
1940: private final int jjMoveStringLiteralDfa0_8() {
1941: switch (curChar) {
1942: case 37:
1943: return jjMoveStringLiteralDfa1_8(0x100000000000L);
1944: default:
1945: return jjMoveNfa_8(3, 0);
1946: }
1947: }
1948:
1949: private final int jjMoveStringLiteralDfa1_8(long active0) {
1950: try {
1951: curChar = input_stream.readChar();
1952: } catch (java.io.IOException e) {
1953: jjStopStringLiteralDfa_8(0, active0);
1954: return 1;
1955: }
1956: switch (curChar) {
1957: case 62:
1958: if ((active0 & 0x100000000000L) != 0L)
1959: return jjStopAtPos(1, 44);
1960: break;
1961: default:
1962: break;
1963: }
1964: return jjStartNfa_8(0, active0);
1965: }
1966:
1967: private final int jjMoveNfa_8(int startState, int curPos) {
1968: int[] nextStates;
1969: int startsAt = 0;
1970: jjnewStateCnt = 3;
1971: int i = 1;
1972: jjstateSet[0] = startState;
1973: int j, kind = 0x7fffffff;
1974: for (;;) {
1975: if (++jjround == 0x7fffffff)
1976: ReInitRounds();
1977: if (curChar < 64) {
1978: long l = 1L << curChar;
1979: MatchLoop: do {
1980: switch (jjstateSet[--i]) {
1981: case 3:
1982: if ((0xffffffdfffffffffL & l) != 0L) {
1983: if (kind > 45)
1984: kind = 45;
1985: jjCheckNAddTwoStates(0, 1);
1986: } else if (curChar == 37)
1987: jjstateSet[jjnewStateCnt++] = 2;
1988: break;
1989: case 0:
1990: if ((0xffffffdfffffffffL & l) == 0L)
1991: break;
1992: if (kind > 45)
1993: kind = 45;
1994: jjCheckNAddTwoStates(0, 1);
1995: break;
1996: case 1:
1997: if (curChar == 37)
1998: jjstateSet[jjnewStateCnt++] = 2;
1999: break;
2000: case 2:
2001: if ((0xbfffffffffffffffL & l) == 0L)
2002: break;
2003: if (kind > 45)
2004: kind = 45;
2005: jjCheckNAddTwoStates(0, 1);
2006: break;
2007: default:
2008: break;
2009: }
2010: } while (i != startsAt);
2011: } else if (curChar < 128) {
2012: long l = 1L << (curChar & 077);
2013: MatchLoop: do {
2014: switch (jjstateSet[--i]) {
2015: case 3:
2016: case 0:
2017: case 2:
2018: if (kind > 45)
2019: kind = 45;
2020: jjCheckNAddTwoStates(0, 1);
2021: break;
2022: default:
2023: break;
2024: }
2025: } while (i != startsAt);
2026: } else {
2027: int i2 = (curChar & 0xff) >> 6;
2028: long l2 = 1L << (curChar & 077);
2029: MatchLoop: do {
2030: switch (jjstateSet[--i]) {
2031: case 3:
2032: case 0:
2033: case 2:
2034: if ((jjbitVec0[i2] & l2) == 0L)
2035: break;
2036: if (kind > 45)
2037: kind = 45;
2038: jjCheckNAddTwoStates(0, 1);
2039: break;
2040: default:
2041: break;
2042: }
2043: } while (i != startsAt);
2044: }
2045: if (kind != 0x7fffffff) {
2046: jjmatchedKind = kind;
2047: jjmatchedPos = curPos;
2048: kind = 0x7fffffff;
2049: }
2050: ++curPos;
2051: if ((i = jjnewStateCnt) == (startsAt = 3 - (jjnewStateCnt = startsAt)))
2052: return curPos;
2053: try {
2054: curChar = input_stream.readChar();
2055: } catch (java.io.IOException e) {
2056: return curPos;
2057: }
2058: }
2059: }
2060:
2061: private final int jjStopStringLiteralDfa_11(int pos, long active0) {
2062: switch (pos) {
2063: default:
2064: return -1;
2065: }
2066: }
2067:
2068: private final int jjStartNfa_11(int pos, long active0) {
2069: return jjMoveNfa_11(jjStopStringLiteralDfa_11(pos, active0),
2070: pos + 1);
2071: }
2072:
2073: private final int jjStartNfaWithStates_11(int pos, int kind,
2074: int state) {
2075: jjmatchedKind = kind;
2076: jjmatchedPos = pos;
2077: try {
2078: curChar = input_stream.readChar();
2079: } catch (java.io.IOException e) {
2080: return pos + 1;
2081: }
2082: return jjMoveNfa_11(state, pos + 1);
2083: }
2084:
2085: private final int jjMoveStringLiteralDfa0_11() {
2086: switch (curChar) {
2087: case 47:
2088: return jjMoveStringLiteralDfa1_11(0x2000000000000000L);
2089: case 61:
2090: return jjStopAtPos(0, 62);
2091: case 62:
2092: return jjStopAtPos(0, 59);
2093: default:
2094: return jjMoveNfa_11(1, 0);
2095: }
2096: }
2097:
2098: private final int jjMoveStringLiteralDfa1_11(long active0) {
2099: try {
2100: curChar = input_stream.readChar();
2101: } catch (java.io.IOException e) {
2102: jjStopStringLiteralDfa_11(0, active0);
2103: return 1;
2104: }
2105: switch (curChar) {
2106: case 62:
2107: if ((active0 & 0x2000000000000000L) != 0L)
2108: return jjStopAtPos(1, 61);
2109: break;
2110: default:
2111: break;
2112: }
2113: return jjStartNfa_11(0, active0);
2114: }
2115:
2116: private final int jjMoveNfa_11(int startState, int curPos) {
2117: int[] nextStates;
2118: int startsAt = 0;
2119: jjnewStateCnt = 6;
2120: int i = 1;
2121: jjstateSet[0] = startState;
2122: int j, kind = 0x7fffffff;
2123: for (;;) {
2124: if (++jjround == 0x7fffffff)
2125: ReInitRounds();
2126: if (curChar < 64) {
2127: long l = 1L << curChar;
2128: MatchLoop: do {
2129: switch (jjstateSet[--i]) {
2130: case 1:
2131: if ((0x100002600L & l) != 0L) {
2132: if (kind > 21)
2133: kind = 21;
2134: jjCheckNAdd(0);
2135: } else if (curChar == 33)
2136: jjCheckNAdd(3);
2137: else if (curChar == 36) {
2138: if (kind > 58)
2139: kind = 58;
2140: jjCheckNAdd(2);
2141: } else if (curChar == 63)
2142: jjCheckNAdd(3);
2143: break;
2144: case 0:
2145: if ((0x100002600L & l) == 0L)
2146: break;
2147: kind = 21;
2148: jjCheckNAdd(0);
2149: break;
2150: case 2:
2151: if ((0x7ff601000000000L & l) == 0L)
2152: break;
2153: if (kind > 58)
2154: kind = 58;
2155: jjCheckNAdd(2);
2156: break;
2157: case 3:
2158: if (curChar == 62)
2159: kind = 60;
2160: break;
2161: case 4:
2162: if (curChar == 63)
2163: jjCheckNAdd(3);
2164: break;
2165: case 5:
2166: if (curChar == 33)
2167: jjCheckNAdd(3);
2168: break;
2169: default:
2170: break;
2171: }
2172: } while (i != startsAt);
2173: } else if (curChar < 128) {
2174: long l = 1L << (curChar & 077);
2175: MatchLoop: do {
2176: switch (jjstateSet[--i]) {
2177: case 1:
2178: case 2:
2179: if ((0x7fffffe87fffffeL & l) == 0L)
2180: break;
2181: if (kind > 58)
2182: kind = 58;
2183: jjCheckNAdd(2);
2184: break;
2185: default:
2186: break;
2187: }
2188: } while (i != startsAt);
2189: } else {
2190: int i2 = (curChar & 0xff) >> 6;
2191: long l2 = 1L << (curChar & 077);
2192: MatchLoop: do {
2193: switch (jjstateSet[--i]) {
2194: case 1:
2195: case 2:
2196: if ((jjbitVec1[i2] & l2) == 0L)
2197: break;
2198: if (kind > 58)
2199: kind = 58;
2200: jjCheckNAdd(2);
2201: break;
2202: default:
2203: break;
2204: }
2205: } while (i != startsAt);
2206: }
2207: if (kind != 0x7fffffff) {
2208: jjmatchedKind = kind;
2209: jjmatchedPos = curPos;
2210: kind = 0x7fffffff;
2211: }
2212: ++curPos;
2213: if ((i = jjnewStateCnt) == (startsAt = 6 - (jjnewStateCnt = startsAt)))
2214: return curPos;
2215: try {
2216: curChar = input_stream.readChar();
2217: } catch (java.io.IOException e) {
2218: return curPos;
2219: }
2220: }
2221: }
2222:
2223: private final int jjMoveStringLiteralDfa0_15() {
2224: return jjMoveNfa_15(1, 0);
2225: }
2226:
2227: private final int jjMoveNfa_15(int startState, int curPos) {
2228: int[] nextStates;
2229: int startsAt = 0;
2230: jjnewStateCnt = 3;
2231: int i = 1;
2232: jjstateSet[0] = startState;
2233: int j, kind = 0x7fffffff;
2234: for (;;) {
2235: if (++jjround == 0x7fffffff)
2236: ReInitRounds();
2237: if (curChar < 64) {
2238: long l = 1L << curChar;
2239: MatchLoop: do {
2240: switch (jjstateSet[--i]) {
2241: case 1:
2242: if ((0x100002600L & l) != 0L) {
2243: if (kind > 20)
2244: kind = 20;
2245: jjCheckNAdd(0);
2246: } else if (curChar == 36) {
2247: if (kind > 35)
2248: kind = 35;
2249: jjCheckNAdd(2);
2250: }
2251: break;
2252: case 0:
2253: if ((0x100002600L & l) == 0L)
2254: break;
2255: kind = 20;
2256: jjCheckNAdd(0);
2257: break;
2258: case 2:
2259: if ((0x7ff601000000000L & l) == 0L)
2260: break;
2261: if (kind > 35)
2262: kind = 35;
2263: jjCheckNAdd(2);
2264: break;
2265: default:
2266: break;
2267: }
2268: } while (i != startsAt);
2269: } else if (curChar < 128) {
2270: long l = 1L << (curChar & 077);
2271: MatchLoop: do {
2272: switch (jjstateSet[--i]) {
2273: case 1:
2274: case 2:
2275: if ((0x7fffffe87fffffeL & l) == 0L)
2276: break;
2277: if (kind > 35)
2278: kind = 35;
2279: jjCheckNAdd(2);
2280: break;
2281: default:
2282: break;
2283: }
2284: } while (i != startsAt);
2285: } else {
2286: int i2 = (curChar & 0xff) >> 6;
2287: long l2 = 1L << (curChar & 077);
2288: MatchLoop: do {
2289: switch (jjstateSet[--i]) {
2290: case 1:
2291: case 2:
2292: if ((jjbitVec1[i2] & l2) == 0L)
2293: break;
2294: if (kind > 35)
2295: kind = 35;
2296: jjCheckNAdd(2);
2297: break;
2298: default:
2299: break;
2300: }
2301: } while (i != startsAt);
2302: }
2303: if (kind != 0x7fffffff) {
2304: jjmatchedKind = kind;
2305: jjmatchedPos = curPos;
2306: kind = 0x7fffffff;
2307: }
2308: ++curPos;
2309: if ((i = jjnewStateCnt) == (startsAt = 3 - (jjnewStateCnt = startsAt)))
2310: return curPos;
2311: try {
2312: curChar = input_stream.readChar();
2313: } catch (java.io.IOException e) {
2314: return curPos;
2315: }
2316: }
2317: }
2318:
2319: private final int jjStopStringLiteralDfa_1(int pos, long active0,
2320: long active1) {
2321: switch (pos) {
2322: default:
2323: return -1;
2324: }
2325: }
2326:
2327: private final int jjStartNfa_1(int pos, long active0, long active1) {
2328: return jjMoveNfa_1(jjStopStringLiteralDfa_1(pos, active0,
2329: active1), pos + 1);
2330: }
2331:
2332: private final int jjStartNfaWithStates_1(int pos, int kind,
2333: int state) {
2334: jjmatchedKind = kind;
2335: jjmatchedPos = pos;
2336: try {
2337: curChar = input_stream.readChar();
2338: } catch (java.io.IOException e) {
2339: return pos + 1;
2340: }
2341: return jjMoveNfa_1(state, pos + 1);
2342: }
2343:
2344: private final int jjMoveStringLiteralDfa0_1() {
2345: switch (curChar) {
2346: case 34:
2347: return jjStopAtPos(0, 72);
2348: default:
2349: return jjMoveNfa_1(9, 0);
2350: }
2351: }
2352:
2353: private final int jjMoveNfa_1(int startState, int curPos) {
2354: int[] nextStates;
2355: int startsAt = 0;
2356: jjnewStateCnt = 37;
2357: int i = 1;
2358: jjstateSet[0] = startState;
2359: int j, kind = 0x7fffffff;
2360: for (;;) {
2361: if (++jjround == 0x7fffffff)
2362: ReInitRounds();
2363: if (curChar < 64) {
2364: long l = 1L << curChar;
2365: MatchLoop: do {
2366: switch (jjstateSet[--i]) {
2367: case 9:
2368: if ((0xffffffe3ffffffffL & l) != 0L) {
2369: if (kind > 73)
2370: kind = 73;
2371: jjCheckNAddStates(2, 4);
2372: } else if ((0x1800000000L & l) != 0L)
2373: jjCheckNAddTwoStates(30, 36);
2374: if (curChar == 60)
2375: jjstateSet[jjnewStateCnt++] = 26;
2376: else if (curChar == 35)
2377: jjstateSet[jjnewStateCnt++] = 10;
2378: else if (curChar == 36)
2379: jjstateSet[jjnewStateCnt++] = 0;
2380: break;
2381: case 1:
2382: if ((0xffffff7bffffffffL & l) != 0L)
2383: jjCheckNAddStates(5, 8);
2384: break;
2385: case 2:
2386: if (curChar == 34)
2387: jjCheckNAddTwoStates(3, 4);
2388: break;
2389: case 3:
2390: if ((0xfffffffbffffffffL & l) != 0L)
2391: jjCheckNAddTwoStates(3, 4);
2392: break;
2393: case 4:
2394: if (curChar == 34)
2395: jjCheckNAddStates(5, 8);
2396: break;
2397: case 5:
2398: if (curChar == 39)
2399: jjCheckNAddTwoStates(6, 7);
2400: break;
2401: case 6:
2402: if ((0xffffff7fffffffffL & l) != 0L)
2403: jjCheckNAddTwoStates(6, 7);
2404: break;
2405: case 7:
2406: if (curChar == 39)
2407: jjCheckNAddStates(5, 8);
2408: break;
2409: case 11:
2410: if ((0xffffff7bffffffffL & l) != 0L)
2411: jjCheckNAddStates(9, 12);
2412: break;
2413: case 12:
2414: if (curChar == 34)
2415: jjCheckNAddTwoStates(13, 14);
2416: break;
2417: case 13:
2418: if ((0xfffffffbffffffffL & l) != 0L)
2419: jjCheckNAddTwoStates(13, 14);
2420: break;
2421: case 14:
2422: if (curChar == 34)
2423: jjCheckNAddStates(9, 12);
2424: break;
2425: case 15:
2426: if (curChar == 39)
2427: jjCheckNAddTwoStates(16, 17);
2428: break;
2429: case 16:
2430: if ((0xffffff7fffffffffL & l) != 0L)
2431: jjCheckNAddTwoStates(16, 17);
2432: break;
2433: case 17:
2434: if (curChar == 39)
2435: jjCheckNAddStates(9, 12);
2436: break;
2437: case 19:
2438: if (curChar == 35)
2439: jjstateSet[jjnewStateCnt++] = 10;
2440: break;
2441: case 20:
2442: if (curChar == 61)
2443: jjCheckNAddTwoStates(21, 22);
2444: break;
2445: case 21:
2446: if ((0xffffffdfffffffffL & l) != 0L)
2447: jjCheckNAddStates(13, 15);
2448: break;
2449: case 22:
2450: if (curChar == 37)
2451: jjstateSet[jjnewStateCnt++] = 23;
2452: break;
2453: case 23:
2454: if ((0xbfffffffffffffffL & l) != 0L)
2455: jjCheckNAddStates(13, 15);
2456: break;
2457: case 24:
2458: if (curChar == 62 && kind > 68)
2459: kind = 68;
2460: break;
2461: case 25:
2462: if (curChar == 37)
2463: jjstateSet[jjnewStateCnt++] = 24;
2464: break;
2465: case 26:
2466: if (curChar == 37)
2467: jjstateSet[jjnewStateCnt++] = 20;
2468: break;
2469: case 27:
2470: if (curChar == 60)
2471: jjstateSet[jjnewStateCnt++] = 26;
2472: break;
2473: case 28:
2474: if ((0xffffffe3ffffffffL & l) == 0L)
2475: break;
2476: if (kind > 73)
2477: kind = 73;
2478: jjCheckNAddStates(2, 4);
2479: break;
2480: case 29:
2481: if ((0x1800000000L & l) != 0L)
2482: jjCheckNAdd(30);
2483: break;
2484: case 30:
2485: if ((0xfffffffbffffffffL & l) == 0L)
2486: break;
2487: if (kind > 73)
2488: kind = 73;
2489: jjCheckNAddStates(2, 4);
2490: break;
2491: case 33:
2492: if (curChar == 35)
2493: jjCheckNAdd(32);
2494: break;
2495: case 34:
2496: if (curChar == 36)
2497: jjCheckNAdd(32);
2498: break;
2499: case 35:
2500: if ((0x1800000000L & l) != 0L)
2501: jjCheckNAddTwoStates(30, 36);
2502: break;
2503: case 36:
2504: if (curChar == 34 && kind > 74)
2505: kind = 74;
2506: break;
2507: default:
2508: break;
2509: }
2510: } while (i != startsAt);
2511: } else if (curChar < 128) {
2512: long l = 1L << (curChar & 077);
2513: MatchLoop: do {
2514: switch (jjstateSet[--i]) {
2515: case 9:
2516: if (kind > 73)
2517: kind = 73;
2518: jjCheckNAddStates(2, 4);
2519: if (curChar == 92)
2520: jjAddStates(16, 17);
2521: break;
2522: case 0:
2523: if (curChar == 123)
2524: jjCheckNAddStates(5, 8);
2525: break;
2526: case 1:
2527: if ((0xdfffffffffffffffL & l) != 0L)
2528: jjCheckNAddStates(5, 8);
2529: break;
2530: case 3:
2531: jjAddStates(18, 19);
2532: break;
2533: case 6:
2534: jjAddStates(20, 21);
2535: break;
2536: case 8:
2537: if (curChar == 125 && kind > 66)
2538: kind = 66;
2539: break;
2540: case 10:
2541: if (curChar == 123)
2542: jjCheckNAddStates(9, 12);
2543: break;
2544: case 11:
2545: if ((0xdfffffffffffffffL & l) != 0L)
2546: jjCheckNAddStates(9, 12);
2547: break;
2548: case 13:
2549: jjAddStates(22, 23);
2550: break;
2551: case 16:
2552: jjAddStates(24, 25);
2553: break;
2554: case 18:
2555: if (curChar == 125 && kind > 67)
2556: kind = 67;
2557: break;
2558: case 21:
2559: case 23:
2560: jjCheckNAddStates(13, 15);
2561: break;
2562: case 28:
2563: if (kind > 73)
2564: kind = 73;
2565: jjCheckNAddStates(2, 4);
2566: break;
2567: case 30:
2568: if ((0xf7ffffffffffffffL & l) == 0L)
2569: break;
2570: if (kind > 73)
2571: kind = 73;
2572: jjCheckNAddStates(2, 4);
2573: break;
2574: case 31:
2575: if (curChar == 92)
2576: jjAddStates(16, 17);
2577: break;
2578: case 32:
2579: if (curChar != 123)
2580: break;
2581: if (kind > 73)
2582: kind = 73;
2583: jjCheckNAddStates(2, 4);
2584: break;
2585: default:
2586: break;
2587: }
2588: } while (i != startsAt);
2589: } else {
2590: int i2 = (curChar & 0xff) >> 6;
2591: long l2 = 1L << (curChar & 077);
2592: MatchLoop: do {
2593: switch (jjstateSet[--i]) {
2594: case 9:
2595: case 28:
2596: case 30:
2597: if ((jjbitVec0[i2] & l2) == 0L)
2598: break;
2599: if (kind > 73)
2600: kind = 73;
2601: jjCheckNAddStates(2, 4);
2602: break;
2603: case 1:
2604: if ((jjbitVec0[i2] & l2) != 0L)
2605: jjAddStates(5, 8);
2606: break;
2607: case 3:
2608: if ((jjbitVec0[i2] & l2) != 0L)
2609: jjAddStates(18, 19);
2610: break;
2611: case 6:
2612: if ((jjbitVec0[i2] & l2) != 0L)
2613: jjAddStates(20, 21);
2614: break;
2615: case 11:
2616: if ((jjbitVec0[i2] & l2) != 0L)
2617: jjAddStates(9, 12);
2618: break;
2619: case 13:
2620: if ((jjbitVec0[i2] & l2) != 0L)
2621: jjAddStates(22, 23);
2622: break;
2623: case 16:
2624: if ((jjbitVec0[i2] & l2) != 0L)
2625: jjAddStates(24, 25);
2626: break;
2627: case 21:
2628: case 23:
2629: if ((jjbitVec0[i2] & l2) != 0L)
2630: jjCheckNAddStates(13, 15);
2631: break;
2632: default:
2633: break;
2634: }
2635: } while (i != startsAt);
2636: }
2637: if (kind != 0x7fffffff) {
2638: jjmatchedKind = kind;
2639: jjmatchedPos = curPos;
2640: kind = 0x7fffffff;
2641: }
2642: ++curPos;
2643: if ((i = jjnewStateCnt) == (startsAt = 37 - (jjnewStateCnt = startsAt)))
2644: return curPos;
2645: try {
2646: curChar = input_stream.readChar();
2647: } catch (java.io.IOException e) {
2648: return curPos;
2649: }
2650: }
2651: }
2652:
2653: private final int jjStopStringLiteralDfa_5(int pos, long active0) {
2654: switch (pos) {
2655: default:
2656: return -1;
2657: }
2658: }
2659:
2660: private final int jjStartNfa_5(int pos, long active0) {
2661: return jjMoveNfa_5(jjStopStringLiteralDfa_5(pos, active0),
2662: pos + 1);
2663: }
2664:
2665: private final int jjStartNfaWithStates_5(int pos, int kind,
2666: int state) {
2667: jjmatchedKind = kind;
2668: jjmatchedPos = pos;
2669: try {
2670: curChar = input_stream.readChar();
2671: } catch (java.io.IOException e) {
2672: return pos + 1;
2673: }
2674: return jjMoveNfa_5(state, pos + 1);
2675: }
2676:
2677: private final int jjMoveStringLiteralDfa0_5() {
2678: switch (curChar) {
2679: case 62:
2680: return jjStopAtPos(0, 52);
2681: case 80:
2682: case 112:
2683: return jjMoveStringLiteralDfa1_5(0x4000000000000L);
2684: case 83:
2685: case 115:
2686: return jjMoveStringLiteralDfa1_5(0x8000000000000L);
2687: default:
2688: return jjMoveNfa_5(1, 0);
2689: }
2690: }
2691:
2692: private final int jjMoveStringLiteralDfa1_5(long active0) {
2693: try {
2694: curChar = input_stream.readChar();
2695: } catch (java.io.IOException e) {
2696: jjStopStringLiteralDfa_5(0, active0);
2697: return 1;
2698: }
2699: switch (curChar) {
2700: case 85:
2701: case 117:
2702: return jjMoveStringLiteralDfa2_5(active0, 0x4000000000000L);
2703: case 89:
2704: case 121:
2705: return jjMoveStringLiteralDfa2_5(active0, 0x8000000000000L);
2706: default:
2707: break;
2708: }
2709: return jjStartNfa_5(0, active0);
2710: }
2711:
2712: private final int jjMoveStringLiteralDfa2_5(long old0, long active0) {
2713: if (((active0 &= old0)) == 0L)
2714: return jjStartNfa_5(0, old0);
2715: try {
2716: curChar = input_stream.readChar();
2717: } catch (java.io.IOException e) {
2718: jjStopStringLiteralDfa_5(1, active0);
2719: return 2;
2720: }
2721: switch (curChar) {
2722: case 66:
2723: case 98:
2724: return jjMoveStringLiteralDfa3_5(active0, 0x4000000000000L);
2725: case 83:
2726: case 115:
2727: return jjMoveStringLiteralDfa3_5(active0, 0x8000000000000L);
2728: default:
2729: break;
2730: }
2731: return jjStartNfa_5(1, active0);
2732: }
2733:
2734: private final int jjMoveStringLiteralDfa3_5(long old0, long active0) {
2735: if (((active0 &= old0)) == 0L)
2736: return jjStartNfa_5(1, old0);
2737: try {
2738: curChar = input_stream.readChar();
2739: } catch (java.io.IOException e) {
2740: jjStopStringLiteralDfa_5(2, active0);
2741: return 3;
2742: }
2743: switch (curChar) {
2744: case 76:
2745: case 108:
2746: return jjMoveStringLiteralDfa4_5(active0, 0x4000000000000L);
2747: case 84:
2748: case 116:
2749: return jjMoveStringLiteralDfa4_5(active0, 0x8000000000000L);
2750: default:
2751: break;
2752: }
2753: return jjStartNfa_5(2, active0);
2754: }
2755:
2756: private final int jjMoveStringLiteralDfa4_5(long old0, long active0) {
2757: if (((active0 &= old0)) == 0L)
2758: return jjStartNfa_5(2, old0);
2759: try {
2760: curChar = input_stream.readChar();
2761: } catch (java.io.IOException e) {
2762: jjStopStringLiteralDfa_5(3, active0);
2763: return 4;
2764: }
2765: switch (curChar) {
2766: case 69:
2767: case 101:
2768: return jjMoveStringLiteralDfa5_5(active0, 0x8000000000000L);
2769: case 73:
2770: case 105:
2771: return jjMoveStringLiteralDfa5_5(active0, 0x4000000000000L);
2772: default:
2773: break;
2774: }
2775: return jjStartNfa_5(3, active0);
2776: }
2777:
2778: private final int jjMoveStringLiteralDfa5_5(long old0, long active0) {
2779: if (((active0 &= old0)) == 0L)
2780: return jjStartNfa_5(3, old0);
2781: try {
2782: curChar = input_stream.readChar();
2783: } catch (java.io.IOException e) {
2784: jjStopStringLiteralDfa_5(4, active0);
2785: return 5;
2786: }
2787: switch (curChar) {
2788: case 67:
2789: case 99:
2790: if ((active0 & 0x4000000000000L) != 0L)
2791: return jjStopAtPos(5, 50);
2792: break;
2793: case 77:
2794: case 109:
2795: if ((active0 & 0x8000000000000L) != 0L)
2796: return jjStopAtPos(5, 51);
2797: break;
2798: default:
2799: break;
2800: }
2801: return jjStartNfa_5(4, active0);
2802: }
2803:
2804: private final int jjMoveNfa_5(int startState, int curPos) {
2805: int[] nextStates;
2806: int startsAt = 0;
2807: jjnewStateCnt = 7;
2808: int i = 1;
2809: jjstateSet[0] = startState;
2810: int j, kind = 0x7fffffff;
2811: for (;;) {
2812: if (++jjround == 0x7fffffff)
2813: ReInitRounds();
2814: if (curChar < 64) {
2815: long l = 1L << curChar;
2816: MatchLoop: do {
2817: switch (jjstateSet[--i]) {
2818: case 1:
2819: if ((0x100002600L & l) != 0L) {
2820: if (kind > 48)
2821: kind = 48;
2822: jjCheckNAdd(0);
2823: } else if (curChar == 34)
2824: jjCheckNAddTwoStates(5, 6);
2825: else if (curChar == 39)
2826: jjCheckNAddTwoStates(2, 3);
2827: break;
2828: case 0:
2829: if ((0x100002600L & l) == 0L)
2830: break;
2831: if (kind > 48)
2832: kind = 48;
2833: jjCheckNAdd(0);
2834: break;
2835: case 2:
2836: if ((0xffffff7fffffffffL & l) != 0L)
2837: jjCheckNAddTwoStates(2, 3);
2838: break;
2839: case 3:
2840: if (curChar == 39 && kind > 53)
2841: kind = 53;
2842: break;
2843: case 4:
2844: if (curChar == 34)
2845: jjCheckNAddTwoStates(5, 6);
2846: break;
2847: case 5:
2848: if ((0xfffffffbffffffffL & l) != 0L)
2849: jjCheckNAddTwoStates(5, 6);
2850: break;
2851: case 6:
2852: if (curChar == 34 && kind > 53)
2853: kind = 53;
2854: break;
2855: default:
2856: break;
2857: }
2858: } while (i != startsAt);
2859: } else if (curChar < 128) {
2860: long l = 1L << (curChar & 077);
2861: MatchLoop: do {
2862: switch (jjstateSet[--i]) {
2863: case 2:
2864: jjAddStates(42, 43);
2865: break;
2866: case 5:
2867: jjAddStates(44, 45);
2868: break;
2869: default:
2870: break;
2871: }
2872: } while (i != startsAt);
2873: } else {
2874: int i2 = (curChar & 0xff) >> 6;
2875: long l2 = 1L << (curChar & 077);
2876: MatchLoop: do {
2877: switch (jjstateSet[--i]) {
2878: case 2:
2879: if ((jjbitVec0[i2] & l2) != 0L)
2880: jjAddStates(42, 43);
2881: break;
2882: case 5:
2883: if ((jjbitVec0[i2] & l2) != 0L)
2884: jjAddStates(44, 45);
2885: break;
2886: default:
2887: break;
2888: }
2889: } while (i != startsAt);
2890: }
2891: if (kind != 0x7fffffff) {
2892: jjmatchedKind = kind;
2893: jjmatchedPos = curPos;
2894: kind = 0x7fffffff;
2895: }
2896: ++curPos;
2897: if ((i = jjnewStateCnt) == (startsAt = 7 - (jjnewStateCnt = startsAt)))
2898: return curPos;
2899: try {
2900: curChar = input_stream.readChar();
2901: } catch (java.io.IOException e) {
2902: return curPos;
2903: }
2904: }
2905: }
2906:
2907: private final int jjStopStringLiteralDfa_10(int pos, long active0) {
2908: switch (pos) {
2909: case 0:
2910: if ((active0 & 0x10000000000L) != 0L)
2911: return 2;
2912: return -1;
2913: default:
2914: return -1;
2915: }
2916: }
2917:
2918: private final int jjStartNfa_10(int pos, long active0) {
2919: return jjMoveNfa_10(jjStopStringLiteralDfa_10(pos, active0),
2920: pos + 1);
2921: }
2922:
2923: private final int jjStartNfaWithStates_10(int pos, int kind,
2924: int state) {
2925: jjmatchedKind = kind;
2926: jjmatchedPos = pos;
2927: try {
2928: curChar = input_stream.readChar();
2929: } catch (java.io.IOException e) {
2930: return pos + 1;
2931: }
2932: return jjMoveNfa_10(state, pos + 1);
2933: }
2934:
2935: private final int jjMoveStringLiteralDfa0_10() {
2936: switch (curChar) {
2937: case 37:
2938: return jjMoveStringLiteralDfa1_10(0x10000000000L);
2939: default:
2940: return jjMoveNfa_10(3, 0);
2941: }
2942: }
2943:
2944: private final int jjMoveStringLiteralDfa1_10(long active0) {
2945: try {
2946: curChar = input_stream.readChar();
2947: } catch (java.io.IOException e) {
2948: jjStopStringLiteralDfa_10(0, active0);
2949: return 1;
2950: }
2951: switch (curChar) {
2952: case 62:
2953: if ((active0 & 0x10000000000L) != 0L)
2954: return jjStopAtPos(1, 40);
2955: break;
2956: default:
2957: break;
2958: }
2959: return jjStartNfa_10(0, active0);
2960: }
2961:
2962: private final int jjMoveNfa_10(int startState, int curPos) {
2963: int[] nextStates;
2964: int startsAt = 0;
2965: jjnewStateCnt = 3;
2966: int i = 1;
2967: jjstateSet[0] = startState;
2968: int j, kind = 0x7fffffff;
2969: for (;;) {
2970: if (++jjround == 0x7fffffff)
2971: ReInitRounds();
2972: if (curChar < 64) {
2973: long l = 1L << curChar;
2974: MatchLoop: do {
2975: switch (jjstateSet[--i]) {
2976: case 3:
2977: if ((0xffffffdfffffffffL & l) != 0L) {
2978: if (kind > 41)
2979: kind = 41;
2980: jjCheckNAddTwoStates(0, 1);
2981: } else if (curChar == 37)
2982: jjstateSet[jjnewStateCnt++] = 2;
2983: break;
2984: case 0:
2985: if ((0xffffffdfffffffffL & l) == 0L)
2986: break;
2987: if (kind > 41)
2988: kind = 41;
2989: jjCheckNAddTwoStates(0, 1);
2990: break;
2991: case 1:
2992: if (curChar == 37)
2993: jjstateSet[jjnewStateCnt++] = 2;
2994: break;
2995: case 2:
2996: if ((0xbfffffffffffffffL & l) == 0L)
2997: break;
2998: if (kind > 41)
2999: kind = 41;
3000: jjCheckNAddTwoStates(0, 1);
3001: break;
3002: default:
3003: break;
3004: }
3005: } while (i != startsAt);
3006: } else if (curChar < 128) {
3007: long l = 1L << (curChar & 077);
3008: MatchLoop: do {
3009: switch (jjstateSet[--i]) {
3010: case 3:
3011: case 0:
3012: case 2:
3013: if (kind > 41)
3014: kind = 41;
3015: jjCheckNAddTwoStates(0, 1);
3016: break;
3017: default:
3018: break;
3019: }
3020: } while (i != startsAt);
3021: } else {
3022: int i2 = (curChar & 0xff) >> 6;
3023: long l2 = 1L << (curChar & 077);
3024: MatchLoop: do {
3025: switch (jjstateSet[--i]) {
3026: case 3:
3027: case 0:
3028: case 2:
3029: if ((jjbitVec0[i2] & l2) == 0L)
3030: break;
3031: if (kind > 41)
3032: kind = 41;
3033: jjCheckNAddTwoStates(0, 1);
3034: break;
3035: default:
3036: break;
3037: }
3038: } while (i != startsAt);
3039: }
3040: if (kind != 0x7fffffff) {
3041: jjmatchedKind = kind;
3042: jjmatchedPos = curPos;
3043: kind = 0x7fffffff;
3044: }
3045: ++curPos;
3046: if ((i = jjnewStateCnt) == (startsAt = 3 - (jjnewStateCnt = startsAt)))
3047: return curPos;
3048: try {
3049: curChar = input_stream.readChar();
3050: } catch (java.io.IOException e) {
3051: return curPos;
3052: }
3053: }
3054: }
3055:
3056: private final int jjStopStringLiteralDfa_14(int pos, long active0) {
3057: switch (pos) {
3058: default:
3059: return -1;
3060: }
3061: }
3062:
3063: private final int jjStartNfa_14(int pos, long active0) {
3064: return jjMoveNfa_14(jjStopStringLiteralDfa_14(pos, active0),
3065: pos + 1);
3066: }
3067:
3068: private final int jjStartNfaWithStates_14(int pos, int kind,
3069: int state) {
3070: jjmatchedKind = kind;
3071: jjmatchedPos = pos;
3072: try {
3073: curChar = input_stream.readChar();
3074: } catch (java.io.IOException e) {
3075: return pos + 1;
3076: }
3077: return jjMoveNfa_14(state, pos + 1);
3078: }
3079:
3080: private final int jjMoveStringLiteralDfa0_14() {
3081: switch (curChar) {
3082: case 37:
3083: return jjMoveStringLiteralDfa1_14(0x8000000000L);
3084: case 61:
3085: return jjStopAtPos(0, 37);
3086: default:
3087: return jjMoveNfa_14(1, 0);
3088: }
3089: }
3090:
3091: private final int jjMoveStringLiteralDfa1_14(long active0) {
3092: try {
3093: curChar = input_stream.readChar();
3094: } catch (java.io.IOException e) {
3095: jjStopStringLiteralDfa_14(0, active0);
3096: return 1;
3097: }
3098: switch (curChar) {
3099: case 62:
3100: if ((active0 & 0x8000000000L) != 0L)
3101: return jjStopAtPos(1, 39);
3102: break;
3103: default:
3104: break;
3105: }
3106: return jjStartNfa_14(0, active0);
3107: }
3108:
3109: private final int jjMoveNfa_14(int startState, int curPos) {
3110: int[] nextStates;
3111: int startsAt = 0;
3112: jjnewStateCnt = 9;
3113: int i = 1;
3114: jjstateSet[0] = startState;
3115: int j, kind = 0x7fffffff;
3116: for (;;) {
3117: if (++jjround == 0x7fffffff)
3118: ReInitRounds();
3119: if (curChar < 64) {
3120: long l = 1L << curChar;
3121: MatchLoop: do {
3122: switch (jjstateSet[--i]) {
3123: case 1:
3124: if ((0x100002600L & l) != 0L) {
3125: if (kind > 20)
3126: kind = 20;
3127: jjCheckNAdd(0);
3128: } else if (curChar == 34)
3129: jjCheckNAddTwoStates(7, 8);
3130: else if (curChar == 39)
3131: jjCheckNAddTwoStates(4, 5);
3132: else if (curChar == 36) {
3133: if (kind > 36)
3134: kind = 36;
3135: jjCheckNAdd(2);
3136: }
3137: break;
3138: case 0:
3139: if ((0x100002600L & l) == 0L)
3140: break;
3141: if (kind > 20)
3142: kind = 20;
3143: jjCheckNAdd(0);
3144: break;
3145: case 2:
3146: if ((0x7ff601000000000L & l) == 0L)
3147: break;
3148: if (kind > 36)
3149: kind = 36;
3150: jjCheckNAdd(2);
3151: break;
3152: case 3:
3153: if (curChar == 39)
3154: jjCheckNAddTwoStates(4, 5);
3155: break;
3156: case 4:
3157: if ((0xffffff7fffffffffL & l) != 0L)
3158: jjCheckNAddTwoStates(4, 5);
3159: break;
3160: case 5:
3161: if (curChar == 39 && kind > 38)
3162: kind = 38;
3163: break;
3164: case 6:
3165: if (curChar == 34)
3166: jjCheckNAddTwoStates(7, 8);
3167: break;
3168: case 7:
3169: if ((0xfffffffbffffffffL & l) != 0L)
3170: jjCheckNAddTwoStates(7, 8);
3171: break;
3172: case 8:
3173: if (curChar == 34 && kind > 38)
3174: kind = 38;
3175: break;
3176: default:
3177: break;
3178: }
3179: } while (i != startsAt);
3180: } else if (curChar < 128) {
3181: long l = 1L << (curChar & 077);
3182: MatchLoop: do {
3183: switch (jjstateSet[--i]) {
3184: case 1:
3185: case 2:
3186: if ((0x7fffffe87fffffeL & l) == 0L)
3187: break;
3188: if (kind > 36)
3189: kind = 36;
3190: jjCheckNAdd(2);
3191: break;
3192: case 4:
3193: jjAddStates(38, 39);
3194: break;
3195: case 7:
3196: jjAddStates(40, 41);
3197: break;
3198: default:
3199: break;
3200: }
3201: } while (i != startsAt);
3202: } else {
3203: int i2 = (curChar & 0xff) >> 6;
3204: long l2 = 1L << (curChar & 077);
3205: MatchLoop: do {
3206: switch (jjstateSet[--i]) {
3207: case 1:
3208: case 2:
3209: if ((jjbitVec1[i2] & l2) == 0L)
3210: break;
3211: if (kind > 36)
3212: kind = 36;
3213: jjCheckNAdd(2);
3214: break;
3215: case 4:
3216: if ((jjbitVec0[i2] & l2) != 0L)
3217: jjAddStates(38, 39);
3218: break;
3219: case 7:
3220: if ((jjbitVec0[i2] & l2) != 0L)
3221: jjAddStates(40, 41);
3222: break;
3223: default:
3224: break;
3225: }
3226: } while (i != startsAt);
3227: }
3228: if (kind != 0x7fffffff) {
3229: jjmatchedKind = kind;
3230: jjmatchedPos = curPos;
3231: kind = 0x7fffffff;
3232: }
3233: ++curPos;
3234: if ((i = jjnewStateCnt) == (startsAt = 9 - (jjnewStateCnt = startsAt)))
3235: return curPos;
3236: try {
3237: curChar = input_stream.readChar();
3238: } catch (java.io.IOException e) {
3239: return curPos;
3240: }
3241: }
3242: }
3243:
3244: static final int[] jjnextStates = { 1, 4, 28, 29, 31, 1, 2, 5, 8,
3245: 11, 12, 15, 18, 21, 22, 25, 33, 34, 3, 4, 6, 7, 13, 14, 16,
3246: 17, 0, 1, 2, 3, 7, 11, 12, 14, 2, 3, 6, 9, 4, 5, 7, 8, 2,
3247: 3, 5, 6, };
3248: public static final String[] jjstrLiteralImages = { "", null, null,
3249: null, null, null, null, null, null, null, null, null, null,
3250: null, null, null, null, null, null, null, null, null,
3251: "\74", "\74\57", "\74\41\55\55", "\74\77", null, null,
3252: "\74\45\55\55", "\74\45\41", "\74\45\75", "\74\45",
3253: "\74\45\100", null, null, null, null, "\75", null,
3254: "\45\76", "\45\76", null, "\45\76", null, "\45\76", null,
3255: "\55\55\45\76", null, null, null, null, null, "\76", null,
3256: null, "\135\135\76", null, null, null, "\76", null,
3257: "\57\76", "\75", null, "\47", "\42", null, null, null,
3258: "\47", null, null, "\42", null, null, null, null, };
3259: public static final String[] lexStateNames = { "CommentState",
3260: "AttrValueBetweenDoubleQuotesState",
3261: "AttrValueBetweenSingleQuotesState", "StartTagState",
3262: "CDataState", "DocTypeExternalIdState", "DocTypeState",
3263: "JspCommentState", "JspDeclarationState",
3264: "JspExpressionState", "JspScriptletState", "InTagState",
3265: "AfterTagState", "AttrValueState",
3266: "JspDirectiveAttributesState", "JspDirectiveState",
3267: "DEFAULT", };
3268: public static final int[] jjnewLexState = { -1, -1, -1, -1, -1, -1,
3269: -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
3270: -1, 3, 3, 0, 3, 6, 4, 7, 8, 9, 10, 15, -1, -1, 14, -1, -1,
3271: -1, 12, 12, -1, 12, -1, 12, -1, 12, -1, -1, 5, -1, -1, 12,
3272: -1, -1, 12, 11, 16, -1, 12, 12, 12, 13, -1, 2, 1, -1, -1,
3273: -1, 11, -1, 11, 11, -1, 11, 12, -1, };
3274: static final long[] jjtoToken = { 0xffffffffffc00001L, 0x1fffL, };
3275: static final long[] jjtoSkip = { 0x300000L, 0x0L, };
3276: static final long[] jjtoSpecial = { 0x200000L, 0x0L, };
3277: protected CharStream input_stream;
3278: private final int[] jjrounds = new int[37];
3279: private final int[] jjstateSet = new int[74];
3280: protected char curChar;
3281:
3282: public JspParserTokenManager(CharStream stream) {
3283: input_stream = stream;
3284: }
3285:
3286: public JspParserTokenManager(CharStream stream, int lexState) {
3287: this (stream);
3288: SwitchTo(lexState);
3289: }
3290:
3291: public void ReInit(CharStream stream) {
3292: jjmatchedPos = jjnewStateCnt = 0;
3293: curLexState = defaultLexState;
3294: input_stream = stream;
3295: ReInitRounds();
3296: }
3297:
3298: private final void ReInitRounds() {
3299: int i;
3300: jjround = 0x80000001;
3301: for (i = 37; i-- > 0;)
3302: jjrounds[i] = 0x80000000;
3303: }
3304:
3305: public void ReInit(CharStream stream, int lexState) {
3306: ReInit(stream);
3307: SwitchTo(lexState);
3308: }
3309:
3310: public void SwitchTo(int lexState) {
3311: if (lexState >= 17 || lexState < 0)
3312: throw new TokenMgrError(
3313: "Error: Ignoring invalid lexical state : "
3314: + lexState + ". State unchanged.",
3315: TokenMgrError.INVALID_LEXICAL_STATE);
3316: else
3317: curLexState = lexState;
3318: }
3319:
3320: protected Token jjFillToken() {
3321: Token t = Token.newToken(jjmatchedKind);
3322: t.kind = jjmatchedKind;
3323: String im = jjstrLiteralImages[jjmatchedKind];
3324: t.image = (im == null) ? input_stream.GetImage() : im;
3325: t.beginLine = input_stream.getBeginLine();
3326: t.beginColumn = input_stream.getBeginColumn();
3327: t.endLine = input_stream.getEndLine();
3328: t.endColumn = input_stream.getEndColumn();
3329: return t;
3330: }
3331:
3332: int curLexState = 16;
3333: int defaultLexState = 16;
3334: int jjnewStateCnt;
3335: int jjround;
3336: int jjmatchedPos;
3337: int jjmatchedKind;
3338:
3339: public Token getNextToken() {
3340: int kind;
3341: Token specialToken = null;
3342: Token matchedToken;
3343: int curPos = 0;
3344:
3345: EOFLoop: for (;;) {
3346: try {
3347: curChar = input_stream.BeginToken();
3348: } catch (java.io.IOException e) {
3349: jjmatchedKind = 0;
3350: matchedToken = jjFillToken();
3351: matchedToken.specialToken = specialToken;
3352: return matchedToken;
3353: }
3354:
3355: switch (curLexState) {
3356: case 0:
3357: jjmatchedKind = 0x7fffffff;
3358: jjmatchedPos = 0;
3359: curPos = jjMoveStringLiteralDfa0_0();
3360: if (jjmatchedPos == 0 && jjmatchedKind > 76) {
3361: jjmatchedKind = 76;
3362: }
3363: break;
3364: case 1:
3365: jjmatchedKind = 0x7fffffff;
3366: jjmatchedPos = 0;
3367: curPos = jjMoveStringLiteralDfa0_1();
3368: break;
3369: case 2:
3370: jjmatchedKind = 0x7fffffff;
3371: jjmatchedPos = 0;
3372: curPos = jjMoveStringLiteralDfa0_2();
3373: break;
3374: case 3:
3375: jjmatchedKind = 0x7fffffff;
3376: jjmatchedPos = 0;
3377: curPos = jjMoveStringLiteralDfa0_3();
3378: if (jjmatchedPos == 0 && jjmatchedKind > 57) {
3379: jjmatchedKind = 57;
3380: }
3381: break;
3382: case 4:
3383: jjmatchedKind = 0x7fffffff;
3384: jjmatchedPos = 0;
3385: curPos = jjMoveStringLiteralDfa0_4();
3386: if (jjmatchedPos == 0 && jjmatchedKind > 54) {
3387: jjmatchedKind = 54;
3388: }
3389: break;
3390: case 5:
3391: jjmatchedKind = 0x7fffffff;
3392: jjmatchedPos = 0;
3393: curPos = jjMoveStringLiteralDfa0_5();
3394: break;
3395: case 6:
3396: jjmatchedKind = 0x7fffffff;
3397: jjmatchedPos = 0;
3398: curPos = jjMoveStringLiteralDfa0_6();
3399: break;
3400: case 7:
3401: jjmatchedKind = 0x7fffffff;
3402: jjmatchedPos = 0;
3403: curPos = jjMoveStringLiteralDfa0_7();
3404: break;
3405: case 8:
3406: jjmatchedKind = 0x7fffffff;
3407: jjmatchedPos = 0;
3408: curPos = jjMoveStringLiteralDfa0_8();
3409: break;
3410: case 9:
3411: jjmatchedKind = 0x7fffffff;
3412: jjmatchedPos = 0;
3413: curPos = jjMoveStringLiteralDfa0_9();
3414: break;
3415: case 10:
3416: jjmatchedKind = 0x7fffffff;
3417: jjmatchedPos = 0;
3418: curPos = jjMoveStringLiteralDfa0_10();
3419: break;
3420: case 11:
3421: jjmatchedKind = 0x7fffffff;
3422: jjmatchedPos = 0;
3423: curPos = jjMoveStringLiteralDfa0_11();
3424: if (jjmatchedPos == 0 && jjmatchedKind > 63) {
3425: jjmatchedKind = 63;
3426: }
3427: break;
3428: case 12:
3429: jjmatchedKind = 0x7fffffff;
3430: jjmatchedPos = 0;
3431: curPos = jjMoveStringLiteralDfa0_12();
3432: break;
3433: case 13:
3434: jjmatchedKind = 0x7fffffff;
3435: jjmatchedPos = 0;
3436: curPos = jjMoveStringLiteralDfa0_13();
3437: break;
3438: case 14:
3439: jjmatchedKind = 0x7fffffff;
3440: jjmatchedPos = 0;
3441: curPos = jjMoveStringLiteralDfa0_14();
3442: break;
3443: case 15:
3444: jjmatchedKind = 0x7fffffff;
3445: jjmatchedPos = 0;
3446: curPos = jjMoveStringLiteralDfa0_15();
3447: break;
3448: case 16:
3449: jjmatchedKind = 0x7fffffff;
3450: jjmatchedPos = 0;
3451: curPos = jjMoveStringLiteralDfa0_16();
3452: break;
3453: }
3454: if (jjmatchedKind != 0x7fffffff) {
3455: if (jjmatchedPos + 1 < curPos)
3456: input_stream.backup(curPos - jjmatchedPos - 1);
3457: if ((jjtoToken[jjmatchedKind >> 6] & (1L << (jjmatchedKind & 077))) != 0L) {
3458: matchedToken = jjFillToken();
3459: matchedToken.specialToken = specialToken;
3460: if (jjnewLexState[jjmatchedKind] != -1)
3461: curLexState = jjnewLexState[jjmatchedKind];
3462: return matchedToken;
3463: } else {
3464: if ((jjtoSpecial[jjmatchedKind >> 6] & (1L << (jjmatchedKind & 077))) != 0L) {
3465: matchedToken = jjFillToken();
3466: if (specialToken == null)
3467: specialToken = matchedToken;
3468: else {
3469: matchedToken.specialToken = specialToken;
3470: specialToken = (specialToken.next = matchedToken);
3471: }
3472: }
3473: if (jjnewLexState[jjmatchedKind] != -1)
3474: curLexState = jjnewLexState[jjmatchedKind];
3475: continue EOFLoop;
3476: }
3477: }
3478: int error_line = input_stream.getEndLine();
3479: int error_column = input_stream.getEndColumn();
3480: String error_after = null;
3481: boolean EOFSeen = false;
3482: try {
3483: input_stream.readChar();
3484: input_stream.backup(1);
3485: } catch (java.io.IOException e1) {
3486: EOFSeen = true;
3487: error_after = curPos <= 1 ? "" : input_stream
3488: .GetImage();
3489: if (curChar == '\n' || curChar == '\r') {
3490: error_line++;
3491: error_column = 0;
3492: } else
3493: error_column++;
3494: }
3495: if (!EOFSeen) {
3496: input_stream.backup(1);
3497: error_after = curPos <= 1 ? "" : input_stream
3498: .GetImage();
3499: }
3500: throw new TokenMgrError(EOFSeen, curLexState, error_line,
3501: error_column, error_after, curChar,
3502: TokenMgrError.LEXICAL_ERROR);
3503: }
3504: }
3505:
3506: }
|