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