0001: /*
0002: * All content copyright (c) 2003-2006 Terracotta, Inc., except as may otherwise be noted in a separate copyright notice. All rights reserved.
0003: */
0004: package com.tc.aspectwerkz.expression.ast;
0005:
0006: public class ExpressionParserTokenManager implements
0007: ExpressionParserConstants {
0008: public static java.io.PrintStream debugStream = System.out;
0009:
0010: public static void setDebugStream(java.io.PrintStream ds) {
0011: debugStream = ds;
0012: }
0013:
0014: private static final int jjStopStringLiteralDfa_5(int pos,
0015: long active0, long active1) {
0016: switch (pos) {
0017: case 0:
0018: if ((active0 & 0x7dff800L) != 0L) {
0019: jjmatchedKind = 28;
0020: return 22;
0021: }
0022: if ((active0 & 0x10L) != 0L)
0023: return 1;
0024: if ((active0 & 0x200000L) != 0L) {
0025: jjmatchedKind = 28;
0026: return 5;
0027: }
0028: return -1;
0029: case 1:
0030: if ((active0 & 0x7fff800L) != 0L) {
0031: jjmatchedKind = 28;
0032: jjmatchedPos = 1;
0033: return 22;
0034: }
0035: return -1;
0036: case 2:
0037: if ((active0 & 0x1000000L) != 0L) {
0038: jjmatchedKind = 27;
0039: jjmatchedPos = 2;
0040: return -1;
0041: }
0042: if ((active0 & 0x6fff800L) != 0L) {
0043: jjmatchedKind = 28;
0044: jjmatchedPos = 2;
0045: return 22;
0046: }
0047: return -1;
0048: case 3:
0049: if ((active0 & 0x1000000L) != 0L) {
0050: if (jjmatchedPos < 2) {
0051: jjmatchedKind = 27;
0052: jjmatchedPos = 2;
0053: }
0054: return -1;
0055: }
0056: if ((active0 & 0x6ff9800L) != 0L) {
0057: jjmatchedKind = 28;
0058: jjmatchedPos = 3;
0059: return 22;
0060: }
0061: return -1;
0062: case 4:
0063: if ((active0 & 0x65f8800L) != 0L) {
0064: jjmatchedKind = 28;
0065: jjmatchedPos = 4;
0066: return 22;
0067: }
0068: return -1;
0069: case 5:
0070: if ((active0 & 0x6578800L) != 0L) {
0071: jjmatchedKind = 28;
0072: jjmatchedPos = 5;
0073: return 22;
0074: }
0075: return -1;
0076: case 6:
0077: if ((active0 & 0x6168800L) != 0L) {
0078: jjmatchedKind = 28;
0079: jjmatchedPos = 6;
0080: return 22;
0081: }
0082: return -1;
0083: case 7:
0084: if ((active0 & 0x6160800L) != 0L) {
0085: jjmatchedKind = 28;
0086: jjmatchedPos = 7;
0087: return 22;
0088: }
0089: return -1;
0090: case 8:
0091: if ((active0 & 0x2160800L) != 0L) {
0092: jjmatchedKind = 28;
0093: jjmatchedPos = 8;
0094: return 22;
0095: }
0096: return -1;
0097: case 9:
0098: if ((active0 & 0x160000L) != 0L) {
0099: jjmatchedKind = 28;
0100: jjmatchedPos = 9;
0101: return 22;
0102: }
0103: return -1;
0104: case 10:
0105: if ((active0 & 0x40000L) != 0L) {
0106: jjmatchedKind = 28;
0107: jjmatchedPos = 10;
0108: return 22;
0109: }
0110: return -1;
0111: case 11:
0112: if ((active0 & 0x40000L) != 0L) {
0113: jjmatchedKind = 28;
0114: jjmatchedPos = 11;
0115: return 22;
0116: }
0117: return -1;
0118: case 12:
0119: if ((active0 & 0x40000L) != 0L) {
0120: jjmatchedKind = 28;
0121: jjmatchedPos = 12;
0122: return 22;
0123: }
0124: return -1;
0125: case 13:
0126: if ((active0 & 0x40000L) != 0L) {
0127: jjmatchedKind = 28;
0128: jjmatchedPos = 13;
0129: return 22;
0130: }
0131: return -1;
0132: case 14:
0133: if ((active0 & 0x40000L) != 0L) {
0134: jjmatchedKind = 28;
0135: jjmatchedPos = 14;
0136: return 22;
0137: }
0138: return -1;
0139: case 15:
0140: if ((active0 & 0x40000L) != 0L) {
0141: jjmatchedKind = 28;
0142: jjmatchedPos = 15;
0143: return 22;
0144: }
0145: return -1;
0146: case 16:
0147: if ((active0 & 0x40000L) != 0L) {
0148: jjmatchedKind = 28;
0149: jjmatchedPos = 16;
0150: return 22;
0151: }
0152: return -1;
0153: case 17:
0154: if ((active0 & 0x40000L) != 0L) {
0155: jjmatchedKind = 28;
0156: jjmatchedPos = 17;
0157: return 22;
0158: }
0159: return -1;
0160: case 18:
0161: if ((active0 & 0x40000L) != 0L) {
0162: jjmatchedKind = 28;
0163: jjmatchedPos = 18;
0164: return 22;
0165: }
0166: return -1;
0167: case 19:
0168: if ((active0 & 0x40000L) != 0L) {
0169: jjmatchedKind = 28;
0170: jjmatchedPos = 19;
0171: return 22;
0172: }
0173: return -1;
0174: default:
0175: return -1;
0176: }
0177: }
0178:
0179: private static final int jjStartNfa_5(int pos, long active0,
0180: long active1) {
0181: return jjMoveNfa_5(jjStopStringLiteralDfa_5(pos, active0,
0182: active1), pos + 1);
0183: }
0184:
0185: static private final int jjStopAtPos(int pos, int kind) {
0186: jjmatchedKind = kind;
0187: jjmatchedPos = pos;
0188: return pos + 1;
0189: }
0190:
0191: static private final int jjStartNfaWithStates_5(int pos, int kind,
0192: int state) {
0193: jjmatchedKind = kind;
0194: jjmatchedPos = pos;
0195: try {
0196: curChar = input_stream.readChar();
0197: } catch (java.io.IOException e) {
0198: return pos + 1;
0199: }
0200: return jjMoveNfa_5(state, pos + 1);
0201: }
0202:
0203: static private final int jjMoveStringLiteralDfa0_5() {
0204: switch (curChar) {
0205: case 33:
0206: return jjStopAtPos(0, 10);
0207: case 40:
0208: return jjStopAtPos(0, 86);
0209: case 41:
0210: return jjStopAtPos(0, 87);
0211: case 44:
0212: return jjStopAtPos(0, 3);
0213: case 46:
0214: return jjStartNfaWithStates_5(0, 4, 1);
0215: case 97:
0216: return jjMoveStringLiteralDfa1_5(0x200000L);
0217: case 99:
0218: return jjMoveStringLiteralDfa1_5(0x181000L);
0219: case 101:
0220: return jjMoveStringLiteralDfa1_5(0x800L);
0221: case 103:
0222: return jjMoveStringLiteralDfa1_5(0x4000L);
0223: case 104:
0224: return jjMoveStringLiteralDfa1_5(0x6008000L);
0225: case 105:
0226: return jjMoveStringLiteralDfa1_5(0x1000000L);
0227: case 115:
0228: return jjMoveStringLiteralDfa1_5(0x42000L);
0229: case 116:
0230: return jjMoveStringLiteralDfa1_5(0xc00000L);
0231: case 119:
0232: return jjMoveStringLiteralDfa1_5(0x30000L);
0233: default:
0234: return jjMoveNfa_5(0, 0);
0235: }
0236: }
0237:
0238: static private final int jjMoveStringLiteralDfa1_5(long active0) {
0239: try {
0240: curChar = input_stream.readChar();
0241: } catch (java.io.IOException e) {
0242: jjStopStringLiteralDfa_5(0, active0, 0L);
0243: return 1;
0244: }
0245: switch (curChar) {
0246: case 97:
0247: return jjMoveStringLiteralDfa2_5(active0, 0x6409000L);
0248: case 101:
0249: return jjMoveStringLiteralDfa2_5(active0, 0x6000L);
0250: case 102:
0251: return jjMoveStringLiteralDfa2_5(active0, 0x1180000L);
0252: case 104:
0253: return jjMoveStringLiteralDfa2_5(active0, 0x800000L);
0254: case 105:
0255: return jjMoveStringLiteralDfa2_5(active0, 0x30000L);
0256: case 114:
0257: return jjMoveStringLiteralDfa2_5(active0, 0x200000L);
0258: case 116:
0259: return jjMoveStringLiteralDfa2_5(active0, 0x40000L);
0260: case 120:
0261: return jjMoveStringLiteralDfa2_5(active0, 0x800L);
0262: default:
0263: break;
0264: }
0265: return jjStartNfa_5(0, active0, 0L);
0266: }
0267:
0268: static private final int jjMoveStringLiteralDfa2_5(long old0,
0269: long active0) {
0270: if (((active0 &= old0)) == 0L)
0271: return jjStartNfa_5(0, old0, 0L);
0272: try {
0273: curChar = input_stream.readChar();
0274: } catch (java.io.IOException e) {
0275: jjStopStringLiteralDfa_5(1, active0, 0L);
0276: return 2;
0277: }
0278: switch (curChar) {
0279: case 40:
0280: return jjMoveStringLiteralDfa3_5(active0, 0x1000000L);
0281: case 97:
0282: return jjMoveStringLiteralDfa3_5(active0, 0x40000L);
0283: case 101:
0284: return jjMoveStringLiteralDfa3_5(active0, 0x800L);
0285: case 103:
0286: return jjMoveStringLiteralDfa3_5(active0, 0x200000L);
0287: case 105:
0288: return jjMoveStringLiteralDfa3_5(active0, 0x800000L);
0289: case 108:
0290: return jjMoveStringLiteralDfa3_5(active0, 0x181000L);
0291: case 110:
0292: return jjMoveStringLiteralDfa3_5(active0, 0x8000L);
0293: case 114:
0294: return jjMoveStringLiteralDfa3_5(active0, 0x400000L);
0295: case 115:
0296: return jjMoveStringLiteralDfa3_5(active0, 0x6000000L);
0297: case 116:
0298: return jjMoveStringLiteralDfa3_5(active0, 0x36000L);
0299: default:
0300: break;
0301: }
0302: return jjStartNfa_5(1, active0, 0L);
0303: }
0304:
0305: static private final int jjMoveStringLiteralDfa3_5(long old0,
0306: long active0) {
0307: if (((active0 &= old0)) == 0L)
0308: return jjStartNfa_5(1, old0, 0L);
0309: try {
0310: curChar = input_stream.readChar();
0311: } catch (java.io.IOException e) {
0312: jjStopStringLiteralDfa_5(2, active0, 0L);
0313: return 3;
0314: }
0315: switch (curChar) {
0316: case 40:
0317: if ((active0 & 0x2000L) != 0L)
0318: return jjStopAtPos(3, 13);
0319: else if ((active0 & 0x4000L) != 0L)
0320: return jjStopAtPos(3, 14);
0321: break;
0322: case 41:
0323: if ((active0 & 0x1000000L) != 0L)
0324: return jjStopAtPos(3, 24);
0325: break;
0326: case 99:
0327: return jjMoveStringLiteralDfa4_5(active0, 0x800L);
0328: case 100:
0329: return jjMoveStringLiteralDfa4_5(active0, 0x8000L);
0330: case 102:
0331: return jjMoveStringLiteralDfa4_5(active0, 0x4000000L);
0332: case 103:
0333: return jjMoveStringLiteralDfa4_5(active0, 0x400000L);
0334: case 104:
0335: return jjMoveStringLiteralDfa4_5(active0, 0x30000L);
0336: case 108:
0337: return jjMoveStringLiteralDfa4_5(active0, 0x1000L);
0338: case 109:
0339: return jjMoveStringLiteralDfa4_5(active0, 0x2000000L);
0340: case 111:
0341: return jjMoveStringLiteralDfa4_5(active0, 0x180000L);
0342: case 115:
0343: return jjMoveStringLiteralDfa4_5(active0, 0xa00000L);
0344: case 116:
0345: return jjMoveStringLiteralDfa4_5(active0, 0x40000L);
0346: default:
0347: break;
0348: }
0349: return jjStartNfa_5(2, active0, 0L);
0350: }
0351:
0352: static private final int jjMoveStringLiteralDfa4_5(long old0,
0353: long active0) {
0354: if (((active0 &= old0)) == 0L)
0355: return jjStartNfa_5(2, old0, 0L);
0356: try {
0357: curChar = input_stream.readChar();
0358: } catch (java.io.IOException e) {
0359: jjStopStringLiteralDfa_5(3, active0, 0L);
0360: return 4;
0361: }
0362: switch (curChar) {
0363: case 40:
0364: if ((active0 & 0x1000L) != 0L)
0365: return jjStopAtPos(4, 12);
0366: else if ((active0 & 0x200000L) != 0L)
0367: return jjStopAtPos(4, 21);
0368: else if ((active0 & 0x800000L) != 0L)
0369: return jjStopAtPos(4, 23);
0370: break;
0371: case 101:
0372: return jjMoveStringLiteralDfa5_5(active0, 0x2400000L);
0373: case 105:
0374: return jjMoveStringLiteralDfa5_5(active0, 0x4070000L);
0375: case 108:
0376: return jjMoveStringLiteralDfa5_5(active0, 0x8000L);
0377: case 117:
0378: return jjMoveStringLiteralDfa5_5(active0, 0x800L);
0379: case 119:
0380: return jjMoveStringLiteralDfa5_5(active0, 0x180000L);
0381: default:
0382: break;
0383: }
0384: return jjStartNfa_5(3, active0, 0L);
0385: }
0386:
0387: static private final int jjMoveStringLiteralDfa5_5(long old0,
0388: long active0) {
0389: if (((active0 &= old0)) == 0L)
0390: return jjStartNfa_5(3, old0, 0L);
0391: try {
0392: curChar = input_stream.readChar();
0393: } catch (java.io.IOException e) {
0394: jjStopStringLiteralDfa_5(4, active0, 0L);
0395: return 5;
0396: }
0397: switch (curChar) {
0398: case 40:
0399: if ((active0 & 0x80000L) != 0L)
0400: return jjStopAtPos(5, 19);
0401: break;
0402: case 98:
0403: return jjMoveStringLiteralDfa6_5(active0, 0x100000L);
0404: case 99:
0405: return jjMoveStringLiteralDfa6_5(active0, 0x40000L);
0406: case 101:
0407: return jjMoveStringLiteralDfa6_5(active0, 0x4008000L);
0408: case 110:
0409: return jjMoveStringLiteralDfa6_5(active0, 0x30000L);
0410: case 116:
0411: return jjMoveStringLiteralDfa6_5(active0, 0x2400800L);
0412: default:
0413: break;
0414: }
0415: return jjStartNfa_5(4, active0, 0L);
0416: }
0417:
0418: static private final int jjMoveStringLiteralDfa6_5(long old0,
0419: long active0) {
0420: if (((active0 &= old0)) == 0L)
0421: return jjStartNfa_5(4, old0, 0L);
0422: try {
0423: curChar = input_stream.readChar();
0424: } catch (java.io.IOException e) {
0425: jjStopStringLiteralDfa_5(5, active0, 0L);
0426: return 6;
0427: }
0428: switch (curChar) {
0429: case 40:
0430: if ((active0 & 0x10000L) != 0L)
0431: return jjStopAtPos(6, 16);
0432: else if ((active0 & 0x400000L) != 0L)
0433: return jjStopAtPos(6, 22);
0434: break;
0435: case 99:
0436: return jjMoveStringLiteralDfa7_5(active0, 0x20000L);
0437: case 101:
0438: return jjMoveStringLiteralDfa7_5(active0, 0x100000L);
0439: case 104:
0440: return jjMoveStringLiteralDfa7_5(active0, 0x2000000L);
0441: case 105:
0442: return jjMoveStringLiteralDfa7_5(active0, 0x40800L);
0443: case 108:
0444: return jjMoveStringLiteralDfa7_5(active0, 0x4000000L);
0445: case 114:
0446: return jjMoveStringLiteralDfa7_5(active0, 0x8000L);
0447: default:
0448: break;
0449: }
0450: return jjStartNfa_5(5, active0, 0L);
0451: }
0452:
0453: static private final int jjMoveStringLiteralDfa7_5(long old0,
0454: long active0) {
0455: if (((active0 &= old0)) == 0L)
0456: return jjStartNfa_5(5, old0, 0L);
0457: try {
0458: curChar = input_stream.readChar();
0459: } catch (java.io.IOException e) {
0460: jjStopStringLiteralDfa_5(6, active0, 0L);
0461: return 7;
0462: }
0463: switch (curChar) {
0464: case 40:
0465: if ((active0 & 0x8000L) != 0L)
0466: return jjStopAtPos(7, 15);
0467: break;
0468: case 100:
0469: return jjMoveStringLiteralDfa8_5(active0, 0x4000000L);
0470: case 108:
0471: return jjMoveStringLiteralDfa8_5(active0, 0x100000L);
0472: case 110:
0473: return jjMoveStringLiteralDfa8_5(active0, 0x40000L);
0474: case 111:
0475: return jjMoveStringLiteralDfa8_5(active0, 0x2020800L);
0476: default:
0477: break;
0478: }
0479: return jjStartNfa_5(6, active0, 0L);
0480: }
0481:
0482: static private final int jjMoveStringLiteralDfa8_5(long old0,
0483: long active0) {
0484: if (((active0 &= old0)) == 0L)
0485: return jjStartNfa_5(6, old0, 0L);
0486: try {
0487: curChar = input_stream.readChar();
0488: } catch (java.io.IOException e) {
0489: jjStopStringLiteralDfa_5(7, active0, 0L);
0490: return 8;
0491: }
0492: switch (curChar) {
0493: case 40:
0494: if ((active0 & 0x4000000L) != 0L)
0495: return jjStopAtPos(8, 26);
0496: break;
0497: case 100:
0498: return jjMoveStringLiteralDfa9_5(active0, 0x2020000L);
0499: case 105:
0500: return jjMoveStringLiteralDfa9_5(active0, 0x40000L);
0501: case 110:
0502: return jjMoveStringLiteralDfa9_5(active0, 0x800L);
0503: case 111:
0504: return jjMoveStringLiteralDfa9_5(active0, 0x100000L);
0505: default:
0506: break;
0507: }
0508: return jjStartNfa_5(7, active0, 0L);
0509: }
0510:
0511: static private final int jjMoveStringLiteralDfa9_5(long old0,
0512: long active0) {
0513: if (((active0 &= old0)) == 0L)
0514: return jjStartNfa_5(7, old0, 0L);
0515: try {
0516: curChar = input_stream.readChar();
0517: } catch (java.io.IOException e) {
0518: jjStopStringLiteralDfa_5(8, active0, 0L);
0519: return 9;
0520: }
0521: switch (curChar) {
0522: case 40:
0523: if ((active0 & 0x800L) != 0L)
0524: return jjStopAtPos(9, 11);
0525: else if ((active0 & 0x2000000L) != 0L)
0526: return jjStopAtPos(9, 25);
0527: break;
0528: case 101:
0529: return jjMoveStringLiteralDfa10_5(active0, 0x20000L);
0530: case 116:
0531: return jjMoveStringLiteralDfa10_5(active0, 0x40000L);
0532: case 119:
0533: return jjMoveStringLiteralDfa10_5(active0, 0x100000L);
0534: default:
0535: break;
0536: }
0537: return jjStartNfa_5(8, active0, 0L);
0538: }
0539:
0540: static private final int jjMoveStringLiteralDfa10_5(long old0,
0541: long active0) {
0542: if (((active0 &= old0)) == 0L)
0543: return jjStartNfa_5(8, old0, 0L);
0544: try {
0545: curChar = input_stream.readChar();
0546: } catch (java.io.IOException e) {
0547: jjStopStringLiteralDfa_5(9, active0, 0L);
0548: return 10;
0549: }
0550: switch (curChar) {
0551: case 40:
0552: if ((active0 & 0x20000L) != 0L)
0553: return jjStopAtPos(10, 17);
0554: else if ((active0 & 0x100000L) != 0L)
0555: return jjStopAtPos(10, 20);
0556: break;
0557: case 105:
0558: return jjMoveStringLiteralDfa11_5(active0, 0x40000L);
0559: default:
0560: break;
0561: }
0562: return jjStartNfa_5(9, active0, 0L);
0563: }
0564:
0565: static private final int jjMoveStringLiteralDfa11_5(long old0,
0566: long active0) {
0567: if (((active0 &= old0)) == 0L)
0568: return jjStartNfa_5(9, old0, 0L);
0569: try {
0570: curChar = input_stream.readChar();
0571: } catch (java.io.IOException e) {
0572: jjStopStringLiteralDfa_5(10, active0, 0L);
0573: return 11;
0574: }
0575: switch (curChar) {
0576: case 97:
0577: return jjMoveStringLiteralDfa12_5(active0, 0x40000L);
0578: default:
0579: break;
0580: }
0581: return jjStartNfa_5(10, active0, 0L);
0582: }
0583:
0584: static private final int jjMoveStringLiteralDfa12_5(long old0,
0585: long active0) {
0586: if (((active0 &= old0)) == 0L)
0587: return jjStartNfa_5(10, old0, 0L);
0588: try {
0589: curChar = input_stream.readChar();
0590: } catch (java.io.IOException e) {
0591: jjStopStringLiteralDfa_5(11, active0, 0L);
0592: return 12;
0593: }
0594: switch (curChar) {
0595: case 108:
0596: return jjMoveStringLiteralDfa13_5(active0, 0x40000L);
0597: default:
0598: break;
0599: }
0600: return jjStartNfa_5(11, active0, 0L);
0601: }
0602:
0603: static private final int jjMoveStringLiteralDfa13_5(long old0,
0604: long active0) {
0605: if (((active0 &= old0)) == 0L)
0606: return jjStartNfa_5(11, old0, 0L);
0607: try {
0608: curChar = input_stream.readChar();
0609: } catch (java.io.IOException e) {
0610: jjStopStringLiteralDfa_5(12, active0, 0L);
0611: return 13;
0612: }
0613: switch (curChar) {
0614: case 105:
0615: return jjMoveStringLiteralDfa14_5(active0, 0x40000L);
0616: default:
0617: break;
0618: }
0619: return jjStartNfa_5(12, active0, 0L);
0620: }
0621:
0622: static private final int jjMoveStringLiteralDfa14_5(long old0,
0623: long active0) {
0624: if (((active0 &= old0)) == 0L)
0625: return jjStartNfa_5(12, old0, 0L);
0626: try {
0627: curChar = input_stream.readChar();
0628: } catch (java.io.IOException e) {
0629: jjStopStringLiteralDfa_5(13, active0, 0L);
0630: return 14;
0631: }
0632: switch (curChar) {
0633: case 122:
0634: return jjMoveStringLiteralDfa15_5(active0, 0x40000L);
0635: default:
0636: break;
0637: }
0638: return jjStartNfa_5(13, active0, 0L);
0639: }
0640:
0641: static private final int jjMoveStringLiteralDfa15_5(long old0,
0642: long active0) {
0643: if (((active0 &= old0)) == 0L)
0644: return jjStartNfa_5(13, old0, 0L);
0645: try {
0646: curChar = input_stream.readChar();
0647: } catch (java.io.IOException e) {
0648: jjStopStringLiteralDfa_5(14, active0, 0L);
0649: return 15;
0650: }
0651: switch (curChar) {
0652: case 97:
0653: return jjMoveStringLiteralDfa16_5(active0, 0x40000L);
0654: default:
0655: break;
0656: }
0657: return jjStartNfa_5(14, active0, 0L);
0658: }
0659:
0660: static private final int jjMoveStringLiteralDfa16_5(long old0,
0661: long active0) {
0662: if (((active0 &= old0)) == 0L)
0663: return jjStartNfa_5(14, old0, 0L);
0664: try {
0665: curChar = input_stream.readChar();
0666: } catch (java.io.IOException e) {
0667: jjStopStringLiteralDfa_5(15, active0, 0L);
0668: return 16;
0669: }
0670: switch (curChar) {
0671: case 116:
0672: return jjMoveStringLiteralDfa17_5(active0, 0x40000L);
0673: default:
0674: break;
0675: }
0676: return jjStartNfa_5(15, active0, 0L);
0677: }
0678:
0679: static private final int jjMoveStringLiteralDfa17_5(long old0,
0680: long active0) {
0681: if (((active0 &= old0)) == 0L)
0682: return jjStartNfa_5(15, old0, 0L);
0683: try {
0684: curChar = input_stream.readChar();
0685: } catch (java.io.IOException e) {
0686: jjStopStringLiteralDfa_5(16, active0, 0L);
0687: return 17;
0688: }
0689: switch (curChar) {
0690: case 105:
0691: return jjMoveStringLiteralDfa18_5(active0, 0x40000L);
0692: default:
0693: break;
0694: }
0695: return jjStartNfa_5(16, active0, 0L);
0696: }
0697:
0698: static private final int jjMoveStringLiteralDfa18_5(long old0,
0699: long active0) {
0700: if (((active0 &= old0)) == 0L)
0701: return jjStartNfa_5(16, old0, 0L);
0702: try {
0703: curChar = input_stream.readChar();
0704: } catch (java.io.IOException e) {
0705: jjStopStringLiteralDfa_5(17, active0, 0L);
0706: return 18;
0707: }
0708: switch (curChar) {
0709: case 111:
0710: return jjMoveStringLiteralDfa19_5(active0, 0x40000L);
0711: default:
0712: break;
0713: }
0714: return jjStartNfa_5(17, active0, 0L);
0715: }
0716:
0717: static private final int jjMoveStringLiteralDfa19_5(long old0,
0718: long active0) {
0719: if (((active0 &= old0)) == 0L)
0720: return jjStartNfa_5(17, old0, 0L);
0721: try {
0722: curChar = input_stream.readChar();
0723: } catch (java.io.IOException e) {
0724: jjStopStringLiteralDfa_5(18, active0, 0L);
0725: return 19;
0726: }
0727: switch (curChar) {
0728: case 110:
0729: return jjMoveStringLiteralDfa20_5(active0, 0x40000L);
0730: default:
0731: break;
0732: }
0733: return jjStartNfa_5(18, active0, 0L);
0734: }
0735:
0736: static private final int jjMoveStringLiteralDfa20_5(long old0,
0737: long active0) {
0738: if (((active0 &= old0)) == 0L)
0739: return jjStartNfa_5(18, old0, 0L);
0740: try {
0741: curChar = input_stream.readChar();
0742: } catch (java.io.IOException e) {
0743: jjStopStringLiteralDfa_5(19, active0, 0L);
0744: return 20;
0745: }
0746: switch (curChar) {
0747: case 40:
0748: if ((active0 & 0x40000L) != 0L)
0749: return jjStopAtPos(20, 18);
0750: break;
0751: default:
0752: break;
0753: }
0754: return jjStartNfa_5(19, active0, 0L);
0755: }
0756:
0757: static private final void jjCheckNAdd(int state) {
0758: if (jjrounds[state] != jjround) {
0759: jjstateSet[jjnewStateCnt++] = state;
0760: jjrounds[state] = jjround;
0761: }
0762: }
0763:
0764: static private final void jjAddStates(int start, int end) {
0765: do {
0766: jjstateSet[jjnewStateCnt++] = jjnextStates[start];
0767: } while (start++ != end);
0768: }
0769:
0770: static private final void jjCheckNAddTwoStates(int state1,
0771: int state2) {
0772: jjCheckNAdd(state1);
0773: jjCheckNAdd(state2);
0774: }
0775:
0776: static private final void jjCheckNAddStates(int start, int end) {
0777: do {
0778: jjCheckNAdd(jjnextStates[start]);
0779: } while (start++ != end);
0780: }
0781:
0782: static private final void jjCheckNAddStates(int start) {
0783: jjCheckNAdd(jjnextStates[start]);
0784: jjCheckNAdd(jjnextStates[start + 1]);
0785: }
0786:
0787: static private final int jjMoveNfa_5(int startState, int curPos) {
0788: int[] nextStates;
0789: int startsAt = 0;
0790: jjnewStateCnt = 22;
0791: int i = 1;
0792: jjstateSet[0] = startState;
0793: int j, kind = 0x7fffffff;
0794: for (;;) {
0795: if (++jjround == 0x7fffffff)
0796: ReInitRounds();
0797: if (curChar < 64) {
0798: long l = 1L << curChar;
0799: MatchLoop: do {
0800: switch (jjstateSet[--i]) {
0801: case 5:
0802: if ((0x3ff401000000000L & l) != 0L) {
0803: if (kind > 28)
0804: kind = 28;
0805: jjCheckNAdd(21);
0806: } else if (curChar == 40) {
0807: if (kind > 27)
0808: kind = 27;
0809: }
0810: if ((0x3ff401000000000L & l) != 0L)
0811: jjCheckNAddTwoStates(19, 20);
0812: break;
0813: case 22:
0814: if ((0x3ff401000000000L & l) != 0L) {
0815: if (kind > 28)
0816: kind = 28;
0817: jjCheckNAdd(21);
0818: } else if (curChar == 40) {
0819: if (kind > 27)
0820: kind = 27;
0821: }
0822: if ((0x3ff401000000000L & l) != 0L)
0823: jjCheckNAddTwoStates(19, 20);
0824: break;
0825: case 1:
0826: if ((0x3ff401000000000L & l) != 0L) {
0827: if (kind > 28)
0828: kind = 28;
0829: jjCheckNAdd(21);
0830: } else if (curChar == 40) {
0831: if (kind > 27)
0832: kind = 27;
0833: }
0834: if ((0x3ff401000000000L & l) != 0L)
0835: jjCheckNAddTwoStates(19, 20);
0836: if (curChar == 46) {
0837: if (kind > 7)
0838: kind = 7;
0839: }
0840: break;
0841: case 0:
0842: if ((0x3ff401000000000L & l) != 0L) {
0843: if (kind > 28)
0844: kind = 28;
0845: jjCheckNAddStates(0, 2);
0846: } else if (curChar == 38) {
0847: if (kind > 8)
0848: kind = 8;
0849: }
0850: if (curChar == 38)
0851: jjstateSet[jjnewStateCnt++] = 2;
0852: else if (curChar == 46)
0853: jjstateSet[jjnewStateCnt++] = 1;
0854: break;
0855: case 2:
0856: if (curChar == 38 && kind > 8)
0857: kind = 8;
0858: break;
0859: case 3:
0860: if (curChar == 38)
0861: jjstateSet[jjnewStateCnt++] = 2;
0862: break;
0863: case 10:
0864: if (curChar == 38 && kind > 8)
0865: kind = 8;
0866: break;
0867: case 18:
0868: if ((0x3ff401000000000L & l) == 0L)
0869: break;
0870: if (kind > 28)
0871: kind = 28;
0872: jjCheckNAddStates(0, 2);
0873: break;
0874: case 19:
0875: if ((0x3ff401000000000L & l) != 0L)
0876: jjCheckNAddTwoStates(19, 20);
0877: break;
0878: case 20:
0879: if (curChar == 40)
0880: kind = 27;
0881: break;
0882: case 21:
0883: if ((0x3ff401000000000L & l) == 0L)
0884: break;
0885: if (kind > 28)
0886: kind = 28;
0887: jjCheckNAdd(21);
0888: break;
0889: default:
0890: break;
0891: }
0892: } while (i != startsAt);
0893: } else if (curChar < 128) {
0894: long l = 1L << (curChar & 077);
0895: MatchLoop: do {
0896: switch (jjstateSet[--i]) {
0897: case 5:
0898: if ((0x7fffffe87fffffeL & l) != 0L) {
0899: if (kind > 28)
0900: kind = 28;
0901: jjCheckNAdd(21);
0902: }
0903: if ((0x7fffffe87fffffeL & l) != 0L)
0904: jjCheckNAddTwoStates(19, 20);
0905: if (curChar == 110)
0906: jjstateSet[jjnewStateCnt++] = 4;
0907: break;
0908: case 22:
0909: if ((0x7fffffe87fffffeL & l) != 0L) {
0910: if (kind > 28)
0911: kind = 28;
0912: jjCheckNAdd(21);
0913: }
0914: if ((0x7fffffe87fffffeL & l) != 0L)
0915: jjCheckNAddTwoStates(19, 20);
0916: break;
0917: case 1:
0918: if ((0x7fffffe87fffffeL & l) != 0L) {
0919: if (kind > 28)
0920: kind = 28;
0921: jjCheckNAdd(21);
0922: }
0923: if ((0x7fffffe87fffffeL & l) != 0L)
0924: jjCheckNAddTwoStates(19, 20);
0925: break;
0926: case 0:
0927: if ((0x7fffffe87fffffeL & l) != 0L) {
0928: if (kind > 28)
0929: kind = 28;
0930: jjCheckNAddStates(0, 2);
0931: } else if (curChar == 124) {
0932: if (kind > 9)
0933: kind = 9;
0934: }
0935: if (curChar == 79)
0936: jjstateSet[jjnewStateCnt++] = 15;
0937: else if (curChar == 111)
0938: jjstateSet[jjnewStateCnt++] = 13;
0939: else if (curChar == 124)
0940: jjstateSet[jjnewStateCnt++] = 11;
0941: else if (curChar == 65)
0942: jjstateSet[jjnewStateCnt++] = 8;
0943: else if (curChar == 97)
0944: jjstateSet[jjnewStateCnt++] = 5;
0945: break;
0946: case 4:
0947: if (curChar == 100 && kind > 8)
0948: kind = 8;
0949: break;
0950: case 6:
0951: if (curChar == 97)
0952: jjstateSet[jjnewStateCnt++] = 5;
0953: break;
0954: case 7:
0955: if (curChar == 68 && kind > 8)
0956: kind = 8;
0957: break;
0958: case 8:
0959: if (curChar == 78)
0960: jjstateSet[jjnewStateCnt++] = 7;
0961: break;
0962: case 9:
0963: if (curChar == 65)
0964: jjstateSet[jjnewStateCnt++] = 8;
0965: break;
0966: case 11:
0967: if (curChar == 124 && kind > 9)
0968: kind = 9;
0969: break;
0970: case 12:
0971: if (curChar == 124)
0972: jjstateSet[jjnewStateCnt++] = 11;
0973: break;
0974: case 13:
0975: if (curChar == 114 && kind > 9)
0976: kind = 9;
0977: break;
0978: case 14:
0979: if (curChar == 111)
0980: jjstateSet[jjnewStateCnt++] = 13;
0981: break;
0982: case 15:
0983: if (curChar == 82 && kind > 9)
0984: kind = 9;
0985: break;
0986: case 16:
0987: if (curChar == 79)
0988: jjstateSet[jjnewStateCnt++] = 15;
0989: break;
0990: case 17:
0991: if (curChar == 124 && kind > 9)
0992: kind = 9;
0993: break;
0994: case 18:
0995: if ((0x7fffffe87fffffeL & l) == 0L)
0996: break;
0997: if (kind > 28)
0998: kind = 28;
0999: jjCheckNAddStates(0, 2);
1000: break;
1001: case 19:
1002: if ((0x7fffffe87fffffeL & l) != 0L)
1003: jjCheckNAddTwoStates(19, 20);
1004: break;
1005: case 21:
1006: if ((0x7fffffe87fffffeL & l) == 0L)
1007: break;
1008: if (kind > 28)
1009: kind = 28;
1010: jjCheckNAdd(21);
1011: break;
1012: default:
1013: break;
1014: }
1015: } while (i != startsAt);
1016: } else {
1017: int i2 = (curChar & 0xff) >> 6;
1018: long l2 = 1L << (curChar & 077);
1019: MatchLoop: do {
1020: switch (jjstateSet[--i]) {
1021: default:
1022: break;
1023: }
1024: } while (i != startsAt);
1025: }
1026: if (kind != 0x7fffffff) {
1027: jjmatchedKind = kind;
1028: jjmatchedPos = curPos;
1029: kind = 0x7fffffff;
1030: }
1031: ++curPos;
1032: if ((i = jjnewStateCnt) == (startsAt = 22 - (jjnewStateCnt = startsAt)))
1033: return curPos;
1034: try {
1035: curChar = input_stream.readChar();
1036: } catch (java.io.IOException e) {
1037: return curPos;
1038: }
1039: }
1040: }
1041:
1042: private static final int jjStopStringLiteralDfa_0(int pos,
1043: long active0, long active1) {
1044: switch (pos) {
1045: default:
1046: return -1;
1047: }
1048: }
1049:
1050: private static final int jjStartNfa_0(int pos, long active0,
1051: long active1) {
1052: return jjMoveNfa_0(jjStopStringLiteralDfa_0(pos, active0,
1053: active1), pos + 1);
1054: }
1055:
1056: static private final int jjStartNfaWithStates_0(int pos, int kind,
1057: int state) {
1058: jjmatchedKind = kind;
1059: jjmatchedPos = pos;
1060: try {
1061: curChar = input_stream.readChar();
1062: } catch (java.io.IOException e) {
1063: return pos + 1;
1064: }
1065: return jjMoveNfa_0(state, pos + 1);
1066: }
1067:
1068: static private final int jjMoveStringLiteralDfa0_0() {
1069: switch (curChar) {
1070: case 41:
1071: return jjStopAtPos(0, 85);
1072: case 44:
1073: return jjStopAtPos(0, 3);
1074: case 46:
1075: return jjStartNfaWithStates_0(0, 4, 1);
1076: default:
1077: return jjMoveNfa_0(0, 0);
1078: }
1079: }
1080:
1081: static private final int jjMoveNfa_0(int startState, int curPos) {
1082: int[] nextStates;
1083: int startsAt = 0;
1084: jjnewStateCnt = 11;
1085: int i = 1;
1086: jjstateSet[0] = startState;
1087: int j, kind = 0x7fffffff;
1088: for (;;) {
1089: if (++jjround == 0x7fffffff)
1090: ReInitRounds();
1091: if (curChar < 64) {
1092: long l = 1L << curChar;
1093: MatchLoop: do {
1094: switch (jjstateSet[--i]) {
1095: case 0:
1096: if ((0x3ff081800000000L & l) != 0L) {
1097: if (kind > 82)
1098: kind = 82;
1099: jjCheckNAddStates(3, 7);
1100: } else if (curChar == 46)
1101: jjstateSet[jjnewStateCnt++] = 1;
1102: break;
1103: case 1:
1104: if (curChar == 46 && kind > 7)
1105: kind = 7;
1106: break;
1107: case 2:
1108: if ((0x3ff081800000000L & l) == 0L)
1109: break;
1110: if (kind > 82)
1111: kind = 82;
1112: jjCheckNAddStates(3, 7);
1113: break;
1114: case 3:
1115: if ((0x3ff081800000000L & l) == 0L)
1116: break;
1117: if (kind > 82)
1118: kind = 82;
1119: jjCheckNAddTwoStates(3, 4);
1120: break;
1121: case 4:
1122: if (curChar == 46)
1123: jjCheckNAdd(5);
1124: break;
1125: case 5:
1126: if ((0x3ff081800000000L & l) == 0L)
1127: break;
1128: if (kind > 82)
1129: kind = 82;
1130: jjCheckNAddTwoStates(4, 5);
1131: break;
1132: case 6:
1133: if ((0x3ff081800000000L & l) == 0L)
1134: break;
1135: if (kind > 83)
1136: kind = 83;
1137: jjCheckNAddStates(8, 10);
1138: break;
1139: case 7:
1140: if (curChar == 46)
1141: jjCheckNAdd(8);
1142: break;
1143: case 8:
1144: if ((0x3ff081800000000L & l) == 0L)
1145: break;
1146: if (kind > 83)
1147: kind = 83;
1148: jjCheckNAddStates(11, 13);
1149: break;
1150: default:
1151: break;
1152: }
1153: } while (i != startsAt);
1154: } else if (curChar < 128) {
1155: long l = 1L << (curChar & 077);
1156: MatchLoop: do {
1157: switch (jjstateSet[--i]) {
1158: case 0:
1159: if ((0x7fffffe87fffffeL & l) == 0L)
1160: break;
1161: if (kind > 82)
1162: kind = 82;
1163: jjCheckNAddStates(3, 7);
1164: break;
1165: case 3:
1166: if ((0x7fffffe87fffffeL & l) == 0L)
1167: break;
1168: if (kind > 82)
1169: kind = 82;
1170: jjCheckNAddTwoStates(3, 4);
1171: break;
1172: case 5:
1173: if ((0x7fffffe87fffffeL & l) == 0L)
1174: break;
1175: if (kind > 82)
1176: kind = 82;
1177: jjCheckNAddTwoStates(4, 5);
1178: break;
1179: case 6:
1180: if ((0x7fffffe87fffffeL & l) == 0L)
1181: break;
1182: if (kind > 83)
1183: kind = 83;
1184: jjCheckNAddStates(8, 10);
1185: break;
1186: case 8:
1187: if ((0x7fffffe87fffffeL & l) == 0L)
1188: break;
1189: if (kind > 83)
1190: kind = 83;
1191: jjCheckNAddStates(11, 13);
1192: break;
1193: case 9:
1194: if (curChar != 93)
1195: break;
1196: kind = 83;
1197: jjCheckNAdd(10);
1198: break;
1199: case 10:
1200: if (curChar == 91)
1201: jjstateSet[jjnewStateCnt++] = 9;
1202: break;
1203: default:
1204: break;
1205: }
1206: } while (i != startsAt);
1207: } else {
1208: int i2 = (curChar & 0xff) >> 6;
1209: long l2 = 1L << (curChar & 077);
1210: MatchLoop: do {
1211: switch (jjstateSet[--i]) {
1212: default:
1213: break;
1214: }
1215: } while (i != startsAt);
1216: }
1217: if (kind != 0x7fffffff) {
1218: jjmatchedKind = kind;
1219: jjmatchedPos = curPos;
1220: kind = 0x7fffffff;
1221: }
1222: ++curPos;
1223: if ((i = jjnewStateCnt) == (startsAt = 11 - (jjnewStateCnt = startsAt)))
1224: return curPos;
1225: try {
1226: curChar = input_stream.readChar();
1227: } catch (java.io.IOException e) {
1228: return curPos;
1229: }
1230: }
1231: }
1232:
1233: private static final int jjStopStringLiteralDfa_4(int pos,
1234: long active0) {
1235: switch (pos) {
1236: case 0:
1237: if ((active0 & 0x10L) != 0L)
1238: return 12;
1239: if ((active0 & 0x7e0000000L) != 0L) {
1240: jjmatchedKind = 37;
1241: return 13;
1242: }
1243: return -1;
1244: case 1:
1245: if ((active0 & 0x7e0000000L) != 0L) {
1246: jjmatchedKind = 37;
1247: jjmatchedPos = 1;
1248: return 13;
1249: }
1250: return -1;
1251: case 2:
1252: if ((active0 & 0x7e0000000L) != 0L) {
1253: jjmatchedKind = 37;
1254: jjmatchedPos = 2;
1255: return 13;
1256: }
1257: return -1;
1258: case 3:
1259: if ((active0 & 0x7e0000000L) != 0L) {
1260: jjmatchedKind = 37;
1261: jjmatchedPos = 3;
1262: return 13;
1263: }
1264: return -1;
1265: case 4:
1266: if ((active0 & 0x3e0000000L) != 0L) {
1267: jjmatchedKind = 37;
1268: jjmatchedPos = 4;
1269: return 13;
1270: }
1271: if ((active0 & 0x400000000L) != 0L)
1272: return 13;
1273: return -1;
1274: case 5:
1275: if ((active0 & 0x180000000L) != 0L)
1276: return 13;
1277: if ((active0 & 0x260000000L) != 0L) {
1278: jjmatchedKind = 37;
1279: jjmatchedPos = 5;
1280: return 13;
1281: }
1282: return -1;
1283: case 6:
1284: if ((active0 & 0x240000000L) != 0L) {
1285: jjmatchedKind = 37;
1286: jjmatchedPos = 6;
1287: return 13;
1288: }
1289: if ((active0 & 0x20000000L) != 0L)
1290: return 13;
1291: return -1;
1292: case 7:
1293: if ((active0 & 0x200000000L) != 0L)
1294: return 13;
1295: if ((active0 & 0x40000000L) != 0L) {
1296: jjmatchedKind = 37;
1297: jjmatchedPos = 7;
1298: return 13;
1299: }
1300: return -1;
1301: default:
1302: return -1;
1303: }
1304: }
1305:
1306: private static final int jjStartNfa_4(int pos, long active0) {
1307: return jjMoveNfa_4(jjStopStringLiteralDfa_4(pos, active0),
1308: pos + 1);
1309: }
1310:
1311: static private final int jjStartNfaWithStates_4(int pos, int kind,
1312: int state) {
1313: jjmatchedKind = kind;
1314: jjmatchedPos = pos;
1315: try {
1316: curChar = input_stream.readChar();
1317: } catch (java.io.IOException e) {
1318: return pos + 1;
1319: }
1320: return jjMoveNfa_4(state, pos + 1);
1321: }
1322:
1323: static private final int jjMoveStringLiteralDfa0_4() {
1324: switch (curChar) {
1325: case 33:
1326: return jjStopAtPos(0, 35);
1327: case 41:
1328: return jjStopAtPos(0, 41);
1329: case 44:
1330: return jjStopAtPos(0, 3);
1331: case 46:
1332: return jjStartNfaWithStates_4(0, 4, 12);
1333: case 97:
1334: return jjMoveStringLiteralDfa1_4(0x200000000L);
1335: case 102:
1336: return jjMoveStringLiteralDfa1_4(0x400000000L);
1337: case 112:
1338: return jjMoveStringLiteralDfa1_4(0xe0000000L);
1339: case 115:
1340: return jjMoveStringLiteralDfa1_4(0x100000000L);
1341: default:
1342: return jjMoveNfa_4(0, 0);
1343: }
1344: }
1345:
1346: static private final int jjMoveStringLiteralDfa1_4(long active0) {
1347: try {
1348: curChar = input_stream.readChar();
1349: } catch (java.io.IOException e) {
1350: jjStopStringLiteralDfa_4(0, active0);
1351: return 1;
1352: }
1353: switch (curChar) {
1354: case 98:
1355: return jjMoveStringLiteralDfa2_4(active0, 0x200000000L);
1356: case 105:
1357: return jjMoveStringLiteralDfa2_4(active0, 0x400000000L);
1358: case 114:
1359: return jjMoveStringLiteralDfa2_4(active0, 0x60000000L);
1360: case 116:
1361: return jjMoveStringLiteralDfa2_4(active0, 0x100000000L);
1362: case 117:
1363: return jjMoveStringLiteralDfa2_4(active0, 0x80000000L);
1364: default:
1365: break;
1366: }
1367: return jjStartNfa_4(0, active0);
1368: }
1369:
1370: static private final int jjMoveStringLiteralDfa2_4(long old0,
1371: long active0) {
1372: if (((active0 &= old0)) == 0L)
1373: return jjStartNfa_4(0, old0);
1374: try {
1375: curChar = input_stream.readChar();
1376: } catch (java.io.IOException e) {
1377: jjStopStringLiteralDfa_4(1, active0);
1378: return 2;
1379: }
1380: switch (curChar) {
1381: case 97:
1382: return jjMoveStringLiteralDfa3_4(active0, 0x100000000L);
1383: case 98:
1384: return jjMoveStringLiteralDfa3_4(active0, 0x80000000L);
1385: case 105:
1386: return jjMoveStringLiteralDfa3_4(active0, 0x20000000L);
1387: case 110:
1388: return jjMoveStringLiteralDfa3_4(active0, 0x400000000L);
1389: case 111:
1390: return jjMoveStringLiteralDfa3_4(active0, 0x40000000L);
1391: case 115:
1392: return jjMoveStringLiteralDfa3_4(active0, 0x200000000L);
1393: default:
1394: break;
1395: }
1396: return jjStartNfa_4(1, active0);
1397: }
1398:
1399: static private final int jjMoveStringLiteralDfa3_4(long old0,
1400: long active0) {
1401: if (((active0 &= old0)) == 0L)
1402: return jjStartNfa_4(1, old0);
1403: try {
1404: curChar = input_stream.readChar();
1405: } catch (java.io.IOException e) {
1406: jjStopStringLiteralDfa_4(2, active0);
1407: return 3;
1408: }
1409: switch (curChar) {
1410: case 97:
1411: return jjMoveStringLiteralDfa4_4(active0, 0x400000000L);
1412: case 108:
1413: return jjMoveStringLiteralDfa4_4(active0, 0x80000000L);
1414: case 116:
1415: return jjMoveStringLiteralDfa4_4(active0, 0x340000000L);
1416: case 118:
1417: return jjMoveStringLiteralDfa4_4(active0, 0x20000000L);
1418: default:
1419: break;
1420: }
1421: return jjStartNfa_4(2, active0);
1422: }
1423:
1424: static private final int jjMoveStringLiteralDfa4_4(long old0,
1425: long active0) {
1426: if (((active0 &= old0)) == 0L)
1427: return jjStartNfa_4(2, old0);
1428: try {
1429: curChar = input_stream.readChar();
1430: } catch (java.io.IOException e) {
1431: jjStopStringLiteralDfa_4(3, active0);
1432: return 4;
1433: }
1434: switch (curChar) {
1435: case 97:
1436: return jjMoveStringLiteralDfa5_4(active0, 0x20000000L);
1437: case 101:
1438: return jjMoveStringLiteralDfa5_4(active0, 0x40000000L);
1439: case 105:
1440: return jjMoveStringLiteralDfa5_4(active0, 0x180000000L);
1441: case 108:
1442: if ((active0 & 0x400000000L) != 0L)
1443: return jjStartNfaWithStates_4(4, 34, 13);
1444: break;
1445: case 114:
1446: return jjMoveStringLiteralDfa5_4(active0, 0x200000000L);
1447: default:
1448: break;
1449: }
1450: return jjStartNfa_4(3, active0);
1451: }
1452:
1453: static private final int jjMoveStringLiteralDfa5_4(long old0,
1454: long active0) {
1455: if (((active0 &= old0)) == 0L)
1456: return jjStartNfa_4(3, old0);
1457: try {
1458: curChar = input_stream.readChar();
1459: } catch (java.io.IOException e) {
1460: jjStopStringLiteralDfa_4(4, active0);
1461: return 5;
1462: }
1463: switch (curChar) {
1464: case 97:
1465: return jjMoveStringLiteralDfa6_4(active0, 0x200000000L);
1466: case 99:
1467: if ((active0 & 0x80000000L) != 0L)
1468: return jjStartNfaWithStates_4(5, 31, 13);
1469: else if ((active0 & 0x100000000L) != 0L)
1470: return jjStartNfaWithStates_4(5, 32, 13);
1471: return jjMoveStringLiteralDfa6_4(active0, 0x40000000L);
1472: case 116:
1473: return jjMoveStringLiteralDfa6_4(active0, 0x20000000L);
1474: default:
1475: break;
1476: }
1477: return jjStartNfa_4(4, active0);
1478: }
1479:
1480: static private final int jjMoveStringLiteralDfa6_4(long old0,
1481: long active0) {
1482: if (((active0 &= old0)) == 0L)
1483: return jjStartNfa_4(4, old0);
1484: try {
1485: curChar = input_stream.readChar();
1486: } catch (java.io.IOException e) {
1487: jjStopStringLiteralDfa_4(5, active0);
1488: return 6;
1489: }
1490: switch (curChar) {
1491: case 99:
1492: return jjMoveStringLiteralDfa7_4(active0, 0x200000000L);
1493: case 101:
1494: if ((active0 & 0x20000000L) != 0L)
1495: return jjStartNfaWithStates_4(6, 29, 13);
1496: break;
1497: case 116:
1498: return jjMoveStringLiteralDfa7_4(active0, 0x40000000L);
1499: default:
1500: break;
1501: }
1502: return jjStartNfa_4(5, active0);
1503: }
1504:
1505: static private final int jjMoveStringLiteralDfa7_4(long old0,
1506: long active0) {
1507: if (((active0 &= old0)) == 0L)
1508: return jjStartNfa_4(5, old0);
1509: try {
1510: curChar = input_stream.readChar();
1511: } catch (java.io.IOException e) {
1512: jjStopStringLiteralDfa_4(6, active0);
1513: return 7;
1514: }
1515: switch (curChar) {
1516: case 101:
1517: return jjMoveStringLiteralDfa8_4(active0, 0x40000000L);
1518: case 116:
1519: if ((active0 & 0x200000000L) != 0L)
1520: return jjStartNfaWithStates_4(7, 33, 13);
1521: break;
1522: default:
1523: break;
1524: }
1525: return jjStartNfa_4(6, active0);
1526: }
1527:
1528: static private final int jjMoveStringLiteralDfa8_4(long old0,
1529: long active0) {
1530: if (((active0 &= old0)) == 0L)
1531: return jjStartNfa_4(6, old0);
1532: try {
1533: curChar = input_stream.readChar();
1534: } catch (java.io.IOException e) {
1535: jjStopStringLiteralDfa_4(7, active0);
1536: return 8;
1537: }
1538: switch (curChar) {
1539: case 100:
1540: if ((active0 & 0x40000000L) != 0L)
1541: return jjStartNfaWithStates_4(8, 30, 13);
1542: break;
1543: default:
1544: break;
1545: }
1546: return jjStartNfa_4(7, active0);
1547: }
1548:
1549: static private final int jjMoveNfa_4(int startState, int curPos) {
1550: int[] nextStates;
1551: int startsAt = 0;
1552: jjnewStateCnt = 13;
1553: int i = 1;
1554: jjstateSet[0] = startState;
1555: int j, kind = 0x7fffffff;
1556: for (;;) {
1557: if (++jjround == 0x7fffffff)
1558: ReInitRounds();
1559: if (curChar < 64) {
1560: long l = 1L << curChar;
1561: MatchLoop: do {
1562: switch (jjstateSet[--i]) {
1563: case 13:
1564: if ((0x3ff0c1800000000L & l) != 0L) {
1565: if (kind > 37)
1566: kind = 37;
1567: jjCheckNAddTwoStates(4, 5);
1568: } else if (curChar == 46)
1569: jjCheckNAddStates(14, 16);
1570: break;
1571: case 12:
1572: if (curChar == 46) {
1573: if (kind > 37)
1574: kind = 37;
1575: jjCheckNAddTwoStates(4, 5);
1576: }
1577: if (curChar == 46) {
1578: if (kind > 7)
1579: kind = 7;
1580: }
1581: break;
1582: case 0:
1583: if ((0x3ff0c1800000000L & l) != 0L) {
1584: if (kind > 37)
1585: kind = 37;
1586: jjCheckNAddTwoStates(4, 5);
1587: } else if (curChar == 46)
1588: jjCheckNAddTwoStates(12, 6);
1589: break;
1590: case 1:
1591: if ((0x3ff081800000000L & l) == 0L)
1592: break;
1593: if (kind > 36)
1594: kind = 36;
1595: jjCheckNAddTwoStates(1, 2);
1596: break;
1597: case 2:
1598: if (curChar == 46)
1599: jjCheckNAdd(3);
1600: break;
1601: case 3:
1602: if ((0x3ff081800000000L & l) == 0L)
1603: break;
1604: if (kind > 36)
1605: kind = 36;
1606: jjCheckNAddTwoStates(2, 3);
1607: break;
1608: case 4:
1609: if ((0x3ff0c1800000000L & l) == 0L)
1610: break;
1611: if (kind > 37)
1612: kind = 37;
1613: jjCheckNAddTwoStates(4, 5);
1614: break;
1615: case 5:
1616: if (curChar == 46)
1617: jjCheckNAddStates(14, 16);
1618: break;
1619: case 6:
1620: if (curChar != 46)
1621: break;
1622: if (kind > 37)
1623: kind = 37;
1624: jjCheckNAddTwoStates(4, 5);
1625: break;
1626: case 7:
1627: if ((0x3ff0c1800000000L & l) == 0L)
1628: break;
1629: if (kind > 37)
1630: kind = 37;
1631: jjCheckNAddTwoStates(7, 8);
1632: break;
1633: case 8:
1634: if (curChar == 46)
1635: jjCheckNAddStates(17, 19);
1636: break;
1637: case 9:
1638: if (curChar == 46)
1639: jjCheckNAdd(10);
1640: break;
1641: case 10:
1642: if (curChar != 46)
1643: break;
1644: if (kind > 37)
1645: kind = 37;
1646: jjCheckNAddTwoStates(7, 8);
1647: break;
1648: case 11:
1649: if (curChar == 46)
1650: jjCheckNAddTwoStates(12, 6);
1651: break;
1652: default:
1653: break;
1654: }
1655: } while (i != startsAt);
1656: } else if (curChar < 128) {
1657: long l = 1L << (curChar & 077);
1658: MatchLoop: do {
1659: switch (jjstateSet[--i]) {
1660: case 13:
1661: case 4:
1662: if ((0x7fffffe87fffffeL & l) == 0L)
1663: break;
1664: if (kind > 37)
1665: kind = 37;
1666: jjCheckNAddTwoStates(4, 5);
1667: break;
1668: case 0:
1669: if ((0x7fffffe87fffffeL & l) != 0L) {
1670: if (kind > 37)
1671: kind = 37;
1672: jjCheckNAddTwoStates(4, 5);
1673: } else if (curChar == 64)
1674: jjCheckNAdd(1);
1675: break;
1676: case 1:
1677: if ((0x7fffffe87fffffeL & l) == 0L)
1678: break;
1679: if (kind > 36)
1680: kind = 36;
1681: jjCheckNAddTwoStates(1, 2);
1682: break;
1683: case 3:
1684: if ((0x7fffffe87fffffeL & l) == 0L)
1685: break;
1686: if (kind > 36)
1687: kind = 36;
1688: jjCheckNAddTwoStates(2, 3);
1689: break;
1690: case 7:
1691: if ((0x7fffffe87fffffeL & l) == 0L)
1692: break;
1693: if (kind > 37)
1694: kind = 37;
1695: jjAddStates(20, 21);
1696: break;
1697: default:
1698: break;
1699: }
1700: } while (i != startsAt);
1701: } else {
1702: int i2 = (curChar & 0xff) >> 6;
1703: long l2 = 1L << (curChar & 077);
1704: MatchLoop: do {
1705: switch (jjstateSet[--i]) {
1706: default:
1707: break;
1708: }
1709: } while (i != startsAt);
1710: }
1711: if (kind != 0x7fffffff) {
1712: jjmatchedKind = kind;
1713: jjmatchedPos = curPos;
1714: kind = 0x7fffffff;
1715: }
1716: ++curPos;
1717: if ((i = jjnewStateCnt) == (startsAt = 13 - (jjnewStateCnt = startsAt)))
1718: return curPos;
1719: try {
1720: curChar = input_stream.readChar();
1721: } catch (java.io.IOException e) {
1722: return curPos;
1723: }
1724: }
1725: }
1726:
1727: private static final int jjStopStringLiteralDfa_2(int pos,
1728: long active0, long active1) {
1729: switch (pos) {
1730: case 0:
1731: if ((active0 & 0xf000000000000000L) != 0L
1732: || (active1 & 0x7L) != 0L) {
1733: jjmatchedKind = 70;
1734: return 23;
1735: }
1736: if ((active0 & 0x10L) != 0L)
1737: return 5;
1738: return -1;
1739: case 1:
1740: if ((active0 & 0xf000000000000000L) != 0L
1741: || (active1 & 0x7L) != 0L) {
1742: jjmatchedKind = 70;
1743: jjmatchedPos = 1;
1744: return 23;
1745: }
1746: return -1;
1747: case 2:
1748: if ((active0 & 0xf000000000000000L) != 0L
1749: || (active1 & 0x7L) != 0L) {
1750: jjmatchedKind = 70;
1751: jjmatchedPos = 2;
1752: return 23;
1753: }
1754: return -1;
1755: case 3:
1756: if ((active0 & 0xf000000000000000L) != 0L
1757: || (active1 & 0x7L) != 0L) {
1758: jjmatchedKind = 70;
1759: jjmatchedPos = 3;
1760: return 23;
1761: }
1762: return -1;
1763: case 4:
1764: if ((active0 & 0xf000000000000000L) != 0L
1765: || (active1 & 0x5L) != 0L) {
1766: jjmatchedKind = 70;
1767: jjmatchedPos = 4;
1768: return 23;
1769: }
1770: if ((active1 & 0x2L) != 0L)
1771: return 23;
1772: return -1;
1773: case 5:
1774: if ((active0 & 0x3000000000000000L) != 0L
1775: || (active1 & 0x5L) != 0L) {
1776: jjmatchedKind = 70;
1777: jjmatchedPos = 5;
1778: return 23;
1779: }
1780: if ((active0 & 0xc000000000000000L) != 0L)
1781: return 23;
1782: return -1;
1783: case 6:
1784: if ((active0 & 0x2000000000000000L) != 0L
1785: || (active1 & 0x5L) != 0L) {
1786: jjmatchedKind = 70;
1787: jjmatchedPos = 6;
1788: return 23;
1789: }
1790: if ((active0 & 0x1000000000000000L) != 0L)
1791: return 23;
1792: return -1;
1793: case 7:
1794: if ((active0 & 0x2000000000000000L) != 0L
1795: || (active1 & 0x4L) != 0L) {
1796: jjmatchedKind = 70;
1797: jjmatchedPos = 7;
1798: return 23;
1799: }
1800: if ((active1 & 0x1L) != 0L)
1801: return 23;
1802: return -1;
1803: default:
1804: return -1;
1805: }
1806: }
1807:
1808: private static final int jjStartNfa_2(int pos, long active0,
1809: long active1) {
1810: return jjMoveNfa_2(jjStopStringLiteralDfa_2(pos, active0,
1811: active1), pos + 1);
1812: }
1813:
1814: static private final int jjStartNfaWithStates_2(int pos, int kind,
1815: int state) {
1816: jjmatchedKind = kind;
1817: jjmatchedPos = pos;
1818: try {
1819: curChar = input_stream.readChar();
1820: } catch (java.io.IOException e) {
1821: return pos + 1;
1822: }
1823: return jjMoveNfa_2(state, pos + 1);
1824: }
1825:
1826: static private final int jjMoveStringLiteralDfa0_2() {
1827: switch (curChar) {
1828: case 33:
1829: return jjStopAtPos(0, 67);
1830: case 41:
1831: return jjStopAtPos(0, 74);
1832: case 44:
1833: return jjStopAtPos(0, 3);
1834: case 46:
1835: return jjStartNfaWithStates_2(0, 4, 5);
1836: case 97:
1837: return jjMoveStringLiteralDfa1_2(0x0L, 0x1L);
1838: case 102:
1839: return jjMoveStringLiteralDfa1_2(0x0L, 0x2L);
1840: case 112:
1841: return jjMoveStringLiteralDfa1_2(0x7000000000000000L, 0x0L);
1842: case 115:
1843: return jjMoveStringLiteralDfa1_2(0x8000000000000000L, 0x0L);
1844: case 116:
1845: return jjMoveStringLiteralDfa1_2(0x0L, 0x4L);
1846: default:
1847: return jjMoveNfa_2(0, 0);
1848: }
1849: }
1850:
1851: static private final int jjMoveStringLiteralDfa1_2(long active0,
1852: long active1) {
1853: try {
1854: curChar = input_stream.readChar();
1855: } catch (java.io.IOException e) {
1856: jjStopStringLiteralDfa_2(0, active0, active1);
1857: return 1;
1858: }
1859: switch (curChar) {
1860: case 98:
1861: return jjMoveStringLiteralDfa2_2(active0, 0L, active1, 0x1L);
1862: case 105:
1863: return jjMoveStringLiteralDfa2_2(active0, 0L, active1, 0x2L);
1864: case 114:
1865: return jjMoveStringLiteralDfa2_2(active0,
1866: 0x3000000000000000L, active1, 0x4L);
1867: case 116:
1868: return jjMoveStringLiteralDfa2_2(active0,
1869: 0x8000000000000000L, active1, 0L);
1870: case 117:
1871: return jjMoveStringLiteralDfa2_2(active0,
1872: 0x4000000000000000L, active1, 0L);
1873: default:
1874: break;
1875: }
1876: return jjStartNfa_2(0, active0, active1);
1877: }
1878:
1879: static private final int jjMoveStringLiteralDfa2_2(long old0,
1880: long active0, long old1, long active1) {
1881: if (((active0 &= old0) | (active1 &= old1)) == 0L)
1882: return jjStartNfa_2(0, old0, old1);
1883: try {
1884: curChar = input_stream.readChar();
1885: } catch (java.io.IOException e) {
1886: jjStopStringLiteralDfa_2(1, active0, active1);
1887: return 2;
1888: }
1889: switch (curChar) {
1890: case 97:
1891: return jjMoveStringLiteralDfa3_2(active0,
1892: 0x8000000000000000L, active1, 0x4L);
1893: case 98:
1894: return jjMoveStringLiteralDfa3_2(active0,
1895: 0x4000000000000000L, active1, 0L);
1896: case 105:
1897: return jjMoveStringLiteralDfa3_2(active0,
1898: 0x1000000000000000L, active1, 0L);
1899: case 110:
1900: return jjMoveStringLiteralDfa3_2(active0, 0L, active1, 0x2L);
1901: case 111:
1902: return jjMoveStringLiteralDfa3_2(active0,
1903: 0x2000000000000000L, active1, 0L);
1904: case 115:
1905: return jjMoveStringLiteralDfa3_2(active0, 0L, active1, 0x1L);
1906: default:
1907: break;
1908: }
1909: return jjStartNfa_2(1, active0, active1);
1910: }
1911:
1912: static private final int jjMoveStringLiteralDfa3_2(long old0,
1913: long active0, long old1, long active1) {
1914: if (((active0 &= old0) | (active1 &= old1)) == 0L)
1915: return jjStartNfa_2(1, old0, old1);
1916: try {
1917: curChar = input_stream.readChar();
1918: } catch (java.io.IOException e) {
1919: jjStopStringLiteralDfa_2(2, active0, active1);
1920: return 3;
1921: }
1922: switch (curChar) {
1923: case 97:
1924: return jjMoveStringLiteralDfa4_2(active0, 0L, active1, 0x2L);
1925: case 108:
1926: return jjMoveStringLiteralDfa4_2(active0,
1927: 0x4000000000000000L, active1, 0L);
1928: case 110:
1929: return jjMoveStringLiteralDfa4_2(active0, 0L, active1, 0x4L);
1930: case 116:
1931: return jjMoveStringLiteralDfa4_2(active0,
1932: 0xa000000000000000L, active1, 0x1L);
1933: case 118:
1934: return jjMoveStringLiteralDfa4_2(active0,
1935: 0x1000000000000000L, active1, 0L);
1936: default:
1937: break;
1938: }
1939: return jjStartNfa_2(2, active0, active1);
1940: }
1941:
1942: static private final int jjMoveStringLiteralDfa4_2(long old0,
1943: long active0, long old1, long active1) {
1944: if (((active0 &= old0) | (active1 &= old1)) == 0L)
1945: return jjStartNfa_2(2, old0, old1);
1946: try {
1947: curChar = input_stream.readChar();
1948: } catch (java.io.IOException e) {
1949: jjStopStringLiteralDfa_2(3, active0, active1);
1950: return 4;
1951: }
1952: switch (curChar) {
1953: case 97:
1954: return jjMoveStringLiteralDfa5_2(active0,
1955: 0x1000000000000000L, active1, 0L);
1956: case 101:
1957: return jjMoveStringLiteralDfa5_2(active0,
1958: 0x2000000000000000L, active1, 0L);
1959: case 105:
1960: return jjMoveStringLiteralDfa5_2(active0,
1961: 0xc000000000000000L, active1, 0L);
1962: case 108:
1963: if ((active1 & 0x2L) != 0L)
1964: return jjStartNfaWithStates_2(4, 65, 23);
1965: break;
1966: case 114:
1967: return jjMoveStringLiteralDfa5_2(active0, 0L, active1, 0x1L);
1968: case 115:
1969: return jjMoveStringLiteralDfa5_2(active0, 0L, active1, 0x4L);
1970: default:
1971: break;
1972: }
1973: return jjStartNfa_2(3, active0, active1);
1974: }
1975:
1976: static private final int jjMoveStringLiteralDfa5_2(long old0,
1977: long active0, long old1, long active1) {
1978: if (((active0 &= old0) | (active1 &= old1)) == 0L)
1979: return jjStartNfa_2(3, old0, old1);
1980: try {
1981: curChar = input_stream.readChar();
1982: } catch (java.io.IOException e) {
1983: jjStopStringLiteralDfa_2(4, active0, active1);
1984: return 5;
1985: }
1986: switch (curChar) {
1987: case 97:
1988: return jjMoveStringLiteralDfa6_2(active0, 0L, active1, 0x1L);
1989: case 99:
1990: if ((active0 & 0x4000000000000000L) != 0L)
1991: return jjStartNfaWithStates_2(5, 62, 23);
1992: else if ((active0 & 0x8000000000000000L) != 0L)
1993: return jjStartNfaWithStates_2(5, 63, 23);
1994: return jjMoveStringLiteralDfa6_2(active0,
1995: 0x2000000000000000L, active1, 0L);
1996: case 105:
1997: return jjMoveStringLiteralDfa6_2(active0, 0L, active1, 0x4L);
1998: case 116:
1999: return jjMoveStringLiteralDfa6_2(active0,
2000: 0x1000000000000000L, active1, 0L);
2001: default:
2002: break;
2003: }
2004: return jjStartNfa_2(4, active0, active1);
2005: }
2006:
2007: static private final int jjMoveStringLiteralDfa6_2(long old0,
2008: long active0, long old1, long active1) {
2009: if (((active0 &= old0) | (active1 &= old1)) == 0L)
2010: return jjStartNfa_2(4, old0, old1);
2011: try {
2012: curChar = input_stream.readChar();
2013: } catch (java.io.IOException e) {
2014: jjStopStringLiteralDfa_2(5, active0, active1);
2015: return 6;
2016: }
2017: switch (curChar) {
2018: case 99:
2019: return jjMoveStringLiteralDfa7_2(active0, 0L, active1, 0x1L);
2020: case 101:
2021: if ((active0 & 0x1000000000000000L) != 0L)
2022: return jjStartNfaWithStates_2(6, 60, 23);
2023: return jjMoveStringLiteralDfa7_2(active0, 0L, active1, 0x4L);
2024: case 116:
2025: return jjMoveStringLiteralDfa7_2(active0,
2026: 0x2000000000000000L, active1, 0L);
2027: default:
2028: break;
2029: }
2030: return jjStartNfa_2(5, active0, active1);
2031: }
2032:
2033: static private final int jjMoveStringLiteralDfa7_2(long old0,
2034: long active0, long old1, long active1) {
2035: if (((active0 &= old0) | (active1 &= old1)) == 0L)
2036: return jjStartNfa_2(5, old0, old1);
2037: try {
2038: curChar = input_stream.readChar();
2039: } catch (java.io.IOException e) {
2040: jjStopStringLiteralDfa_2(6, active0, active1);
2041: return 7;
2042: }
2043: switch (curChar) {
2044: case 101:
2045: return jjMoveStringLiteralDfa8_2(active0,
2046: 0x2000000000000000L, active1, 0L);
2047: case 110:
2048: return jjMoveStringLiteralDfa8_2(active0, 0L, active1, 0x4L);
2049: case 116:
2050: if ((active1 & 0x1L) != 0L)
2051: return jjStartNfaWithStates_2(7, 64, 23);
2052: break;
2053: default:
2054: break;
2055: }
2056: return jjStartNfa_2(6, active0, active1);
2057: }
2058:
2059: static private final int jjMoveStringLiteralDfa8_2(long old0,
2060: long active0, long old1, long active1) {
2061: if (((active0 &= old0) | (active1 &= old1)) == 0L)
2062: return jjStartNfa_2(6, old0, old1);
2063: try {
2064: curChar = input_stream.readChar();
2065: } catch (java.io.IOException e) {
2066: jjStopStringLiteralDfa_2(7, active0, active1);
2067: return 8;
2068: }
2069: switch (curChar) {
2070: case 100:
2071: if ((active0 & 0x2000000000000000L) != 0L)
2072: return jjStartNfaWithStates_2(8, 61, 23);
2073: break;
2074: case 116:
2075: if ((active1 & 0x4L) != 0L)
2076: return jjStartNfaWithStates_2(8, 66, 23);
2077: break;
2078: default:
2079: break;
2080: }
2081: return jjStartNfa_2(7, active0, active1);
2082: }
2083:
2084: static private final int jjMoveNfa_2(int startState, int curPos) {
2085: int[] nextStates;
2086: int startsAt = 0;
2087: jjnewStateCnt = 23;
2088: int i = 1;
2089: jjstateSet[0] = startState;
2090: int j, kind = 0x7fffffff;
2091: for (;;) {
2092: if (++jjround == 0x7fffffff)
2093: ReInitRounds();
2094: if (curChar < 64) {
2095: long l = 1L << curChar;
2096: MatchLoop: do {
2097: switch (jjstateSet[--i]) {
2098: case 5:
2099: if (curChar == 46)
2100: jjCheckNAddStates(22, 24);
2101: if (curChar == 46) {
2102: if (kind > 70)
2103: kind = 70;
2104: jjCheckNAddTwoStates(7, 8);
2105: }
2106: if (curChar == 46) {
2107: if (kind > 7)
2108: kind = 7;
2109: }
2110: break;
2111: case 23:
2112: if ((0x3ff0c1800000000L & l) != 0L)
2113: jjCheckNAddStates(22, 24);
2114: else if (curChar == 46)
2115: jjCheckNAddStates(25, 27);
2116: if ((0x3ff0c1800000000L & l) != 0L) {
2117: if (kind > 70)
2118: kind = 70;
2119: jjCheckNAddTwoStates(7, 8);
2120: } else if (curChar == 46)
2121: jjCheckNAddStates(28, 30);
2122: break;
2123: case 0:
2124: if ((0x3ff0c1800000000L & l) != 0L) {
2125: if (kind > 70)
2126: kind = 70;
2127: jjCheckNAddStates(31, 35);
2128: } else if (curChar == 46)
2129: jjCheckNAddStates(36, 38);
2130: break;
2131: case 1:
2132: if ((0x3ff081800000000L & l) == 0L)
2133: break;
2134: if (kind > 68)
2135: kind = 68;
2136: jjCheckNAddTwoStates(1, 2);
2137: break;
2138: case 2:
2139: if (curChar == 46)
2140: jjCheckNAdd(3);
2141: break;
2142: case 3:
2143: if ((0x3ff081800000000L & l) == 0L)
2144: break;
2145: if (kind > 68)
2146: kind = 68;
2147: jjCheckNAddTwoStates(2, 3);
2148: break;
2149: case 4:
2150: if (curChar == 46)
2151: jjCheckNAddStates(36, 38);
2152: break;
2153: case 6:
2154: if (curChar != 46)
2155: break;
2156: if (kind > 70)
2157: kind = 70;
2158: jjCheckNAddTwoStates(7, 8);
2159: break;
2160: case 7:
2161: if ((0x3ff0c1800000000L & l) == 0L)
2162: break;
2163: if (kind > 70)
2164: kind = 70;
2165: jjCheckNAddTwoStates(7, 8);
2166: break;
2167: case 8:
2168: if (curChar == 46)
2169: jjCheckNAddStates(25, 27);
2170: break;
2171: case 9:
2172: if ((0x3ff0c1800000000L & l) == 0L)
2173: break;
2174: if (kind > 70)
2175: kind = 70;
2176: jjCheckNAddTwoStates(9, 10);
2177: break;
2178: case 10:
2179: if (curChar == 46)
2180: jjCheckNAddStates(39, 41);
2181: break;
2182: case 11:
2183: if (curChar == 46)
2184: jjCheckNAdd(12);
2185: break;
2186: case 12:
2187: if (curChar != 46)
2188: break;
2189: if (kind > 70)
2190: kind = 70;
2191: jjCheckNAddTwoStates(9, 10);
2192: break;
2193: case 13:
2194: if (curChar == 46)
2195: jjCheckNAddStates(22, 24);
2196: break;
2197: case 14:
2198: if ((0x3ff0c1800000000L & l) != 0L)
2199: jjCheckNAddStates(22, 24);
2200: break;
2201: case 17:
2202: if (curChar == 46)
2203: jjCheckNAddStates(28, 30);
2204: break;
2205: case 18:
2206: if ((0x3ff0c1800000000L & l) != 0L)
2207: jjCheckNAddStates(42, 44);
2208: break;
2209: case 19:
2210: if (curChar == 46)
2211: jjCheckNAddStates(45, 47);
2212: break;
2213: case 20:
2214: if (curChar == 46)
2215: jjCheckNAdd(21);
2216: break;
2217: case 21:
2218: if (curChar == 46)
2219: jjCheckNAddStates(42, 44);
2220: break;
2221: case 22:
2222: if ((0x3ff0c1800000000L & l) == 0L)
2223: break;
2224: if (kind > 70)
2225: kind = 70;
2226: jjCheckNAddStates(31, 35);
2227: break;
2228: default:
2229: break;
2230: }
2231: } while (i != startsAt);
2232: } else if (curChar < 128) {
2233: long l = 1L << (curChar & 077);
2234: MatchLoop: do {
2235: switch (jjstateSet[--i]) {
2236: case 23:
2237: if ((0x7fffffe87fffffeL & l) != 0L)
2238: jjCheckNAddStates(22, 24);
2239: else if (curChar == 91)
2240: jjstateSet[jjnewStateCnt++] = 15;
2241: if ((0x7fffffe87fffffeL & l) != 0L) {
2242: if (kind > 70)
2243: kind = 70;
2244: jjCheckNAddTwoStates(7, 8);
2245: }
2246: break;
2247: case 0:
2248: if ((0x7fffffe87fffffeL & l) != 0L) {
2249: if (kind > 70)
2250: kind = 70;
2251: jjCheckNAddStates(31, 35);
2252: } else if (curChar == 64)
2253: jjCheckNAdd(1);
2254: break;
2255: case 1:
2256: if ((0x7fffffe87fffffeL & l) == 0L)
2257: break;
2258: if (kind > 68)
2259: kind = 68;
2260: jjCheckNAddTwoStates(1, 2);
2261: break;
2262: case 3:
2263: if ((0x7fffffe87fffffeL & l) == 0L)
2264: break;
2265: if (kind > 68)
2266: kind = 68;
2267: jjCheckNAddTwoStates(2, 3);
2268: break;
2269: case 7:
2270: if ((0x7fffffe87fffffeL & l) == 0L)
2271: break;
2272: if (kind > 70)
2273: kind = 70;
2274: jjCheckNAddTwoStates(7, 8);
2275: break;
2276: case 9:
2277: if ((0x7fffffe87fffffeL & l) == 0L)
2278: break;
2279: if (kind > 70)
2280: kind = 70;
2281: jjAddStates(48, 49);
2282: break;
2283: case 14:
2284: if ((0x7fffffe87fffffeL & l) != 0L)
2285: jjCheckNAddStates(22, 24);
2286: break;
2287: case 15:
2288: if (curChar != 93)
2289: break;
2290: kind = 71;
2291: jjCheckNAdd(16);
2292: break;
2293: case 16:
2294: if (curChar == 91)
2295: jjstateSet[jjnewStateCnt++] = 15;
2296: break;
2297: case 18:
2298: if ((0x7fffffe87fffffeL & l) != 0L)
2299: jjCheckNAddStates(42, 44);
2300: break;
2301: case 22:
2302: if ((0x7fffffe87fffffeL & l) == 0L)
2303: break;
2304: if (kind > 70)
2305: kind = 70;
2306: jjCheckNAddStates(31, 35);
2307: break;
2308: default:
2309: break;
2310: }
2311: } while (i != startsAt);
2312: } else {
2313: int i2 = (curChar & 0xff) >> 6;
2314: long l2 = 1L << (curChar & 077);
2315: MatchLoop: do {
2316: switch (jjstateSet[--i]) {
2317: default:
2318: break;
2319: }
2320: } while (i != startsAt);
2321: }
2322: if (kind != 0x7fffffff) {
2323: jjmatchedKind = kind;
2324: jjmatchedPos = curPos;
2325: kind = 0x7fffffff;
2326: }
2327: ++curPos;
2328: if ((i = jjnewStateCnt) == (startsAt = 23 - (jjnewStateCnt = startsAt)))
2329: return curPos;
2330: try {
2331: curChar = input_stream.readChar();
2332: } catch (java.io.IOException e) {
2333: return curPos;
2334: }
2335: }
2336: }
2337:
2338: private static final int jjStopStringLiteralDfa_3(int pos,
2339: long active0) {
2340: switch (pos) {
2341: case 0:
2342: if ((active0 & 0x10L) != 0L)
2343: return 5;
2344: if ((active0 & 0x7fc0000000000L) != 0L) {
2345: jjmatchedKind = 54;
2346: return 23;
2347: }
2348: return -1;
2349: case 1:
2350: if ((active0 & 0x7fc0000000000L) != 0L) {
2351: jjmatchedKind = 54;
2352: jjmatchedPos = 1;
2353: return 23;
2354: }
2355: return -1;
2356: case 2:
2357: if ((active0 & 0x7fc0000000000L) != 0L) {
2358: jjmatchedKind = 54;
2359: jjmatchedPos = 2;
2360: return 23;
2361: }
2362: return -1;
2363: case 3:
2364: if ((active0 & 0x7fc0000000000L) != 0L) {
2365: jjmatchedKind = 54;
2366: jjmatchedPos = 3;
2367: return 23;
2368: }
2369: return -1;
2370: case 4:
2371: if ((active0 & 0x77c0000000000L) != 0L) {
2372: jjmatchedKind = 54;
2373: jjmatchedPos = 4;
2374: return 23;
2375: }
2376: if ((active0 & 0x800000000000L) != 0L)
2377: return 23;
2378: return -1;
2379: case 5:
2380: if ((active0 & 0x2580000000000L) != 0L) {
2381: if (jjmatchedPos != 5) {
2382: jjmatchedKind = 54;
2383: jjmatchedPos = 5;
2384: }
2385: return 23;
2386: }
2387: if ((active0 & 0x5240000000000L) != 0L)
2388: return 23;
2389: return -1;
2390: case 6:
2391: if ((active0 & 0x6480000000000L) != 0L) {
2392: jjmatchedKind = 54;
2393: jjmatchedPos = 6;
2394: return 23;
2395: }
2396: if ((active0 & 0x100000000000L) != 0L)
2397: return 23;
2398: return -1;
2399: case 7:
2400: if ((active0 & 0x6080000000000L) != 0L) {
2401: jjmatchedKind = 54;
2402: jjmatchedPos = 7;
2403: return 23;
2404: }
2405: if ((active0 & 0x400000000000L) != 0L)
2406: return 23;
2407: return -1;
2408: case 8:
2409: if ((active0 & 0x6000000000000L) != 0L) {
2410: jjmatchedKind = 54;
2411: jjmatchedPos = 8;
2412: return 23;
2413: }
2414: if ((active0 & 0x80000000000L) != 0L)
2415: return 23;
2416: return -1;
2417: case 9:
2418: if ((active0 & 0x6000000000000L) != 0L) {
2419: jjmatchedKind = 54;
2420: jjmatchedPos = 9;
2421: return 23;
2422: }
2423: return -1;
2424: case 10:
2425: if ((active0 & 0x6000000000000L) != 0L) {
2426: jjmatchedKind = 54;
2427: jjmatchedPos = 10;
2428: return 23;
2429: }
2430: return -1;
2431: case 11:
2432: if ((active0 & 0x4000000000000L) != 0L) {
2433: jjmatchedKind = 54;
2434: jjmatchedPos = 11;
2435: return 23;
2436: }
2437: if ((active0 & 0x2000000000000L) != 0L)
2438: return 23;
2439: return -1;
2440: case 12:
2441: if ((active0 & 0x4000000000000L) != 0L) {
2442: jjmatchedKind = 54;
2443: jjmatchedPos = 12;
2444: return 23;
2445: }
2446: return -1;
2447: case 13:
2448: if ((active0 & 0x4000000000000L) != 0L) {
2449: jjmatchedKind = 54;
2450: jjmatchedPos = 13;
2451: return 23;
2452: }
2453: return -1;
2454: case 14:
2455: if ((active0 & 0x4000000000000L) != 0L) {
2456: jjmatchedKind = 54;
2457: jjmatchedPos = 14;
2458: return 23;
2459: }
2460: return -1;
2461: case 15:
2462: if ((active0 & 0x4000000000000L) != 0L) {
2463: jjmatchedKind = 54;
2464: jjmatchedPos = 15;
2465: return 23;
2466: }
2467: return -1;
2468: case 16:
2469: if ((active0 & 0x4000000000000L) != 0L) {
2470: jjmatchedKind = 54;
2471: jjmatchedPos = 16;
2472: return 23;
2473: }
2474: return -1;
2475: case 17:
2476: if ((active0 & 0x4000000000000L) != 0L) {
2477: jjmatchedKind = 54;
2478: jjmatchedPos = 17;
2479: return 23;
2480: }
2481: return -1;
2482: case 18:
2483: if ((active0 & 0x4000000000000L) != 0L) {
2484: jjmatchedKind = 54;
2485: jjmatchedPos = 18;
2486: return 23;
2487: }
2488: return -1;
2489: default:
2490: return -1;
2491: }
2492: }
2493:
2494: private static final int jjStartNfa_3(int pos, long active0) {
2495: return jjMoveNfa_3(jjStopStringLiteralDfa_3(pos, active0),
2496: pos + 1);
2497: }
2498:
2499: static private final int jjStartNfaWithStates_3(int pos, int kind,
2500: int state) {
2501: jjmatchedKind = kind;
2502: jjmatchedPos = pos;
2503: try {
2504: curChar = input_stream.readChar();
2505: } catch (java.io.IOException e) {
2506: return pos + 1;
2507: }
2508: return jjMoveNfa_3(state, pos + 1);
2509: }
2510:
2511: static private final int jjMoveStringLiteralDfa0_3() {
2512: switch (curChar) {
2513: case 33:
2514: return jjStopAtPos(0, 51);
2515: case 40:
2516: return jjStopAtPos(0, 57);
2517: case 41:
2518: return jjStopAtPos(0, 58);
2519: case 44:
2520: return jjStopAtPos(0, 3);
2521: case 46:
2522: return jjStartNfaWithStates_3(0, 4, 5);
2523: case 97:
2524: return jjMoveStringLiteralDfa1_3(0x400000000000L);
2525: case 102:
2526: return jjMoveStringLiteralDfa1_3(0x800000000000L);
2527: case 110:
2528: return jjMoveStringLiteralDfa1_3(0x1000000000000L);
2529: case 112:
2530: return jjMoveStringLiteralDfa1_3(0x1c0000000000L);
2531: case 115:
2532: return jjMoveStringLiteralDfa1_3(0x6200000000000L);
2533: default:
2534: return jjMoveNfa_3(0, 0);
2535: }
2536: }
2537:
2538: static private final int jjMoveStringLiteralDfa1_3(long active0) {
2539: try {
2540: curChar = input_stream.readChar();
2541: } catch (java.io.IOException e) {
2542: jjStopStringLiteralDfa_3(0, active0);
2543: return 1;
2544: }
2545: switch (curChar) {
2546: case 97:
2547: return jjMoveStringLiteralDfa2_3(active0, 0x1000000000000L);
2548: case 98:
2549: return jjMoveStringLiteralDfa2_3(active0, 0x400000000000L);
2550: case 105:
2551: return jjMoveStringLiteralDfa2_3(active0, 0x800000000000L);
2552: case 114:
2553: return jjMoveStringLiteralDfa2_3(active0, 0x180000000000L);
2554: case 116:
2555: return jjMoveStringLiteralDfa2_3(active0, 0x4200000000000L);
2556: case 117:
2557: return jjMoveStringLiteralDfa2_3(active0, 0x40000000000L);
2558: case 121:
2559: return jjMoveStringLiteralDfa2_3(active0, 0x2000000000000L);
2560: default:
2561: break;
2562: }
2563: return jjStartNfa_3(0, active0);
2564: }
2565:
2566: static private final int jjMoveStringLiteralDfa2_3(long old0,
2567: long active0) {
2568: if (((active0 &= old0)) == 0L)
2569: return jjStartNfa_3(0, old0);
2570: try {
2571: curChar = input_stream.readChar();
2572: } catch (java.io.IOException e) {
2573: jjStopStringLiteralDfa_3(1, active0);
2574: return 2;
2575: }
2576: switch (curChar) {
2577: case 97:
2578: return jjMoveStringLiteralDfa3_3(active0, 0x4200000000000L);
2579: case 98:
2580: return jjMoveStringLiteralDfa3_3(active0, 0x40000000000L);
2581: case 105:
2582: return jjMoveStringLiteralDfa3_3(active0, 0x100000000000L);
2583: case 110:
2584: return jjMoveStringLiteralDfa3_3(active0, 0x2800000000000L);
2585: case 111:
2586: return jjMoveStringLiteralDfa3_3(active0, 0x80000000000L);
2587: case 115:
2588: return jjMoveStringLiteralDfa3_3(active0, 0x400000000000L);
2589: case 116:
2590: return jjMoveStringLiteralDfa3_3(active0, 0x1000000000000L);
2591: default:
2592: break;
2593: }
2594: return jjStartNfa_3(1, active0);
2595: }
2596:
2597: static private final int jjMoveStringLiteralDfa3_3(long old0,
2598: long active0) {
2599: if (((active0 &= old0)) == 0L)
2600: return jjStartNfa_3(1, old0);
2601: try {
2602: curChar = input_stream.readChar();
2603: } catch (java.io.IOException e) {
2604: jjStopStringLiteralDfa_3(2, active0);
2605: return 3;
2606: }
2607: switch (curChar) {
2608: case 97:
2609: return jjMoveStringLiteralDfa4_3(active0, 0x800000000000L);
2610: case 99:
2611: return jjMoveStringLiteralDfa4_3(active0, 0x2000000000000L);
2612: case 105:
2613: return jjMoveStringLiteralDfa4_3(active0, 0x1000000000000L);
2614: case 108:
2615: return jjMoveStringLiteralDfa4_3(active0, 0x40000000000L);
2616: case 116:
2617: return jjMoveStringLiteralDfa4_3(active0, 0x4680000000000L);
2618: case 118:
2619: return jjMoveStringLiteralDfa4_3(active0, 0x100000000000L);
2620: default:
2621: break;
2622: }
2623: return jjStartNfa_3(2, active0);
2624: }
2625:
2626: static private final int jjMoveStringLiteralDfa4_3(long old0,
2627: long active0) {
2628: if (((active0 &= old0)) == 0L)
2629: return jjStartNfa_3(2, old0);
2630: try {
2631: curChar = input_stream.readChar();
2632: } catch (java.io.IOException e) {
2633: jjStopStringLiteralDfa_3(3, active0);
2634: return 4;
2635: }
2636: switch (curChar) {
2637: case 97:
2638: return jjMoveStringLiteralDfa5_3(active0, 0x100000000000L);
2639: case 101:
2640: return jjMoveStringLiteralDfa5_3(active0, 0x80000000000L);
2641: case 104:
2642: return jjMoveStringLiteralDfa5_3(active0, 0x2000000000000L);
2643: case 105:
2644: return jjMoveStringLiteralDfa5_3(active0, 0x4240000000000L);
2645: case 108:
2646: if ((active0 & 0x800000000000L) != 0L)
2647: return jjStartNfaWithStates_3(4, 47, 23);
2648: break;
2649: case 114:
2650: return jjMoveStringLiteralDfa5_3(active0, 0x400000000000L);
2651: case 118:
2652: return jjMoveStringLiteralDfa5_3(active0, 0x1000000000000L);
2653: default:
2654: break;
2655: }
2656: return jjStartNfa_3(3, active0);
2657: }
2658:
2659: static private final int jjMoveStringLiteralDfa5_3(long old0,
2660: long active0) {
2661: if (((active0 &= old0)) == 0L)
2662: return jjStartNfa_3(3, old0);
2663: try {
2664: curChar = input_stream.readChar();
2665: } catch (java.io.IOException e) {
2666: jjStopStringLiteralDfa_3(4, active0);
2667: return 5;
2668: }
2669: switch (curChar) {
2670: case 97:
2671: return jjMoveStringLiteralDfa6_3(active0, 0x400000000000L);
2672: case 99:
2673: if ((active0 & 0x40000000000L) != 0L)
2674: return jjStartNfaWithStates_3(5, 42, 23);
2675: else if ((active0 & 0x200000000000L) != 0L) {
2676: jjmatchedKind = 45;
2677: jjmatchedPos = 5;
2678: }
2679: return jjMoveStringLiteralDfa6_3(active0, 0x4080000000000L);
2680: case 101:
2681: if ((active0 & 0x1000000000000L) != 0L)
2682: return jjStartNfaWithStates_3(5, 48, 23);
2683: break;
2684: case 114:
2685: return jjMoveStringLiteralDfa6_3(active0, 0x2000000000000L);
2686: case 116:
2687: return jjMoveStringLiteralDfa6_3(active0, 0x100000000000L);
2688: default:
2689: break;
2690: }
2691: return jjStartNfa_3(4, active0);
2692: }
2693:
2694: static private final int jjMoveStringLiteralDfa6_3(long old0,
2695: long active0) {
2696: if (((active0 &= old0)) == 0L)
2697: return jjStartNfa_3(4, old0);
2698: try {
2699: curChar = input_stream.readChar();
2700: } catch (java.io.IOException e) {
2701: jjStopStringLiteralDfa_3(5, active0);
2702: return 6;
2703: }
2704: switch (curChar) {
2705: case 99:
2706: return jjMoveStringLiteralDfa7_3(active0, 0x400000000000L);
2707: case 101:
2708: if ((active0 & 0x100000000000L) != 0L)
2709: return jjStartNfaWithStates_3(6, 44, 23);
2710: break;
2711: case 105:
2712: return jjMoveStringLiteralDfa7_3(active0, 0x4000000000000L);
2713: case 111:
2714: return jjMoveStringLiteralDfa7_3(active0, 0x2000000000000L);
2715: case 116:
2716: return jjMoveStringLiteralDfa7_3(active0, 0x80000000000L);
2717: default:
2718: break;
2719: }
2720: return jjStartNfa_3(5, active0);
2721: }
2722:
2723: static private final int jjMoveStringLiteralDfa7_3(long old0,
2724: long active0) {
2725: if (((active0 &= old0)) == 0L)
2726: return jjStartNfa_3(5, old0);
2727: try {
2728: curChar = input_stream.readChar();
2729: } catch (java.io.IOException e) {
2730: jjStopStringLiteralDfa_3(6, active0);
2731: return 7;
2732: }
2733: switch (curChar) {
2734: case 101:
2735: return jjMoveStringLiteralDfa8_3(active0, 0x80000000000L);
2736: case 110:
2737: return jjMoveStringLiteralDfa8_3(active0, 0x6000000000000L);
2738: case 116:
2739: if ((active0 & 0x400000000000L) != 0L)
2740: return jjStartNfaWithStates_3(7, 46, 23);
2741: break;
2742: default:
2743: break;
2744: }
2745: return jjStartNfa_3(6, active0);
2746: }
2747:
2748: static private final int jjMoveStringLiteralDfa8_3(long old0,
2749: long active0) {
2750: if (((active0 &= old0)) == 0L)
2751: return jjStartNfa_3(6, old0);
2752: try {
2753: curChar = input_stream.readChar();
2754: } catch (java.io.IOException e) {
2755: jjStopStringLiteralDfa_3(7, active0);
2756: return 8;
2757: }
2758: switch (curChar) {
2759: case 100:
2760: if ((active0 & 0x80000000000L) != 0L)
2761: return jjStartNfaWithStates_3(8, 43, 23);
2762: break;
2763: case 105:
2764: return jjMoveStringLiteralDfa9_3(active0, 0x6000000000000L);
2765: default:
2766: break;
2767: }
2768: return jjStartNfa_3(7, active0);
2769: }
2770:
2771: static private final int jjMoveStringLiteralDfa9_3(long old0,
2772: long active0) {
2773: if (((active0 &= old0)) == 0L)
2774: return jjStartNfa_3(7, old0);
2775: try {
2776: curChar = input_stream.readChar();
2777: } catch (java.io.IOException e) {
2778: jjStopStringLiteralDfa_3(8, active0);
2779: return 9;
2780: }
2781: switch (curChar) {
2782: case 116:
2783: return jjMoveStringLiteralDfa10_3(active0, 0x4000000000000L);
2784: case 122:
2785: return jjMoveStringLiteralDfa10_3(active0, 0x2000000000000L);
2786: default:
2787: break;
2788: }
2789: return jjStartNfa_3(8, active0);
2790: }
2791:
2792: static private final int jjMoveStringLiteralDfa10_3(long old0,
2793: long active0) {
2794: if (((active0 &= old0)) == 0L)
2795: return jjStartNfa_3(8, old0);
2796: try {
2797: curChar = input_stream.readChar();
2798: } catch (java.io.IOException e) {
2799: jjStopStringLiteralDfa_3(9, active0);
2800: return 10;
2801: }
2802: switch (curChar) {
2803: case 101:
2804: return jjMoveStringLiteralDfa11_3(active0, 0x2000000000000L);
2805: case 105:
2806: return jjMoveStringLiteralDfa11_3(active0, 0x4000000000000L);
2807: default:
2808: break;
2809: }
2810: return jjStartNfa_3(9, active0);
2811: }
2812:
2813: static private final int jjMoveStringLiteralDfa11_3(long old0,
2814: long active0) {
2815: if (((active0 &= old0)) == 0L)
2816: return jjStartNfa_3(9, old0);
2817: try {
2818: curChar = input_stream.readChar();
2819: } catch (java.io.IOException e) {
2820: jjStopStringLiteralDfa_3(10, active0);
2821: return 11;
2822: }
2823: switch (curChar) {
2824: case 97:
2825: return jjMoveStringLiteralDfa12_3(active0, 0x4000000000000L);
2826: case 100:
2827: if ((active0 & 0x2000000000000L) != 0L)
2828: return jjStartNfaWithStates_3(11, 49, 23);
2829: break;
2830: default:
2831: break;
2832: }
2833: return jjStartNfa_3(10, active0);
2834: }
2835:
2836: static private final int jjMoveStringLiteralDfa12_3(long old0,
2837: long active0) {
2838: if (((active0 &= old0)) == 0L)
2839: return jjStartNfa_3(10, old0);
2840: try {
2841: curChar = input_stream.readChar();
2842: } catch (java.io.IOException e) {
2843: jjStopStringLiteralDfa_3(11, active0);
2844: return 12;
2845: }
2846: switch (curChar) {
2847: case 108:
2848: return jjMoveStringLiteralDfa13_3(active0, 0x4000000000000L);
2849: default:
2850: break;
2851: }
2852: return jjStartNfa_3(11, active0);
2853: }
2854:
2855: static private final int jjMoveStringLiteralDfa13_3(long old0,
2856: long active0) {
2857: if (((active0 &= old0)) == 0L)
2858: return jjStartNfa_3(11, old0);
2859: try {
2860: curChar = input_stream.readChar();
2861: } catch (java.io.IOException e) {
2862: jjStopStringLiteralDfa_3(12, active0);
2863: return 13;
2864: }
2865: switch (curChar) {
2866: case 105:
2867: return jjMoveStringLiteralDfa14_3(active0, 0x4000000000000L);
2868: default:
2869: break;
2870: }
2871: return jjStartNfa_3(12, active0);
2872: }
2873:
2874: static private final int jjMoveStringLiteralDfa14_3(long old0,
2875: long active0) {
2876: if (((active0 &= old0)) == 0L)
2877: return jjStartNfa_3(12, old0);
2878: try {
2879: curChar = input_stream.readChar();
2880: } catch (java.io.IOException e) {
2881: jjStopStringLiteralDfa_3(13, active0);
2882: return 14;
2883: }
2884: switch (curChar) {
2885: case 122:
2886: return jjMoveStringLiteralDfa15_3(active0, 0x4000000000000L);
2887: default:
2888: break;
2889: }
2890: return jjStartNfa_3(13, active0);
2891: }
2892:
2893: static private final int jjMoveStringLiteralDfa15_3(long old0,
2894: long active0) {
2895: if (((active0 &= old0)) == 0L)
2896: return jjStartNfa_3(13, old0);
2897: try {
2898: curChar = input_stream.readChar();
2899: } catch (java.io.IOException e) {
2900: jjStopStringLiteralDfa_3(14, active0);
2901: return 15;
2902: }
2903: switch (curChar) {
2904: case 97:
2905: return jjMoveStringLiteralDfa16_3(active0, 0x4000000000000L);
2906: default:
2907: break;
2908: }
2909: return jjStartNfa_3(14, active0);
2910: }
2911:
2912: static private final int jjMoveStringLiteralDfa16_3(long old0,
2913: long active0) {
2914: if (((active0 &= old0)) == 0L)
2915: return jjStartNfa_3(14, old0);
2916: try {
2917: curChar = input_stream.readChar();
2918: } catch (java.io.IOException e) {
2919: jjStopStringLiteralDfa_3(15, active0);
2920: return 16;
2921: }
2922: switch (curChar) {
2923: case 116:
2924: return jjMoveStringLiteralDfa17_3(active0, 0x4000000000000L);
2925: default:
2926: break;
2927: }
2928: return jjStartNfa_3(15, active0);
2929: }
2930:
2931: static private final int jjMoveStringLiteralDfa17_3(long old0,
2932: long active0) {
2933: if (((active0 &= old0)) == 0L)
2934: return jjStartNfa_3(15, old0);
2935: try {
2936: curChar = input_stream.readChar();
2937: } catch (java.io.IOException e) {
2938: jjStopStringLiteralDfa_3(16, active0);
2939: return 17;
2940: }
2941: switch (curChar) {
2942: case 105:
2943: return jjMoveStringLiteralDfa18_3(active0, 0x4000000000000L);
2944: default:
2945: break;
2946: }
2947: return jjStartNfa_3(16, active0);
2948: }
2949:
2950: static private final int jjMoveStringLiteralDfa18_3(long old0,
2951: long active0) {
2952: if (((active0 &= old0)) == 0L)
2953: return jjStartNfa_3(16, old0);
2954: try {
2955: curChar = input_stream.readChar();
2956: } catch (java.io.IOException e) {
2957: jjStopStringLiteralDfa_3(17, active0);
2958: return 18;
2959: }
2960: switch (curChar) {
2961: case 111:
2962: return jjMoveStringLiteralDfa19_3(active0, 0x4000000000000L);
2963: default:
2964: break;
2965: }
2966: return jjStartNfa_3(17, active0);
2967: }
2968:
2969: static private final int jjMoveStringLiteralDfa19_3(long old0,
2970: long active0) {
2971: if (((active0 &= old0)) == 0L)
2972: return jjStartNfa_3(17, old0);
2973: try {
2974: curChar = input_stream.readChar();
2975: } catch (java.io.IOException e) {
2976: jjStopStringLiteralDfa_3(18, active0);
2977: return 19;
2978: }
2979: switch (curChar) {
2980: case 110:
2981: if ((active0 & 0x4000000000000L) != 0L)
2982: return jjStartNfaWithStates_3(19, 50, 23);
2983: break;
2984: default:
2985: break;
2986: }
2987: return jjStartNfa_3(18, active0);
2988: }
2989:
2990: static private final int jjMoveNfa_3(int startState, int curPos) {
2991: int[] nextStates;
2992: int startsAt = 0;
2993: jjnewStateCnt = 23;
2994: int i = 1;
2995: jjstateSet[0] = startState;
2996: int j, kind = 0x7fffffff;
2997: for (;;) {
2998: if (++jjround == 0x7fffffff)
2999: ReInitRounds();
3000: if (curChar < 64) {
3001: long l = 1L << curChar;
3002: MatchLoop: do {
3003: switch (jjstateSet[--i]) {
3004: case 5:
3005: if (curChar == 46)
3006: jjCheckNAddStates(22, 24);
3007: if (curChar == 46) {
3008: if (kind > 54)
3009: kind = 54;
3010: jjCheckNAddTwoStates(7, 8);
3011: }
3012: if (curChar == 46) {
3013: if (kind > 7)
3014: kind = 7;
3015: }
3016: break;
3017: case 23:
3018: if ((0x3ff0c1800000000L & l) != 0L)
3019: jjCheckNAddStates(22, 24);
3020: else if (curChar == 46)
3021: jjCheckNAddStates(25, 27);
3022: if ((0x3ff0c1800000000L & l) != 0L) {
3023: if (kind > 54)
3024: kind = 54;
3025: jjCheckNAddTwoStates(7, 8);
3026: } else if (curChar == 46)
3027: jjCheckNAddStates(28, 30);
3028: break;
3029: case 0:
3030: if ((0x3ff0c1800000000L & l) != 0L) {
3031: if (kind > 54)
3032: kind = 54;
3033: jjCheckNAddStates(31, 35);
3034: } else if (curChar == 46)
3035: jjCheckNAddStates(36, 38);
3036: break;
3037: case 1:
3038: if ((0x3ff081800000000L & l) == 0L)
3039: break;
3040: if (kind > 52)
3041: kind = 52;
3042: jjCheckNAddTwoStates(1, 2);
3043: break;
3044: case 2:
3045: if (curChar == 46)
3046: jjCheckNAdd(3);
3047: break;
3048: case 3:
3049: if ((0x3ff081800000000L & l) == 0L)
3050: break;
3051: if (kind > 52)
3052: kind = 52;
3053: jjCheckNAddTwoStates(2, 3);
3054: break;
3055: case 4:
3056: if (curChar == 46)
3057: jjCheckNAddStates(36, 38);
3058: break;
3059: case 6:
3060: if (curChar != 46)
3061: break;
3062: if (kind > 54)
3063: kind = 54;
3064: jjCheckNAddTwoStates(7, 8);
3065: break;
3066: case 7:
3067: if ((0x3ff0c1800000000L & l) == 0L)
3068: break;
3069: if (kind > 54)
3070: kind = 54;
3071: jjCheckNAddTwoStates(7, 8);
3072: break;
3073: case 8:
3074: if (curChar == 46)
3075: jjCheckNAddStates(25, 27);
3076: break;
3077: case 9:
3078: if ((0x3ff0c1800000000L & l) == 0L)
3079: break;
3080: if (kind > 54)
3081: kind = 54;
3082: jjCheckNAddTwoStates(9, 10);
3083: break;
3084: case 10:
3085: if (curChar == 46)
3086: jjCheckNAddStates(39, 41);
3087: break;
3088: case 11:
3089: if (curChar == 46)
3090: jjCheckNAdd(12);
3091: break;
3092: case 12:
3093: if (curChar != 46)
3094: break;
3095: if (kind > 54)
3096: kind = 54;
3097: jjCheckNAddTwoStates(9, 10);
3098: break;
3099: case 13:
3100: if (curChar == 46)
3101: jjCheckNAddStates(22, 24);
3102: break;
3103: case 14:
3104: if ((0x3ff0c1800000000L & l) != 0L)
3105: jjCheckNAddStates(22, 24);
3106: break;
3107: case 17:
3108: if (curChar == 46)
3109: jjCheckNAddStates(28, 30);
3110: break;
3111: case 18:
3112: if ((0x3ff0c1800000000L & l) != 0L)
3113: jjCheckNAddStates(42, 44);
3114: break;
3115: case 19:
3116: if (curChar == 46)
3117: jjCheckNAddStates(45, 47);
3118: break;
3119: case 20:
3120: if (curChar == 46)
3121: jjCheckNAdd(21);
3122: break;
3123: case 21:
3124: if (curChar == 46)
3125: jjCheckNAddStates(42, 44);
3126: break;
3127: case 22:
3128: if ((0x3ff0c1800000000L & l) == 0L)
3129: break;
3130: if (kind > 54)
3131: kind = 54;
3132: jjCheckNAddStates(31, 35);
3133: break;
3134: default:
3135: break;
3136: }
3137: } while (i != startsAt);
3138: } else if (curChar < 128) {
3139: long l = 1L << (curChar & 077);
3140: MatchLoop: do {
3141: switch (jjstateSet[--i]) {
3142: case 23:
3143: if ((0x7fffffe87fffffeL & l) != 0L)
3144: jjCheckNAddStates(22, 24);
3145: else if (curChar == 91)
3146: jjstateSet[jjnewStateCnt++] = 15;
3147: if ((0x7fffffe87fffffeL & l) != 0L) {
3148: if (kind > 54)
3149: kind = 54;
3150: jjCheckNAddTwoStates(7, 8);
3151: }
3152: break;
3153: case 0:
3154: if ((0x7fffffe87fffffeL & l) != 0L) {
3155: if (kind > 54)
3156: kind = 54;
3157: jjCheckNAddStates(31, 35);
3158: } else if (curChar == 64)
3159: jjCheckNAdd(1);
3160: break;
3161: case 1:
3162: if ((0x7fffffe87fffffeL & l) == 0L)
3163: break;
3164: if (kind > 52)
3165: kind = 52;
3166: jjCheckNAddTwoStates(1, 2);
3167: break;
3168: case 3:
3169: if ((0x7fffffe87fffffeL & l) == 0L)
3170: break;
3171: if (kind > 52)
3172: kind = 52;
3173: jjCheckNAddTwoStates(2, 3);
3174: break;
3175: case 7:
3176: if ((0x7fffffe87fffffeL & l) == 0L)
3177: break;
3178: if (kind > 54)
3179: kind = 54;
3180: jjCheckNAddTwoStates(7, 8);
3181: break;
3182: case 9:
3183: if ((0x7fffffe87fffffeL & l) == 0L)
3184: break;
3185: if (kind > 54)
3186: kind = 54;
3187: jjAddStates(48, 49);
3188: break;
3189: case 14:
3190: if ((0x7fffffe87fffffeL & l) != 0L)
3191: jjCheckNAddStates(22, 24);
3192: break;
3193: case 15:
3194: if (curChar != 93)
3195: break;
3196: kind = 55;
3197: jjCheckNAdd(16);
3198: break;
3199: case 16:
3200: if (curChar == 91)
3201: jjstateSet[jjnewStateCnt++] = 15;
3202: break;
3203: case 18:
3204: if ((0x7fffffe87fffffeL & l) != 0L)
3205: jjCheckNAddStates(42, 44);
3206: break;
3207: case 22:
3208: if ((0x7fffffe87fffffeL & l) == 0L)
3209: break;
3210: if (kind > 54)
3211: kind = 54;
3212: jjCheckNAddStates(31, 35);
3213: break;
3214: default:
3215: break;
3216: }
3217: } while (i != startsAt);
3218: } else {
3219: int i2 = (curChar & 0xff) >> 6;
3220: long l2 = 1L << (curChar & 077);
3221: MatchLoop: do {
3222: switch (jjstateSet[--i]) {
3223: default:
3224: break;
3225: }
3226: } while (i != startsAt);
3227: }
3228: if (kind != 0x7fffffff) {
3229: jjmatchedKind = kind;
3230: jjmatchedPos = curPos;
3231: kind = 0x7fffffff;
3232: }
3233: ++curPos;
3234: if ((i = jjnewStateCnt) == (startsAt = 23 - (jjnewStateCnt = startsAt)))
3235: return curPos;
3236: try {
3237: curChar = input_stream.readChar();
3238: } catch (java.io.IOException e) {
3239: return curPos;
3240: }
3241: }
3242: }
3243:
3244: private static final int jjStopStringLiteralDfa_1(int pos,
3245: long active0, long active1) {
3246: switch (pos) {
3247: default:
3248: return -1;
3249: }
3250: }
3251:
3252: private static final int jjStartNfa_1(int pos, long active0,
3253: long active1) {
3254: return jjMoveNfa_1(jjStopStringLiteralDfa_1(pos, active0,
3255: active1), pos + 1);
3256: }
3257:
3258: static private final int jjStartNfaWithStates_1(int pos, int kind,
3259: int state) {
3260: jjmatchedKind = kind;
3261: jjmatchedPos = pos;
3262: try {
3263: curChar = input_stream.readChar();
3264: } catch (java.io.IOException e) {
3265: return pos + 1;
3266: }
3267: return jjMoveNfa_1(state, pos + 1);
3268: }
3269:
3270: static private final int jjMoveStringLiteralDfa0_1() {
3271: switch (curChar) {
3272: case 33:
3273: return jjStopAtPos(0, 80);
3274: case 44:
3275: return jjStopAtPos(0, 3);
3276: case 46:
3277: return jjStartNfaWithStates_1(0, 4, 5);
3278: default:
3279: return jjMoveNfa_1(0, 0);
3280: }
3281: }
3282:
3283: static private final int jjMoveNfa_1(int startState, int curPos) {
3284: int[] nextStates;
3285: int startsAt = 0;
3286: jjnewStateCnt = 23;
3287: int i = 1;
3288: jjstateSet[0] = startState;
3289: int j, kind = 0x7fffffff;
3290: for (;;) {
3291: if (++jjround == 0x7fffffff)
3292: ReInitRounds();
3293: if (curChar < 64) {
3294: long l = 1L << curChar;
3295: MatchLoop: do {
3296: switch (jjstateSet[--i]) {
3297: case 5:
3298: if (curChar == 46)
3299: jjCheckNAddStates(22, 24);
3300: if (curChar == 46) {
3301: if (kind > 76)
3302: kind = 76;
3303: jjCheckNAddTwoStates(7, 8);
3304: }
3305: if (curChar == 46) {
3306: if (kind > 7)
3307: kind = 7;
3308: }
3309: break;
3310: case 0:
3311: if ((0x3ff0c1800000000L & l) != 0L) {
3312: if (kind > 76)
3313: kind = 76;
3314: jjCheckNAddStates(31, 35);
3315: } else if (curChar == 46)
3316: jjCheckNAddStates(36, 38);
3317: break;
3318: case 1:
3319: if ((0x3ff0c1800000000L & l) == 0L)
3320: break;
3321: if (kind > 78)
3322: kind = 78;
3323: jjCheckNAddTwoStates(1, 2);
3324: break;
3325: case 2:
3326: if (curChar == 46)
3327: jjstateSet[jjnewStateCnt++] = 3;
3328: break;
3329: case 3:
3330: if (curChar != 46)
3331: break;
3332: if (kind > 78)
3333: kind = 78;
3334: jjCheckNAddTwoStates(1, 2);
3335: break;
3336: case 4:
3337: if (curChar == 46)
3338: jjCheckNAddStates(36, 38);
3339: break;
3340: case 6:
3341: if (curChar != 46)
3342: break;
3343: if (kind > 76)
3344: kind = 76;
3345: jjCheckNAddTwoStates(7, 8);
3346: break;
3347: case 7:
3348: if ((0x3ff0c1800000000L & l) == 0L)
3349: break;
3350: if (kind > 76)
3351: kind = 76;
3352: jjCheckNAddTwoStates(7, 8);
3353: break;
3354: case 8:
3355: if (curChar == 46)
3356: jjCheckNAddStates(25, 27);
3357: break;
3358: case 9:
3359: if ((0x3ff0c1800000000L & l) == 0L)
3360: break;
3361: if (kind > 76)
3362: kind = 76;
3363: jjCheckNAddTwoStates(9, 10);
3364: break;
3365: case 10:
3366: if (curChar == 46)
3367: jjCheckNAddStates(39, 41);
3368: break;
3369: case 11:
3370: if (curChar == 46)
3371: jjCheckNAdd(12);
3372: break;
3373: case 12:
3374: if (curChar != 46)
3375: break;
3376: if (kind > 76)
3377: kind = 76;
3378: jjCheckNAddTwoStates(9, 10);
3379: break;
3380: case 13:
3381: if (curChar == 46)
3382: jjCheckNAddStates(22, 24);
3383: break;
3384: case 14:
3385: if ((0x3ff0c1800000000L & l) != 0L)
3386: jjCheckNAddStates(22, 24);
3387: break;
3388: case 17:
3389: if (curChar == 46)
3390: jjCheckNAddStates(28, 30);
3391: break;
3392: case 18:
3393: if ((0x3ff0c1800000000L & l) != 0L)
3394: jjCheckNAddStates(42, 44);
3395: break;
3396: case 19:
3397: if (curChar == 46)
3398: jjCheckNAddStates(45, 47);
3399: break;
3400: case 20:
3401: if (curChar == 46)
3402: jjCheckNAdd(21);
3403: break;
3404: case 21:
3405: if (curChar == 46)
3406: jjCheckNAddStates(42, 44);
3407: break;
3408: case 22:
3409: if ((0x3ff0c1800000000L & l) == 0L)
3410: break;
3411: if (kind > 76)
3412: kind = 76;
3413: jjCheckNAddStates(31, 35);
3414: break;
3415: default:
3416: break;
3417: }
3418: } while (i != startsAt);
3419: } else if (curChar < 128) {
3420: long l = 1L << (curChar & 077);
3421: MatchLoop: do {
3422: switch (jjstateSet[--i]) {
3423: case 0:
3424: if ((0x7fffffe87fffffeL & l) != 0L) {
3425: if (kind > 76)
3426: kind = 76;
3427: jjCheckNAddStates(31, 35);
3428: } else if (curChar == 64)
3429: jjCheckNAddTwoStates(1, 2);
3430: break;
3431: case 1:
3432: if ((0x7fffffe87fffffeL & l) == 0L)
3433: break;
3434: if (kind > 78)
3435: kind = 78;
3436: jjCheckNAddTwoStates(1, 2);
3437: break;
3438: case 7:
3439: if ((0x7fffffe87fffffeL & l) == 0L)
3440: break;
3441: if (kind > 76)
3442: kind = 76;
3443: jjCheckNAddTwoStates(7, 8);
3444: break;
3445: case 9:
3446: if ((0x7fffffe87fffffeL & l) == 0L)
3447: break;
3448: if (kind > 76)
3449: kind = 76;
3450: jjAddStates(48, 49);
3451: break;
3452: case 14:
3453: if ((0x7fffffe87fffffeL & l) != 0L)
3454: jjCheckNAddStates(22, 24);
3455: break;
3456: case 15:
3457: if (curChar != 93)
3458: break;
3459: kind = 77;
3460: jjCheckNAdd(16);
3461: break;
3462: case 16:
3463: if (curChar == 91)
3464: jjstateSet[jjnewStateCnt++] = 15;
3465: break;
3466: case 18:
3467: if ((0x7fffffe87fffffeL & l) != 0L)
3468: jjCheckNAddStates(42, 44);
3469: break;
3470: case 22:
3471: if ((0x7fffffe87fffffeL & l) == 0L)
3472: break;
3473: if (kind > 76)
3474: kind = 76;
3475: jjCheckNAddStates(31, 35);
3476: break;
3477: default:
3478: break;
3479: }
3480: } while (i != startsAt);
3481: } else {
3482: int i2 = (curChar & 0xff) >> 6;
3483: long l2 = 1L << (curChar & 077);
3484: MatchLoop: do {
3485: switch (jjstateSet[--i]) {
3486: default:
3487: break;
3488: }
3489: } while (i != startsAt);
3490: }
3491: if (kind != 0x7fffffff) {
3492: jjmatchedKind = kind;
3493: jjmatchedPos = curPos;
3494: kind = 0x7fffffff;
3495: }
3496: ++curPos;
3497: if ((i = jjnewStateCnt) == (startsAt = 23 - (jjnewStateCnt = startsAt)))
3498: return curPos;
3499: try {
3500: curChar = input_stream.readChar();
3501: } catch (java.io.IOException e) {
3502: return curPos;
3503: }
3504: }
3505: }
3506:
3507: static final int[] jjnextStates = { 19, 20, 21, 3, 4, 6, 7, 10, 6,
3508: 7, 10, 7, 8, 10, 6, 7, 9, 7, 9, 10, 7, 8, 14, 16, 17, 6, 9,
3509: 11, 13, 18, 20, 7, 14, 16, 17, 8, 5, 6, 13, 9, 11, 12, 18,
3510: 16, 19, 18, 20, 21, 9, 10, };
3511: public static final String[] jjstrLiteralImages = {
3512: "",
3513: null,
3514: null,
3515: "\54",
3516: "\56",
3517: null,
3518: null,
3519: null,
3520: null,
3521: null,
3522: "\41",
3523: "\145\170\145\143\165\164\151\157\156\50",
3524: "\143\141\154\154\50",
3525: "\163\145\164\50",
3526: "\147\145\164\50",
3527: "\150\141\156\144\154\145\162\50",
3528: "\167\151\164\150\151\156\50",
3529: "\167\151\164\150\151\156\143\157\144\145\50",
3530: "\163\164\141\164\151\143\151\156\151\164\151\141\154\151\172\141\164\151\157\156\50",
3531: "\143\146\154\157\167\50",
3532: "\143\146\154\157\167\142\145\154\157\167\50",
3533: "\141\162\147\163\50",
3534: "\164\141\162\147\145\164\50",
3535: "\164\150\151\163\50",
3536: "\151\146\50\51",
3537: "\150\141\163\155\145\164\150\157\144\50",
3538: "\150\141\163\146\151\145\154\144\50",
3539: null,
3540: null,
3541: "\160\162\151\166\141\164\145",
3542: "\160\162\157\164\145\143\164\145\144",
3543: "\160\165\142\154\151\143",
3544: "\163\164\141\164\151\143",
3545: "\141\142\163\164\162\141\143\164",
3546: "\146\151\156\141\154",
3547: "\41",
3548: null,
3549: null,
3550: null,
3551: null,
3552: null,
3553: "\51",
3554: "\160\165\142\154\151\143",
3555: "\160\162\157\164\145\143\164\145\144",
3556: "\160\162\151\166\141\164\145",
3557: "\163\164\141\164\151\143",
3558: "\141\142\163\164\162\141\143\164",
3559: "\146\151\156\141\154",
3560: "\156\141\164\151\166\145",
3561: "\163\171\156\143\150\162\157\156\151\172\145\144",
3562: "\163\164\141\164\151\143\151\156\151\164\151\141\154\151\172\141\164\151\157\156",
3563: "\41", null, null, null, null, null, "\50", "\51", null,
3564: "\160\162\151\166\141\164\145",
3565: "\160\162\157\164\145\143\164\145\144",
3566: "\160\165\142\154\151\143", "\163\164\141\164\151\143",
3567: "\141\142\163\164\162\141\143\164", "\146\151\156\141\154",
3568: "\164\162\141\156\163\151\145\156\164", "\41", null, null,
3569: null, null, null, null, "\51", null, null, null, null,
3570: null, "\41", null, null, null, null, "\51", "\50", "\51", };
3571: public static final String[] lexStateNames = { "IN_ARGS",
3572: "PARAMETERS", "FIELD", "METHOD", "CLASS", "DEFAULT", };
3573: public static final int[] jjnewLexState = { -1, -1, -1, -1, -1, -1,
3574: -1, -1, -1, -1, -1, 3, 3, 2, 2, 4, 4, 3, 4, -1, -1, 0, 4,
3575: 4, -1, 3, 2, 0, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
3576: -1, -1, 5, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
3577: -1, -1, -1, -1, 5, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
3578: -1, -1, -1, -1, -1, 5, -1, -1, -1, -1, -1, -1, -1, -1, -1,
3579: -1, 5, -1, -1, };
3580: static final long[] jjtoToken = { 0xf6dffe3fffffff99L, 0xed74dfL, };
3581: static final long[] jjtoSkip = { 0x6L, 0x0L, };
3582: static protected SimpleCharStream input_stream;
3583: static private final int[] jjrounds = new int[23];
3584: static private final int[] jjstateSet = new int[46];
3585: static protected char curChar;
3586:
3587: public ExpressionParserTokenManager(SimpleCharStream stream) {
3588: if (input_stream != null)
3589: throw new TokenMgrError(
3590: "ERROR: Second call to constructor of static lexer. You must use ReInit() to initialize the static variables.",
3591: TokenMgrError.STATIC_LEXER_ERROR);
3592: input_stream = stream;
3593: }
3594:
3595: public ExpressionParserTokenManager(SimpleCharStream stream,
3596: int lexState) {
3597: this (stream);
3598: SwitchTo(lexState);
3599: }
3600:
3601: static public void ReInit(SimpleCharStream stream) {
3602: jjmatchedPos = jjnewStateCnt = 0;
3603: curLexState = defaultLexState;
3604: input_stream = stream;
3605: ReInitRounds();
3606: }
3607:
3608: static private final void ReInitRounds() {
3609: int i;
3610: jjround = 0x80000001;
3611: for (i = 23; i-- > 0;)
3612: jjrounds[i] = 0x80000000;
3613: }
3614:
3615: static public void ReInit(SimpleCharStream stream, int lexState) {
3616: ReInit(stream);
3617: SwitchTo(lexState);
3618: }
3619:
3620: static public void SwitchTo(int lexState) {
3621: if (lexState >= 6 || lexState < 0)
3622: throw new TokenMgrError(
3623: "Error: Ignoring invalid lexical state : "
3624: + lexState + ". State unchanged.",
3625: TokenMgrError.INVALID_LEXICAL_STATE);
3626: else
3627: curLexState = lexState;
3628: }
3629:
3630: static protected Token jjFillToken() {
3631: Token t = Token.newToken(jjmatchedKind);
3632: t.kind = jjmatchedKind;
3633: String im = jjstrLiteralImages[jjmatchedKind];
3634: t.image = (im == null) ? input_stream.GetImage() : im;
3635: t.beginLine = input_stream.getBeginLine();
3636: t.beginColumn = input_stream.getBeginColumn();
3637: t.endLine = input_stream.getEndLine();
3638: t.endColumn = input_stream.getEndColumn();
3639: return t;
3640: }
3641:
3642: static int curLexState = 5;
3643: static int defaultLexState = 5;
3644: static int jjnewStateCnt;
3645: static int jjround;
3646: static int jjmatchedPos;
3647: static int jjmatchedKind;
3648:
3649: public static Token getNextToken() {
3650: int kind;
3651: Token specialToken = null;
3652: Token matchedToken;
3653: int curPos = 0;
3654:
3655: EOFLoop: for (;;) {
3656: try {
3657: curChar = input_stream.BeginToken();
3658: } catch (java.io.IOException e) {
3659: jjmatchedKind = 0;
3660: matchedToken = jjFillToken();
3661: return matchedToken;
3662: }
3663:
3664: switch (curLexState) {
3665: case 0:
3666: try {
3667: input_stream.backup(0);
3668: while (curChar <= 32
3669: && (0x100000200L & (1L << curChar)) != 0L)
3670: curChar = input_stream.BeginToken();
3671: } catch (java.io.IOException e1) {
3672: continue EOFLoop;
3673: }
3674: jjmatchedKind = 0x7fffffff;
3675: jjmatchedPos = 0;
3676: curPos = jjMoveStringLiteralDfa0_0();
3677: break;
3678: case 1:
3679: try {
3680: input_stream.backup(0);
3681: while (curChar <= 32
3682: && (0x100000200L & (1L << curChar)) != 0L)
3683: curChar = input_stream.BeginToken();
3684: } catch (java.io.IOException e1) {
3685: continue EOFLoop;
3686: }
3687: jjmatchedKind = 0x7fffffff;
3688: jjmatchedPos = 0;
3689: curPos = jjMoveStringLiteralDfa0_1();
3690: break;
3691: case 2:
3692: try {
3693: input_stream.backup(0);
3694: while (curChar <= 32
3695: && (0x100000200L & (1L << curChar)) != 0L)
3696: curChar = input_stream.BeginToken();
3697: } catch (java.io.IOException e1) {
3698: continue EOFLoop;
3699: }
3700: jjmatchedKind = 0x7fffffff;
3701: jjmatchedPos = 0;
3702: curPos = jjMoveStringLiteralDfa0_2();
3703: break;
3704: case 3:
3705: try {
3706: input_stream.backup(0);
3707: while (curChar <= 32
3708: && (0x100000200L & (1L << curChar)) != 0L)
3709: curChar = input_stream.BeginToken();
3710: } catch (java.io.IOException e1) {
3711: continue EOFLoop;
3712: }
3713: jjmatchedKind = 0x7fffffff;
3714: jjmatchedPos = 0;
3715: curPos = jjMoveStringLiteralDfa0_3();
3716: break;
3717: case 4:
3718: try {
3719: input_stream.backup(0);
3720: while (curChar <= 32
3721: && (0x100000200L & (1L << curChar)) != 0L)
3722: curChar = input_stream.BeginToken();
3723: } catch (java.io.IOException e1) {
3724: continue EOFLoop;
3725: }
3726: jjmatchedKind = 0x7fffffff;
3727: jjmatchedPos = 0;
3728: curPos = jjMoveStringLiteralDfa0_4();
3729: break;
3730: case 5:
3731: try {
3732: input_stream.backup(0);
3733: while (curChar <= 32
3734: && (0x100000200L & (1L << curChar)) != 0L)
3735: curChar = input_stream.BeginToken();
3736: } catch (java.io.IOException e1) {
3737: continue EOFLoop;
3738: }
3739: jjmatchedKind = 0x7fffffff;
3740: jjmatchedPos = 0;
3741: curPos = jjMoveStringLiteralDfa0_5();
3742: break;
3743: }
3744: if (jjmatchedKind != 0x7fffffff) {
3745: if (jjmatchedPos + 1 < curPos)
3746: input_stream.backup(curPos - jjmatchedPos - 1);
3747: if ((jjtoToken[jjmatchedKind >> 6] & (1L << (jjmatchedKind & 077))) != 0L) {
3748: matchedToken = jjFillToken();
3749: if (jjnewLexState[jjmatchedKind] != -1)
3750: curLexState = jjnewLexState[jjmatchedKind];
3751: return matchedToken;
3752: } else {
3753: if (jjnewLexState[jjmatchedKind] != -1)
3754: curLexState = jjnewLexState[jjmatchedKind];
3755: continue EOFLoop;
3756: }
3757: }
3758: int error_line = input_stream.getEndLine();
3759: int error_column = input_stream.getEndColumn();
3760: String error_after = null;
3761: boolean EOFSeen = false;
3762: try {
3763: input_stream.readChar();
3764: input_stream.backup(1);
3765: } catch (java.io.IOException e1) {
3766: EOFSeen = true;
3767: error_after = curPos <= 1 ? "" : input_stream
3768: .GetImage();
3769: if (curChar == '\n' || curChar == '\r') {
3770: error_line++;
3771: error_column = 0;
3772: } else
3773: error_column++;
3774: }
3775: if (!EOFSeen) {
3776: input_stream.backup(1);
3777: error_after = curPos <= 1 ? "" : input_stream
3778: .GetImage();
3779: }
3780: throw new TokenMgrError(EOFSeen, curLexState, error_line,
3781: error_column, error_after, curChar,
3782: TokenMgrError.LEXICAL_ERROR);
3783: }
3784: }
3785:
3786: }
|