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