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