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