0001: /* Generated By:JJTree&JavaCC: Do not edit this line. SyntaxTreeBuilderTokenManager.java */
0002: package org.openrdf.query.parser.serql.ast;
0003:
0004: import java.io.StringReader;
0005: import org.openrdf.query.algebra.Compare.CompareOp;
0006: import org.openrdf.model.vocabulary.XMLSchema;
0007:
0008: public class SyntaxTreeBuilderTokenManager implements
0009: SyntaxTreeBuilderConstants {
0010: public java.io.PrintStream debugStream = System.out;
0011:
0012: public void setDebugStream(java.io.PrintStream ds) {
0013: debugStream = ds;
0014: }
0015:
0016: private final int jjStopStringLiteralDfa_0(int pos, long active0) {
0017: switch (pos) {
0018: case 0:
0019: if ((active0 & 0x1ffffffffe00000L) != 0L) {
0020: jjmatchedKind = 68;
0021: return 114;
0022: }
0023: if ((active0 & 0x300L) != 0L)
0024: return 6;
0025: return -1;
0026: case 1:
0027: if ((active0 & 0x92000800000000L) != 0L)
0028: return 114;
0029: if ((active0 & 0x16dfff7ffe00000L) != 0L) {
0030: if (jjmatchedPos != 1) {
0031: jjmatchedKind = 68;
0032: jjmatchedPos = 1;
0033: }
0034: return 114;
0035: }
0036: return -1;
0037: case 2:
0038: if ((active0 & 0x60000600000000L) != 0L)
0039: return 114;
0040: if ((active0 & 0x11dfff1ffe00000L) != 0L) {
0041: jjmatchedKind = 68;
0042: jjmatchedPos = 2;
0043: return 114;
0044: }
0045: return -1;
0046: case 3:
0047: if ((active0 & 0x11deea17be00000L) != 0L) {
0048: jjmatchedKind = 68;
0049: jjmatchedPos = 3;
0050: return 114;
0051: }
0052: if ((active0 & 0x115084000000L) != 0L)
0053: return 114;
0054: return -1;
0055: case 4:
0056: if ((active0 & 0xc888130200000L) != 0L)
0057: return 114;
0058: if ((active0 & 0x11166204bc00000L) != 0L) {
0059: jjmatchedKind = 68;
0060: jjmatchedPos = 4;
0061: return 114;
0062: }
0063: return -1;
0064: case 5:
0065: if ((active0 & 0x100002040800000L) != 0L)
0066: return 114;
0067: if ((active0 & 0x1166000b400000L) != 0L) {
0068: jjmatchedKind = 68;
0069: jjmatchedPos = 5;
0070: return 114;
0071: }
0072: return -1;
0073: case 6:
0074: if ((active0 & 0x400008000000L) != 0L)
0075: return 114;
0076: if ((active0 & 0x11260003400000L) != 0L) {
0077: jjmatchedKind = 68;
0078: jjmatchedPos = 6;
0079: return 114;
0080: }
0081: return -1;
0082: case 7:
0083: if ((active0 & 0x11240001400000L) != 0L) {
0084: jjmatchedKind = 68;
0085: jjmatchedPos = 7;
0086: return 114;
0087: }
0088: if ((active0 & 0x20002000000L) != 0L)
0089: return 114;
0090: return -1;
0091: case 8:
0092: if ((active0 & 0x11040001400000L) != 0L)
0093: return 114;
0094: if ((active0 & 0x200000000000L) != 0L) {
0095: jjmatchedKind = 68;
0096: jjmatchedPos = 8;
0097: return 114;
0098: }
0099: return -1;
0100: default:
0101: return -1;
0102: }
0103: }
0104:
0105: private final int jjStartNfa_0(int pos, long active0) {
0106: return jjMoveNfa_0(jjStopStringLiteralDfa_0(pos, active0),
0107: pos + 1);
0108: }
0109:
0110: private final int jjStopAtPos(int pos, int kind) {
0111: jjmatchedKind = kind;
0112: jjmatchedPos = pos;
0113: return pos + 1;
0114: }
0115:
0116: private final int jjStartNfaWithStates_0(int pos, int kind,
0117: int state) {
0118: jjmatchedKind = kind;
0119: jjmatchedPos = pos;
0120: try {
0121: curChar = input_stream.readChar();
0122: } catch (java.io.IOException e) {
0123: return pos + 1;
0124: }
0125: return jjMoveNfa_0(state, pos + 1);
0126: }
0127:
0128: private final int jjMoveStringLiteralDfa0_0() {
0129: switch (curChar) {
0130: case 33:
0131: return jjMoveStringLiteralDfa1_0(0x80L);
0132: case 40:
0133: return jjStopAtPos(0, 17);
0134: case 41:
0135: return jjStopAtPos(0, 18);
0136: case 42:
0137: return jjStopAtPos(0, 12);
0138: case 44:
0139: return jjStopAtPos(0, 13);
0140: case 59:
0141: return jjStopAtPos(0, 14);
0142: case 60:
0143: jjmatchedKind = 8;
0144: return jjMoveStringLiteralDfa1_0(0x200L);
0145: case 61:
0146: return jjStopAtPos(0, 6);
0147: case 62:
0148: jjmatchedKind = 11;
0149: return jjMoveStringLiteralDfa1_0(0x400L);
0150: case 91:
0151: return jjStopAtPos(0, 19);
0152: case 93:
0153: return jjStopAtPos(0, 20);
0154: case 65:
0155: case 97:
0156: return jjMoveStringLiteralDfa1_0(0x62000400000000L);
0157: case 66:
0158: case 98:
0159: return jjMoveStringLiteralDfa1_0(0x80000000000L);
0160: case 67:
0161: case 99:
0162: return jjMoveStringLiteralDfa1_0(0x4009000000L);
0163: case 68:
0164: case 100:
0165: return jjMoveStringLiteralDfa1_0(0x20002000000L);
0166: case 69:
0167: case 101:
0168: return jjMoveStringLiteralDfa1_0(0x100000000000000L);
0169: case 70:
0170: case 102:
0171: return jjMoveStringLiteralDfa1_0(0x104000000L);
0172: case 73:
0173: case 105:
0174: return jjMoveStringLiteralDfa1_0(0x91e02000000000L);
0175: case 76:
0176: case 108:
0177: return jjMoveStringLiteralDfa1_0(0x59020000000L);
0178: case 77:
0179: case 109:
0180: return jjMoveStringLiteralDfa1_0(0x8000000000000L);
0181: case 78:
0182: case 110:
0183: return jjMoveStringLiteralDfa1_0(0x100200400000L);
0184: case 79:
0185: case 111:
0186: return jjMoveStringLiteralDfa1_0(0x840000000L);
0187: case 83:
0188: case 115:
0189: return jjMoveStringLiteralDfa1_0(0x800000L);
0190: case 84:
0191: case 116:
0192: return jjMoveStringLiteralDfa1_0(0x80000000L);
0193: case 85:
0194: case 117:
0195: return jjMoveStringLiteralDfa1_0(0x4000000200000L);
0196: case 87:
0197: case 119:
0198: return jjMoveStringLiteralDfa1_0(0x10000000L);
0199: case 123:
0200: return jjStopAtPos(0, 15);
0201: case 125:
0202: return jjStopAtPos(0, 16);
0203: default:
0204: return jjMoveNfa_0(0, 0);
0205: }
0206: }
0207:
0208: private final int jjMoveStringLiteralDfa1_0(long active0) {
0209: try {
0210: curChar = input_stream.readChar();
0211: } catch (java.io.IOException e) {
0212: jjStopStringLiteralDfa_0(0, active0);
0213: return 1;
0214: }
0215: switch (curChar) {
0216: case 61:
0217: if ((active0 & 0x80L) != 0L)
0218: return jjStopAtPos(1, 7);
0219: else if ((active0 & 0x200L) != 0L)
0220: return jjStopAtPos(1, 9);
0221: else if ((active0 & 0x400L) != 0L)
0222: return jjStopAtPos(1, 10);
0223: break;
0224: case 65:
0225: case 97:
0226: return jjMoveStringLiteralDfa2_0(active0, 0x3c100400000L);
0227: case 69:
0228: case 101:
0229: return jjMoveStringLiteralDfa2_0(active0, 0x800000L);
0230: case 70:
0231: case 102:
0232: return jjMoveStringLiteralDfa2_0(active0, 0x40000000L);
0233: case 71:
0234: case 103:
0235: return jjMoveStringLiteralDfa2_0(active0, 0x2000000000L);
0236: case 72:
0237: case 104:
0238: return jjMoveStringLiteralDfa2_0(active0, 0x10000000L);
0239: case 73:
0240: case 105:
0241: return jjMoveStringLiteralDfa2_0(active0, 0x8001022000000L);
0242: case 76:
0243: case 108:
0244: return jjMoveStringLiteralDfa2_0(active0, 0x40000000000000L);
0245: case 78:
0246: case 110:
0247: if ((active0 & 0x80000000000000L) != 0L) {
0248: jjmatchedKind = 55;
0249: jjmatchedPos = 1;
0250: }
0251: return jjMoveStringLiteralDfa2_0(active0, 0x34000400000000L);
0252: case 79:
0253: case 111:
0254: return jjMoveStringLiteralDfa2_0(active0, 0xc0209000000L);
0255: case 82:
0256: case 114:
0257: if ((active0 & 0x800000000L) != 0L)
0258: return jjStartNfaWithStates_0(1, 35, 114);
0259: return jjMoveStringLiteralDfa2_0(active0, 0x84000000L);
0260: case 83:
0261: case 115:
0262: if ((active0 & 0x2000000000000L) != 0L)
0263: return jjStartNfaWithStates_0(1, 49, 114);
0264: return jjMoveStringLiteralDfa2_0(active0, 0x1e00000200000L);
0265: case 85:
0266: case 117:
0267: return jjMoveStringLiteralDfa2_0(active0, 0x100000000000L);
0268: case 88:
0269: case 120:
0270: return jjMoveStringLiteralDfa2_0(active0,
0271: 0x100000000000000L);
0272: default:
0273: break;
0274: }
0275: return jjStartNfa_0(0, active0);
0276: }
0277:
0278: private final int jjMoveStringLiteralDfa2_0(long old0, long active0) {
0279: if (((active0 &= old0)) == 0L)
0280: return jjStartNfa_0(0, old0);
0281: try {
0282: curChar = input_stream.readChar();
0283: } catch (java.io.IOException e) {
0284: jjStopStringLiteralDfa_0(1, active0);
0285: return 2;
0286: }
0287: switch (curChar) {
0288: case 66:
0289: case 98:
0290: return jjMoveStringLiteralDfa3_0(active0, 0x408000000000L);
0291: case 67:
0292: case 99:
0293: return jjMoveStringLiteralDfa3_0(active0, 0x40000000000L);
0294: case 68:
0295: case 100:
0296: if ((active0 & 0x400000000L) != 0L)
0297: return jjStartNfaWithStates_0(2, 34, 114);
0298: break;
0299: case 69:
0300: case 101:
0301: return jjMoveStringLiteralDfa3_0(active0, 0x10000000L);
0302: case 70:
0303: case 102:
0304: return jjMoveStringLiteralDfa3_0(active0, 0x40000000L);
0305: case 73:
0306: case 105:
0307: return jjMoveStringLiteralDfa3_0(active0,
0308: 0x104000000200000L);
0309: case 75:
0310: case 107:
0311: return jjMoveStringLiteralDfa3_0(active0, 0x1000000000L);
0312: case 76:
0313: case 108:
0314: if ((active0 & 0x40000000000000L) != 0L)
0315: return jjStartNfaWithStates_0(2, 54, 114);
0316: return jjMoveStringLiteralDfa3_0(active0, 0x1100100800000L);
0317: case 77:
0318: case 109:
0319: return jjMoveStringLiteralDfa3_0(active0, 0x20400000L);
0320: case 78:
0321: case 110:
0322: return jjMoveStringLiteralDfa3_0(active0, 0x8012009000000L);
0323: case 79:
0324: case 111:
0325: return jjMoveStringLiteralDfa3_0(active0, 0x4000000L);
0326: case 82:
0327: case 114:
0328: return jjMoveStringLiteralDfa3_0(active0, 0x200000000000L);
0329: case 83:
0330: case 115:
0331: return jjMoveStringLiteralDfa3_0(active0, 0x4002000000L);
0332: case 84:
0333: case 116:
0334: if ((active0 & 0x200000000L) != 0L)
0335: return jjStartNfaWithStates_0(2, 33, 114);
0336: return jjMoveStringLiteralDfa3_0(active0, 0x10020000000000L);
0337: case 85:
0338: case 117:
0339: return jjMoveStringLiteralDfa3_0(active0, 0x880080000000L);
0340: case 89:
0341: case 121:
0342: if ((active0 & 0x20000000000000L) != 0L)
0343: return jjStartNfaWithStates_0(2, 53, 114);
0344: break;
0345: default:
0346: break;
0347: }
0348: return jjStartNfa_0(1, active0);
0349: }
0350:
0351: private final int jjMoveStringLiteralDfa3_0(long old0, long active0) {
0352: if (((active0 &= old0)) == 0L)
0353: return jjStartNfa_0(1, old0);
0354: try {
0355: curChar = input_stream.readChar();
0356: } catch (java.io.IOException e) {
0357: jjStopStringLiteralDfa_0(2, active0);
0358: return 3;
0359: }
0360: switch (curChar) {
0361: case 65:
0362: case 97:
0363: return jjMoveStringLiteralDfa4_0(active0, 0x60000000000L);
0364: case 69:
0365: case 101:
0366: if ((active0 & 0x80000000L) != 0L)
0367: return jjStartNfaWithStates_0(3, 31, 114);
0368: else if ((active0 & 0x1000000000L) != 0L)
0369: return jjStartNfaWithStates_0(3, 36, 114);
0370: else if ((active0 & 0x4000000000L) != 0L)
0371: return jjStartNfaWithStates_0(3, 38, 114);
0372: return jjMoveStringLiteralDfa4_0(active0, 0x10208000c00000L);
0373: case 71:
0374: case 103:
0375: if ((active0 & 0x10000000000L) != 0L)
0376: return jjStartNfaWithStates_0(3, 40, 114);
0377: break;
0378: case 73:
0379: case 105:
0380: return jjMoveStringLiteralDfa4_0(active0, 0x1000020000000L);
0381: case 76:
0382: case 108:
0383: if ((active0 & 0x100000000000L) != 0L)
0384: return jjStartNfaWithStates_0(3, 44, 114);
0385: break;
0386: case 77:
0387: case 109:
0388: if ((active0 & 0x4000000L) != 0L)
0389: return jjStartNfaWithStates_0(3, 26, 114);
0390: break;
0391: case 78:
0392: case 110:
0393: return jjMoveStringLiteralDfa4_0(active0, 0x480000200000L);
0394: case 79:
0395: case 111:
0396: return jjMoveStringLiteralDfa4_0(active0, 0x4002000000000L);
0397: case 82:
0398: case 114:
0399: return jjMoveStringLiteralDfa4_0(active0, 0x800010000000L);
0400: case 83:
0401: case 115:
0402: return jjMoveStringLiteralDfa4_0(active0,
0403: 0x100000141000000L);
0404: case 84:
0405: case 116:
0406: return jjMoveStringLiteralDfa4_0(active0, 0xa000000L);
0407: case 85:
0408: case 117:
0409: return jjMoveStringLiteralDfa4_0(active0, 0x8000000000000L);
0410: default:
0411: break;
0412: }
0413: return jjStartNfa_0(2, active0);
0414: }
0415:
0416: private final int jjMoveStringLiteralDfa4_0(long old0, long active0) {
0417: if (((active0 &= old0)) == 0L)
0418: return jjStartNfa_0(2, old0);
0419: try {
0420: curChar = input_stream.readChar();
0421: } catch (java.io.IOException e) {
0422: jjStopStringLiteralDfa_0(3, active0);
0423: return 4;
0424: }
0425: switch (curChar) {
0426: case 67:
0427: case 99:
0428: return jjMoveStringLiteralDfa5_0(active0, 0x800000L);
0429: case 68:
0430: case 100:
0431: if ((active0 & 0x80000000000L) != 0L)
0432: return jjStartNfaWithStates_0(4, 43, 114);
0433: break;
0434: case 69:
0435: case 101:
0436: if ((active0 & 0x10000000L) != 0L)
0437: return jjStartNfaWithStates_0(4, 28, 114);
0438: else if ((active0 & 0x100000000L) != 0L)
0439: return jjStartNfaWithStates_0(4, 32, 114);
0440: return jjMoveStringLiteralDfa5_0(active0, 0x48000000L);
0441: case 71:
0442: case 103:
0443: if ((active0 & 0x200000L) != 0L)
0444: return jjStartNfaWithStates_0(4, 21, 114);
0445: break;
0446: case 73:
0447: case 105:
0448: if ((active0 & 0x800000000000L) != 0L)
0449: return jjStartNfaWithStates_0(4, 47, 114);
0450: return jjMoveStringLiteralDfa5_0(active0, 0x2000000L);
0451: case 76:
0452: case 108:
0453: if ((active0 & 0x8000000000L) != 0L)
0454: return jjStartNfaWithStates_0(4, 39, 114);
0455: return jjMoveStringLiteralDfa5_0(active0, 0x40000000000L);
0456: case 78:
0457: case 110:
0458: if ((active0 & 0x4000000000000L) != 0L)
0459: return jjStartNfaWithStates_0(4, 50, 114);
0460: break;
0461: case 79:
0462: case 111:
0463: return jjMoveStringLiteralDfa5_0(active0, 0x400000000000L);
0464: case 82:
0465: case 114:
0466: return jjMoveStringLiteralDfa5_0(active0, 0x10002000000000L);
0467: case 83:
0468: case 115:
0469: if ((active0 & 0x8000000000000L) != 0L)
0470: return jjStartNfaWithStates_0(4, 51, 114);
0471: return jjMoveStringLiteralDfa5_0(active0, 0x200000400000L);
0472: case 84:
0473: case 116:
0474: if ((active0 & 0x20000000L) != 0L)
0475: return jjStartNfaWithStates_0(4, 29, 114);
0476: return jjMoveStringLiteralDfa5_0(active0,
0477: 0x101020001000000L);
0478: default:
0479: break;
0480: }
0481: return jjStartNfa_0(3, active0);
0482: }
0483:
0484: private final int jjMoveStringLiteralDfa5_0(long old0, long active0) {
0485: if (((active0 &= old0)) == 0L)
0486: return jjStartNfa_0(3, old0);
0487: try {
0488: curChar = input_stream.readChar();
0489: } catch (java.io.IOException e) {
0490: jjStopStringLiteralDfa_0(4, active0);
0491: return 5;
0492: }
0493: switch (curChar) {
0494: case 68:
0495: case 100:
0496: return jjMoveStringLiteralDfa6_0(active0, 0x400000000000L);
0497: case 69:
0498: case 101:
0499: if ((active0 & 0x2000000000L) != 0L)
0500: return jjStartNfaWithStates_0(5, 37, 114);
0501: return jjMoveStringLiteralDfa6_0(active0, 0x1000000000000L);
0502: case 78:
0503: case 110:
0504: return jjMoveStringLiteralDfa6_0(active0, 0x40002000000L);
0505: case 79:
0506: case 111:
0507: return jjMoveStringLiteralDfa6_0(active0, 0x200000000000L);
0508: case 80:
0509: case 112:
0510: return jjMoveStringLiteralDfa6_0(active0, 0x400000L);
0511: case 82:
0512: case 114:
0513: return jjMoveStringLiteralDfa6_0(active0, 0x1000000L);
0514: case 83:
0515: case 115:
0516: if ((active0 & 0x100000000000000L) != 0L)
0517: return jjStartNfaWithStates_0(5, 56, 114);
0518: return jjMoveStringLiteralDfa6_0(active0, 0x10000000000000L);
0519: case 84:
0520: case 116:
0521: if ((active0 & 0x800000L) != 0L)
0522: return jjStartNfaWithStates_0(5, 23, 114);
0523: else if ((active0 & 0x40000000L) != 0L)
0524: return jjStartNfaWithStates_0(5, 30, 114);
0525: break;
0526: case 88:
0527: case 120:
0528: return jjMoveStringLiteralDfa6_0(active0, 0x8000000L);
0529: case 89:
0530: case 121:
0531: return jjMoveStringLiteralDfa6_0(active0, 0x20000000000L);
0532: default:
0533: break;
0534: }
0535: return jjStartNfa_0(4, active0);
0536: }
0537:
0538: private final int jjMoveStringLiteralDfa6_0(long old0, long active0) {
0539: if (((active0 &= old0)) == 0L)
0540: return jjStartNfa_0(4, old0);
0541: try {
0542: curChar = input_stream.readChar();
0543: } catch (java.io.IOException e) {
0544: jjStopStringLiteralDfa_0(5, active0);
0545: return 6;
0546: }
0547: switch (curChar) {
0548: case 65:
0549: case 97:
0550: return jjMoveStringLiteralDfa7_0(active0, 0x40000400000L);
0551: case 67:
0552: case 99:
0553: return jjMoveStringLiteralDfa7_0(active0, 0x2000000L);
0554: case 69:
0555: case 101:
0556: if ((active0 & 0x400000000000L) != 0L)
0557: return jjStartNfaWithStates_0(6, 46, 114);
0558: return jjMoveStringLiteralDfa7_0(active0, 0x10000000000000L);
0559: case 80:
0560: case 112:
0561: return jjMoveStringLiteralDfa7_0(active0, 0x20000000000L);
0562: case 82:
0563: case 114:
0564: return jjMoveStringLiteralDfa7_0(active0, 0x1000000000000L);
0565: case 84:
0566: case 116:
0567: if ((active0 & 0x8000000L) != 0L)
0568: return jjStartNfaWithStates_0(6, 27, 114);
0569: break;
0570: case 85:
0571: case 117:
0572: return jjMoveStringLiteralDfa7_0(active0, 0x200001000000L);
0573: default:
0574: break;
0575: }
0576: return jjStartNfa_0(5, active0);
0577: }
0578:
0579: private final int jjMoveStringLiteralDfa7_0(long old0, long active0) {
0580: if (((active0 &= old0)) == 0L)
0581: return jjStartNfa_0(5, old0);
0582: try {
0583: curChar = input_stream.readChar();
0584: } catch (java.io.IOException e) {
0585: jjStopStringLiteralDfa_0(6, active0);
0586: return 7;
0587: }
0588: switch (curChar) {
0589: case 65:
0590: case 97:
0591: return jjMoveStringLiteralDfa8_0(active0, 0x1000000000000L);
0592: case 67:
0593: case 99:
0594: return jjMoveStringLiteralDfa8_0(active0, 0x10000001400000L);
0595: case 69:
0596: case 101:
0597: if ((active0 & 0x20000000000L) != 0L)
0598: return jjStartNfaWithStates_0(7, 41, 114);
0599: break;
0600: case 77:
0601: case 109:
0602: return jjMoveStringLiteralDfa8_0(active0, 0x40000000000L);
0603: case 82:
0604: case 114:
0605: return jjMoveStringLiteralDfa8_0(active0, 0x200000000000L);
0606: case 84:
0607: case 116:
0608: if ((active0 & 0x2000000L) != 0L)
0609: return jjStartNfaWithStates_0(7, 25, 114);
0610: break;
0611: default:
0612: break;
0613: }
0614: return jjStartNfa_0(6, active0);
0615: }
0616:
0617: private final int jjMoveStringLiteralDfa8_0(long old0, long active0) {
0618: if (((active0 &= old0)) == 0L)
0619: return jjStartNfa_0(6, old0);
0620: try {
0621: curChar = input_stream.readChar();
0622: } catch (java.io.IOException e) {
0623: jjStopStringLiteralDfa_0(7, active0);
0624: return 8;
0625: }
0626: switch (curChar) {
0627: case 67:
0628: case 99:
0629: return jjMoveStringLiteralDfa9_0(active0, 0x200000000000L);
0630: case 69:
0631: case 101:
0632: if ((active0 & 0x400000L) != 0L)
0633: return jjStartNfaWithStates_0(8, 22, 114);
0634: else if ((active0 & 0x40000000000L) != 0L)
0635: return jjStartNfaWithStates_0(8, 42, 114);
0636: break;
0637: case 76:
0638: case 108:
0639: if ((active0 & 0x1000000000000L) != 0L)
0640: return jjStartNfaWithStates_0(8, 48, 114);
0641: break;
0642: case 84:
0643: case 116:
0644: if ((active0 & 0x1000000L) != 0L)
0645: return jjStartNfaWithStates_0(8, 24, 114);
0646: else if ((active0 & 0x10000000000000L) != 0L)
0647: return jjStartNfaWithStates_0(8, 52, 114);
0648: break;
0649: default:
0650: break;
0651: }
0652: return jjStartNfa_0(7, active0);
0653: }
0654:
0655: private final int jjMoveStringLiteralDfa9_0(long old0, long active0) {
0656: if (((active0 &= old0)) == 0L)
0657: return jjStartNfa_0(7, old0);
0658: try {
0659: curChar = input_stream.readChar();
0660: } catch (java.io.IOException e) {
0661: jjStopStringLiteralDfa_0(8, active0);
0662: return 9;
0663: }
0664: switch (curChar) {
0665: case 69:
0666: case 101:
0667: if ((active0 & 0x200000000000L) != 0L)
0668: return jjStartNfaWithStates_0(9, 45, 114);
0669: break;
0670: default:
0671: break;
0672: }
0673: return jjStartNfa_0(8, active0);
0674: }
0675:
0676: private final void jjCheckNAdd(int state) {
0677: if (jjrounds[state] != jjround) {
0678: jjstateSet[jjnewStateCnt++] = state;
0679: jjrounds[state] = jjround;
0680: }
0681: }
0682:
0683: private final void jjAddStates(int start, int end) {
0684: do {
0685: jjstateSet[jjnewStateCnt++] = jjnextStates[start];
0686: } while (start++ != end);
0687: }
0688:
0689: private final void jjCheckNAddTwoStates(int state1, int state2) {
0690: jjCheckNAdd(state1);
0691: jjCheckNAdd(state2);
0692: }
0693:
0694: private final void jjCheckNAddStates(int start, int end) {
0695: do {
0696: jjCheckNAdd(jjnextStates[start]);
0697: } while (start++ != end);
0698: }
0699:
0700: private final void jjCheckNAddStates(int start) {
0701: jjCheckNAdd(jjnextStates[start]);
0702: jjCheckNAdd(jjnextStates[start + 1]);
0703: }
0704:
0705: static final long[] jjbitVec0 = { 0xfffffffffffffffeL,
0706: 0xffffffffffffffffL, 0xffffffffffffffffL,
0707: 0xffffffffffffffffL };
0708: static final long[] jjbitVec2 = { 0x0L, 0x0L, 0xffffffffffffffffL,
0709: 0xffffffffffffffffL };
0710: static final long[] jjbitVec3 = { 0x1600L, 0x0L, 0x0L, 0x0L };
0711: static final long[] jjbitVec4 = { 0x0L, 0xffc000000000L, 0x0L,
0712: 0xffc000000000L };
0713: static final long[] jjbitVec5 = { 0x0L, 0x3ff00000000L, 0x0L,
0714: 0x3ff000000000000L };
0715: static final long[] jjbitVec6 = { 0x0L, 0xffc000000000L, 0x0L,
0716: 0xff8000000000L };
0717: static final long[] jjbitVec7 = { 0x0L, 0xffc000000000L, 0x0L, 0x0L };
0718: static final long[] jjbitVec8 = { 0x0L, 0x3ff0000L, 0x0L,
0719: 0x3ff0000L };
0720: static final long[] jjbitVec9 = { 0x3ff00000000L, 0x0L, 0x0L, 0x0L };
0721: static final long[] jjbitVec10 = { 0x0L, 0xffffffffffffc000L,
0722: 0xfffff0007fffffffL, 0x7fffffL };
0723: static final long[] jjbitVec11 = { 0x0L, 0x0L, 0x0L,
0724: 0xff7fffffff7fffffL };
0725: static final long[] jjbitVec12 = { 0x7ff3ffffffffffffL,
0726: 0x7ffffffffffffdfeL, 0xffffffffffffffffL,
0727: 0xfc31ffffffffe00fL };
0728: static final long[] jjbitVec13 = { 0xffffffL, 0xffffffffffff0000L,
0729: 0xf80001ffffffffffL, 0x3L };
0730: static final long[] jjbitVec14 = { 0x0L, 0x0L, 0xfffffffbffffd740L,
0731: 0xffffffc7f7fffL };
0732: static final long[] jjbitVec15 = { 0xffffffffffffdffeL,
0733: 0xffffffffdffeffffL, 0xffffffffffff0003L,
0734: 0x33fcfffffff199fL };
0735: static final long[] jjbitVec16 = { 0xfffe000000000000L,
0736: 0xfffffffe027fffffL, 0x7fL, 0x707ffffff0000L };
0737: static final long[] jjbitVec17 = { 0x7fffffe00000000L,
0738: 0xfffe0000000007feL, 0x7cffffffffffffffL, 0x60002f7fffL };
0739: static final long[] jjbitVec18 = { 0x23ffffffffffffe0L,
0740: 0x3ff000000L, 0x3c5fdfffff99fe0L, 0x30003b0000000L };
0741: static final long[] jjbitVec19 = { 0x36dfdfffff987e0L,
0742: 0x1c00005e000000L, 0x23edfdfffffbafe0L, 0x100000000L };
0743: static final long[] jjbitVec20 = { 0x23cdfdfffff99fe0L,
0744: 0x3b0000000L, 0x3bfc718d63dc7e0L, 0x0L };
0745: static final long[] jjbitVec21 = { 0x3effdfffffddfe0L,
0746: 0x300000000L, 0x3effdfffffddfe0L, 0x340000000L };
0747: static final long[] jjbitVec22 = { 0x3fffdfffffddfe0L,
0748: 0x300000000L, 0x0L, 0x0L };
0749: static final long[] jjbitVec23 = { 0xd7ffffffffffeL, 0x3fL,
0750: 0x200d6caefef02596L, 0x1fL };
0751: static final long[] jjbitVec24 = { 0x0L, 0x3fffffffeffL, 0x0L, 0x0L };
0752: static final long[] jjbitVec25 = { 0x0L, 0x0L, 0xffffffff00000000L,
0753: 0x7fffffffff003fL };
0754: static final long[] jjbitVec26 = { 0x500000000007daedL,
0755: 0x2c62ab82315001L, 0xf580c90040000000L, 0x201080000000007L };
0756: static final long[] jjbitVec27 = { 0xffffffffffffffffL,
0757: 0xffffffffffffffffL, 0xffffffff0fffffffL,
0758: 0x3ffffffffffffffL };
0759: static final long[] jjbitVec28 = { 0xffffffff3f3fffffL,
0760: 0x3fffffffaaff3f3fL, 0x5fdfffffffffffffL,
0761: 0x1fdc1fff0fcf1fdcL };
0762: static final long[] jjbitVec29 = { 0x4c4000000000L, 0x0L, 0x7L,
0763: 0x0L };
0764: static final long[] jjbitVec30 = { 0x3fe00000080L,
0765: 0xfffffffffffffffeL, 0xfffffffe001fffffL,
0766: 0x7ffffffffffffffL };
0767: static final long[] jjbitVec31 = { 0x1fffffffffe0L, 0x0L, 0x0L,
0768: 0x0L };
0769: static final long[] jjbitVec32 = { 0xffffffffffffffffL,
0770: 0xffffffffffffffffL, 0x3fffffffffL, 0x0L };
0771: static final long[] jjbitVec33 = { 0xffffffffffffffffL,
0772: 0xffffffffffffffffL, 0xfffffffffL, 0x0L };
0773: static final long[] jjbitVec34 = { 0x0L, 0x0L, 0x80000000000000L,
0774: 0xff7fffffff7fffffL };
0775: static final long[] jjbitVec35 = { 0xffffffL, 0xffffffffffff0000L,
0776: 0xf80001ffffffffffL, 0x30003L };
0777: static final long[] jjbitVec36 = { 0xffffffffffffffffL,
0778: 0x30000003fL, 0xfffffffbffffd7c0L, 0xffffffc7f7fffL };
0779: static final long[] jjbitVec37 = { 0xffffffffffffdffeL,
0780: 0xffffffffdffeffffL, 0xffffffffffff007bL,
0781: 0x33fcfffffff199fL };
0782: static final long[] jjbitVec38 = { 0xfffe000000000000L,
0783: 0xfffffffe027fffffL, 0xbbfffffbfffe007fL, 0x707ffffff0016L };
0784: static final long[] jjbitVec39 = { 0x7fffffe00000000L,
0785: 0xffff03ff0007ffffL, 0x7cffffffffffffffL,
0786: 0x3ff3dffffef7fffL };
0787: static final long[] jjbitVec40 = { 0xf3ffffffffffffeeL,
0788: 0xffcfff1e3fffL, 0xd3c5fdfffff99feeL, 0x3ffcfb080399fL };
0789: static final long[] jjbitVec41 = { 0xd36dfdfffff987e4L,
0790: 0x1fffc05e003987L, 0xf3edfdfffffbafeeL, 0xffc100003bbfL };
0791: static final long[] jjbitVec42 = { 0xf3cdfdfffff99feeL,
0792: 0xffc3b0c0398fL, 0xc3bfc718d63dc7ecL, 0xff8000803dc7L };
0793: static final long[] jjbitVec43 = { 0xc3effdfffffddfeeL,
0794: 0xffc300603ddfL, 0xc3effdfffffddfecL, 0xffc340603ddfL };
0795: static final long[] jjbitVec44 = { 0xc3fffdfffffddfecL,
0796: 0xffc300803dcfL, 0x0L, 0x0L };
0797: static final long[] jjbitVec45 = { 0x7ff7ffffffffffeL, 0x3ff7fffL,
0798: 0x3bff6caefef02596L, 0x3ff3f5fL };
0799: static final long[] jjbitVec46 = { 0xc2a003ff03000000L,
0800: 0xfffe03fffffffeffL, 0x2fe3ffffebf0fdfL, 0x0L };
0801: static final long[] jjbitVec47 = { 0x0L, 0x0L, 0x0L, 0x21fff0000L };
0802: static final long[] jjbitVec48 = { 0x3efffe000000a0L,
0803: 0xfffffffffffffffeL, 0xfffffffe661fffffL,
0804: 0x77ffffffffffffffL };
0805:
0806: private final int jjMoveNfa_0(int startState, int curPos) {
0807: int[] nextStates;
0808: int startsAt = 0;
0809: jjnewStateCnt = 114;
0810: int i = 1;
0811: jjstateSet[0] = startState;
0812: int j, kind = 0x7fffffff;
0813: for (;;) {
0814: if (++jjround == 0x7fffffff)
0815: ReInitRounds();
0816: if (curChar < 64) {
0817: long l = 1L << curChar;
0818: MatchLoop: do {
0819: switch (jjstateSet[--i]) {
0820: case 0:
0821: if ((0x3ff000000000000L & l) != 0L) {
0822: if (kind > 69)
0823: kind = 69;
0824: jjCheckNAddStates(0, 2);
0825: } else if ((0x280000000000L & l) != 0L)
0826: jjCheckNAddTwoStates(20, 21);
0827: else if (curChar == 34)
0828: jjCheckNAddStates(3, 11);
0829: else if (curChar == 46)
0830: jjCheckNAdd(22);
0831: else if (curChar == 60)
0832: jjstateSet[jjnewStateCnt++] = 6;
0833: else if (curChar == 35) {
0834: if (kind > 5)
0835: kind = 5;
0836: jjCheckNAddStates(12, 14);
0837: }
0838: if (curChar == 45)
0839: jjCheckNAdd(18);
0840: else if (curChar == 43)
0841: jjCheckNAdd(16);
0842: break;
0843: case 114:
0844: if ((0x3ff600000000000L & l) != 0L) {
0845: if (kind > 68)
0846: kind = 68;
0847: jjCheckNAdd(109);
0848: } else if (curChar == 58) {
0849: if (kind > 66)
0850: kind = 66;
0851: jjCheckNAdd(108);
0852: }
0853: if ((0x3ff600000000000L & l) != 0L)
0854: jjCheckNAddTwoStates(106, 107);
0855: break;
0856: case 1:
0857: if ((0xffffffffffffdbffL & l) == 0L)
0858: break;
0859: if (kind > 5)
0860: kind = 5;
0861: jjCheckNAddStates(12, 14);
0862: break;
0863: case 2:
0864: if ((0x2400L & l) != 0L && kind > 5)
0865: kind = 5;
0866: break;
0867: case 3:
0868: if (curChar == 10 && kind > 5)
0869: kind = 5;
0870: break;
0871: case 4:
0872: if (curChar == 13)
0873: jjstateSet[jjnewStateCnt++] = 3;
0874: break;
0875: case 5:
0876: if (curChar == 60)
0877: jjstateSet[jjnewStateCnt++] = 6;
0878: break;
0879: case 7:
0880: if ((0x3ff680000000000L & l) != 0L)
0881: jjAddStates(15, 16);
0882: break;
0883: case 8:
0884: if (curChar == 58)
0885: jjCheckNAdd(9);
0886: break;
0887: case 9:
0888: if ((0xaffffffa00000000L & l) != 0L)
0889: jjCheckNAddTwoStates(9, 10);
0890: break;
0891: case 10:
0892: if (curChar == 62 && kind > 64)
0893: kind = 64;
0894: break;
0895: case 11:
0896: if (curChar == 58)
0897: jjstateSet[jjnewStateCnt++] = 12;
0898: break;
0899: case 13:
0900: if ((0x3ff600000000000L & l) == 0L)
0901: break;
0902: if (kind > 67)
0903: kind = 67;
0904: jjstateSet[jjnewStateCnt++] = 13;
0905: break;
0906: case 15:
0907: if (curChar == 43)
0908: jjCheckNAdd(16);
0909: break;
0910: case 16:
0911: if ((0x3ff000000000000L & l) == 0L)
0912: break;
0913: if (kind > 69)
0914: kind = 69;
0915: jjCheckNAdd(16);
0916: break;
0917: case 17:
0918: if (curChar == 45)
0919: jjCheckNAdd(18);
0920: break;
0921: case 18:
0922: if ((0x3ff000000000000L & l) == 0L)
0923: break;
0924: if (kind > 70)
0925: kind = 70;
0926: jjCheckNAdd(18);
0927: break;
0928: case 19:
0929: if ((0x280000000000L & l) != 0L)
0930: jjCheckNAddTwoStates(20, 21);
0931: break;
0932: case 20:
0933: if ((0x3ff000000000000L & l) != 0L)
0934: jjCheckNAddTwoStates(20, 21);
0935: break;
0936: case 21:
0937: if (curChar == 46)
0938: jjCheckNAdd(22);
0939: break;
0940: case 22:
0941: if ((0x3ff000000000000L & l) == 0L)
0942: break;
0943: if (kind > 71)
0944: kind = 71;
0945: jjCheckNAdd(22);
0946: break;
0947: case 23:
0948: if (curChar == 34)
0949: jjCheckNAddStates(3, 11);
0950: break;
0951: case 24:
0952: if ((0xfffffffbffffffffL & l) != 0L)
0953: jjCheckNAddStates(17, 19);
0954: break;
0955: case 25:
0956: if (curChar == 34)
0957: jjstateSet[jjnewStateCnt++] = 26;
0958: break;
0959: case 28:
0960: if (curChar == 45)
0961: jjCheckNAdd(29);
0962: break;
0963: case 29:
0964: if ((0x3ff000000000000L & l) == 0L)
0965: break;
0966: if (kind > 57)
0967: kind = 57;
0968: jjCheckNAddTwoStates(28, 29);
0969: break;
0970: case 31:
0971: if (curChar == 9)
0972: jjCheckNAddStates(17, 19);
0973: break;
0974: case 32:
0975: if (curChar == 13)
0976: jjCheckNAddStates(17, 19);
0977: break;
0978: case 33:
0979: if (curChar == 10)
0980: jjCheckNAddStates(17, 19);
0981: break;
0982: case 34:
0983: if (curChar == 34)
0984: jjCheckNAddStates(17, 19);
0985: break;
0986: case 37:
0987: if ((0x3ff000000000000L & l) != 0L)
0988: jjstateSet[jjnewStateCnt++] = 38;
0989: break;
0990: case 38:
0991: if ((0x3ff000000000000L & l) != 0L)
0992: jjstateSet[jjnewStateCnt++] = 39;
0993: break;
0994: case 39:
0995: if ((0x3ff000000000000L & l) != 0L)
0996: jjstateSet[jjnewStateCnt++] = 40;
0997: break;
0998: case 40:
0999: if ((0x3ff000000000000L & l) != 0L)
1000: jjstateSet[jjnewStateCnt++] = 41;
1001: break;
1002: case 41:
1003: if ((0x3ff000000000000L & l) != 0L)
1004: jjstateSet[jjnewStateCnt++] = 42;
1005: break;
1006: case 42:
1007: if ((0x3ff000000000000L & l) != 0L)
1008: jjstateSet[jjnewStateCnt++] = 43;
1009: break;
1010: case 43:
1011: case 48:
1012: if ((0x3ff000000000000L & l) != 0L)
1013: jjCheckNAdd(44);
1014: break;
1015: case 44:
1016: if ((0x3ff000000000000L & l) != 0L)
1017: jjCheckNAddStates(17, 19);
1018: break;
1019: case 46:
1020: if ((0x3ff000000000000L & l) != 0L)
1021: jjstateSet[jjnewStateCnt++] = 47;
1022: break;
1023: case 47:
1024: if ((0x3ff000000000000L & l) != 0L)
1025: jjstateSet[jjnewStateCnt++] = 48;
1026: break;
1027: case 49:
1028: if ((0xfffffffbffffffffL & l) != 0L)
1029: jjCheckNAddStates(20, 22);
1030: break;
1031: case 50:
1032: if (curChar == 34)
1033: jjstateSet[jjnewStateCnt++] = 64;
1034: break;
1035: case 52:
1036: if (curChar == 60)
1037: jjstateSet[jjnewStateCnt++] = 53;
1038: break;
1039: case 54:
1040: if ((0x3ff680000000000L & l) != 0L)
1041: jjAddStates(23, 24);
1042: break;
1043: case 55:
1044: if (curChar == 58)
1045: jjCheckNAdd(56);
1046: break;
1047: case 56:
1048: if ((0xaffffffa00000000L & l) != 0L)
1049: jjCheckNAddTwoStates(56, 57);
1050: break;
1051: case 57:
1052: if (curChar == 62 && kind > 58)
1053: kind = 58;
1054: break;
1055: case 59:
1056: if ((0x3ff600000000000L & l) != 0L)
1057: jjCheckNAddTwoStates(59, 60);
1058: break;
1059: case 60:
1060: if (curChar != 58)
1061: break;
1062: if (kind > 58)
1063: kind = 58;
1064: jjCheckNAdd(61);
1065: break;
1066: case 61:
1067: if ((0x3ff600000000000L & l) == 0L)
1068: break;
1069: if (kind > 58)
1070: kind = 58;
1071: jjCheckNAdd(61);
1072: break;
1073: case 63:
1074: if ((0x3ff600000000000L & l) != 0L)
1075: jjCheckNAddTwoStates(63, 60);
1076: break;
1077: case 66:
1078: if (curChar == 9)
1079: jjCheckNAddStates(20, 22);
1080: break;
1081: case 67:
1082: if (curChar == 13)
1083: jjCheckNAddStates(20, 22);
1084: break;
1085: case 68:
1086: if (curChar == 10)
1087: jjCheckNAddStates(20, 22);
1088: break;
1089: case 69:
1090: if (curChar == 34)
1091: jjCheckNAddStates(20, 22);
1092: break;
1093: case 72:
1094: if ((0x3ff000000000000L & l) != 0L)
1095: jjstateSet[jjnewStateCnt++] = 73;
1096: break;
1097: case 73:
1098: if ((0x3ff000000000000L & l) != 0L)
1099: jjstateSet[jjnewStateCnt++] = 74;
1100: break;
1101: case 74:
1102: if ((0x3ff000000000000L & l) != 0L)
1103: jjstateSet[jjnewStateCnt++] = 75;
1104: break;
1105: case 75:
1106: if ((0x3ff000000000000L & l) != 0L)
1107: jjstateSet[jjnewStateCnt++] = 76;
1108: break;
1109: case 76:
1110: if ((0x3ff000000000000L & l) != 0L)
1111: jjstateSet[jjnewStateCnt++] = 77;
1112: break;
1113: case 77:
1114: if ((0x3ff000000000000L & l) != 0L)
1115: jjstateSet[jjnewStateCnt++] = 78;
1116: break;
1117: case 78:
1118: case 83:
1119: if ((0x3ff000000000000L & l) != 0L)
1120: jjCheckNAdd(79);
1121: break;
1122: case 79:
1123: if ((0x3ff000000000000L & l) != 0L)
1124: jjCheckNAddStates(20, 22);
1125: break;
1126: case 81:
1127: if ((0x3ff000000000000L & l) != 0L)
1128: jjstateSet[jjnewStateCnt++] = 82;
1129: break;
1130: case 82:
1131: if ((0x3ff000000000000L & l) != 0L)
1132: jjstateSet[jjnewStateCnt++] = 83;
1133: break;
1134: case 84:
1135: if ((0xfffffffbffffffffL & l) != 0L)
1136: jjCheckNAddStates(25, 27);
1137: break;
1138: case 85:
1139: if (curChar == 34 && kind > 59)
1140: kind = 59;
1141: break;
1142: case 87:
1143: if (curChar == 9)
1144: jjCheckNAddStates(25, 27);
1145: break;
1146: case 88:
1147: if (curChar == 13)
1148: jjCheckNAddStates(25, 27);
1149: break;
1150: case 89:
1151: if (curChar == 10)
1152: jjCheckNAddStates(25, 27);
1153: break;
1154: case 90:
1155: if (curChar == 34)
1156: jjCheckNAddStates(25, 27);
1157: break;
1158: case 93:
1159: if ((0x3ff000000000000L & l) != 0L)
1160: jjstateSet[jjnewStateCnt++] = 94;
1161: break;
1162: case 94:
1163: if ((0x3ff000000000000L & l) != 0L)
1164: jjstateSet[jjnewStateCnt++] = 95;
1165: break;
1166: case 95:
1167: if ((0x3ff000000000000L & l) != 0L)
1168: jjstateSet[jjnewStateCnt++] = 96;
1169: break;
1170: case 96:
1171: if ((0x3ff000000000000L & l) != 0L)
1172: jjstateSet[jjnewStateCnt++] = 97;
1173: break;
1174: case 97:
1175: if ((0x3ff000000000000L & l) != 0L)
1176: jjstateSet[jjnewStateCnt++] = 98;
1177: break;
1178: case 98:
1179: if ((0x3ff000000000000L & l) != 0L)
1180: jjstateSet[jjnewStateCnt++] = 99;
1181: break;
1182: case 99:
1183: case 104:
1184: if ((0x3ff000000000000L & l) != 0L)
1185: jjCheckNAdd(100);
1186: break;
1187: case 100:
1188: if ((0x3ff000000000000L & l) != 0L)
1189: jjCheckNAddStates(25, 27);
1190: break;
1191: case 102:
1192: if ((0x3ff000000000000L & l) != 0L)
1193: jjstateSet[jjnewStateCnt++] = 103;
1194: break;
1195: case 103:
1196: if ((0x3ff000000000000L & l) != 0L)
1197: jjstateSet[jjnewStateCnt++] = 104;
1198: break;
1199: case 106:
1200: if ((0x3ff600000000000L & l) != 0L)
1201: jjCheckNAddTwoStates(106, 107);
1202: break;
1203: case 107:
1204: if (curChar != 58)
1205: break;
1206: if (kind > 66)
1207: kind = 66;
1208: jjCheckNAdd(108);
1209: break;
1210: case 108:
1211: if ((0x3ff600000000000L & l) == 0L)
1212: break;
1213: if (kind > 66)
1214: kind = 66;
1215: jjCheckNAdd(108);
1216: break;
1217: case 109:
1218: if ((0x3ff600000000000L & l) == 0L)
1219: break;
1220: if (kind > 68)
1221: kind = 68;
1222: jjCheckNAdd(109);
1223: break;
1224: case 111:
1225: if ((0x3ff600000000000L & l) != 0L)
1226: jjCheckNAddTwoStates(111, 107);
1227: break;
1228: case 112:
1229: if ((0x3ff600000000000L & l) == 0L)
1230: break;
1231: if (kind > 68)
1232: kind = 68;
1233: jjstateSet[jjnewStateCnt++] = 112;
1234: break;
1235: case 113:
1236: if ((0x3ff000000000000L & l) == 0L)
1237: break;
1238: if (kind > 69)
1239: kind = 69;
1240: jjCheckNAddStates(0, 2);
1241: break;
1242: default:
1243: break;
1244: }
1245: } while (i != startsAt);
1246: } else if (curChar < 128) {
1247: long l = 1L << (curChar & 077);
1248: MatchLoop: do {
1249: switch (jjstateSet[--i]) {
1250: case 0:
1251: if ((0x7fffffe07fffffeL & l) != 0L) {
1252: if (kind > 68)
1253: kind = 68;
1254: jjCheckNAddStates(28, 30);
1255: } else if (curChar == 95)
1256: jjCheckNAddTwoStates(111, 112);
1257: if (curChar == 95)
1258: jjstateSet[jjnewStateCnt++] = 11;
1259: break;
1260: case 114:
1261: if ((0x7fffffe87fffffeL & l) != 0L) {
1262: if (kind > 68)
1263: kind = 68;
1264: jjCheckNAdd(109);
1265: }
1266: if ((0x7fffffe87fffffeL & l) != 0L)
1267: jjCheckNAddTwoStates(106, 107);
1268: break;
1269: case 1:
1270: if (kind > 5)
1271: kind = 5;
1272: jjAddStates(12, 14);
1273: break;
1274: case 6:
1275: case 7:
1276: if ((0x7fffffe07fffffeL & l) != 0L)
1277: jjCheckNAddTwoStates(7, 8);
1278: break;
1279: case 9:
1280: if ((0xc7fffffeafffffffL & l) != 0L)
1281: jjAddStates(31, 32);
1282: break;
1283: case 12:
1284: case 13:
1285: if ((0x7fffffe87fffffeL & l) == 0L)
1286: break;
1287: if (kind > 67)
1288: kind = 67;
1289: jjCheckNAdd(13);
1290: break;
1291: case 14:
1292: if (curChar == 95)
1293: jjstateSet[jjnewStateCnt++] = 11;
1294: break;
1295: case 24:
1296: if ((0xffffffffefffffffL & l) != 0L)
1297: jjCheckNAddStates(17, 19);
1298: break;
1299: case 26:
1300: if (curChar == 64)
1301: jjCheckNAdd(27);
1302: break;
1303: case 27:
1304: if ((0x7fffffe07fffffeL & l) == 0L)
1305: break;
1306: if (kind > 57)
1307: kind = 57;
1308: jjCheckNAddTwoStates(27, 28);
1309: break;
1310: case 29:
1311: if ((0x7fffffe07fffffeL & l) == 0L)
1312: break;
1313: if (kind > 57)
1314: kind = 57;
1315: jjCheckNAddTwoStates(28, 29);
1316: break;
1317: case 30:
1318: if (curChar == 92)
1319: jjAddStates(33, 39);
1320: break;
1321: case 35:
1322: if (curChar == 92)
1323: jjCheckNAddStates(17, 19);
1324: break;
1325: case 36:
1326: if ((0x20000000200000L & l) != 0L)
1327: jjstateSet[jjnewStateCnt++] = 37;
1328: break;
1329: case 37:
1330: if ((0x7e0000007eL & l) != 0L)
1331: jjstateSet[jjnewStateCnt++] = 38;
1332: break;
1333: case 38:
1334: if ((0x7e0000007eL & l) != 0L)
1335: jjstateSet[jjnewStateCnt++] = 39;
1336: break;
1337: case 39:
1338: if ((0x7e0000007eL & l) != 0L)
1339: jjstateSet[jjnewStateCnt++] = 40;
1340: break;
1341: case 40:
1342: if ((0x7e0000007eL & l) != 0L)
1343: jjstateSet[jjnewStateCnt++] = 41;
1344: break;
1345: case 41:
1346: if ((0x7e0000007eL & l) != 0L)
1347: jjstateSet[jjnewStateCnt++] = 42;
1348: break;
1349: case 42:
1350: if ((0x7e0000007eL & l) != 0L)
1351: jjstateSet[jjnewStateCnt++] = 43;
1352: break;
1353: case 43:
1354: case 48:
1355: if ((0x7e0000007eL & l) != 0L)
1356: jjCheckNAdd(44);
1357: break;
1358: case 44:
1359: if ((0x7e0000007eL & l) != 0L)
1360: jjCheckNAddStates(17, 19);
1361: break;
1362: case 45:
1363: if ((0x20000000200000L & l) != 0L)
1364: jjstateSet[jjnewStateCnt++] = 46;
1365: break;
1366: case 46:
1367: if ((0x7e0000007eL & l) != 0L)
1368: jjstateSet[jjnewStateCnt++] = 47;
1369: break;
1370: case 47:
1371: if ((0x7e0000007eL & l) != 0L)
1372: jjstateSet[jjnewStateCnt++] = 48;
1373: break;
1374: case 49:
1375: if ((0xffffffffefffffffL & l) != 0L)
1376: jjCheckNAddStates(20, 22);
1377: break;
1378: case 51:
1379: if (curChar == 94)
1380: jjAddStates(40, 42);
1381: break;
1382: case 53:
1383: case 54:
1384: if ((0x7fffffe07fffffeL & l) != 0L)
1385: jjCheckNAddTwoStates(54, 55);
1386: break;
1387: case 56:
1388: if ((0xc7fffffeafffffffL & l) != 0L)
1389: jjAddStates(43, 44);
1390: break;
1391: case 58:
1392: if ((0x7fffffe07fffffeL & l) != 0L)
1393: jjCheckNAddTwoStates(59, 60);
1394: break;
1395: case 59:
1396: if ((0x7fffffe87fffffeL & l) != 0L)
1397: jjCheckNAddTwoStates(59, 60);
1398: break;
1399: case 61:
1400: if ((0x7fffffe87fffffeL & l) == 0L)
1401: break;
1402: if (kind > 58)
1403: kind = 58;
1404: jjstateSet[jjnewStateCnt++] = 61;
1405: break;
1406: case 62:
1407: if (curChar == 95)
1408: jjCheckNAdd(63);
1409: break;
1410: case 63:
1411: if ((0x7fffffe87fffffeL & l) != 0L)
1412: jjCheckNAddTwoStates(63, 60);
1413: break;
1414: case 64:
1415: if (curChar == 94)
1416: jjstateSet[jjnewStateCnt++] = 51;
1417: break;
1418: case 65:
1419: if (curChar == 92)
1420: jjAddStates(45, 51);
1421: break;
1422: case 70:
1423: if (curChar == 92)
1424: jjCheckNAddStates(20, 22);
1425: break;
1426: case 71:
1427: if ((0x20000000200000L & l) != 0L)
1428: jjstateSet[jjnewStateCnt++] = 72;
1429: break;
1430: case 72:
1431: if ((0x7e0000007eL & l) != 0L)
1432: jjstateSet[jjnewStateCnt++] = 73;
1433: break;
1434: case 73:
1435: if ((0x7e0000007eL & l) != 0L)
1436: jjstateSet[jjnewStateCnt++] = 74;
1437: break;
1438: case 74:
1439: if ((0x7e0000007eL & l) != 0L)
1440: jjstateSet[jjnewStateCnt++] = 75;
1441: break;
1442: case 75:
1443: if ((0x7e0000007eL & l) != 0L)
1444: jjstateSet[jjnewStateCnt++] = 76;
1445: break;
1446: case 76:
1447: if ((0x7e0000007eL & l) != 0L)
1448: jjstateSet[jjnewStateCnt++] = 77;
1449: break;
1450: case 77:
1451: if ((0x7e0000007eL & l) != 0L)
1452: jjstateSet[jjnewStateCnt++] = 78;
1453: break;
1454: case 78:
1455: case 83:
1456: if ((0x7e0000007eL & l) != 0L)
1457: jjCheckNAdd(79);
1458: break;
1459: case 79:
1460: if ((0x7e0000007eL & l) != 0L)
1461: jjCheckNAddStates(20, 22);
1462: break;
1463: case 80:
1464: if ((0x20000000200000L & l) != 0L)
1465: jjstateSet[jjnewStateCnt++] = 81;
1466: break;
1467: case 81:
1468: if ((0x7e0000007eL & l) != 0L)
1469: jjstateSet[jjnewStateCnt++] = 82;
1470: break;
1471: case 82:
1472: if ((0x7e0000007eL & l) != 0L)
1473: jjstateSet[jjnewStateCnt++] = 83;
1474: break;
1475: case 84:
1476: if ((0xffffffffefffffffL & l) != 0L)
1477: jjCheckNAddStates(25, 27);
1478: break;
1479: case 86:
1480: if (curChar == 92)
1481: jjAddStates(52, 58);
1482: break;
1483: case 91:
1484: if (curChar == 92)
1485: jjCheckNAddStates(25, 27);
1486: break;
1487: case 92:
1488: if ((0x20000000200000L & l) != 0L)
1489: jjstateSet[jjnewStateCnt++] = 93;
1490: break;
1491: case 93:
1492: if ((0x7e0000007eL & l) != 0L)
1493: jjstateSet[jjnewStateCnt++] = 94;
1494: break;
1495: case 94:
1496: if ((0x7e0000007eL & l) != 0L)
1497: jjstateSet[jjnewStateCnt++] = 95;
1498: break;
1499: case 95:
1500: if ((0x7e0000007eL & l) != 0L)
1501: jjstateSet[jjnewStateCnt++] = 96;
1502: break;
1503: case 96:
1504: if ((0x7e0000007eL & l) != 0L)
1505: jjstateSet[jjnewStateCnt++] = 97;
1506: break;
1507: case 97:
1508: if ((0x7e0000007eL & l) != 0L)
1509: jjstateSet[jjnewStateCnt++] = 98;
1510: break;
1511: case 98:
1512: if ((0x7e0000007eL & l) != 0L)
1513: jjstateSet[jjnewStateCnt++] = 99;
1514: break;
1515: case 99:
1516: case 104:
1517: if ((0x7e0000007eL & l) != 0L)
1518: jjCheckNAdd(100);
1519: break;
1520: case 100:
1521: if ((0x7e0000007eL & l) != 0L)
1522: jjCheckNAddStates(25, 27);
1523: break;
1524: case 101:
1525: if ((0x20000000200000L & l) != 0L)
1526: jjstateSet[jjnewStateCnt++] = 102;
1527: break;
1528: case 102:
1529: if ((0x7e0000007eL & l) != 0L)
1530: jjstateSet[jjnewStateCnt++] = 103;
1531: break;
1532: case 103:
1533: if ((0x7e0000007eL & l) != 0L)
1534: jjstateSet[jjnewStateCnt++] = 104;
1535: break;
1536: case 105:
1537: if ((0x7fffffe07fffffeL & l) == 0L)
1538: break;
1539: if (kind > 68)
1540: kind = 68;
1541: jjCheckNAddStates(28, 30);
1542: break;
1543: case 106:
1544: if ((0x7fffffe87fffffeL & l) != 0L)
1545: jjCheckNAddTwoStates(106, 107);
1546: break;
1547: case 108:
1548: if ((0x7fffffe87fffffeL & l) == 0L)
1549: break;
1550: if (kind > 66)
1551: kind = 66;
1552: jjstateSet[jjnewStateCnt++] = 108;
1553: break;
1554: case 109:
1555: if ((0x7fffffe87fffffeL & l) == 0L)
1556: break;
1557: if (kind > 68)
1558: kind = 68;
1559: jjCheckNAdd(109);
1560: break;
1561: case 110:
1562: if (curChar == 95)
1563: jjCheckNAddTwoStates(111, 112);
1564: break;
1565: case 111:
1566: if ((0x7fffffe87fffffeL & l) != 0L)
1567: jjCheckNAddTwoStates(111, 107);
1568: break;
1569: case 112:
1570: if ((0x7fffffe87fffffeL & l) == 0L)
1571: break;
1572: if (kind > 68)
1573: kind = 68;
1574: jjCheckNAdd(112);
1575: break;
1576: default:
1577: break;
1578: }
1579: } while (i != startsAt);
1580: } else {
1581: int hiByte = (int) (curChar >> 8);
1582: int i1 = hiByte >> 6;
1583: long l1 = 1L << (hiByte & 077);
1584: int i2 = (curChar & 0xff) >> 6;
1585: long l2 = 1L << (curChar & 077);
1586: MatchLoop: do {
1587: switch (jjstateSet[--i]) {
1588: case 0:
1589: if (!jjCanMove_2(hiByte, i1, i2, l1, l2))
1590: break;
1591: if (kind > 68)
1592: kind = 68;
1593: jjCheckNAddStates(28, 30);
1594: break;
1595: case 114:
1596: if (jjCanMove_3(hiByte, i1, i2, l1, l2))
1597: jjCheckNAddTwoStates(106, 107);
1598: if (jjCanMove_3(hiByte, i1, i2, l1, l2)) {
1599: if (kind > 68)
1600: kind = 68;
1601: jjCheckNAdd(109);
1602: }
1603: break;
1604: case 1:
1605: if (!jjCanMove_0(hiByte, i1, i2, l1, l2))
1606: break;
1607: if (kind > 5)
1608: kind = 5;
1609: jjAddStates(12, 14);
1610: break;
1611: case 7:
1612: if (jjCanMove_1(hiByte, i1, i2, l1, l2))
1613: jjAddStates(15, 16);
1614: break;
1615: case 9:
1616: if (jjCanMove_0(hiByte, i1, i2, l1, l2))
1617: jjAddStates(31, 32);
1618: break;
1619: case 12:
1620: if (!jjCanMove_2(hiByte, i1, i2, l1, l2))
1621: break;
1622: if (kind > 67)
1623: kind = 67;
1624: jjCheckNAdd(13);
1625: break;
1626: case 13:
1627: if (!jjCanMove_3(hiByte, i1, i2, l1, l2))
1628: break;
1629: if (kind > 67)
1630: kind = 67;
1631: jjCheckNAdd(13);
1632: break;
1633: case 24:
1634: if (jjCanMove_0(hiByte, i1, i2, l1, l2))
1635: jjAddStates(17, 19);
1636: break;
1637: case 49:
1638: if (jjCanMove_0(hiByte, i1, i2, l1, l2))
1639: jjAddStates(20, 22);
1640: break;
1641: case 54:
1642: if (jjCanMove_1(hiByte, i1, i2, l1, l2))
1643: jjAddStates(23, 24);
1644: break;
1645: case 56:
1646: if (jjCanMove_0(hiByte, i1, i2, l1, l2))
1647: jjAddStates(43, 44);
1648: break;
1649: case 58:
1650: if (jjCanMove_2(hiByte, i1, i2, l1, l2))
1651: jjCheckNAddTwoStates(59, 60);
1652: break;
1653: case 59:
1654: if (jjCanMove_3(hiByte, i1, i2, l1, l2))
1655: jjCheckNAddTwoStates(59, 60);
1656: break;
1657: case 61:
1658: if (!jjCanMove_3(hiByte, i1, i2, l1, l2))
1659: break;
1660: if (kind > 58)
1661: kind = 58;
1662: jjstateSet[jjnewStateCnt++] = 61;
1663: break;
1664: case 63:
1665: if (jjCanMove_3(hiByte, i1, i2, l1, l2))
1666: jjCheckNAddTwoStates(63, 60);
1667: break;
1668: case 84:
1669: if (jjCanMove_0(hiByte, i1, i2, l1, l2))
1670: jjAddStates(25, 27);
1671: break;
1672: case 106:
1673: if (jjCanMove_3(hiByte, i1, i2, l1, l2))
1674: jjCheckNAddTwoStates(106, 107);
1675: break;
1676: case 108:
1677: if (!jjCanMove_3(hiByte, i1, i2, l1, l2))
1678: break;
1679: if (kind > 66)
1680: kind = 66;
1681: jjstateSet[jjnewStateCnt++] = 108;
1682: break;
1683: case 109:
1684: if (!jjCanMove_3(hiByte, i1, i2, l1, l2))
1685: break;
1686: if (kind > 68)
1687: kind = 68;
1688: jjCheckNAdd(109);
1689: break;
1690: case 111:
1691: if (jjCanMove_3(hiByte, i1, i2, l1, l2))
1692: jjCheckNAddTwoStates(111, 107);
1693: break;
1694: case 112:
1695: if (!jjCanMove_3(hiByte, i1, i2, l1, l2))
1696: break;
1697: if (kind > 68)
1698: kind = 68;
1699: jjstateSet[jjnewStateCnt++] = 112;
1700: break;
1701: default:
1702: break;
1703: }
1704: } while (i != startsAt);
1705: }
1706: if (kind != 0x7fffffff) {
1707: jjmatchedKind = kind;
1708: jjmatchedPos = curPos;
1709: kind = 0x7fffffff;
1710: }
1711: ++curPos;
1712: if ((i = jjnewStateCnt) == (startsAt = 114 - (jjnewStateCnt = startsAt)))
1713: return curPos;
1714: try {
1715: curChar = input_stream.readChar();
1716: } catch (java.io.IOException e) {
1717: return curPos;
1718: }
1719: }
1720: }
1721:
1722: static final int[] jjnextStates = { 16, 20, 21, 24, 25, 49, 50, 84,
1723: 85, 86, 65, 30, 1, 2, 4, 7, 8, 24, 25, 30, 49, 50, 65, 54,
1724: 55, 84, 85, 86, 106, 107, 109, 9, 10, 31, 32, 33, 34, 35,
1725: 36, 45, 52, 58, 62, 56, 57, 66, 67, 68, 69, 70, 71, 80, 87,
1726: 88, 89, 90, 91, 92, 101, };
1727:
1728: private static final boolean jjCanMove_0(int hiByte, int i1,
1729: int i2, long l1, long l2) {
1730: switch (hiByte) {
1731: case 0:
1732: return ((jjbitVec2[i2] & l2) != 0L);
1733: default:
1734: if ((jjbitVec0[i1] & l1) != 0L)
1735: return true;
1736: return false;
1737: }
1738: }
1739:
1740: private static final boolean jjCanMove_1(int hiByte, int i1,
1741: int i2, long l1, long l2) {
1742: switch (hiByte) {
1743: case 6:
1744: return ((jjbitVec5[i2] & l2) != 0L);
1745: case 11:
1746: return ((jjbitVec6[i2] & l2) != 0L);
1747: case 13:
1748: return ((jjbitVec7[i2] & l2) != 0L);
1749: case 14:
1750: return ((jjbitVec8[i2] & l2) != 0L);
1751: case 15:
1752: return ((jjbitVec9[i2] & l2) != 0L);
1753: default:
1754: if ((jjbitVec3[i1] & l1) != 0L)
1755: if ((jjbitVec4[i2] & l2) == 0L)
1756: return false;
1757: else
1758: return true;
1759: return false;
1760: }
1761: }
1762:
1763: private static final boolean jjCanMove_2(int hiByte, int i1,
1764: int i2, long l1, long l2) {
1765: switch (hiByte) {
1766: case 0:
1767: return ((jjbitVec11[i2] & l2) != 0L);
1768: case 1:
1769: return ((jjbitVec12[i2] & l2) != 0L);
1770: case 2:
1771: return ((jjbitVec13[i2] & l2) != 0L);
1772: case 3:
1773: return ((jjbitVec14[i2] & l2) != 0L);
1774: case 4:
1775: return ((jjbitVec15[i2] & l2) != 0L);
1776: case 5:
1777: return ((jjbitVec16[i2] & l2) != 0L);
1778: case 6:
1779: return ((jjbitVec17[i2] & l2) != 0L);
1780: case 9:
1781: return ((jjbitVec18[i2] & l2) != 0L);
1782: case 10:
1783: return ((jjbitVec19[i2] & l2) != 0L);
1784: case 11:
1785: return ((jjbitVec20[i2] & l2) != 0L);
1786: case 12:
1787: return ((jjbitVec21[i2] & l2) != 0L);
1788: case 13:
1789: return ((jjbitVec22[i2] & l2) != 0L);
1790: case 14:
1791: return ((jjbitVec23[i2] & l2) != 0L);
1792: case 15:
1793: return ((jjbitVec24[i2] & l2) != 0L);
1794: case 16:
1795: return ((jjbitVec25[i2] & l2) != 0L);
1796: case 17:
1797: return ((jjbitVec26[i2] & l2) != 0L);
1798: case 30:
1799: return ((jjbitVec27[i2] & l2) != 0L);
1800: case 31:
1801: return ((jjbitVec28[i2] & l2) != 0L);
1802: case 33:
1803: return ((jjbitVec29[i2] & l2) != 0L);
1804: case 48:
1805: return ((jjbitVec30[i2] & l2) != 0L);
1806: case 49:
1807: return ((jjbitVec31[i2] & l2) != 0L);
1808: case 159:
1809: return ((jjbitVec32[i2] & l2) != 0L);
1810: case 215:
1811: return ((jjbitVec33[i2] & l2) != 0L);
1812: default:
1813: if ((jjbitVec10[i1] & l1) != 0L)
1814: return true;
1815: return false;
1816: }
1817: }
1818:
1819: private static final boolean jjCanMove_3(int hiByte, int i1,
1820: int i2, long l1, long l2) {
1821: switch (hiByte) {
1822: case 0:
1823: return ((jjbitVec34[i2] & l2) != 0L);
1824: case 1:
1825: return ((jjbitVec12[i2] & l2) != 0L);
1826: case 2:
1827: return ((jjbitVec35[i2] & l2) != 0L);
1828: case 3:
1829: return ((jjbitVec36[i2] & l2) != 0L);
1830: case 4:
1831: return ((jjbitVec37[i2] & l2) != 0L);
1832: case 5:
1833: return ((jjbitVec38[i2] & l2) != 0L);
1834: case 6:
1835: return ((jjbitVec39[i2] & l2) != 0L);
1836: case 9:
1837: return ((jjbitVec40[i2] & l2) != 0L);
1838: case 10:
1839: return ((jjbitVec41[i2] & l2) != 0L);
1840: case 11:
1841: return ((jjbitVec42[i2] & l2) != 0L);
1842: case 12:
1843: return ((jjbitVec43[i2] & l2) != 0L);
1844: case 13:
1845: return ((jjbitVec44[i2] & l2) != 0L);
1846: case 14:
1847: return ((jjbitVec45[i2] & l2) != 0L);
1848: case 15:
1849: return ((jjbitVec46[i2] & l2) != 0L);
1850: case 16:
1851: return ((jjbitVec25[i2] & l2) != 0L);
1852: case 17:
1853: return ((jjbitVec26[i2] & l2) != 0L);
1854: case 30:
1855: return ((jjbitVec27[i2] & l2) != 0L);
1856: case 31:
1857: return ((jjbitVec28[i2] & l2) != 0L);
1858: case 32:
1859: return ((jjbitVec47[i2] & l2) != 0L);
1860: case 33:
1861: return ((jjbitVec29[i2] & l2) != 0L);
1862: case 48:
1863: return ((jjbitVec48[i2] & l2) != 0L);
1864: case 49:
1865: return ((jjbitVec31[i2] & l2) != 0L);
1866: case 159:
1867: return ((jjbitVec32[i2] & l2) != 0L);
1868: case 215:
1869: return ((jjbitVec33[i2] & l2) != 0L);
1870: default:
1871: if ((jjbitVec10[i1] & l1) != 0L)
1872: return true;
1873: return false;
1874: }
1875: }
1876:
1877: public static final String[] jjstrLiteralImages = { "", null, null,
1878: null, null, null, "\75", "\41\75", "\74", "\74\75",
1879: "\76\75", "\76", "\52", "\54", "\73", "\173", "\175",
1880: "\50", "\51", "\133", "\135", null, null, null, null, null,
1881: null, null, null, null, null, null, null, null, null, null,
1882: null, null, null, null, null, null, null, null, null, null,
1883: null, null, null, null, null, null, null, null, null, null,
1884: null, null, null, null, null, null, null, null, null, null,
1885: null, null, null, null, null, null, null, null, null, null,
1886: null, null, null, null, null, null, null, };
1887: public static final String[] lexStateNames = { "DEFAULT", };
1888: static final long[] jjtoToken = { 0xfffffffffffffc1L, 0xfdL, };
1889: static final long[] jjtoSkip = { 0x3eL, 0x0L, };
1890: static final long[] jjtoSpecial = { 0x20L, 0x0L, };
1891: protected SimpleCharStream input_stream;
1892: private final int[] jjrounds = new int[114];
1893: private final int[] jjstateSet = new int[228];
1894: protected char curChar;
1895:
1896: public SyntaxTreeBuilderTokenManager(SimpleCharStream stream) {
1897: if (SimpleCharStream.staticFlag)
1898: throw new Error(
1899: "ERROR: Cannot use a static CharStream class with a non-static lexical analyzer.");
1900: input_stream = stream;
1901: }
1902:
1903: public SyntaxTreeBuilderTokenManager(SimpleCharStream stream,
1904: int lexState) {
1905: this (stream);
1906: SwitchTo(lexState);
1907: }
1908:
1909: public void ReInit(SimpleCharStream stream) {
1910: jjmatchedPos = jjnewStateCnt = 0;
1911: curLexState = defaultLexState;
1912: input_stream = stream;
1913: ReInitRounds();
1914: }
1915:
1916: private final void ReInitRounds() {
1917: int i;
1918: jjround = 0x80000001;
1919: for (i = 114; i-- > 0;)
1920: jjrounds[i] = 0x80000000;
1921: }
1922:
1923: public void ReInit(SimpleCharStream stream, int lexState) {
1924: ReInit(stream);
1925: SwitchTo(lexState);
1926: }
1927:
1928: public void SwitchTo(int lexState) {
1929: if (lexState >= 1 || lexState < 0)
1930: throw new TokenMgrError(
1931: "Error: Ignoring invalid lexical state : "
1932: + lexState + ". State unchanged.",
1933: TokenMgrError.INVALID_LEXICAL_STATE);
1934: else
1935: curLexState = lexState;
1936: }
1937:
1938: protected Token jjFillToken() {
1939: Token t = Token.newToken(jjmatchedKind);
1940: t.kind = jjmatchedKind;
1941: String im = jjstrLiteralImages[jjmatchedKind];
1942: t.image = (im == null) ? input_stream.GetImage() : im;
1943: t.beginLine = input_stream.getBeginLine();
1944: t.beginColumn = input_stream.getBeginColumn();
1945: t.endLine = input_stream.getEndLine();
1946: t.endColumn = input_stream.getEndColumn();
1947: return t;
1948: }
1949:
1950: int curLexState = 0;
1951: int defaultLexState = 0;
1952: int jjnewStateCnt;
1953: int jjround;
1954: int jjmatchedPos;
1955: int jjmatchedKind;
1956:
1957: public Token getNextToken() {
1958: int kind;
1959: Token specialToken = null;
1960: Token matchedToken;
1961: int curPos = 0;
1962:
1963: EOFLoop: for (;;) {
1964: try {
1965: curChar = input_stream.BeginToken();
1966: } catch (java.io.IOException e) {
1967: jjmatchedKind = 0;
1968: matchedToken = jjFillToken();
1969: matchedToken.specialToken = specialToken;
1970: return matchedToken;
1971: }
1972:
1973: try {
1974: input_stream.backup(0);
1975: while (curChar <= 32
1976: && (0x100002600L & (1L << curChar)) != 0L)
1977: curChar = input_stream.BeginToken();
1978: } catch (java.io.IOException e1) {
1979: continue EOFLoop;
1980: }
1981: jjmatchedKind = 0x7fffffff;
1982: jjmatchedPos = 0;
1983: curPos = jjMoveStringLiteralDfa0_0();
1984: if (jjmatchedKind != 0x7fffffff) {
1985: if (jjmatchedPos + 1 < curPos)
1986: input_stream.backup(curPos - jjmatchedPos - 1);
1987: if ((jjtoToken[jjmatchedKind >> 6] & (1L << (jjmatchedKind & 077))) != 0L) {
1988: matchedToken = jjFillToken();
1989: matchedToken.specialToken = specialToken;
1990: return matchedToken;
1991: } else {
1992: if ((jjtoSpecial[jjmatchedKind >> 6] & (1L << (jjmatchedKind & 077))) != 0L) {
1993: matchedToken = jjFillToken();
1994: if (specialToken == null)
1995: specialToken = matchedToken;
1996: else {
1997: matchedToken.specialToken = specialToken;
1998: specialToken = (specialToken.next = matchedToken);
1999: }
2000: }
2001: continue EOFLoop;
2002: }
2003: }
2004: int error_line = input_stream.getEndLine();
2005: int error_column = input_stream.getEndColumn();
2006: String error_after = null;
2007: boolean EOFSeen = false;
2008: try {
2009: input_stream.readChar();
2010: input_stream.backup(1);
2011: } catch (java.io.IOException e1) {
2012: EOFSeen = true;
2013: error_after = curPos <= 1 ? "" : input_stream
2014: .GetImage();
2015: if (curChar == '\n' || curChar == '\r') {
2016: error_line++;
2017: error_column = 0;
2018: } else
2019: error_column++;
2020: }
2021: if (!EOFSeen) {
2022: input_stream.backup(1);
2023: error_after = curPos <= 1 ? "" : input_stream
2024: .GetImage();
2025: }
2026: throw new TokenMgrError(EOFSeen, curLexState, error_line,
2027: error_column, error_after, curChar,
2028: TokenMgrError.LEXICAL_ERROR);
2029: }
2030: }
2031:
2032: }
|