0001: /* Generated By:JavaCC: Do not edit this line. OscriptParserTokenManager.java */
0002: package oscript.parser;
0003:
0004: import java.util.LinkedList;
0005: import java.util.Vector;
0006: import oscript.syntaxtree.*;
0007: import java.util.Vector;
0008:
0009: public class OscriptParserTokenManager implements
0010: OscriptParserConstants {
0011: static private boolean stillInFormalComment;
0012:
0013: private static final int jjStopStringLiteralDfa_0(int pos,
0014: long active0, long active1) {
0015: switch (pos) {
0016: case 0:
0017: if ((active0 & 0x2000000L) != 0L
0018: || (active1 & 0x20000000008000L) != 0L)
0019: return 10;
0020: if ((active0 & 0x140L) != 0L
0021: || (active1 & 0x200400000000L) != 0L)
0022: return 2;
0023: if ((active1 & 0x100L) != 0L)
0024: return 8;
0025: if ((active0 & 0x3ffffffdf80000L) != 0L) {
0026: jjmatchedKind = 67;
0027: return 40;
0028: }
0029: return -1;
0030: case 1:
0031: if ((active0 & 0x100L) != 0L)
0032: return 0;
0033: if ((active0 & 0x3ffffdfcf80000L) != 0L) {
0034: if (jjmatchedPos != 1) {
0035: jjmatchedKind = 67;
0036: jjmatchedPos = 1;
0037: }
0038: return 40;
0039: }
0040: if ((active0 & 0x201000000L) != 0L)
0041: return 40;
0042: if ((active1 & 0x200000000000L) != 0L)
0043: return 60;
0044: return -1;
0045: case 2:
0046: if ((active0 & 0x35ffdd7cf80000L) != 0L) {
0047: if (jjmatchedPos != 2) {
0048: jjmatchedKind = 67;
0049: jjmatchedPos = 2;
0050: }
0051: return 40;
0052: }
0053: if ((active0 & 0xa002080000000L) != 0L)
0054: return 40;
0055: return -1;
0056: case 3:
0057: if ((active0 & 0x24bf9d68f80000L) != 0L) {
0058: jjmatchedKind = 67;
0059: jjmatchedPos = 3;
0060: return 40;
0061: }
0062: if ((active0 & 0x11404014000000L) != 0L)
0063: return 40;
0064: return -1;
0065: case 4:
0066: if ((active0 & 0x42f8d48900000L) != 0L) {
0067: jjmatchedKind = 67;
0068: jjmatchedPos = 4;
0069: return 40;
0070: }
0071: if ((active0 & 0x20901020680000L) != 0L)
0072: return 40;
0073: return -1;
0074: case 5:
0075: if ((active0 & 0x4218548800000L) != 0L) {
0076: jjmatchedKind = 67;
0077: jjmatchedPos = 5;
0078: return 40;
0079: }
0080: if ((active0 & 0xe0800100000L) != 0L)
0081: return 40;
0082: return -1;
0083: case 6:
0084: if ((active0 & 0x4210500800000L) != 0L) {
0085: jjmatchedKind = 67;
0086: jjmatchedPos = 6;
0087: return 40;
0088: }
0089: if ((active0 & 0x8048000000L) != 0L)
0090: return 40;
0091: return -1;
0092: case 7:
0093: if ((active0 & 0x100800000L) != 0L)
0094: return 40;
0095: if ((active0 & 0x4210400000000L) != 0L) {
0096: jjmatchedKind = 67;
0097: jjmatchedPos = 7;
0098: return 40;
0099: }
0100: return -1;
0101: case 8:
0102: if ((active0 & 0x200400000000L) != 0L) {
0103: jjmatchedKind = 67;
0104: jjmatchedPos = 8;
0105: return 40;
0106: }
0107: if ((active0 & 0x4010000000000L) != 0L)
0108: return 40;
0109: return -1;
0110: case 9:
0111: if ((active0 & 0x200000000000L) != 0L) {
0112: jjmatchedKind = 67;
0113: jjmatchedPos = 9;
0114: return 40;
0115: }
0116: if ((active0 & 0x400000000L) != 0L)
0117: return 40;
0118: return -1;
0119: case 10:
0120: if ((active0 & 0x200000000000L) != 0L) {
0121: jjmatchedKind = 67;
0122: jjmatchedPos = 10;
0123: return 40;
0124: }
0125: return -1;
0126: default:
0127: return -1;
0128: }
0129: }
0130:
0131: private static final int jjStartNfa_0(int pos, long active0,
0132: long active1) {
0133: return jjMoveNfa_0(jjStopStringLiteralDfa_0(pos, active0,
0134: active1), pos + 1);
0135: }
0136:
0137: static private final int jjStopAtPos(int pos, int kind) {
0138: jjmatchedKind = kind;
0139: jjmatchedPos = pos;
0140: return pos + 1;
0141: }
0142:
0143: static private final int jjStartNfaWithStates_0(int pos, int kind,
0144: int state) {
0145: jjmatchedKind = kind;
0146: jjmatchedPos = pos;
0147: try {
0148: curChar = input_stream.readChar();
0149: } catch (java.io.IOException e) {
0150: return pos + 1;
0151: }
0152: return jjMoveNfa_0(state, pos + 1);
0153: }
0154:
0155: static private final int jjMoveStringLiteralDfa0_0() {
0156: switch (curChar) {
0157: case 33:
0158: jjmatchedKind = 83;
0159: return jjMoveStringLiteralDfa1_0(0x0L, 0x4000000L);
0160: case 35:
0161: return jjMoveStringLiteralDfa1_0(0x200L, 0x0L);
0162: case 37:
0163: jjmatchedKind = 102;
0164: return jjMoveStringLiteralDfa1_0(0x0L, 0x2000000000000L);
0165: case 38:
0166: jjmatchedKind = 99;
0167: return jjMoveStringLiteralDfa1_0(0x0L, 0x400010000000L);
0168: case 39:
0169: return jjMoveStringLiteralDfa1_0(0x0L, 0x100L);
0170: case 40:
0171: return jjStopAtPos(0, 70);
0172: case 41:
0173: return jjStopAtPos(0, 71);
0174: case 42:
0175: jjmatchedKind = 97;
0176: return jjMoveStringLiteralDfa1_0(0x0L, 0x100000000000L);
0177: case 43:
0178: jjmatchedKind = 95;
0179: return jjMoveStringLiteralDfa1_0(0x0L, 0x40020000000L);
0180: case 44:
0181: return jjStopAtPos(0, 78);
0182: case 45:
0183: jjmatchedKind = 96;
0184: return jjMoveStringLiteralDfa1_0(0x0L, 0x80040000000L);
0185: case 46:
0186: jjmatchedKind = 79;
0187: return jjMoveStringLiteralDfa1_0(0x2000000L,
0188: 0x20000000000000L);
0189: case 47:
0190: jjmatchedKind = 98;
0191: return jjMoveStringLiteralDfa1_0(0x140L, 0x200000000000L);
0192: case 58:
0193: return jjStopAtPos(0, 86);
0194: case 59:
0195: return jjStopAtPos(0, 77);
0196: case 60:
0197: jjmatchedKind = 82;
0198: return jjMoveStringLiteralDfa1_0(0x0L, 0x4008001000000L);
0199: case 61:
0200: jjmatchedKind = 80;
0201: return jjMoveStringLiteralDfa1_0(0x0L, 0x800000L);
0202: case 62:
0203: jjmatchedKind = 81;
0204: return jjMoveStringLiteralDfa1_0(0x0L, 0x18030002000000L);
0205: case 63:
0206: return jjStopAtPos(0, 85);
0207: case 91:
0208: return jjStopAtPos(0, 75);
0209: case 93:
0210: return jjStopAtPos(0, 76);
0211: case 94:
0212: jjmatchedKind = 101;
0213: return jjMoveStringLiteralDfa1_0(0x0L, 0x1000000000000L);
0214: case 98:
0215: return jjMoveStringLiteralDfa1_0(0x80000L, 0x0L);
0216: case 99:
0217: return jjMoveStringLiteralDfa1_0(0xf00000L, 0x0L);
0218: case 100:
0219: return jjMoveStringLiteralDfa1_0(0x1000000L, 0x0L);
0220: case 101:
0221: return jjMoveStringLiteralDfa1_0(0x1c000000L, 0x0L);
0222: case 102:
0223: return jjMoveStringLiteralDfa1_0(0x1e0000000L, 0x0L);
0224: case 105:
0225: return jjMoveStringLiteralDfa1_0(0xe00000000L, 0x0L);
0226: case 109:
0227: return jjMoveStringLiteralDfa1_0(0x1000000000L, 0x0L);
0228: case 110:
0229: return jjMoveStringLiteralDfa1_0(0x6000000000L, 0x0L);
0230: case 112:
0231: return jjMoveStringLiteralDfa1_0(0x38000000000L, 0x0L);
0232: case 114:
0233: return jjMoveStringLiteralDfa1_0(0x40000000000L, 0x0L);
0234: case 115:
0235: return jjMoveStringLiteralDfa1_0(0x380000000000L, 0x0L);
0236: case 116:
0237: return jjMoveStringLiteralDfa1_0(0x3c00000000000L, 0x0L);
0238: case 117:
0239: return jjMoveStringLiteralDfa1_0(0x4000000000000L, 0x0L);
0240: case 118:
0241: return jjMoveStringLiteralDfa1_0(0x18000000000000L, 0x0L);
0242: case 119:
0243: return jjMoveStringLiteralDfa1_0(0x20000000000000L, 0x0L);
0244: case 123:
0245: return jjStopAtPos(0, 73);
0246: case 124:
0247: jjmatchedKind = 100;
0248: return jjMoveStringLiteralDfa1_0(0x0L, 0x800008000000L);
0249: case 125:
0250: return jjStopAtPos(0, 74);
0251: case 126:
0252: return jjStopAtPos(0, 84);
0253: default:
0254: return jjMoveNfa_0(3, 0);
0255: }
0256: }
0257:
0258: static private final int jjMoveStringLiteralDfa1_0(long active0,
0259: long active1) {
0260: try {
0261: curChar = input_stream.readChar();
0262: } catch (java.io.IOException e) {
0263: jjStopStringLiteralDfa_0(0, active0, active1);
0264: return 1;
0265: }
0266: switch (curChar) {
0267: case 33:
0268: if ((active0 & 0x200L) != 0L)
0269: return jjStopAtPos(1, 9);
0270: break;
0271: case 38:
0272: if ((active1 & 0x10000000L) != 0L)
0273: return jjStopAtPos(1, 92);
0274: break;
0275: case 42:
0276: if ((active0 & 0x100L) != 0L)
0277: return jjStartNfaWithStates_0(1, 8, 0);
0278: break;
0279: case 43:
0280: if ((active1 & 0x20000000L) != 0L)
0281: return jjStopAtPos(1, 93);
0282: break;
0283: case 45:
0284: if ((active1 & 0x40000000L) != 0L)
0285: return jjStopAtPos(1, 94);
0286: break;
0287: case 46:
0288: if ((active1 & 0x20000000000000L) != 0L) {
0289: jjmatchedKind = 117;
0290: jjmatchedPos = 1;
0291: }
0292: return jjMoveStringLiteralDfa2_0(active0, 0x2000000L,
0293: active1, 0L);
0294: case 47:
0295: if ((active0 & 0x40L) != 0L)
0296: return jjStopAtPos(1, 6);
0297: break;
0298: case 60:
0299: if ((active1 & 0x8000000000L) != 0L) {
0300: jjmatchedKind = 103;
0301: jjmatchedPos = 1;
0302: }
0303: return jjMoveStringLiteralDfa2_0(active0, 0L, active1,
0304: 0x4000000000000L);
0305: case 61:
0306: if ((active1 & 0x800000L) != 0L)
0307: return jjStopAtPos(1, 87);
0308: else if ((active1 & 0x1000000L) != 0L)
0309: return jjStopAtPos(1, 88);
0310: else if ((active1 & 0x2000000L) != 0L)
0311: return jjStopAtPos(1, 89);
0312: else if ((active1 & 0x4000000L) != 0L)
0313: return jjStopAtPos(1, 90);
0314: else if ((active1 & 0x40000000000L) != 0L)
0315: return jjStopAtPos(1, 106);
0316: else if ((active1 & 0x80000000000L) != 0L)
0317: return jjStopAtPos(1, 107);
0318: else if ((active1 & 0x100000000000L) != 0L)
0319: return jjStopAtPos(1, 108);
0320: else if ((active1 & 0x200000000000L) != 0L)
0321: return jjStartNfaWithStates_0(1, 109, 60);
0322: else if ((active1 & 0x400000000000L) != 0L)
0323: return jjStopAtPos(1, 110);
0324: else if ((active1 & 0x800000000000L) != 0L)
0325: return jjStopAtPos(1, 111);
0326: else if ((active1 & 0x1000000000000L) != 0L)
0327: return jjStopAtPos(1, 112);
0328: else if ((active1 & 0x2000000000000L) != 0L)
0329: return jjStopAtPos(1, 113);
0330: break;
0331: case 62:
0332: if ((active1 & 0x10000000000L) != 0L) {
0333: jjmatchedKind = 104;
0334: jjmatchedPos = 1;
0335: }
0336: return jjMoveStringLiteralDfa2_0(active0, 0L, active1,
0337: 0x18020000000000L);
0338: case 97:
0339: return jjMoveStringLiteralDfa2_0(active0, 0x8000020300000L,
0340: active1, 0L);
0341: case 101:
0342: return jjMoveStringLiteralDfa2_0(active0, 0x42000000000L,
0343: active1, 0L);
0344: case 102:
0345: if ((active0 & 0x200000000L) != 0L)
0346: return jjStartNfaWithStates_0(1, 33, 40);
0347: break;
0348: case 104:
0349: return jjMoveStringLiteralDfa2_0(active0,
0350: 0x20c00000000000L, active1, 0L);
0351: case 105:
0352: return jjMoveStringLiteralDfa2_0(active0, 0x1040000000L,
0353: active1, 0L);
0354: case 108:
0355: return jjMoveStringLiteralDfa2_0(active0, 0x4000000L,
0356: active1, 0L);
0357: case 109:
0358: return jjMoveStringLiteralDfa2_0(active0, 0x800000000L,
0359: active1, 0L);
0360: case 110:
0361: return jjMoveStringLiteralDfa2_0(active0, 0x4000400000000L,
0362: active1, 0L);
0363: case 111:
0364: if ((active0 & 0x1000000L) != 0L)
0365: return jjStartNfaWithStates_0(1, 24, 40);
0366: return jjMoveStringLiteralDfa2_0(active0,
0367: 0x10000080c00000L, active1, 0L);
0368: case 114:
0369: return jjMoveStringLiteralDfa2_0(active0, 0x3018000080000L,
0370: active1, 0L);
0371: case 116:
0372: return jjMoveStringLiteralDfa2_0(active0, 0x80000000000L,
0373: active1, 0L);
0374: case 117:
0375: return jjMoveStringLiteralDfa2_0(active0, 0x124100000000L,
0376: active1, 0L);
0377: case 118:
0378: return jjMoveStringLiteralDfa2_0(active0, 0x10000000L,
0379: active1, 0L);
0380: case 120:
0381: return jjMoveStringLiteralDfa2_0(active0, 0x8000000L,
0382: active1, 0L);
0383: case 121:
0384: return jjMoveStringLiteralDfa2_0(active0, 0x200000000000L,
0385: active1, 0L);
0386: case 123:
0387: if ((active1 & 0x100L) != 0L)
0388: return jjStopAtPos(1, 72);
0389: break;
0390: case 124:
0391: if ((active1 & 0x8000000L) != 0L)
0392: return jjStopAtPos(1, 91);
0393: break;
0394: default:
0395: break;
0396: }
0397: return jjStartNfa_0(0, active0, active1);
0398: }
0399:
0400: static private final int jjMoveStringLiteralDfa2_0(long old0,
0401: long active0, long old1, long active1) {
0402: if (((active0 &= old0) | (active1 &= old1)) == 0L)
0403: return jjStartNfa_0(0, old0, old1);
0404: try {
0405: curChar = input_stream.readChar();
0406: } catch (java.io.IOException e) {
0407: jjStopStringLiteralDfa_0(1, active0, active1);
0408: return 2;
0409: }
0410: switch (curChar) {
0411: case 46:
0412: if ((active0 & 0x2000000L) != 0L)
0413: return jjStopAtPos(2, 25);
0414: break;
0415: case 61:
0416: if ((active1 & 0x4000000000000L) != 0L)
0417: return jjStopAtPos(2, 114);
0418: else if ((active1 & 0x8000000000000L) != 0L)
0419: return jjStopAtPos(2, 115);
0420: break;
0421: case 62:
0422: if ((active1 & 0x20000000000L) != 0L) {
0423: jjmatchedKind = 105;
0424: jjmatchedPos = 2;
0425: }
0426: return jjMoveStringLiteralDfa3_0(active0, 0L, active1,
0427: 0x10000000000000L);
0428: case 97:
0429: return jjMoveStringLiteralDfa3_0(active0, 0x80010000000L,
0430: active1, 0L);
0431: case 98:
0432: return jjMoveStringLiteralDfa3_0(active0, 0x20000000000L,
0433: active1, 0L);
0434: case 100:
0435: return jjMoveStringLiteralDfa3_0(active0, 0x4000000000000L,
0436: active1, 0L);
0437: case 101:
0438: return jjMoveStringLiteralDfa3_0(active0, 0x80000L,
0439: active1, 0L);
0440: case 105:
0441: return jjMoveStringLiteralDfa3_0(active0,
0442: 0x30408000000000L, active1, 0L);
0443: case 108:
0444: return jjMoveStringLiteralDfa3_0(active0, 0x4020100000L,
0445: active1, 0L);
0446: case 110:
0447: return jjMoveStringLiteralDfa3_0(active0, 0x200140c00000L,
0448: active1, 0L);
0449: case 111:
0450: return jjMoveStringLiteralDfa3_0(active0, 0x10000000000L,
0451: active1, 0L);
0452: case 112:
0453: return jjMoveStringLiteralDfa3_0(active0, 0x100800000000L,
0454: active1, 0L);
0455: case 114:
0456: if ((active0 & 0x80000000L) != 0L)
0457: return jjStartNfaWithStates_0(2, 31, 40);
0458: else if ((active0 & 0x8000000000000L) != 0L)
0459: return jjStartNfaWithStates_0(2, 51, 40);
0460: return jjMoveStringLiteralDfa3_0(active0, 0x800000000000L,
0461: active1, 0L);
0462: case 115:
0463: return jjMoveStringLiteralDfa3_0(active0, 0x404000000L,
0464: active1, 0L);
0465: case 116:
0466: return jjMoveStringLiteralDfa3_0(active0, 0x40008200000L,
0467: active1, 0L);
0468: case 117:
0469: return jjMoveStringLiteralDfa3_0(active0, 0x1000000000000L,
0470: active1, 0L);
0471: case 119:
0472: if ((active0 & 0x2000000000L) != 0L)
0473: return jjStartNfaWithStates_0(2, 37, 40);
0474: break;
0475: case 120:
0476: return jjMoveStringLiteralDfa3_0(active0, 0x1000000000L,
0477: active1, 0L);
0478: case 121:
0479: if ((active0 & 0x2000000000000L) != 0L)
0480: return jjStartNfaWithStates_0(2, 49, 40);
0481: break;
0482: default:
0483: break;
0484: }
0485: return jjStartNfa_0(1, active0, active1);
0486: }
0487:
0488: static private final int jjMoveStringLiteralDfa3_0(long old0,
0489: long active0, long old1, long active1) {
0490: if (((active0 &= old0) | (active1 &= old1)) == 0L)
0491: return jjStartNfa_0(1, old0, old1);
0492: try {
0493: curChar = input_stream.readChar();
0494: } catch (java.io.IOException e) {
0495: jjStopStringLiteralDfa_0(2, active0, active1);
0496: return 3;
0497: }
0498: switch (curChar) {
0499: case 61:
0500: if ((active1 & 0x10000000000000L) != 0L)
0501: return jjStopAtPos(3, 116);
0502: break;
0503: case 97:
0504: return jjMoveStringLiteralDfa4_0(active0, 0x40080000L,
0505: active1, 0L);
0506: case 99:
0507: return jjMoveStringLiteralDfa4_0(active0, 0x200100200000L,
0508: active1, 0L);
0509: case 100:
0510: if ((active0 & 0x10000000000000L) != 0L)
0511: return jjStartNfaWithStates_0(3, 52, 40);
0512: break;
0513: case 101:
0514: if ((active0 & 0x4000000L) != 0L)
0515: return jjStartNfaWithStates_0(3, 26, 40);
0516: else if ((active0 & 0x1000000000000L) != 0L)
0517: return jjStartNfaWithStates_0(3, 48, 40);
0518: return jjMoveStringLiteralDfa4_0(active0, 0x4100008000000L,
0519: active1, 0L);
0520: case 105:
0521: return jjMoveStringLiteralDfa4_0(active0, 0x1000000000L,
0522: active1, 0L);
0523: case 108:
0524: if ((active0 & 0x10000000L) != 0L)
0525: return jjStartNfaWithStates_0(3, 28, 40);
0526: else if ((active0 & 0x4000000000L) != 0L)
0527: return jjStartNfaWithStates_0(3, 38, 40);
0528: return jjMoveStringLiteralDfa4_0(active0,
0529: 0x20020000100000L, active1, 0L);
0530: case 111:
0531: return jjMoveStringLiteralDfa4_0(active0, 0x800800000000L,
0532: active1, 0L);
0533: case 115:
0534: if ((active0 & 0x400000000000L) != 0L)
0535: return jjStartNfaWithStates_0(3, 46, 40);
0536: return jjMoveStringLiteralDfa4_0(active0, 0x20400000L,
0537: active1, 0L);
0538: case 116:
0539: return jjMoveStringLiteralDfa4_0(active0, 0x90400800000L,
0540: active1, 0L);
0541: case 117:
0542: return jjMoveStringLiteralDfa4_0(active0, 0x40000000000L,
0543: active1, 0L);
0544: case 118:
0545: return jjMoveStringLiteralDfa4_0(active0, 0x8000000000L,
0546: active1, 0L);
0547: default:
0548: break;
0549: }
0550: return jjStartNfa_0(2, active0, active1);
0551: }
0552:
0553: static private final int jjMoveStringLiteralDfa4_0(long old0,
0554: long active0, long old1, long active1) {
0555: if (((active0 &= old0) | (active1 &= old1)) == 0L)
0556: return jjStartNfa_0(2, old0, old1);
0557: try {
0558: curChar = input_stream.readChar();
0559: } catch (java.io.IOException e) {
0560: jjStopStringLiteralDfa_0(3, active0, 0L);
0561: return 4;
0562: }
0563: switch (curChar) {
0564: case 97:
0565: return jjMoveStringLiteralDfa5_0(active0, 0x8400000000L);
0566: case 101:
0567: if ((active0 & 0x20000000L) != 0L)
0568: return jjStartNfaWithStates_0(4, 29, 40);
0569: else if ((active0 & 0x20000000000000L) != 0L)
0570: return jjStartNfaWithStates_0(4, 53, 40);
0571: return jjMoveStringLiteralDfa5_0(active0, 0x10000100000L);
0572: case 102:
0573: return jjMoveStringLiteralDfa5_0(active0, 0x4000000000000L);
0574: case 104:
0575: if ((active0 & 0x200000L) != 0L)
0576: return jjStartNfaWithStates_0(4, 21, 40);
0577: return jjMoveStringLiteralDfa5_0(active0, 0x200000000000L);
0578: case 105:
0579: return jjMoveStringLiteralDfa5_0(active0, 0xa0000800000L);
0580: case 107:
0581: if ((active0 & 0x80000L) != 0L)
0582: return jjStartNfaWithStates_0(4, 19, 40);
0583: break;
0584: case 108:
0585: return jjMoveStringLiteralDfa5_0(active0, 0x40000000L);
0586: case 110:
0587: if ((active0 & 0x1000000000L) != 0L)
0588: return jjStartNfaWithStates_0(4, 36, 40);
0589: return jjMoveStringLiteralDfa5_0(active0, 0x8000000L);
0590: case 114:
0591: if ((active0 & 0x100000000000L) != 0L)
0592: return jjStartNfaWithStates_0(4, 44, 40);
0593: return jjMoveStringLiteralDfa5_0(active0, 0x40800000000L);
0594: case 116:
0595: if ((active0 & 0x400000L) != 0L)
0596: return jjStartNfaWithStates_0(4, 22, 40);
0597: return jjMoveStringLiteralDfa5_0(active0, 0x100000000L);
0598: case 119:
0599: if ((active0 & 0x800000000000L) != 0L)
0600: return jjStartNfaWithStates_0(4, 47, 40);
0601: break;
0602: default:
0603: break;
0604: }
0605: return jjStartNfa_0(3, active0, 0L);
0606: }
0607:
0608: static private final int jjMoveStringLiteralDfa5_0(long old0,
0609: long active0) {
0610: if (((active0 &= old0)) == 0L)
0611: return jjStartNfa_0(3, old0, 0L);
0612: try {
0613: curChar = input_stream.readChar();
0614: } catch (java.io.IOException e) {
0615: jjStopStringLiteralDfa_0(4, active0, 0L);
0616: return 5;
0617: }
0618: switch (curChar) {
0619: case 99:
0620: if ((active0 & 0x20000000000L) != 0L)
0621: return jjStartNfaWithStates_0(5, 41, 40);
0622: else if ((active0 & 0x80000000000L) != 0L)
0623: return jjStartNfaWithStates_0(5, 43, 40);
0624: return jjMoveStringLiteralDfa6_0(active0, 0x10000000000L);
0625: case 100:
0626: return jjMoveStringLiteralDfa6_0(active0, 0x8000000L);
0627: case 101:
0628: if ((active0 & 0x100000L) != 0L)
0629: return jjStartNfaWithStates_0(5, 20, 40);
0630: break;
0631: case 105:
0632: return jjMoveStringLiteralDfa6_0(active0, 0x4000100000000L);
0633: case 108:
0634: return jjMoveStringLiteralDfa6_0(active0, 0x40000000L);
0635: case 110:
0636: if ((active0 & 0x40000000000L) != 0L)
0637: return jjStartNfaWithStates_0(5, 42, 40);
0638: return jjMoveStringLiteralDfa6_0(active0, 0x400800000L);
0639: case 114:
0640: return jjMoveStringLiteralDfa6_0(active0, 0x200000000000L);
0641: case 116:
0642: if ((active0 & 0x800000000L) != 0L)
0643: return jjStartNfaWithStates_0(5, 35, 40);
0644: return jjMoveStringLiteralDfa6_0(active0, 0x8000000000L);
0645: default:
0646: break;
0647: }
0648: return jjStartNfa_0(4, active0, 0L);
0649: }
0650:
0651: static private final int jjMoveStringLiteralDfa6_0(long old0,
0652: long active0) {
0653: if (((active0 &= old0)) == 0L)
0654: return jjStartNfa_0(4, old0, 0L);
0655: try {
0656: curChar = input_stream.readChar();
0657: } catch (java.io.IOException e) {
0658: jjStopStringLiteralDfa_0(5, active0, 0L);
0659: return 6;
0660: }
0661: switch (curChar) {
0662: case 99:
0663: return jjMoveStringLiteralDfa7_0(active0, 0x400000000L);
0664: case 101:
0665: if ((active0 & 0x8000000000L) != 0L)
0666: return jjStartNfaWithStates_0(6, 39, 40);
0667: break;
0668: case 110:
0669: return jjMoveStringLiteralDfa7_0(active0, 0x4000000000000L);
0670: case 111:
0671: return jjMoveStringLiteralDfa7_0(active0, 0x200100000000L);
0672: case 115:
0673: if ((active0 & 0x8000000L) != 0L)
0674: return jjStartNfaWithStates_0(6, 27, 40);
0675: break;
0676: case 116:
0677: return jjMoveStringLiteralDfa7_0(active0, 0x10000000000L);
0678: case 117:
0679: return jjMoveStringLiteralDfa7_0(active0, 0x800000L);
0680: case 121:
0681: if ((active0 & 0x40000000L) != 0L)
0682: return jjStartNfaWithStates_0(6, 30, 40);
0683: break;
0684: default:
0685: break;
0686: }
0687: return jjStartNfa_0(5, active0, 0L);
0688: }
0689:
0690: static private final int jjMoveStringLiteralDfa7_0(long old0,
0691: long active0) {
0692: if (((active0 &= old0)) == 0L)
0693: return jjStartNfa_0(5, old0, 0L);
0694: try {
0695: curChar = input_stream.readChar();
0696: } catch (java.io.IOException e) {
0697: jjStopStringLiteralDfa_0(6, active0, 0L);
0698: return 7;
0699: }
0700: switch (curChar) {
0701: case 101:
0702: if ((active0 & 0x800000L) != 0L)
0703: return jjStartNfaWithStates_0(7, 23, 40);
0704: return jjMoveStringLiteralDfa8_0(active0, 0x4010400000000L);
0705: case 110:
0706: if ((active0 & 0x100000000L) != 0L)
0707: return jjStartNfaWithStates_0(7, 32, 40);
0708: return jjMoveStringLiteralDfa8_0(active0, 0x200000000000L);
0709: default:
0710: break;
0711: }
0712: return jjStartNfa_0(6, active0, 0L);
0713: }
0714:
0715: static private final int jjMoveStringLiteralDfa8_0(long old0,
0716: long active0) {
0717: if (((active0 &= old0)) == 0L)
0718: return jjStartNfa_0(6, old0, 0L);
0719: try {
0720: curChar = input_stream.readChar();
0721: } catch (java.io.IOException e) {
0722: jjStopStringLiteralDfa_0(7, active0, 0L);
0723: return 8;
0724: }
0725: switch (curChar) {
0726: case 100:
0727: if ((active0 & 0x10000000000L) != 0L)
0728: return jjStartNfaWithStates_0(8, 40, 40);
0729: else if ((active0 & 0x4000000000000L) != 0L)
0730: return jjStartNfaWithStates_0(8, 50, 40);
0731: break;
0732: case 105:
0733: return jjMoveStringLiteralDfa9_0(active0, 0x200000000000L);
0734: case 111:
0735: return jjMoveStringLiteralDfa9_0(active0, 0x400000000L);
0736: default:
0737: break;
0738: }
0739: return jjStartNfa_0(7, active0, 0L);
0740: }
0741:
0742: static private final int jjMoveStringLiteralDfa9_0(long old0,
0743: long active0) {
0744: if (((active0 &= old0)) == 0L)
0745: return jjStartNfa_0(7, old0, 0L);
0746: try {
0747: curChar = input_stream.readChar();
0748: } catch (java.io.IOException e) {
0749: jjStopStringLiteralDfa_0(8, active0, 0L);
0750: return 9;
0751: }
0752: switch (curChar) {
0753: case 102:
0754: if ((active0 & 0x400000000L) != 0L)
0755: return jjStartNfaWithStates_0(9, 34, 40);
0756: break;
0757: case 122:
0758: return jjMoveStringLiteralDfa10_0(active0, 0x200000000000L);
0759: default:
0760: break;
0761: }
0762: return jjStartNfa_0(8, active0, 0L);
0763: }
0764:
0765: static private final int jjMoveStringLiteralDfa10_0(long old0,
0766: long active0) {
0767: if (((active0 &= old0)) == 0L)
0768: return jjStartNfa_0(8, old0, 0L);
0769: try {
0770: curChar = input_stream.readChar();
0771: } catch (java.io.IOException e) {
0772: jjStopStringLiteralDfa_0(9, active0, 0L);
0773: return 10;
0774: }
0775: switch (curChar) {
0776: case 101:
0777: return jjMoveStringLiteralDfa11_0(active0, 0x200000000000L);
0778: default:
0779: break;
0780: }
0781: return jjStartNfa_0(9, active0, 0L);
0782: }
0783:
0784: static private final int jjMoveStringLiteralDfa11_0(long old0,
0785: long active0) {
0786: if (((active0 &= old0)) == 0L)
0787: return jjStartNfa_0(9, old0, 0L);
0788: try {
0789: curChar = input_stream.readChar();
0790: } catch (java.io.IOException e) {
0791: jjStopStringLiteralDfa_0(10, active0, 0L);
0792: return 11;
0793: }
0794: switch (curChar) {
0795: case 100:
0796: if ((active0 & 0x200000000000L) != 0L)
0797: return jjStartNfaWithStates_0(11, 45, 40);
0798: break;
0799: default:
0800: break;
0801: }
0802: return jjStartNfa_0(10, active0, 0L);
0803: }
0804:
0805: static private final void jjCheckNAdd(int state) {
0806: if (jjrounds[state] != jjround) {
0807: jjstateSet[jjnewStateCnt++] = state;
0808: jjrounds[state] = jjround;
0809: }
0810: }
0811:
0812: static private final void jjAddStates(int start, int end) {
0813: do {
0814: jjstateSet[jjnewStateCnt++] = jjnextStates[start];
0815: } while (start++ != end);
0816: }
0817:
0818: static private final void jjCheckNAddTwoStates(int state1,
0819: int state2) {
0820: jjCheckNAdd(state1);
0821: jjCheckNAdd(state2);
0822: }
0823:
0824: static private final void jjCheckNAddStates(int start, int end) {
0825: do {
0826: jjCheckNAdd(jjnextStates[start]);
0827: } while (start++ != end);
0828: }
0829:
0830: static private final void jjCheckNAddStates(int start) {
0831: jjCheckNAdd(jjnextStates[start]);
0832: jjCheckNAdd(jjnextStates[start + 1]);
0833: }
0834:
0835: static final long[] jjbitVec0 = { 0xfffffffffffffffeL,
0836: 0xffffffffffffffffL, 0xffffffffffffffffL,
0837: 0xffffffffffffffffL };
0838: static final long[] jjbitVec2 = { 0x0L, 0x0L, 0xffffffffffffffffL,
0839: 0xffffffffffffffffL };
0840: static final long[] jjbitVec3 = { 0x1ff00000fffffffeL,
0841: 0xffffffffffffc000L, 0xffffffffL, 0x600000000000000L };
0842: static final long[] jjbitVec4 = { 0x0L, 0x0L, 0x0L,
0843: 0xff7fffffff7fffffL };
0844: static final long[] jjbitVec5 = { 0x0L, 0xffffffffffffffffL,
0845: 0xffffffffffffffffL, 0xffffffffffffffffL };
0846: static final long[] jjbitVec6 = { 0xffffffffffffffffL,
0847: 0xffffffffffffffffL, 0xffffL, 0x0L };
0848: static final long[] jjbitVec7 = { 0xffffffffffffffffL,
0849: 0xffffffffffffffffL, 0x0L, 0x0L };
0850: static final long[] jjbitVec8 = { 0x3fffffffffffL, 0x0L, 0x0L, 0x0L };
0851:
0852: static private final int jjMoveNfa_0(int startState, int curPos) {
0853: int[] nextStates;
0854: int startsAt = 0;
0855: jjnewStateCnt = 60;
0856: int i = 1;
0857: jjstateSet[0] = startState;
0858: int j, kind = 0x7fffffff;
0859: for (;;) {
0860: if (++jjround == 0x7fffffff)
0861: ReInitRounds();
0862: if (curChar < 64) {
0863: long l = 1L << curChar;
0864: MatchLoop: do {
0865: switch (jjstateSet[--i]) {
0866: case 60:
0867: if ((0xffff7ffeffffdbffL & l) != 0L)
0868: jjCheckNAddStates(0, 2);
0869: else if (curChar == 47) {
0870: if (kind > 63)
0871: kind = 63;
0872: jjstateSet[jjnewStateCnt++] = 37;
0873: }
0874: break;
0875: case 2:
0876: if ((0xffff7bfeffffdbffL & l) != 0L)
0877: jjCheckNAddStates(0, 2);
0878: else if (curChar == 42)
0879: jjstateSet[jjnewStateCnt++] = 0;
0880: break;
0881: case 3:
0882: if ((0x3ff000000000000L & l) != 0L)
0883: jjCheckNAddStates(3, 9);
0884: else if (curChar == 36) {
0885: if (kind > 67)
0886: kind = 67;
0887: jjCheckNAdd(40);
0888: } else if (curChar == 47)
0889: jjAddStates(10, 11);
0890: else if (curChar == 34)
0891: jjCheckNAddStates(12, 14);
0892: else if (curChar == 46)
0893: jjCheckNAdd(10);
0894: else if (curChar == 39)
0895: jjCheckNAdd(8);
0896: if ((0x3fe000000000000L & l) != 0L) {
0897: if (kind > 54)
0898: kind = 54;
0899: jjCheckNAddTwoStates(5, 6);
0900: } else if (curChar == 48) {
0901: if (kind > 54)
0902: kind = 54;
0903: jjCheckNAddStates(15, 17);
0904: } else if (curChar == 47)
0905: jjstateSet[jjnewStateCnt++] = 2;
0906: break;
0907: case 0:
0908: if (curChar == 42)
0909: jjstateSet[jjnewStateCnt++] = 1;
0910: break;
0911: case 1:
0912: if ((0xffff7fffffffffffL & l) != 0L && kind > 7)
0913: kind = 7;
0914: break;
0915: case 4:
0916: if ((0x3fe000000000000L & l) == 0L)
0917: break;
0918: if (kind > 54)
0919: kind = 54;
0920: jjCheckNAddTwoStates(5, 6);
0921: break;
0922: case 5:
0923: if ((0x3ff000000000000L & l) == 0L)
0924: break;
0925: if (kind > 54)
0926: kind = 54;
0927: jjCheckNAddTwoStates(5, 6);
0928: break;
0929: case 7:
0930: if (curChar == 39)
0931: jjCheckNAdd(8);
0932: break;
0933: case 8:
0934: if ((0x3000000000000L & l) == 0L)
0935: break;
0936: if (kind > 54)
0937: kind = 54;
0938: jjCheckNAddTwoStates(8, 6);
0939: break;
0940: case 9:
0941: if (curChar == 46)
0942: jjCheckNAdd(10);
0943: break;
0944: case 10:
0945: if ((0x3ff000000000000L & l) == 0L)
0946: break;
0947: if (kind > 59)
0948: kind = 59;
0949: jjCheckNAddStates(18, 20);
0950: break;
0951: case 12:
0952: if ((0x280000000000L & l) != 0L)
0953: jjCheckNAdd(13);
0954: break;
0955: case 13:
0956: if ((0x3ff000000000000L & l) == 0L)
0957: break;
0958: if (kind > 59)
0959: kind = 59;
0960: jjCheckNAddTwoStates(13, 14);
0961: break;
0962: case 15:
0963: if (curChar == 34)
0964: jjCheckNAddStates(12, 14);
0965: break;
0966: case 16:
0967: if ((0xfffffffbffffdbffL & l) != 0L)
0968: jjCheckNAddStates(12, 14);
0969: break;
0970: case 18:
0971: if ((0x8400000000L & l) != 0L)
0972: jjCheckNAddStates(12, 14);
0973: break;
0974: case 19:
0975: if (curChar == 34 && kind > 61)
0976: kind = 61;
0977: break;
0978: case 20:
0979: if ((0xff000000000000L & l) != 0L)
0980: jjCheckNAddStates(21, 24);
0981: break;
0982: case 21:
0983: if ((0xff000000000000L & l) != 0L)
0984: jjCheckNAddStates(12, 14);
0985: break;
0986: case 22:
0987: if ((0xf000000000000L & l) != 0L)
0988: jjstateSet[jjnewStateCnt++] = 23;
0989: break;
0990: case 23:
0991: if ((0xff000000000000L & l) != 0L)
0992: jjCheckNAdd(21);
0993: break;
0994: case 25:
0995: case 30:
0996: if ((0x3ff000000000000L & l) != 0L)
0997: jjCheckNAdd(26);
0998: break;
0999: case 26:
1000: if ((0x3ff000000000000L & l) != 0L)
1001: jjCheckNAddStates(12, 14);
1002: break;
1003: case 28:
1004: if ((0x3ff000000000000L & l) != 0L)
1005: jjstateSet[jjnewStateCnt++] = 29;
1006: break;
1007: case 29:
1008: if ((0x3ff000000000000L & l) != 0L)
1009: jjstateSet[jjnewStateCnt++] = 30;
1010: break;
1011: case 31:
1012: if (curChar == 47)
1013: jjAddStates(10, 11);
1014: break;
1015: case 32:
1016: if ((0xffff7bfeffffdbffL & l) != 0L)
1017: jjCheckNAddStates(0, 2);
1018: break;
1019: case 33:
1020: if ((0xffff7ffeffffdbffL & l) != 0L)
1021: jjCheckNAddStates(0, 2);
1022: break;
1023: case 35:
1024: if ((0xffffffffffffdbffL & l) != 0L)
1025: jjCheckNAddStates(0, 2);
1026: break;
1027: case 36:
1028: if (curChar != 47)
1029: break;
1030: if (kind > 63)
1031: kind = 63;
1032: jjstateSet[jjnewStateCnt++] = 37;
1033: break;
1034: case 39:
1035: if (curChar != 36)
1036: break;
1037: if (kind > 67)
1038: kind = 67;
1039: jjCheckNAdd(40);
1040: break;
1041: case 40:
1042: if ((0x3ff001000000000L & l) == 0L)
1043: break;
1044: if (kind > 67)
1045: kind = 67;
1046: jjCheckNAdd(40);
1047: break;
1048: case 41:
1049: if ((0x3ff000000000000L & l) != 0L)
1050: jjCheckNAddStates(3, 9);
1051: break;
1052: case 42:
1053: if ((0x3ff000000000000L & l) != 0L)
1054: jjCheckNAddTwoStates(42, 43);
1055: break;
1056: case 43:
1057: if (curChar == 46)
1058: jjCheckNAdd(44);
1059: break;
1060: case 44:
1061: if ((0x3ff000000000000L & l) == 0L)
1062: break;
1063: if (kind > 59)
1064: kind = 59;
1065: jjCheckNAddStates(25, 27);
1066: break;
1067: case 46:
1068: if ((0x280000000000L & l) != 0L)
1069: jjCheckNAdd(47);
1070: break;
1071: case 47:
1072: if ((0x3ff000000000000L & l) == 0L)
1073: break;
1074: if (kind > 59)
1075: kind = 59;
1076: jjCheckNAddTwoStates(47, 14);
1077: break;
1078: case 48:
1079: if ((0x3ff000000000000L & l) != 0L)
1080: jjCheckNAddTwoStates(48, 49);
1081: break;
1082: case 50:
1083: if ((0x280000000000L & l) != 0L)
1084: jjCheckNAdd(51);
1085: break;
1086: case 51:
1087: if ((0x3ff000000000000L & l) == 0L)
1088: break;
1089: if (kind > 59)
1090: kind = 59;
1091: jjCheckNAddTwoStates(51, 14);
1092: break;
1093: case 52:
1094: if ((0x3ff000000000000L & l) != 0L)
1095: jjCheckNAddStates(28, 30);
1096: break;
1097: case 54:
1098: if ((0x280000000000L & l) != 0L)
1099: jjCheckNAdd(55);
1100: break;
1101: case 55:
1102: if ((0x3ff000000000000L & l) != 0L)
1103: jjCheckNAddTwoStates(55, 14);
1104: break;
1105: case 56:
1106: if (curChar != 48)
1107: break;
1108: if (kind > 54)
1109: kind = 54;
1110: jjCheckNAddStates(15, 17);
1111: break;
1112: case 58:
1113: if ((0x3ff000000000000L & l) == 0L)
1114: break;
1115: if (kind > 54)
1116: kind = 54;
1117: jjCheckNAddTwoStates(58, 6);
1118: break;
1119: case 59:
1120: if ((0xff000000000000L & l) == 0L)
1121: break;
1122: if (kind > 54)
1123: kind = 54;
1124: jjCheckNAddTwoStates(59, 6);
1125: break;
1126: default:
1127: break;
1128: }
1129: } while (i != startsAt);
1130: } else if (curChar < 128) {
1131: long l = 1L << (curChar & 077);
1132: MatchLoop: do {
1133: switch (jjstateSet[--i]) {
1134: case 60:
1135: if ((0xffffffffefffffffL & l) != 0L)
1136: jjCheckNAddStates(0, 2);
1137: else if (curChar == 92)
1138: jjCheckNAdd(35);
1139: break;
1140: case 2:
1141: if ((0xffffffffefffffffL & l) != 0L)
1142: jjCheckNAddStates(0, 2);
1143: else if (curChar == 92)
1144: jjCheckNAdd(35);
1145: break;
1146: case 3:
1147: case 40:
1148: if ((0x7fffffe87fffffeL & l) == 0L)
1149: break;
1150: if (kind > 67)
1151: kind = 67;
1152: jjCheckNAdd(40);
1153: break;
1154: case 1:
1155: if (kind > 7)
1156: kind = 7;
1157: break;
1158: case 6:
1159: if ((0x100000001000L & l) != 0L && kind > 54)
1160: kind = 54;
1161: break;
1162: case 11:
1163: if ((0x2000000020L & l) != 0L)
1164: jjAddStates(31, 32);
1165: break;
1166: case 14:
1167: if ((0x5000000050L & l) != 0L && kind > 59)
1168: kind = 59;
1169: break;
1170: case 16:
1171: if ((0xffffffffefffffffL & l) != 0L)
1172: jjCheckNAddStates(12, 14);
1173: break;
1174: case 17:
1175: if (curChar == 92)
1176: jjAddStates(33, 37);
1177: break;
1178: case 18:
1179: if ((0x14404410000000L & l) != 0L)
1180: jjCheckNAddStates(12, 14);
1181: break;
1182: case 24:
1183: if (curChar == 120)
1184: jjstateSet[jjnewStateCnt++] = 25;
1185: break;
1186: case 25:
1187: case 30:
1188: if ((0x7e0000007eL & l) != 0L)
1189: jjCheckNAdd(26);
1190: break;
1191: case 26:
1192: if ((0x7e0000007eL & l) != 0L)
1193: jjCheckNAddStates(12, 14);
1194: break;
1195: case 27:
1196: if (curChar == 117)
1197: jjstateSet[jjnewStateCnt++] = 28;
1198: break;
1199: case 28:
1200: if ((0x7e0000007eL & l) != 0L)
1201: jjstateSet[jjnewStateCnt++] = 29;
1202: break;
1203: case 29:
1204: if ((0x7e0000007eL & l) != 0L)
1205: jjstateSet[jjnewStateCnt++] = 30;
1206: break;
1207: case 32:
1208: if ((0xffffffffefffffffL & l) != 0L)
1209: jjCheckNAddStates(0, 2);
1210: break;
1211: case 33:
1212: if ((0xffffffffefffffffL & l) != 0L)
1213: jjCheckNAddStates(0, 2);
1214: break;
1215: case 34:
1216: if (curChar == 92)
1217: jjCheckNAdd(35);
1218: break;
1219: case 35:
1220: jjCheckNAddStates(0, 2);
1221: break;
1222: case 37:
1223: if ((0x7fffffe00000000L & l) == 0L)
1224: break;
1225: if (kind > 63)
1226: kind = 63;
1227: jjstateSet[jjnewStateCnt++] = 37;
1228: break;
1229: case 38:
1230: if (curChar == 92)
1231: jjCheckNAdd(35);
1232: break;
1233: case 45:
1234: if ((0x2000000020L & l) != 0L)
1235: jjAddStates(38, 39);
1236: break;
1237: case 49:
1238: if ((0x2000000020L & l) != 0L)
1239: jjAddStates(40, 41);
1240: break;
1241: case 53:
1242: if ((0x2000000020L & l) != 0L)
1243: jjAddStates(42, 43);
1244: break;
1245: case 57:
1246: if ((0x100000001000000L & l) != 0L)
1247: jjCheckNAdd(58);
1248: break;
1249: case 58:
1250: if ((0x7e0000007eL & l) == 0L)
1251: break;
1252: if (kind > 54)
1253: kind = 54;
1254: jjCheckNAddTwoStates(58, 6);
1255: break;
1256: default:
1257: break;
1258: }
1259: } while (i != startsAt);
1260: } else {
1261: int hiByte = (int) (curChar >> 8);
1262: int i1 = hiByte >> 6;
1263: long l1 = 1L << (hiByte & 077);
1264: int i2 = (curChar & 0xff) >> 6;
1265: long l2 = 1L << (curChar & 077);
1266: MatchLoop: do {
1267: switch (jjstateSet[--i]) {
1268: case 60:
1269: case 33:
1270: case 35:
1271: if (jjCanMove_0(hiByte, i1, i2, l1, l2))
1272: jjCheckNAddStates(0, 2);
1273: break;
1274: case 2:
1275: if (jjCanMove_0(hiByte, i1, i2, l1, l2))
1276: jjCheckNAddStates(0, 2);
1277: break;
1278: case 3:
1279: case 40:
1280: if (!jjCanMove_1(hiByte, i1, i2, l1, l2))
1281: break;
1282: if (kind > 67)
1283: kind = 67;
1284: jjCheckNAdd(40);
1285: break;
1286: case 1:
1287: if (jjCanMove_0(hiByte, i1, i2, l1, l2)
1288: && kind > 7)
1289: kind = 7;
1290: break;
1291: case 16:
1292: if (jjCanMove_0(hiByte, i1, i2, l1, l2))
1293: jjAddStates(12, 14);
1294: break;
1295: default:
1296: break;
1297: }
1298: } while (i != startsAt);
1299: }
1300: if (kind != 0x7fffffff) {
1301: jjmatchedKind = kind;
1302: jjmatchedPos = curPos;
1303: kind = 0x7fffffff;
1304: }
1305: ++curPos;
1306: if ((i = jjnewStateCnt) == (startsAt = 60 - (jjnewStateCnt = startsAt)))
1307: return curPos;
1308: try {
1309: curChar = input_stream.readChar();
1310: } catch (java.io.IOException e) {
1311: return curPos;
1312: }
1313: }
1314: }
1315:
1316: static private final int jjMoveStringLiteralDfa0_5() {
1317: switch (curChar) {
1318: case 42:
1319: return jjMoveStringLiteralDfa1_5(0x10000L);
1320: default:
1321: return 1;
1322: }
1323: }
1324:
1325: static private final int jjMoveStringLiteralDfa1_5(long active0) {
1326: try {
1327: curChar = input_stream.readChar();
1328: } catch (java.io.IOException e) {
1329: return 1;
1330: }
1331: switch (curChar) {
1332: case 47:
1333: if ((active0 & 0x10000L) != 0L)
1334: return jjStopAtPos(1, 16);
1335: break;
1336: default:
1337: return 2;
1338: }
1339: return 2;
1340: }
1341:
1342: private static final int jjStopStringLiteralDfa_3(int pos,
1343: long active0) {
1344: switch (pos) {
1345: default:
1346: return -1;
1347: }
1348: }
1349:
1350: private static final int jjStartNfa_3(int pos, long active0) {
1351: return jjMoveNfa_3(jjStopStringLiteralDfa_3(pos, active0),
1352: pos + 1);
1353: }
1354:
1355: static private final int jjStartNfaWithStates_3(int pos, int kind,
1356: int state) {
1357: jjmatchedKind = kind;
1358: jjmatchedPos = pos;
1359: try {
1360: curChar = input_stream.readChar();
1361: } catch (java.io.IOException e) {
1362: return pos + 1;
1363: }
1364: return jjMoveNfa_3(state, pos + 1);
1365: }
1366:
1367: static private final int jjMoveStringLiteralDfa0_3() {
1368: switch (curChar) {
1369: case 114:
1370: return jjMoveStringLiteralDfa1_3(0x2000L);
1371: default:
1372: return jjMoveNfa_3(4, 0);
1373: }
1374: }
1375:
1376: static private final int jjMoveStringLiteralDfa1_3(long active0) {
1377: try {
1378: curChar = input_stream.readChar();
1379: } catch (java.io.IOException e) {
1380: jjStopStringLiteralDfa_3(0, active0);
1381: return 1;
1382: }
1383: switch (curChar) {
1384: case 101:
1385: return jjMoveStringLiteralDfa2_3(active0, 0x2000L);
1386: default:
1387: break;
1388: }
1389: return jjStartNfa_3(0, active0);
1390: }
1391:
1392: static private final int jjMoveStringLiteralDfa2_3(long old0,
1393: long active0) {
1394: if (((active0 &= old0)) == 0L)
1395: return jjStartNfa_3(0, old0);
1396: try {
1397: curChar = input_stream.readChar();
1398: } catch (java.io.IOException e) {
1399: jjStopStringLiteralDfa_3(1, active0);
1400: return 2;
1401: }
1402: switch (curChar) {
1403: case 116:
1404: return jjMoveStringLiteralDfa3_3(active0, 0x2000L);
1405: default:
1406: break;
1407: }
1408: return jjStartNfa_3(1, active0);
1409: }
1410:
1411: static private final int jjMoveStringLiteralDfa3_3(long old0,
1412: long active0) {
1413: if (((active0 &= old0)) == 0L)
1414: return jjStartNfa_3(1, old0);
1415: try {
1416: curChar = input_stream.readChar();
1417: } catch (java.io.IOException e) {
1418: jjStopStringLiteralDfa_3(2, active0);
1419: return 3;
1420: }
1421: switch (curChar) {
1422: case 117:
1423: return jjMoveStringLiteralDfa4_3(active0, 0x2000L);
1424: default:
1425: break;
1426: }
1427: return jjStartNfa_3(2, active0);
1428: }
1429:
1430: static private final int jjMoveStringLiteralDfa4_3(long old0,
1431: long active0) {
1432: if (((active0 &= old0)) == 0L)
1433: return jjStartNfa_3(2, old0);
1434: try {
1435: curChar = input_stream.readChar();
1436: } catch (java.io.IOException e) {
1437: jjStopStringLiteralDfa_3(3, active0);
1438: return 4;
1439: }
1440: switch (curChar) {
1441: case 114:
1442: return jjMoveStringLiteralDfa5_3(active0, 0x2000L);
1443: default:
1444: break;
1445: }
1446: return jjStartNfa_3(3, active0);
1447: }
1448:
1449: static private final int jjMoveStringLiteralDfa5_3(long old0,
1450: long active0) {
1451: if (((active0 &= old0)) == 0L)
1452: return jjStartNfa_3(3, old0);
1453: try {
1454: curChar = input_stream.readChar();
1455: } catch (java.io.IOException e) {
1456: jjStopStringLiteralDfa_3(4, active0);
1457: return 5;
1458: }
1459: switch (curChar) {
1460: case 110:
1461: if ((active0 & 0x2000L) != 0L)
1462: return jjStopAtPos(5, 13);
1463: break;
1464: default:
1465: break;
1466: }
1467: return jjStartNfa_3(4, active0);
1468: }
1469:
1470: static private final int jjMoveNfa_3(int startState, int curPos) {
1471: int[] nextStates;
1472: int startsAt = 0;
1473: jjnewStateCnt = 11;
1474: int i = 1;
1475: jjstateSet[0] = startState;
1476: int j, kind = 0x7fffffff;
1477: for (;;) {
1478: if (++jjround == 0x7fffffff)
1479: ReInitRounds();
1480: if (curChar < 64) {
1481: long l = 1L << curChar;
1482: MatchLoop: do {
1483: switch (jjstateSet[--i]) {
1484: default:
1485: break;
1486: }
1487: } while (i != startsAt);
1488: } else if (curChar < 128) {
1489: long l = 1L << (curChar & 077);
1490: MatchLoop: do {
1491: switch (jjstateSet[--i]) {
1492: case 4:
1493: if (curChar == 116)
1494: jjstateSet[jjnewStateCnt++] = 9;
1495: else if (curChar == 112)
1496: jjstateSet[jjnewStateCnt++] = 3;
1497: break;
1498: case 0:
1499: if (curChar == 109)
1500: kind = 12;
1501: break;
1502: case 1:
1503: if (curChar == 97)
1504: jjstateSet[jjnewStateCnt++] = 0;
1505: break;
1506: case 2:
1507: if (curChar == 114)
1508: jjstateSet[jjnewStateCnt++] = 1;
1509: break;
1510: case 3:
1511: if (curChar == 97)
1512: jjstateSet[jjnewStateCnt++] = 2;
1513: break;
1514: case 5:
1515: if (curChar == 115)
1516: kind = 12;
1517: break;
1518: case 6:
1519: if (curChar == 119)
1520: jjstateSet[jjnewStateCnt++] = 5;
1521: break;
1522: case 7:
1523: if (curChar == 111)
1524: jjstateSet[jjnewStateCnt++] = 6;
1525: break;
1526: case 8:
1527: if (curChar == 114)
1528: jjstateSet[jjnewStateCnt++] = 7;
1529: break;
1530: case 9:
1531: if (curChar == 104)
1532: jjstateSet[jjnewStateCnt++] = 8;
1533: break;
1534: case 10:
1535: if (curChar == 116)
1536: jjstateSet[jjnewStateCnt++] = 9;
1537: break;
1538: default:
1539: break;
1540: }
1541: } while (i != startsAt);
1542: } else {
1543: int hiByte = (int) (curChar >> 8);
1544: int i1 = hiByte >> 6;
1545: long l1 = 1L << (hiByte & 077);
1546: int i2 = (curChar & 0xff) >> 6;
1547: long l2 = 1L << (curChar & 077);
1548: MatchLoop: do {
1549: switch (jjstateSet[--i]) {
1550: default:
1551: break;
1552: }
1553: } while (i != startsAt);
1554: }
1555: if (kind != 0x7fffffff) {
1556: jjmatchedKind = kind;
1557: jjmatchedPos = curPos;
1558: kind = 0x7fffffff;
1559: }
1560: ++curPos;
1561: if ((i = jjnewStateCnt) == (startsAt = 11 - (jjnewStateCnt = startsAt)))
1562: return curPos;
1563: try {
1564: curChar = input_stream.readChar();
1565: } catch (java.io.IOException e) {
1566: return curPos;
1567: }
1568: }
1569: }
1570:
1571: static private final int jjMoveStringLiteralDfa0_1() {
1572: return jjMoveNfa_1(0, 0);
1573: }
1574:
1575: static private final int jjMoveNfa_1(int startState, int curPos) {
1576: int[] nextStates;
1577: int startsAt = 0;
1578: jjnewStateCnt = 3;
1579: int i = 1;
1580: jjstateSet[0] = startState;
1581: int j, kind = 0x7fffffff;
1582: for (;;) {
1583: if (++jjround == 0x7fffffff)
1584: ReInitRounds();
1585: if (curChar < 64) {
1586: long l = 1L << curChar;
1587: MatchLoop: do {
1588: switch (jjstateSet[--i]) {
1589: case 0:
1590: if ((0x2400L & l) != 0L) {
1591: if (kind > 10)
1592: kind = 10;
1593: }
1594: if (curChar == 13)
1595: jjstateSet[jjnewStateCnt++] = 1;
1596: break;
1597: case 1:
1598: if (curChar == 10 && kind > 10)
1599: kind = 10;
1600: break;
1601: case 2:
1602: if (curChar == 13)
1603: jjstateSet[jjnewStateCnt++] = 1;
1604: break;
1605: default:
1606: break;
1607: }
1608: } while (i != startsAt);
1609: } else if (curChar < 128) {
1610: long l = 1L << (curChar & 077);
1611: MatchLoop: do {
1612: switch (jjstateSet[--i]) {
1613: default:
1614: break;
1615: }
1616: } while (i != startsAt);
1617: } else {
1618: int hiByte = (int) (curChar >> 8);
1619: int i1 = hiByte >> 6;
1620: long l1 = 1L << (hiByte & 077);
1621: int i2 = (curChar & 0xff) >> 6;
1622: long l2 = 1L << (curChar & 077);
1623: MatchLoop: do {
1624: switch (jjstateSet[--i]) {
1625: default:
1626: break;
1627: }
1628: } while (i != startsAt);
1629: }
1630: if (kind != 0x7fffffff) {
1631: jjmatchedKind = kind;
1632: jjmatchedPos = curPos;
1633: kind = 0x7fffffff;
1634: }
1635: ++curPos;
1636: if ((i = jjnewStateCnt) == (startsAt = 3 - (jjnewStateCnt = startsAt)))
1637: return curPos;
1638: try {
1639: curChar = input_stream.readChar();
1640: } catch (java.io.IOException e) {
1641: return curPos;
1642: }
1643: }
1644: }
1645:
1646: static private final int jjMoveStringLiteralDfa0_6() {
1647: return jjMoveNfa_6(0, 0);
1648: }
1649:
1650: static private final int jjMoveNfa_6(int startState, int curPos) {
1651: int[] nextStates;
1652: int startsAt = 0;
1653: jjnewStateCnt = 3;
1654: int i = 1;
1655: jjstateSet[0] = startState;
1656: int j, kind = 0x7fffffff;
1657: for (;;) {
1658: if (++jjround == 0x7fffffff)
1659: ReInitRounds();
1660: if (curChar < 64) {
1661: long l = 1L << curChar;
1662: MatchLoop: do {
1663: switch (jjstateSet[--i]) {
1664: case 0:
1665: if ((0x2400L & l) != 0L) {
1666: if (kind > 17)
1667: kind = 17;
1668: }
1669: if (curChar == 13)
1670: jjstateSet[jjnewStateCnt++] = 1;
1671: break;
1672: case 1:
1673: if (curChar == 10 && kind > 17)
1674: kind = 17;
1675: break;
1676: case 2:
1677: if (curChar == 13)
1678: jjstateSet[jjnewStateCnt++] = 1;
1679: break;
1680: default:
1681: break;
1682: }
1683: } while (i != startsAt);
1684: } else if (curChar < 128) {
1685: long l = 1L << (curChar & 077);
1686: MatchLoop: do {
1687: switch (jjstateSet[--i]) {
1688: default:
1689: break;
1690: }
1691: } while (i != startsAt);
1692: } else {
1693: int hiByte = (int) (curChar >> 8);
1694: int i1 = hiByte >> 6;
1695: long l1 = 1L << (hiByte & 077);
1696: int i2 = (curChar & 0xff) >> 6;
1697: long l2 = 1L << (curChar & 077);
1698: MatchLoop: do {
1699: switch (jjstateSet[--i]) {
1700: default:
1701: break;
1702: }
1703: } while (i != startsAt);
1704: }
1705: if (kind != 0x7fffffff) {
1706: jjmatchedKind = kind;
1707: jjmatchedPos = curPos;
1708: kind = 0x7fffffff;
1709: }
1710: ++curPos;
1711: if ((i = jjnewStateCnt) == (startsAt = 3 - (jjnewStateCnt = startsAt)))
1712: return curPos;
1713: try {
1714: curChar = input_stream.readChar();
1715: } catch (java.io.IOException e) {
1716: return curPos;
1717: }
1718: }
1719: }
1720:
1721: static private final int jjMoveStringLiteralDfa0_2() {
1722: return jjMoveNfa_2(1, 0);
1723: }
1724:
1725: static private final int jjMoveNfa_2(int startState, int curPos) {
1726: int[] nextStates;
1727: int startsAt = 0;
1728: jjnewStateCnt = 3;
1729: int i = 1;
1730: jjstateSet[0] = startState;
1731: int j, kind = 0x7fffffff;
1732: for (;;) {
1733: if (++jjround == 0x7fffffff)
1734: ReInitRounds();
1735: if (curChar < 64) {
1736: long l = 1L << curChar;
1737: MatchLoop: do {
1738: switch (jjstateSet[--i]) {
1739: case 1:
1740: if (curChar == 42)
1741: jjstateSet[jjnewStateCnt++] = 0;
1742: break;
1743: case 0:
1744: if (curChar == 47)
1745: kind = 11;
1746: break;
1747: default:
1748: break;
1749: }
1750: } while (i != startsAt);
1751: } else if (curChar < 128) {
1752: long l = 1L << (curChar & 077);
1753: MatchLoop: do {
1754: switch (jjstateSet[--i]) {
1755: case 1:
1756: if (curChar == 64)
1757: kind = 11;
1758: break;
1759: default:
1760: break;
1761: }
1762: } while (i != startsAt);
1763: } else {
1764: int hiByte = (int) (curChar >> 8);
1765: int i1 = hiByte >> 6;
1766: long l1 = 1L << (hiByte & 077);
1767: int i2 = (curChar & 0xff) >> 6;
1768: long l2 = 1L << (curChar & 077);
1769: MatchLoop: do {
1770: switch (jjstateSet[--i]) {
1771: default:
1772: break;
1773: }
1774: } while (i != startsAt);
1775: }
1776: if (kind != 0x7fffffff) {
1777: jjmatchedKind = kind;
1778: jjmatchedPos = curPos;
1779: kind = 0x7fffffff;
1780: }
1781: ++curPos;
1782: if ((i = jjnewStateCnt) == (startsAt = 3 - (jjnewStateCnt = startsAt)))
1783: return curPos;
1784: try {
1785: curChar = input_stream.readChar();
1786: } catch (java.io.IOException e) {
1787: return curPos;
1788: }
1789: }
1790: }
1791:
1792: static private final int jjMoveStringLiteralDfa0_4() {
1793: return jjMoveNfa_4(0, 0);
1794: }
1795:
1796: static private final int jjMoveNfa_4(int startState, int curPos) {
1797: int[] nextStates;
1798: int startsAt = 0;
1799: jjnewStateCnt = 3;
1800: int i = 1;
1801: jjstateSet[0] = startState;
1802: int j, kind = 0x7fffffff;
1803: for (;;) {
1804: if (++jjround == 0x7fffffff)
1805: ReInitRounds();
1806: if (curChar < 64) {
1807: long l = 1L << curChar;
1808: MatchLoop: do {
1809: switch (jjstateSet[--i]) {
1810: case 0:
1811: if (curChar == 32)
1812: jjCheckNAddTwoStates(0, 1);
1813: break;
1814: case 1:
1815: if ((0xfffffffeffffffffL & l) != 0L)
1816: jjCheckNAddTwoStates(1, 2);
1817: break;
1818: case 2:
1819: if (curChar != 32)
1820: break;
1821: if (kind > 14)
1822: kind = 14;
1823: jjCheckNAdd(2);
1824: break;
1825: default:
1826: break;
1827: }
1828: } while (i != startsAt);
1829: } else if (curChar < 128) {
1830: long l = 1L << (curChar & 077);
1831: MatchLoop: do {
1832: switch (jjstateSet[--i]) {
1833: case 1:
1834: jjAddStates(44, 45);
1835: break;
1836: default:
1837: break;
1838: }
1839: } while (i != startsAt);
1840: } else {
1841: int hiByte = (int) (curChar >> 8);
1842: int i1 = hiByte >> 6;
1843: long l1 = 1L << (hiByte & 077);
1844: int i2 = (curChar & 0xff) >> 6;
1845: long l2 = 1L << (curChar & 077);
1846: MatchLoop: do {
1847: switch (jjstateSet[--i]) {
1848: case 1:
1849: if (jjCanMove_0(hiByte, i1, i2, l1, l2))
1850: jjAddStates(44, 45);
1851: break;
1852: default:
1853: break;
1854: }
1855: } while (i != startsAt);
1856: }
1857: if (kind != 0x7fffffff) {
1858: jjmatchedKind = kind;
1859: jjmatchedPos = curPos;
1860: kind = 0x7fffffff;
1861: }
1862: ++curPos;
1863: if ((i = jjnewStateCnt) == (startsAt = 3 - (jjnewStateCnt = startsAt)))
1864: return curPos;
1865: try {
1866: curChar = input_stream.readChar();
1867: } catch (java.io.IOException e) {
1868: return curPos;
1869: }
1870: }
1871: }
1872:
1873: static final int[] jjnextStates = { 33, 34, 36, 42, 43, 48, 49, 52,
1874: 53, 14, 32, 38, 16, 17, 19, 57, 59, 6, 10, 11, 14, 16, 17,
1875: 21, 19, 44, 45, 14, 52, 53, 14, 12, 13, 18, 20, 22, 24, 27,
1876: 46, 47, 50, 51, 54, 55, 1, 2, };
1877:
1878: private static final boolean jjCanMove_0(int hiByte, int i1,
1879: int i2, long l1, long l2) {
1880: switch (hiByte) {
1881: case 0:
1882: return ((jjbitVec2[i2] & l2) != 0L);
1883: default:
1884: if ((jjbitVec0[i1] & l1) != 0L)
1885: return true;
1886: return false;
1887: }
1888: }
1889:
1890: private static final boolean jjCanMove_1(int hiByte, int i1,
1891: int i2, long l1, long l2) {
1892: switch (hiByte) {
1893: case 0:
1894: return ((jjbitVec4[i2] & l2) != 0L);
1895: case 48:
1896: return ((jjbitVec5[i2] & l2) != 0L);
1897: case 49:
1898: return ((jjbitVec6[i2] & l2) != 0L);
1899: case 51:
1900: return ((jjbitVec7[i2] & l2) != 0L);
1901: case 61:
1902: return ((jjbitVec8[i2] & l2) != 0L);
1903: default:
1904: if ((jjbitVec3[i1] & l1) != 0L)
1905: return true;
1906: return false;
1907: }
1908: }
1909:
1910: public static final String[] jjstrLiteralImages = { "", null, null,
1911: null, null, null, null, null, null, null, null, null, null,
1912: null, null, null, null, null, null, "\142\162\145\141\153",
1913: "\143\141\154\154\145\145", "\143\141\164\143\150",
1914: "\143\157\156\163\164", "\143\157\156\164\151\156\165\145",
1915: "\144\157", "\56\56\56", "\145\154\163\145",
1916: "\145\170\164\145\156\144\163", "\145\166\141\154",
1917: "\146\141\154\163\145", "\146\151\156\141\154\154\171",
1918: "\146\157\162", "\146\165\156\143\164\151\157\156",
1919: "\151\146", "\151\156\163\164\141\156\143\145\157\146",
1920: "\151\155\160\157\162\164", "\155\151\170\151\156",
1921: "\156\145\167", "\156\165\154\154",
1922: "\160\162\151\166\141\164\145",
1923: "\160\162\157\164\145\143\164\145\144",
1924: "\160\165\142\154\151\143", "\162\145\164\165\162\156",
1925: "\163\164\141\164\151\143", "\163\165\160\145\162",
1926: "\163\171\156\143\150\162\157\156\151\172\145\144",
1927: "\164\150\151\163", "\164\150\162\157\167",
1928: "\164\162\165\145", "\164\162\171",
1929: "\165\156\144\145\146\151\156\145\144", "\166\141\162",
1930: "\166\157\151\144", "\167\150\151\154\145", null, null,
1931: null, null, null, null, null, null, null, null, null, null,
1932: null, null, null, null, "\50", "\51", "\47\173", "\173",
1933: "\175", "\133", "\135", "\73", "\54", "\56", "\75", "\76",
1934: "\74", "\41", "\176", "\77", "\72", "\75\75", "\74\75",
1935: "\76\75", "\41\75", "\174\174", "\46\46", "\53\53",
1936: "\55\55", "\53", "\55", "\52", "\57", "\46", "\174",
1937: "\136", "\45", "\74\74", "\76\76", "\76\76\76", "\53\75",
1938: "\55\75", "\52\75", "\57\75", "\46\75", "\174\75",
1939: "\136\75", "\45\75", "\74\74\75", "\76\76\75",
1940: "\76\76\76\75", "\56\56", };
1941: public static final String[] lexStateNames = { "DEFAULT",
1942: "IN_SINGLE_LINE_COMMENT", "IN_FORMAL_COMMENT",
1943: "MAYBE_JAVADOC_TAG", "EXPECTING_JAVADOC_TAG_ARG",
1944: "IN_MULTI_LINE_COMMENT", "IN_UNIX_SELF_EXECUTABLE_COMMENT", };
1945: public static final int[] jjnewLexState = { -1, -1, -1, -1, -1, -1,
1946: 1, 2, 5, 6, 0, 3, 4, 2, 2, -1, 0, 0, -1, -1, -1, -1, -1,
1947: -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
1948: -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
1949: -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
1950: -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
1951: -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
1952: -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
1953: -1, -1, -1, -1, -1, };
1954: static final long[] jjtoToken = { 0xa87ffffffffa0001L,
1955: 0x3fffffffffffc8L, };
1956: static final long[] jjtoSkip = { 0x17c3eL, 0x0L, };
1957: static final long[] jjtoSpecial = { 0x17c00L, 0x0L, };
1958: static final long[] jjtoMore = { 0x483c0L, 0x0L, };
1959: static private ASCII_UCodeESC_CharStream input_stream;
1960: static private final int[] jjrounds = new int[60];
1961: static private final int[] jjstateSet = new int[120];
1962: static StringBuffer image;
1963: static int jjimageLen;
1964: static int lengthOfMatch;
1965: static protected char curChar;
1966:
1967: public OscriptParserTokenManager(ASCII_UCodeESC_CharStream stream) {
1968: if (input_stream != null)
1969: throw new TokenMgrError(
1970: "ERROR: Second call to constructor of static lexer. You must use ReInit() to initialize the static variables.",
1971: TokenMgrError.STATIC_LEXER_ERROR);
1972: input_stream = stream;
1973: }
1974:
1975: public OscriptParserTokenManager(ASCII_UCodeESC_CharStream stream,
1976: int lexState) {
1977: this (stream);
1978: SwitchTo(lexState);
1979: }
1980:
1981: static public void ReInit(ASCII_UCodeESC_CharStream stream) {
1982: jjmatchedPos = jjnewStateCnt = 0;
1983: curLexState = defaultLexState;
1984: input_stream = stream;
1985: ReInitRounds();
1986: }
1987:
1988: static private final void ReInitRounds() {
1989: int i;
1990: jjround = 0x80000001;
1991: for (i = 60; i-- > 0;)
1992: jjrounds[i] = 0x80000000;
1993: }
1994:
1995: static public void ReInit(ASCII_UCodeESC_CharStream stream,
1996: int lexState) {
1997: ReInit(stream);
1998: SwitchTo(lexState);
1999: }
2000:
2001: static public void SwitchTo(int lexState) {
2002: if (lexState >= 7 || lexState < 0)
2003: throw new TokenMgrError(
2004: "Error: Ignoring invalid lexical state : "
2005: + lexState + ". State unchanged.",
2006: TokenMgrError.INVALID_LEXICAL_STATE);
2007: else
2008: curLexState = lexState;
2009: }
2010:
2011: static private final Token jjFillToken() {
2012: Token t = Token.newToken(jjmatchedKind);
2013: t.kind = jjmatchedKind;
2014: String im = jjstrLiteralImages[jjmatchedKind];
2015: t.image = (im == null) ? input_stream.GetImage() : im;
2016: t.beginLine = input_stream.getBeginLine();
2017: t.beginColumn = input_stream.getBeginColumn();
2018: t.endLine = input_stream.getEndLine();
2019: t.endColumn = input_stream.getEndColumn();
2020: t.beginOffset = input_stream.getBeginOffset();
2021: t.endOffset = input_stream.getEndOffset();
2022:
2023: return t;
2024: }
2025:
2026: static int curLexState = 0;
2027: static int defaultLexState = 0;
2028: static int jjnewStateCnt;
2029: static int jjround;
2030: static int jjmatchedPos;
2031: static int jjmatchedKind;
2032:
2033: public static final Token getNextToken() {
2034: int kind;
2035: Token specialToken = null;
2036: Token matchedToken;
2037: int curPos = 0;
2038:
2039: EOFLoop: for (;;) {
2040: try {
2041: curChar = input_stream.BeginToken();
2042: } catch (java.io.IOException e) {
2043: jjmatchedKind = 0;
2044: matchedToken = jjFillToken();
2045: matchedToken.specialToken = specialToken;
2046: return matchedToken;
2047: }
2048: image = null;
2049: jjimageLen = 0;
2050:
2051: for (;;) {
2052: switch (curLexState) {
2053: case 0:
2054: try {
2055: input_stream.backup(0);
2056: while (curChar <= 32
2057: && (0x100003600L & (1L << curChar)) != 0L)
2058: curChar = input_stream.BeginToken();
2059: } catch (java.io.IOException e1) {
2060: continue EOFLoop;
2061: }
2062: jjmatchedKind = 0x7fffffff;
2063: jjmatchedPos = 0;
2064: curPos = jjMoveStringLiteralDfa0_0();
2065: break;
2066: case 1:
2067: jjmatchedKind = 0x7fffffff;
2068: jjmatchedPos = 0;
2069: curPos = jjMoveStringLiteralDfa0_1();
2070: if (jjmatchedPos == 0 && jjmatchedKind > 18) {
2071: jjmatchedKind = 18;
2072: }
2073: break;
2074: case 2:
2075: jjmatchedKind = 0x7fffffff;
2076: jjmatchedPos = 0;
2077: curPos = jjMoveStringLiteralDfa0_2();
2078: if (jjmatchedPos == 0 && jjmatchedKind > 18) {
2079: jjmatchedKind = 18;
2080: }
2081: break;
2082: case 3:
2083: jjmatchedKind = 0x7fffffff;
2084: jjmatchedPos = 0;
2085: curPos = jjMoveStringLiteralDfa0_3();
2086: if (jjmatchedPos == 0 && jjmatchedKind > 15) {
2087: jjmatchedKind = 15;
2088: }
2089: break;
2090: case 4:
2091: jjmatchedKind = 0x7fffffff;
2092: jjmatchedPos = 0;
2093: curPos = jjMoveStringLiteralDfa0_4();
2094: break;
2095: case 5:
2096: jjmatchedKind = 0x7fffffff;
2097: jjmatchedPos = 0;
2098: curPos = jjMoveStringLiteralDfa0_5();
2099: if (jjmatchedPos == 0 && jjmatchedKind > 18) {
2100: jjmatchedKind = 18;
2101: }
2102: break;
2103: case 6:
2104: jjmatchedKind = 0x7fffffff;
2105: jjmatchedPos = 0;
2106: curPos = jjMoveStringLiteralDfa0_6();
2107: if (jjmatchedPos == 0 && jjmatchedKind > 18) {
2108: jjmatchedKind = 18;
2109: }
2110: break;
2111: }
2112: if (jjmatchedKind != 0x7fffffff) {
2113: if (jjmatchedPos + 1 < curPos)
2114: input_stream.backup(curPos - jjmatchedPos - 1);
2115: if ((jjtoToken[jjmatchedKind >> 6] & (1L << (jjmatchedKind & 077))) != 0L) {
2116: matchedToken = jjFillToken();
2117: matchedToken.specialToken = specialToken;
2118: if (jjnewLexState[jjmatchedKind] != -1)
2119: curLexState = jjnewLexState[jjmatchedKind];
2120: return matchedToken;
2121: } else if ((jjtoSkip[jjmatchedKind >> 6] & (1L << (jjmatchedKind & 077))) != 0L) {
2122: if ((jjtoSpecial[jjmatchedKind >> 6] & (1L << (jjmatchedKind & 077))) != 0L) {
2123: matchedToken = jjFillToken();
2124: if (specialToken == null)
2125: specialToken = matchedToken;
2126: else {
2127: matchedToken.specialToken = specialToken;
2128: specialToken = (specialToken.next = matchedToken);
2129: }
2130: SkipLexicalActions(matchedToken);
2131: } else
2132: SkipLexicalActions(null);
2133: if (jjnewLexState[jjmatchedKind] != -1)
2134: curLexState = jjnewLexState[jjmatchedKind];
2135: continue EOFLoop;
2136: }
2137: MoreLexicalActions();
2138: if (jjnewLexState[jjmatchedKind] != -1)
2139: curLexState = jjnewLexState[jjmatchedKind];
2140: curPos = 0;
2141: jjmatchedKind = 0x7fffffff;
2142: try {
2143: curChar = input_stream.readChar();
2144: continue;
2145: } catch (java.io.IOException e1) {
2146: }
2147: }
2148: int error_line = input_stream.getEndLine();
2149: int error_column = input_stream.getEndColumn();
2150: String error_after = null;
2151: boolean EOFSeen = false;
2152: try {
2153: input_stream.readChar();
2154: input_stream.backup(1);
2155: } catch (java.io.IOException e1) {
2156: EOFSeen = true;
2157: error_after = curPos <= 1 ? "" : input_stream
2158: .GetImage();
2159: if (curChar == '\n' || curChar == '\r') {
2160: error_line++;
2161: error_column = 0;
2162: } else
2163: error_column++;
2164: }
2165: if (!EOFSeen) {
2166: input_stream.backup(1);
2167: error_after = curPos <= 1 ? "" : input_stream
2168: .GetImage();
2169: }
2170: throw new TokenMgrError(EOFSeen, curLexState,
2171: error_line, error_column, error_after, curChar,
2172: TokenMgrError.LEXICAL_ERROR);
2173: }
2174: }
2175: }
2176:
2177: static final void SkipLexicalActions(Token matchedToken) {
2178: switch (jjmatchedKind) {
2179: case 11:
2180: if (image == null)
2181: image = new StringBuffer(new String(input_stream
2182: .GetSuffix(jjimageLen
2183: + (lengthOfMatch = jjmatchedPos + 1))));
2184: else
2185: image.append(input_stream.GetSuffix(jjimageLen
2186: + (lengthOfMatch = jjmatchedPos + 1)));
2187: stillInFormalComment = image.toString().endsWith("@");
2188: break;
2189: default:
2190: break;
2191: }
2192: }
2193:
2194: static final void MoreLexicalActions() {
2195: jjimageLen += (lengthOfMatch = jjmatchedPos + 1);
2196: switch (jjmatchedKind) {
2197: case 7:
2198: if (image == null)
2199: image = new StringBuffer(new String(input_stream
2200: .GetSuffix(jjimageLen)));
2201: else
2202: image.append(input_stream.GetSuffix(jjimageLen));
2203: jjimageLen = 0;
2204: input_stream.backup(1);
2205: break;
2206: case 15:
2207: if (image == null)
2208: image = new StringBuffer(new String(input_stream
2209: .GetSuffix(jjimageLen)));
2210: else
2211: image.append(input_stream.GetSuffix(jjimageLen));
2212: jjimageLen = 0;
2213: input_stream.backup(1);
2214: if (stillInFormalComment)
2215: SwitchTo(IN_FORMAL_COMMENT);
2216: else
2217: SwitchTo(DEFAULT);
2218: break;
2219: default:
2220: break;
2221: }
2222: }
2223: }
|