0001: /* Generated By:JJTree&JavaCC: Do not edit this line. ELParserTokenManager.java */
0002: package org.apache.el.parser;
0003:
0004: public class ELParserTokenManager implements ELParserConstants {
0005: public java.io.PrintStream debugStream = System.out;
0006:
0007: public void setDebugStream(java.io.PrintStream ds) {
0008: debugStream = ds;
0009: }
0010:
0011: private final int jjStopStringLiteralDfa_0(int pos, long active0) {
0012: switch (pos) {
0013: case 0:
0014: if ((active0 & 0x10L) != 0L)
0015: return 2;
0016: if ((active0 & 0x4L) != 0L) {
0017: jjmatchedKind = 1;
0018: return 4;
0019: }
0020: if ((active0 & 0x8L) != 0L) {
0021: jjmatchedKind = 1;
0022: return 6;
0023: }
0024: return -1;
0025: default:
0026: return -1;
0027: }
0028: }
0029:
0030: private final int jjStartNfa_0(int pos, long active0) {
0031: return jjMoveNfa_0(jjStopStringLiteralDfa_0(pos, active0),
0032: pos + 1);
0033: }
0034:
0035: private final int jjStopAtPos(int pos, int kind) {
0036: jjmatchedKind = kind;
0037: jjmatchedPos = pos;
0038: return pos + 1;
0039: }
0040:
0041: private final int jjStartNfaWithStates_0(int pos, int kind,
0042: int state) {
0043: jjmatchedKind = kind;
0044: jjmatchedPos = pos;
0045: try {
0046: curChar = input_stream.readChar();
0047: } catch (java.io.IOException e) {
0048: return pos + 1;
0049: }
0050: return jjMoveNfa_0(state, pos + 1);
0051: }
0052:
0053: private final int jjMoveStringLiteralDfa0_0() {
0054: switch (curChar) {
0055: case 35:
0056: return jjMoveStringLiteralDfa1_0(0x8L);
0057: case 36:
0058: return jjMoveStringLiteralDfa1_0(0x4L);
0059: case 92:
0060: return jjStartNfaWithStates_0(0, 4, 2);
0061: default:
0062: return jjMoveNfa_0(7, 0);
0063: }
0064: }
0065:
0066: private final int jjMoveStringLiteralDfa1_0(long active0) {
0067: try {
0068: curChar = input_stream.readChar();
0069: } catch (java.io.IOException e) {
0070: jjStopStringLiteralDfa_0(0, active0);
0071: return 1;
0072: }
0073: switch (curChar) {
0074: case 123:
0075: if ((active0 & 0x4L) != 0L)
0076: return jjStopAtPos(1, 2);
0077: else if ((active0 & 0x8L) != 0L)
0078: return jjStopAtPos(1, 3);
0079: break;
0080: default:
0081: break;
0082: }
0083: return jjStartNfa_0(0, active0);
0084: }
0085:
0086: private final void jjCheckNAdd(int state) {
0087: if (jjrounds[state] != jjround) {
0088: jjstateSet[jjnewStateCnt++] = state;
0089: jjrounds[state] = jjround;
0090: }
0091: }
0092:
0093: private final void jjAddStates(int start, int end) {
0094: do {
0095: jjstateSet[jjnewStateCnt++] = jjnextStates[start];
0096: } while (start++ != end);
0097: }
0098:
0099: private final void jjCheckNAddTwoStates(int state1, int state2) {
0100: jjCheckNAdd(state1);
0101: jjCheckNAdd(state2);
0102: }
0103:
0104: private final void jjCheckNAddStates(int start, int end) {
0105: do {
0106: jjCheckNAdd(jjnextStates[start]);
0107: } while (start++ != end);
0108: }
0109:
0110: private final void jjCheckNAddStates(int start) {
0111: jjCheckNAdd(jjnextStates[start]);
0112: jjCheckNAdd(jjnextStates[start + 1]);
0113: }
0114:
0115: static final long[] jjbitVec0 = { 0xfffffffffffffffeL,
0116: 0xffffffffffffffffL, 0xffffffffffffffffL,
0117: 0xffffffffffffffffL };
0118:
0119: static final long[] jjbitVec2 = { 0x0L, 0x0L, 0xffffffffffffffffL,
0120: 0xffffffffffffffffL };
0121:
0122: private final int jjMoveNfa_0(int startState, int curPos) {
0123: int[] nextStates;
0124: int startsAt = 0;
0125: jjnewStateCnt = 8;
0126: int i = 1;
0127: jjstateSet[0] = startState;
0128: int j, kind = 0x7fffffff;
0129: for (;;) {
0130: if (++jjround == 0x7fffffff)
0131: ReInitRounds();
0132: if (curChar < 64) {
0133: long l = 1L << curChar;
0134: MatchLoop: do {
0135: switch (jjstateSet[--i]) {
0136: case 7:
0137: if ((0xffffffe7ffffffffL & l) != 0L) {
0138: if (kind > 1)
0139: kind = 1;
0140: jjCheckNAddStates(0, 3);
0141: } else if ((0x1800000000L & l) != 0L) {
0142: if (kind > 1)
0143: kind = 1;
0144: }
0145: if (curChar == 35)
0146: jjstateSet[jjnewStateCnt++] = 6;
0147: else if (curChar == 36)
0148: jjstateSet[jjnewStateCnt++] = 4;
0149: break;
0150: case 0:
0151: if ((0xffffffe7ffffffffL & l) == 0L)
0152: break;
0153: if (kind > 1)
0154: kind = 1;
0155: jjCheckNAddStates(0, 3);
0156: break;
0157: case 2:
0158: if ((0x1800000000L & l) == 0L)
0159: break;
0160: if (kind > 1)
0161: kind = 1;
0162: jjCheckNAddStates(0, 3);
0163: break;
0164: case 3:
0165: if (curChar == 36)
0166: jjstateSet[jjnewStateCnt++] = 4;
0167: break;
0168: case 4:
0169: if ((0xffffffefffffffffL & l) == 0L)
0170: break;
0171: if (kind > 1)
0172: kind = 1;
0173: jjCheckNAddStates(0, 3);
0174: break;
0175: case 5:
0176: if (curChar == 35)
0177: jjstateSet[jjnewStateCnt++] = 6;
0178: break;
0179: case 6:
0180: if ((0xfffffff7ffffffffL & l) == 0L)
0181: break;
0182: if (kind > 1)
0183: kind = 1;
0184: jjCheckNAddStates(0, 3);
0185: break;
0186: default:
0187: break;
0188: }
0189: } while (i != startsAt);
0190: } else if (curChar < 128) {
0191: long l = 1L << (curChar & 077);
0192: MatchLoop: do {
0193: switch (jjstateSet[--i]) {
0194: case 7:
0195: if ((0xffffffffefffffffL & l) != 0L) {
0196: if (kind > 1)
0197: kind = 1;
0198: jjCheckNAddStates(0, 3);
0199: } else if (curChar == 92)
0200: jjstateSet[jjnewStateCnt++] = 2;
0201: break;
0202: case 0:
0203: if ((0xffffffffefffffffL & l) == 0L)
0204: break;
0205: if (kind > 1)
0206: kind = 1;
0207: jjCheckNAddStates(0, 3);
0208: break;
0209: case 1:
0210: if (curChar == 92)
0211: jjstateSet[jjnewStateCnt++] = 2;
0212: break;
0213: case 2:
0214: if (curChar != 92)
0215: break;
0216: if (kind > 1)
0217: kind = 1;
0218: jjCheckNAddStates(0, 3);
0219: break;
0220: case 4:
0221: case 6:
0222: if ((0xf7ffffffffffffffL & l) == 0L)
0223: break;
0224: if (kind > 1)
0225: kind = 1;
0226: jjCheckNAddStates(0, 3);
0227: break;
0228: default:
0229: break;
0230: }
0231: } while (i != startsAt);
0232: } else {
0233: int hiByte = (int) (curChar >> 8);
0234: int i1 = hiByte >> 6;
0235: long l1 = 1L << (hiByte & 077);
0236: int i2 = (curChar & 0xff) >> 6;
0237: long l2 = 1L << (curChar & 077);
0238: MatchLoop: do {
0239: switch (jjstateSet[--i]) {
0240: case 7:
0241: case 0:
0242: case 4:
0243: case 6:
0244: if (!jjCanMove_0(hiByte, i1, i2, l1, l2))
0245: break;
0246: if (kind > 1)
0247: kind = 1;
0248: jjCheckNAddStates(0, 3);
0249: break;
0250: default:
0251: break;
0252: }
0253: } while (i != startsAt);
0254: }
0255: if (kind != 0x7fffffff) {
0256: jjmatchedKind = kind;
0257: jjmatchedPos = curPos;
0258: kind = 0x7fffffff;
0259: }
0260: ++curPos;
0261: if ((i = jjnewStateCnt) == (startsAt = 8 - (jjnewStateCnt = startsAt)))
0262: return curPos;
0263: try {
0264: curChar = input_stream.readChar();
0265: } catch (java.io.IOException e) {
0266: return curPos;
0267: }
0268: }
0269: }
0270:
0271: private final int jjStopStringLiteralDfa_1(int pos, long active0) {
0272: switch (pos) {
0273: case 0:
0274: if ((active0 & 0x141d555401c000L) != 0L) {
0275: jjmatchedKind = 53;
0276: return 41;
0277: }
0278: if ((active0 & 0x40000L) != 0L)
0279: return 1;
0280: return -1;
0281: case 1:
0282: if ((active0 & 0x41554000000L) != 0L)
0283: return 42;
0284: if ((active0 & 0x1419400001c000L) != 0L) {
0285: jjmatchedKind = 53;
0286: jjmatchedPos = 1;
0287: return 42;
0288: }
0289: return -1;
0290: case 2:
0291: if ((active0 & 0x14014000000000L) != 0L)
0292: return 42;
0293: if ((active0 & 0x18000001c000L) != 0L) {
0294: jjmatchedKind = 53;
0295: jjmatchedPos = 2;
0296: return 42;
0297: }
0298: return -1;
0299: case 3:
0300: if ((active0 & 0x14000L) != 0L)
0301: return 42;
0302: if ((active0 & 0x180000008000L) != 0L) {
0303: jjmatchedKind = 53;
0304: jjmatchedPos = 3;
0305: return 42;
0306: }
0307: return -1;
0308: case 4:
0309: if ((active0 & 0x80000008000L) != 0L)
0310: return 42;
0311: if ((active0 & 0x100000000000L) != 0L) {
0312: jjmatchedKind = 53;
0313: jjmatchedPos = 4;
0314: return 42;
0315: }
0316: return -1;
0317: case 5:
0318: if ((active0 & 0x100000000000L) != 0L) {
0319: jjmatchedKind = 53;
0320: jjmatchedPos = 5;
0321: return 42;
0322: }
0323: return -1;
0324: case 6:
0325: if ((active0 & 0x100000000000L) != 0L) {
0326: jjmatchedKind = 53;
0327: jjmatchedPos = 6;
0328: return 42;
0329: }
0330: return -1;
0331: case 7:
0332: if ((active0 & 0x100000000000L) != 0L) {
0333: jjmatchedKind = 53;
0334: jjmatchedPos = 7;
0335: return 42;
0336: }
0337: return -1;
0338: case 8:
0339: if ((active0 & 0x100000000000L) != 0L) {
0340: jjmatchedKind = 53;
0341: jjmatchedPos = 8;
0342: return 42;
0343: }
0344: return -1;
0345: default:
0346: return -1;
0347: }
0348: }
0349:
0350: private final int jjStartNfa_1(int pos, long active0) {
0351: return jjMoveNfa_1(jjStopStringLiteralDfa_1(pos, active0),
0352: pos + 1);
0353: }
0354:
0355: private final int jjStartNfaWithStates_1(int pos, int kind,
0356: int state) {
0357: jjmatchedKind = kind;
0358: jjmatchedPos = pos;
0359: try {
0360: curChar = input_stream.readChar();
0361: } catch (java.io.IOException e) {
0362: return pos + 1;
0363: }
0364: return jjMoveNfa_1(state, pos + 1);
0365: }
0366:
0367: private final int jjMoveStringLiteralDfa0_1() {
0368: switch (curChar) {
0369: case 33:
0370: jjmatchedKind = 37;
0371: return jjMoveStringLiteralDfa1_1(0x800000000L);
0372: case 37:
0373: return jjStopAtPos(0, 51);
0374: case 38:
0375: return jjMoveStringLiteralDfa1_1(0x8000000000L);
0376: case 40:
0377: return jjStopAtPos(0, 19);
0378: case 41:
0379: return jjStopAtPos(0, 20);
0380: case 42:
0381: return jjStopAtPos(0, 45);
0382: case 43:
0383: return jjStopAtPos(0, 46);
0384: case 44:
0385: return jjStopAtPos(0, 24);
0386: case 45:
0387: return jjStopAtPos(0, 47);
0388: case 46:
0389: return jjStartNfaWithStates_1(0, 18, 1);
0390: case 47:
0391: return jjStopAtPos(0, 49);
0392: case 58:
0393: return jjStopAtPos(0, 23);
0394: case 60:
0395: jjmatchedKind = 27;
0396: return jjMoveStringLiteralDfa1_1(0x80000000L);
0397: case 61:
0398: return jjMoveStringLiteralDfa1_1(0x200000000L);
0399: case 62:
0400: jjmatchedKind = 25;
0401: return jjMoveStringLiteralDfa1_1(0x20000000L);
0402: case 63:
0403: return jjStopAtPos(0, 48);
0404: case 91:
0405: return jjStopAtPos(0, 21);
0406: case 93:
0407: return jjStopAtPos(0, 22);
0408: case 97:
0409: return jjMoveStringLiteralDfa1_1(0x10000000000L);
0410: case 100:
0411: return jjMoveStringLiteralDfa1_1(0x4000000000000L);
0412: case 101:
0413: return jjMoveStringLiteralDfa1_1(0x80400000000L);
0414: case 102:
0415: return jjMoveStringLiteralDfa1_1(0x8000L);
0416: case 103:
0417: return jjMoveStringLiteralDfa1_1(0x44000000L);
0418: case 105:
0419: return jjMoveStringLiteralDfa1_1(0x100000000000L);
0420: case 108:
0421: return jjMoveStringLiteralDfa1_1(0x110000000L);
0422: case 109:
0423: return jjMoveStringLiteralDfa1_1(0x10000000000000L);
0424: case 110:
0425: return jjMoveStringLiteralDfa1_1(0x5000010000L);
0426: case 111:
0427: return jjMoveStringLiteralDfa1_1(0x40000000000L);
0428: case 116:
0429: return jjMoveStringLiteralDfa1_1(0x4000L);
0430: case 124:
0431: return jjMoveStringLiteralDfa1_1(0x20000000000L);
0432: case 125:
0433: return jjStopAtPos(0, 17);
0434: default:
0435: return jjMoveNfa_1(0, 0);
0436: }
0437: }
0438:
0439: private final int jjMoveStringLiteralDfa1_1(long active0) {
0440: try {
0441: curChar = input_stream.readChar();
0442: } catch (java.io.IOException e) {
0443: jjStopStringLiteralDfa_1(0, active0);
0444: return 1;
0445: }
0446: switch (curChar) {
0447: case 38:
0448: if ((active0 & 0x8000000000L) != 0L)
0449: return jjStopAtPos(1, 39);
0450: break;
0451: case 61:
0452: if ((active0 & 0x20000000L) != 0L)
0453: return jjStopAtPos(1, 29);
0454: else if ((active0 & 0x80000000L) != 0L)
0455: return jjStopAtPos(1, 31);
0456: else if ((active0 & 0x200000000L) != 0L)
0457: return jjStopAtPos(1, 33);
0458: else if ((active0 & 0x800000000L) != 0L)
0459: return jjStopAtPos(1, 35);
0460: break;
0461: case 97:
0462: return jjMoveStringLiteralDfa2_1(active0, 0x8000L);
0463: case 101:
0464: if ((active0 & 0x40000000L) != 0L)
0465: return jjStartNfaWithStates_1(1, 30, 42);
0466: else if ((active0 & 0x100000000L) != 0L)
0467: return jjStartNfaWithStates_1(1, 32, 42);
0468: else if ((active0 & 0x1000000000L) != 0L)
0469: return jjStartNfaWithStates_1(1, 36, 42);
0470: break;
0471: case 105:
0472: return jjMoveStringLiteralDfa2_1(active0, 0x4000000000000L);
0473: case 109:
0474: return jjMoveStringLiteralDfa2_1(active0, 0x80000000000L);
0475: case 110:
0476: return jjMoveStringLiteralDfa2_1(active0, 0x110000000000L);
0477: case 111:
0478: return jjMoveStringLiteralDfa2_1(active0, 0x10004000000000L);
0479: case 113:
0480: if ((active0 & 0x400000000L) != 0L)
0481: return jjStartNfaWithStates_1(1, 34, 42);
0482: break;
0483: case 114:
0484: if ((active0 & 0x40000000000L) != 0L)
0485: return jjStartNfaWithStates_1(1, 42, 42);
0486: return jjMoveStringLiteralDfa2_1(active0, 0x4000L);
0487: case 116:
0488: if ((active0 & 0x4000000L) != 0L)
0489: return jjStartNfaWithStates_1(1, 26, 42);
0490: else if ((active0 & 0x10000000L) != 0L)
0491: return jjStartNfaWithStates_1(1, 28, 42);
0492: break;
0493: case 117:
0494: return jjMoveStringLiteralDfa2_1(active0, 0x10000L);
0495: case 124:
0496: if ((active0 & 0x20000000000L) != 0L)
0497: return jjStopAtPos(1, 41);
0498: break;
0499: default:
0500: break;
0501: }
0502: return jjStartNfa_1(0, active0);
0503: }
0504:
0505: private final int jjMoveStringLiteralDfa2_1(long old0, long active0) {
0506: if (((active0 &= old0)) == 0L)
0507: return jjStartNfa_1(0, old0);
0508: try {
0509: curChar = input_stream.readChar();
0510: } catch (java.io.IOException e) {
0511: jjStopStringLiteralDfa_1(1, active0);
0512: return 2;
0513: }
0514: switch (curChar) {
0515: case 100:
0516: if ((active0 & 0x10000000000L) != 0L)
0517: return jjStartNfaWithStates_1(2, 40, 42);
0518: else if ((active0 & 0x10000000000000L) != 0L)
0519: return jjStartNfaWithStates_1(2, 52, 42);
0520: break;
0521: case 108:
0522: return jjMoveStringLiteralDfa3_1(active0, 0x18000L);
0523: case 112:
0524: return jjMoveStringLiteralDfa3_1(active0, 0x80000000000L);
0525: case 115:
0526: return jjMoveStringLiteralDfa3_1(active0, 0x100000000000L);
0527: case 116:
0528: if ((active0 & 0x4000000000L) != 0L)
0529: return jjStartNfaWithStates_1(2, 38, 42);
0530: break;
0531: case 117:
0532: return jjMoveStringLiteralDfa3_1(active0, 0x4000L);
0533: case 118:
0534: if ((active0 & 0x4000000000000L) != 0L)
0535: return jjStartNfaWithStates_1(2, 50, 42);
0536: break;
0537: default:
0538: break;
0539: }
0540: return jjStartNfa_1(1, active0);
0541: }
0542:
0543: private final int jjMoveStringLiteralDfa3_1(long old0, long active0) {
0544: if (((active0 &= old0)) == 0L)
0545: return jjStartNfa_1(1, old0);
0546: try {
0547: curChar = input_stream.readChar();
0548: } catch (java.io.IOException e) {
0549: jjStopStringLiteralDfa_1(2, active0);
0550: return 3;
0551: }
0552: switch (curChar) {
0553: case 101:
0554: if ((active0 & 0x4000L) != 0L)
0555: return jjStartNfaWithStates_1(3, 14, 42);
0556: break;
0557: case 108:
0558: if ((active0 & 0x10000L) != 0L)
0559: return jjStartNfaWithStates_1(3, 16, 42);
0560: break;
0561: case 115:
0562: return jjMoveStringLiteralDfa4_1(active0, 0x8000L);
0563: case 116:
0564: return jjMoveStringLiteralDfa4_1(active0, 0x180000000000L);
0565: default:
0566: break;
0567: }
0568: return jjStartNfa_1(2, active0);
0569: }
0570:
0571: private final int jjMoveStringLiteralDfa4_1(long old0, long active0) {
0572: if (((active0 &= old0)) == 0L)
0573: return jjStartNfa_1(2, old0);
0574: try {
0575: curChar = input_stream.readChar();
0576: } catch (java.io.IOException e) {
0577: jjStopStringLiteralDfa_1(3, active0);
0578: return 4;
0579: }
0580: switch (curChar) {
0581: case 97:
0582: return jjMoveStringLiteralDfa5_1(active0, 0x100000000000L);
0583: case 101:
0584: if ((active0 & 0x8000L) != 0L)
0585: return jjStartNfaWithStates_1(4, 15, 42);
0586: break;
0587: case 121:
0588: if ((active0 & 0x80000000000L) != 0L)
0589: return jjStartNfaWithStates_1(4, 43, 42);
0590: break;
0591: default:
0592: break;
0593: }
0594: return jjStartNfa_1(3, active0);
0595: }
0596:
0597: private final int jjMoveStringLiteralDfa5_1(long old0, long active0) {
0598: if (((active0 &= old0)) == 0L)
0599: return jjStartNfa_1(3, old0);
0600: try {
0601: curChar = input_stream.readChar();
0602: } catch (java.io.IOException e) {
0603: jjStopStringLiteralDfa_1(4, active0);
0604: return 5;
0605: }
0606: switch (curChar) {
0607: case 110:
0608: return jjMoveStringLiteralDfa6_1(active0, 0x100000000000L);
0609: default:
0610: break;
0611: }
0612: return jjStartNfa_1(4, active0);
0613: }
0614:
0615: private final int jjMoveStringLiteralDfa6_1(long old0, long active0) {
0616: if (((active0 &= old0)) == 0L)
0617: return jjStartNfa_1(4, old0);
0618: try {
0619: curChar = input_stream.readChar();
0620: } catch (java.io.IOException e) {
0621: jjStopStringLiteralDfa_1(5, active0);
0622: return 6;
0623: }
0624: switch (curChar) {
0625: case 99:
0626: return jjMoveStringLiteralDfa7_1(active0, 0x100000000000L);
0627: default:
0628: break;
0629: }
0630: return jjStartNfa_1(5, active0);
0631: }
0632:
0633: private final int jjMoveStringLiteralDfa7_1(long old0, long active0) {
0634: if (((active0 &= old0)) == 0L)
0635: return jjStartNfa_1(5, old0);
0636: try {
0637: curChar = input_stream.readChar();
0638: } catch (java.io.IOException e) {
0639: jjStopStringLiteralDfa_1(6, active0);
0640: return 7;
0641: }
0642: switch (curChar) {
0643: case 101:
0644: return jjMoveStringLiteralDfa8_1(active0, 0x100000000000L);
0645: default:
0646: break;
0647: }
0648: return jjStartNfa_1(6, active0);
0649: }
0650:
0651: private final int jjMoveStringLiteralDfa8_1(long old0, long active0) {
0652: if (((active0 &= old0)) == 0L)
0653: return jjStartNfa_1(6, old0);
0654: try {
0655: curChar = input_stream.readChar();
0656: } catch (java.io.IOException e) {
0657: jjStopStringLiteralDfa_1(7, active0);
0658: return 8;
0659: }
0660: switch (curChar) {
0661: case 111:
0662: return jjMoveStringLiteralDfa9_1(active0, 0x100000000000L);
0663: default:
0664: break;
0665: }
0666: return jjStartNfa_1(7, active0);
0667: }
0668:
0669: private final int jjMoveStringLiteralDfa9_1(long old0, long active0) {
0670: if (((active0 &= old0)) == 0L)
0671: return jjStartNfa_1(7, old0);
0672: try {
0673: curChar = input_stream.readChar();
0674: } catch (java.io.IOException e) {
0675: jjStopStringLiteralDfa_1(8, active0);
0676: return 9;
0677: }
0678: switch (curChar) {
0679: case 102:
0680: if ((active0 & 0x100000000000L) != 0L)
0681: return jjStartNfaWithStates_1(9, 44, 42);
0682: break;
0683: default:
0684: break;
0685: }
0686: return jjStartNfa_1(8, active0);
0687: }
0688:
0689: static final long[] jjbitVec3 = { 0x1ff00000fffffffeL,
0690: 0xffffffffffffc000L, 0xffffffffL, 0x600000000000000L };
0691:
0692: static final long[] jjbitVec4 = { 0x0L, 0x0L, 0x0L,
0693: 0xff7fffffff7fffffL };
0694:
0695: static final long[] jjbitVec5 = { 0x0L, 0xffffffffffffffffL,
0696: 0xffffffffffffffffL, 0xffffffffffffffffL };
0697:
0698: static final long[] jjbitVec6 = { 0xffffffffffffffffL,
0699: 0xffffffffffffffffL, 0xffffL, 0x0L };
0700:
0701: static final long[] jjbitVec7 = { 0xffffffffffffffffL,
0702: 0xffffffffffffffffL, 0x0L, 0x0L };
0703:
0704: static final long[] jjbitVec8 = { 0x3fffffffffffL, 0x0L, 0x0L, 0x0L };
0705:
0706: private final int jjMoveNfa_1(int startState, int curPos) {
0707: int[] nextStates;
0708: int startsAt = 0;
0709: jjnewStateCnt = 41;
0710: int i = 1;
0711: jjstateSet[0] = startState;
0712: int j, kind = 0x7fffffff;
0713: for (;;) {
0714: if (++jjround == 0x7fffffff)
0715: ReInitRounds();
0716: if (curChar < 64) {
0717: long l = 1L << curChar;
0718: MatchLoop: do {
0719: switch (jjstateSet[--i]) {
0720: case 41:
0721: if ((0x3ff001000000000L & l) != 0L) {
0722: if (kind > 55)
0723: kind = 55;
0724: jjCheckNAdd(40);
0725: } else if ((0x600000000000L & l) != 0L)
0726: jjCheckNAddStates(4, 6);
0727: else if (curChar == 58) {
0728: if (kind > 54)
0729: kind = 54;
0730: }
0731: if ((0x3ff001000000000L & l) != 0L)
0732: jjCheckNAddStates(7, 10);
0733: if ((0x3ff001000000000L & l) != 0L) {
0734: if (kind > 53)
0735: kind = 53;
0736: jjCheckNAdd(34);
0737: }
0738: if ((0x1800000000L & l) != 0L)
0739: jjCheckNAddStates(11, 14);
0740: break;
0741: case 0:
0742: if ((0x3ff000000000000L & l) != 0L) {
0743: if (kind > 9)
0744: kind = 9;
0745: jjCheckNAddStates(15, 19);
0746: } else if ((0x1800000000L & l) != 0L) {
0747: if (kind > 53)
0748: kind = 53;
0749: jjCheckNAddStates(20, 25);
0750: } else if (curChar == 39)
0751: jjCheckNAddStates(26, 30);
0752: else if (curChar == 34)
0753: jjCheckNAddStates(31, 35);
0754: else if (curChar == 46)
0755: jjCheckNAdd(1);
0756: break;
0757: case 42:
0758: if ((0x3ff001000000000L & l) != 0L) {
0759: if (kind > 55)
0760: kind = 55;
0761: jjCheckNAdd(40);
0762: } else if ((0x600000000000L & l) != 0L)
0763: jjCheckNAddStates(4, 6);
0764: else if (curChar == 58) {
0765: if (kind > 54)
0766: kind = 54;
0767: }
0768: if ((0x3ff001000000000L & l) != 0L)
0769: jjCheckNAddStates(11, 14);
0770: if ((0x3ff001000000000L & l) != 0L)
0771: jjCheckNAddStates(7, 10);
0772: if ((0x3ff001000000000L & l) != 0L) {
0773: if (kind > 53)
0774: kind = 53;
0775: jjCheckNAdd(34);
0776: }
0777: if ((0x1800000000L & l) != 0L)
0778: jjCheckNAddStates(11, 14);
0779: break;
0780: case 1:
0781: if ((0x3ff000000000000L & l) == 0L)
0782: break;
0783: if (kind > 10)
0784: kind = 10;
0785: jjCheckNAddTwoStates(1, 2);
0786: break;
0787: case 3:
0788: if ((0x280000000000L & l) != 0L)
0789: jjCheckNAdd(4);
0790: break;
0791: case 4:
0792: if ((0x3ff000000000000L & l) == 0L)
0793: break;
0794: if (kind > 10)
0795: kind = 10;
0796: jjCheckNAdd(4);
0797: break;
0798: case 5:
0799: if ((0x3ff000000000000L & l) == 0L)
0800: break;
0801: if (kind > 9)
0802: kind = 9;
0803: jjCheckNAddStates(15, 19);
0804: break;
0805: case 6:
0806: if ((0x3ff000000000000L & l) == 0L)
0807: break;
0808: if (kind > 9)
0809: kind = 9;
0810: jjCheckNAdd(6);
0811: break;
0812: case 7:
0813: if ((0x3ff000000000000L & l) != 0L)
0814: jjCheckNAddTwoStates(7, 8);
0815: break;
0816: case 8:
0817: if (curChar != 46)
0818: break;
0819: if (kind > 10)
0820: kind = 10;
0821: jjCheckNAddTwoStates(9, 10);
0822: break;
0823: case 9:
0824: if ((0x3ff000000000000L & l) == 0L)
0825: break;
0826: if (kind > 10)
0827: kind = 10;
0828: jjCheckNAddTwoStates(9, 10);
0829: break;
0830: case 11:
0831: if ((0x280000000000L & l) != 0L)
0832: jjCheckNAdd(12);
0833: break;
0834: case 12:
0835: if ((0x3ff000000000000L & l) == 0L)
0836: break;
0837: if (kind > 10)
0838: kind = 10;
0839: jjCheckNAdd(12);
0840: break;
0841: case 13:
0842: if ((0x3ff000000000000L & l) != 0L)
0843: jjCheckNAddTwoStates(13, 14);
0844: break;
0845: case 15:
0846: if ((0x280000000000L & l) != 0L)
0847: jjCheckNAdd(16);
0848: break;
0849: case 16:
0850: if ((0x3ff000000000000L & l) == 0L)
0851: break;
0852: if (kind > 10)
0853: kind = 10;
0854: jjCheckNAdd(16);
0855: break;
0856: case 17:
0857: if (curChar == 34)
0858: jjCheckNAddStates(31, 35);
0859: break;
0860: case 18:
0861: if ((0xfffffffbffffffffL & l) != 0L)
0862: jjCheckNAddStates(36, 38);
0863: break;
0864: case 20:
0865: if (curChar == 34)
0866: jjCheckNAddStates(36, 38);
0867: break;
0868: case 21:
0869: if (curChar == 34 && kind > 12)
0870: kind = 12;
0871: break;
0872: case 22:
0873: if ((0xfffffffbffffffffL & l) != 0L)
0874: jjCheckNAddTwoStates(22, 23);
0875: break;
0876: case 24:
0877: if ((0xfffffffbffffffffL & l) != 0L
0878: && kind > 13)
0879: kind = 13;
0880: break;
0881: case 25:
0882: if (curChar == 39)
0883: jjCheckNAddStates(26, 30);
0884: break;
0885: case 26:
0886: if ((0xffffff7fffffffffL & l) != 0L)
0887: jjCheckNAddStates(39, 41);
0888: break;
0889: case 28:
0890: if (curChar == 39)
0891: jjCheckNAddStates(39, 41);
0892: break;
0893: case 29:
0894: if (curChar == 39 && kind > 12)
0895: kind = 12;
0896: break;
0897: case 30:
0898: if ((0xffffff7fffffffffL & l) != 0L)
0899: jjCheckNAddTwoStates(30, 31);
0900: break;
0901: case 32:
0902: if ((0xffffff7fffffffffL & l) != 0L
0903: && kind > 13)
0904: kind = 13;
0905: break;
0906: case 33:
0907: if ((0x1800000000L & l) == 0L)
0908: break;
0909: if (kind > 53)
0910: kind = 53;
0911: jjCheckNAddStates(20, 25);
0912: break;
0913: case 34:
0914: if ((0x3ff001000000000L & l) == 0L)
0915: break;
0916: if (kind > 53)
0917: kind = 53;
0918: jjCheckNAdd(34);
0919: break;
0920: case 35:
0921: if ((0x3ff001000000000L & l) != 0L)
0922: jjCheckNAddStates(7, 10);
0923: break;
0924: case 36:
0925: if ((0x1800000000L & l) != 0L)
0926: jjCheckNAddStates(11, 14);
0927: break;
0928: case 37:
0929: if ((0x3ff001000000000L & l) != 0L)
0930: jjCheckNAddStates(11, 14);
0931: break;
0932: case 38:
0933: if ((0x600000000000L & l) != 0L)
0934: jjCheckNAddStates(4, 6);
0935: break;
0936: case 39:
0937: if (curChar == 58 && kind > 54)
0938: kind = 54;
0939: break;
0940: case 40:
0941: if ((0x3ff001000000000L & l) == 0L)
0942: break;
0943: if (kind > 55)
0944: kind = 55;
0945: jjCheckNAdd(40);
0946: break;
0947: default:
0948: break;
0949: }
0950: } while (i != startsAt);
0951: } else if (curChar < 128) {
0952: long l = 1L << (curChar & 077);
0953: MatchLoop: do {
0954: switch (jjstateSet[--i]) {
0955: case 41:
0956: if ((0x7fffffe87fffffeL & l) != 0L) {
0957: if (kind > 55)
0958: kind = 55;
0959: jjCheckNAdd(40);
0960: }
0961: if ((0x7fffffe87fffffeL & l) != 0L)
0962: jjCheckNAddStates(11, 14);
0963: if ((0x7fffffe87fffffeL & l) != 0L)
0964: jjCheckNAddStates(7, 10);
0965: if ((0x7fffffe87fffffeL & l) != 0L) {
0966: if (kind > 53)
0967: kind = 53;
0968: jjCheckNAdd(34);
0969: }
0970: break;
0971: case 0:
0972: if ((0x7fffffe87fffffeL & l) == 0L)
0973: break;
0974: if (kind > 53)
0975: kind = 53;
0976: jjCheckNAddStates(20, 25);
0977: break;
0978: case 42:
0979: if ((0x7fffffe87fffffeL & l) != 0L) {
0980: if (kind > 55)
0981: kind = 55;
0982: jjCheckNAdd(40);
0983: }
0984: if ((0x7fffffe87fffffeL & l) != 0L)
0985: jjCheckNAddStates(11, 14);
0986: if ((0x7fffffe87fffffeL & l) != 0L)
0987: jjCheckNAddStates(11, 14);
0988: if ((0x7fffffe87fffffeL & l) != 0L)
0989: jjCheckNAddStates(7, 10);
0990: if ((0x7fffffe87fffffeL & l) != 0L) {
0991: if (kind > 53)
0992: kind = 53;
0993: jjCheckNAdd(34);
0994: }
0995: break;
0996: case 2:
0997: if ((0x2000000020L & l) != 0L)
0998: jjAddStates(42, 43);
0999: break;
1000: case 10:
1001: if ((0x2000000020L & l) != 0L)
1002: jjAddStates(44, 45);
1003: break;
1004: case 14:
1005: if ((0x2000000020L & l) != 0L)
1006: jjAddStates(46, 47);
1007: break;
1008: case 18:
1009: if ((0xffffffffefffffffL & l) != 0L)
1010: jjCheckNAddStates(36, 38);
1011: break;
1012: case 19:
1013: if (curChar == 92)
1014: jjstateSet[jjnewStateCnt++] = 20;
1015: break;
1016: case 20:
1017: if (curChar == 92)
1018: jjCheckNAddStates(36, 38);
1019: break;
1020: case 22:
1021: if ((0xffffffffefffffffL & l) != 0L)
1022: jjAddStates(48, 49);
1023: break;
1024: case 23:
1025: if (curChar == 92)
1026: jjstateSet[jjnewStateCnt++] = 24;
1027: break;
1028: case 24:
1029: case 32:
1030: if ((0xffffffffefffffffL & l) != 0L
1031: && kind > 13)
1032: kind = 13;
1033: break;
1034: case 26:
1035: if ((0xffffffffefffffffL & l) != 0L)
1036: jjCheckNAddStates(39, 41);
1037: break;
1038: case 27:
1039: if (curChar == 92)
1040: jjstateSet[jjnewStateCnt++] = 28;
1041: break;
1042: case 28:
1043: if (curChar == 92)
1044: jjCheckNAddStates(39, 41);
1045: break;
1046: case 30:
1047: if ((0xffffffffefffffffL & l) != 0L)
1048: jjAddStates(50, 51);
1049: break;
1050: case 31:
1051: if (curChar == 92)
1052: jjstateSet[jjnewStateCnt++] = 32;
1053: break;
1054: case 34:
1055: if ((0x7fffffe87fffffeL & l) == 0L)
1056: break;
1057: if (kind > 53)
1058: kind = 53;
1059: jjCheckNAdd(34);
1060: break;
1061: case 35:
1062: if ((0x7fffffe87fffffeL & l) != 0L)
1063: jjCheckNAddStates(7, 10);
1064: break;
1065: case 36:
1066: if ((0x7fffffe87fffffeL & l) != 0L)
1067: jjCheckNAddStates(11, 14);
1068: break;
1069: case 37:
1070: if ((0x7fffffe87fffffeL & l) != 0L)
1071: jjCheckNAddStates(11, 14);
1072: break;
1073: case 40:
1074: if ((0x7fffffe87fffffeL & l) == 0L)
1075: break;
1076: if (kind > 55)
1077: kind = 55;
1078: jjCheckNAdd(40);
1079: break;
1080: default:
1081: break;
1082: }
1083: } while (i != startsAt);
1084: } else {
1085: int hiByte = (int) (curChar >> 8);
1086: int i1 = hiByte >> 6;
1087: long l1 = 1L << (hiByte & 077);
1088: int i2 = (curChar & 0xff) >> 6;
1089: long l2 = 1L << (curChar & 077);
1090: MatchLoop: do {
1091: switch (jjstateSet[--i]) {
1092: case 41:
1093: if (jjCanMove_1(hiByte, i1, i2, l1, l2)) {
1094: if (kind > 53)
1095: kind = 53;
1096: jjCheckNAdd(34);
1097: }
1098: if (jjCanMove_1(hiByte, i1, i2, l1, l2))
1099: jjCheckNAddStates(7, 10);
1100: if (jjCanMove_1(hiByte, i1, i2, l1, l2))
1101: jjCheckNAddStates(11, 14);
1102: if (jjCanMove_1(hiByte, i1, i2, l1, l2)) {
1103: if (kind > 55)
1104: kind = 55;
1105: jjCheckNAdd(40);
1106: }
1107: break;
1108: case 0:
1109: if (!jjCanMove_1(hiByte, i1, i2, l1, l2))
1110: break;
1111: if (kind > 53)
1112: kind = 53;
1113: jjCheckNAddStates(20, 25);
1114: break;
1115: case 42:
1116: if (jjCanMove_1(hiByte, i1, i2, l1, l2)) {
1117: if (kind > 53)
1118: kind = 53;
1119: jjCheckNAdd(34);
1120: }
1121: if (jjCanMove_1(hiByte, i1, i2, l1, l2))
1122: jjCheckNAddStates(7, 10);
1123: if (jjCanMove_1(hiByte, i1, i2, l1, l2))
1124: jjCheckNAddStates(11, 14);
1125: if (jjCanMove_1(hiByte, i1, i2, l1, l2))
1126: jjCheckNAddStates(11, 14);
1127: if (jjCanMove_1(hiByte, i1, i2, l1, l2)) {
1128: if (kind > 55)
1129: kind = 55;
1130: jjCheckNAdd(40);
1131: }
1132: break;
1133: case 18:
1134: if (jjCanMove_0(hiByte, i1, i2, l1, l2))
1135: jjAddStates(36, 38);
1136: break;
1137: case 22:
1138: if (jjCanMove_0(hiByte, i1, i2, l1, l2))
1139: jjAddStates(48, 49);
1140: break;
1141: case 24:
1142: case 32:
1143: if (jjCanMove_0(hiByte, i1, i2, l1, l2)
1144: && kind > 13)
1145: kind = 13;
1146: break;
1147: case 26:
1148: if (jjCanMove_0(hiByte, i1, i2, l1, l2))
1149: jjAddStates(39, 41);
1150: break;
1151: case 30:
1152: if (jjCanMove_0(hiByte, i1, i2, l1, l2))
1153: jjAddStates(50, 51);
1154: break;
1155: case 34:
1156: if (!jjCanMove_1(hiByte, i1, i2, l1, l2))
1157: break;
1158: if (kind > 53)
1159: kind = 53;
1160: jjCheckNAdd(34);
1161: break;
1162: case 35:
1163: if (jjCanMove_1(hiByte, i1, i2, l1, l2))
1164: jjCheckNAddStates(7, 10);
1165: break;
1166: case 36:
1167: if (jjCanMove_1(hiByte, i1, i2, l1, l2))
1168: jjCheckNAddStates(11, 14);
1169: break;
1170: case 37:
1171: if (jjCanMove_1(hiByte, i1, i2, l1, l2))
1172: jjCheckNAddStates(11, 14);
1173: break;
1174: case 40:
1175: if (!jjCanMove_1(hiByte, i1, i2, l1, l2))
1176: break;
1177: if (kind > 55)
1178: kind = 55;
1179: jjCheckNAdd(40);
1180: break;
1181: default:
1182: break;
1183: }
1184: } while (i != startsAt);
1185: }
1186: if (kind != 0x7fffffff) {
1187: jjmatchedKind = kind;
1188: jjmatchedPos = curPos;
1189: kind = 0x7fffffff;
1190: }
1191: ++curPos;
1192: if ((i = jjnewStateCnt) == (startsAt = 41 - (jjnewStateCnt = startsAt)))
1193: return curPos;
1194: try {
1195: curChar = input_stream.readChar();
1196: } catch (java.io.IOException e) {
1197: return curPos;
1198: }
1199: }
1200: }
1201:
1202: static final int[] jjnextStates = { 0, 1, 3, 5, 36, 38, 39, 35, 36,
1203: 38, 39, 36, 37, 38, 39, 6, 7, 8, 13, 14, 34, 35, 36, 38,
1204: 39, 40, 26, 27, 29, 30, 31, 18, 19, 21, 22, 23, 18, 19, 21,
1205: 26, 27, 29, 3, 4, 11, 12, 15, 16, 22, 23, 30, 31, };
1206:
1207: private static final boolean jjCanMove_0(int hiByte, int i1,
1208: int i2, long l1, long l2) {
1209: switch (hiByte) {
1210: case 0:
1211: return ((jjbitVec2[i2] & l2) != 0L);
1212: default:
1213: if ((jjbitVec0[i1] & l1) != 0L)
1214: return true;
1215: return false;
1216: }
1217: }
1218:
1219: private static final boolean jjCanMove_1(int hiByte, int i1,
1220: int i2, long l1, long l2) {
1221: switch (hiByte) {
1222: case 0:
1223: return ((jjbitVec4[i2] & l2) != 0L);
1224: case 48:
1225: return ((jjbitVec5[i2] & l2) != 0L);
1226: case 49:
1227: return ((jjbitVec6[i2] & l2) != 0L);
1228: case 51:
1229: return ((jjbitVec7[i2] & l2) != 0L);
1230: case 61:
1231: return ((jjbitVec8[i2] & l2) != 0L);
1232: default:
1233: if ((jjbitVec3[i1] & l1) != 0L)
1234: return true;
1235: return false;
1236: }
1237: }
1238:
1239: public static final String[] jjstrLiteralImages = { "", null,
1240: "\44\173", "\43\173", null, null, null, null, null, null,
1241: null, null, null, null, "\164\162\165\145",
1242: "\146\141\154\163\145", "\156\165\154\154", "\175", "\56",
1243: "\50", "\51", "\133", "\135", "\72", "\54", "\76",
1244: "\147\164", "\74", "\154\164", "\76\75", "\147\145",
1245: "\74\75", "\154\145", "\75\75", "\145\161", "\41\75",
1246: "\156\145", "\41", "\156\157\164", "\46\46",
1247: "\141\156\144", "\174\174", "\157\162",
1248: "\145\155\160\164\171",
1249: "\151\156\163\164\141\156\143\145\157\146", "\52", "\53",
1250: "\55", "\77", "\57", "\144\151\166", "\45", "\155\157\144",
1251: null, null, null, null, null, null, null, };
1252:
1253: public static final String[] lexStateNames = { "DEFAULT",
1254: "IN_EXPRESSION", };
1255:
1256: public static final int[] jjnewLexState = { -1, -1, 1, 1, -1, -1,
1257: -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 0, -1, -1, -1,
1258: -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
1259: -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
1260: -1, -1, -1, -1, -1, -1, -1, -1, -1, };
1261:
1262: static final long[] jjtoToken = { 0x8fffffffffff60fL, };
1263:
1264: static final long[] jjtoSkip = { 0x1f0L, };
1265:
1266: protected SimpleCharStream input_stream;
1267:
1268: private final int[] jjrounds = new int[41];
1269:
1270: private final int[] jjstateSet = new int[82];
1271:
1272: protected char curChar;
1273:
1274: public ELParserTokenManager(SimpleCharStream stream) {
1275: if (SimpleCharStream.staticFlag)
1276: throw new Error(
1277: "ERROR: Cannot use a static CharStream class with a non-static lexical analyzer.");
1278: input_stream = stream;
1279: }
1280:
1281: public ELParserTokenManager(SimpleCharStream stream, int lexState) {
1282: this (stream);
1283: SwitchTo(lexState);
1284: }
1285:
1286: public void ReInit(SimpleCharStream stream) {
1287: jjmatchedPos = jjnewStateCnt = 0;
1288: curLexState = defaultLexState;
1289: input_stream = stream;
1290: ReInitRounds();
1291: }
1292:
1293: private final void ReInitRounds() {
1294: int i;
1295: jjround = 0x80000001;
1296: for (i = 41; i-- > 0;)
1297: jjrounds[i] = 0x80000000;
1298: }
1299:
1300: public void ReInit(SimpleCharStream stream, int lexState) {
1301: ReInit(stream);
1302: SwitchTo(lexState);
1303: }
1304:
1305: public void SwitchTo(int lexState) {
1306: if (lexState >= 2 || lexState < 0)
1307: throw new TokenMgrError(
1308: "Error: Ignoring invalid lexical state : "
1309: + lexState + ". State unchanged.",
1310: TokenMgrError.INVALID_LEXICAL_STATE);
1311: else
1312: curLexState = lexState;
1313: }
1314:
1315: protected Token jjFillToken() {
1316: Token t = Token.newToken(jjmatchedKind);
1317: t.kind = jjmatchedKind;
1318: String im = jjstrLiteralImages[jjmatchedKind];
1319: t.image = (im == null) ? input_stream.GetImage() : im;
1320: t.beginLine = input_stream.getBeginLine();
1321: t.beginColumn = input_stream.getBeginColumn();
1322: t.endLine = input_stream.getEndLine();
1323: t.endColumn = input_stream.getEndColumn();
1324: return t;
1325: }
1326:
1327: int curLexState = 0;
1328:
1329: int defaultLexState = 0;
1330:
1331: int jjnewStateCnt;
1332:
1333: int jjround;
1334:
1335: int jjmatchedPos;
1336:
1337: int jjmatchedKind;
1338:
1339: public Token getNextToken() {
1340: int kind;
1341: Token specialToken = null;
1342: Token matchedToken;
1343: int curPos = 0;
1344:
1345: EOFLoop: for (;;) {
1346: try {
1347: curChar = input_stream.BeginToken();
1348: } catch (java.io.IOException e) {
1349: jjmatchedKind = 0;
1350: matchedToken = jjFillToken();
1351: return matchedToken;
1352: }
1353:
1354: switch (curLexState) {
1355: case 0:
1356: jjmatchedKind = 0x7fffffff;
1357: jjmatchedPos = 0;
1358: curPos = jjMoveStringLiteralDfa0_0();
1359: break;
1360: case 1:
1361: try {
1362: input_stream.backup(0);
1363: while (curChar <= 32
1364: && (0x100002600L & (1L << curChar)) != 0L)
1365: curChar = input_stream.BeginToken();
1366: } catch (java.io.IOException e1) {
1367: continue EOFLoop;
1368: }
1369: jjmatchedKind = 0x7fffffff;
1370: jjmatchedPos = 0;
1371: curPos = jjMoveStringLiteralDfa0_1();
1372: if (jjmatchedPos == 0 && jjmatchedKind > 59) {
1373: jjmatchedKind = 59;
1374: }
1375: break;
1376: }
1377: if (jjmatchedKind != 0x7fffffff) {
1378: if (jjmatchedPos + 1 < curPos)
1379: input_stream.backup(curPos - jjmatchedPos - 1);
1380: if ((jjtoToken[jjmatchedKind >> 6] & (1L << (jjmatchedKind & 077))) != 0L) {
1381: matchedToken = jjFillToken();
1382: if (jjnewLexState[jjmatchedKind] != -1)
1383: curLexState = jjnewLexState[jjmatchedKind];
1384: return matchedToken;
1385: } else {
1386: if (jjnewLexState[jjmatchedKind] != -1)
1387: curLexState = jjnewLexState[jjmatchedKind];
1388: continue EOFLoop;
1389: }
1390: }
1391: int error_line = input_stream.getEndLine();
1392: int error_column = input_stream.getEndColumn();
1393: String error_after = null;
1394: boolean EOFSeen = false;
1395: try {
1396: input_stream.readChar();
1397: input_stream.backup(1);
1398: } catch (java.io.IOException e1) {
1399: EOFSeen = true;
1400: error_after = curPos <= 1 ? "" : input_stream
1401: .GetImage();
1402: if (curChar == '\n' || curChar == '\r') {
1403: error_line++;
1404: error_column = 0;
1405: } else
1406: error_column++;
1407: }
1408: if (!EOFSeen) {
1409: input_stream.backup(1);
1410: error_after = curPos <= 1 ? "" : input_stream
1411: .GetImage();
1412: }
1413: throw new TokenMgrError(EOFSeen, curLexState, error_line,
1414: error_column, error_after, curChar,
1415: TokenMgrError.LEXICAL_ERROR);
1416: }
1417: }
1418:
1419: }
|