0001: /* Generated By:JavaCC: Do not edit this line. CompactSyntaxTokenManager.java */
0002: package org.kohsuke.rngom.parse.compact;
0003:
0004: import java.io.Reader;
0005: import java.net.MalformedURLException;
0006: import java.net.URL;
0007: import java.util.Arrays;
0008: import java.util.ArrayList;
0009: import java.util.Collections;
0010: import java.util.Enumeration;
0011: import java.util.Hashtable;
0012: import java.util.List;
0013: import org.kohsuke.rngom.ast.builder.Annotations;
0014: import org.kohsuke.rngom.ast.builder.BuildException;
0015: import org.kohsuke.rngom.ast.builder.CommentList;
0016: import org.kohsuke.rngom.ast.builder.DataPatternBuilder;
0017: import org.kohsuke.rngom.ast.builder.Div;
0018: import org.kohsuke.rngom.ast.builder.ElementAnnotationBuilder;
0019: import org.kohsuke.rngom.ast.builder.Grammar;
0020: import org.kohsuke.rngom.ast.builder.GrammarSection;
0021: import org.kohsuke.rngom.ast.builder.Include;
0022: import org.kohsuke.rngom.ast.builder.IncludedGrammar;
0023: import org.kohsuke.rngom.ast.builder.NameClassBuilder;
0024: import org.kohsuke.rngom.ast.builder.SchemaBuilder;
0025: import org.kohsuke.rngom.ast.builder.Scope;
0026: import org.kohsuke.rngom.ast.om.Location;
0027: import org.kohsuke.rngom.ast.om.ParsedElementAnnotation;
0028: import org.kohsuke.rngom.ast.om.ParsedNameClass;
0029: import org.kohsuke.rngom.ast.om.ParsedPattern;
0030: import org.kohsuke.rngom.parse.Context;
0031: import org.kohsuke.rngom.parse.IllegalSchemaException;
0032: import org.kohsuke.rngom.parse.Parseable;
0033: import org.xml.sax.ErrorHandler;
0034: import org.xml.sax.SAXException;
0035: import org.xml.sax.SAXParseException;
0036: import org.xml.sax.helpers.LocatorImpl;
0037: import org.kohsuke.rngom.util.Localizer;
0038: import org.kohsuke.rngom.xml.util.WellKnownNamespaces;
0039:
0040: public class CompactSyntaxTokenManager implements
0041: CompactSyntaxConstants {
0042: public java.io.PrintStream debugStream = System.out;
0043:
0044: public void setDebugStream(java.io.PrintStream ds) {
0045: debugStream = ds;
0046: }
0047:
0048: private final int jjStopStringLiteralDfa_0(int pos, long active0) {
0049: switch (pos) {
0050: case 0:
0051: if ((active0 & 0x1f8c0fe4e0L) != 0L) {
0052: jjmatchedKind = 54;
0053: return 43;
0054: }
0055: if ((active0 & 0x800000000000000L) != 0L) {
0056: jjmatchedKind = 60;
0057: return -1;
0058: }
0059: return -1;
0060: case 1:
0061: if ((active0 & 0x1f8c0fe4e0L) != 0L) {
0062: jjmatchedKind = 54;
0063: jjmatchedPos = 1;
0064: return 43;
0065: }
0066: if ((active0 & 0x800000000000000L) != 0L) {
0067: if (jjmatchedPos == 0) {
0068: jjmatchedKind = 60;
0069: jjmatchedPos = 0;
0070: }
0071: return -1;
0072: }
0073: return -1;
0074: case 2:
0075: if ((active0 & 0x1f8c0fe4a0L) != 0L) {
0076: jjmatchedKind = 54;
0077: jjmatchedPos = 2;
0078: return 43;
0079: }
0080: if ((active0 & 0x40L) != 0L)
0081: return 43;
0082: return -1;
0083: case 3:
0084: if ((active0 & 0x1f0c0be4a0L) != 0L) {
0085: jjmatchedKind = 54;
0086: jjmatchedPos = 3;
0087: return 43;
0088: }
0089: if ((active0 & 0x80040000L) != 0L)
0090: return 43;
0091: return -1;
0092: case 4:
0093: if ((active0 & 0xe0c09e480L) != 0L) {
0094: jjmatchedKind = 54;
0095: jjmatchedPos = 4;
0096: return 43;
0097: }
0098: if ((active0 & 0x1100020020L) != 0L)
0099: return 43;
0100: return -1;
0101: case 5:
0102: if ((active0 & 0x20c09e480L) != 0L) {
0103: jjmatchedKind = 54;
0104: jjmatchedPos = 5;
0105: return 43;
0106: }
0107: if ((active0 & 0xc00000000L) != 0L)
0108: return 43;
0109: return -1;
0110: case 6:
0111: if ((active0 & 0x208092000L) != 0L) {
0112: jjmatchedKind = 54;
0113: jjmatchedPos = 6;
0114: return 43;
0115: }
0116: if ((active0 & 0x400c480L) != 0L)
0117: return 43;
0118: return -1;
0119: case 7:
0120: if ((active0 & 0x8092000L) != 0L) {
0121: jjmatchedKind = 54;
0122: jjmatchedPos = 7;
0123: return 43;
0124: }
0125: if ((active0 & 0x200000000L) != 0L)
0126: return 43;
0127: return -1;
0128: case 8:
0129: if ((active0 & 0x80000L) != 0L) {
0130: jjmatchedKind = 54;
0131: jjmatchedPos = 8;
0132: return 43;
0133: }
0134: if ((active0 & 0x8012000L) != 0L)
0135: return 43;
0136: return -1;
0137: default:
0138: return -1;
0139: }
0140: }
0141:
0142: private final int jjStartNfa_0(int pos, long active0) {
0143: return jjMoveNfa_0(jjStopStringLiteralDfa_0(pos, active0),
0144: pos + 1);
0145: }
0146:
0147: private final int jjStopAtPos(int pos, int kind) {
0148: jjmatchedKind = kind;
0149: jjmatchedPos = pos;
0150: return pos + 1;
0151: }
0152:
0153: private final int jjStartNfaWithStates_0(int pos, int kind,
0154: int state) {
0155: jjmatchedKind = kind;
0156: jjmatchedPos = pos;
0157: try {
0158: curChar = input_stream.readChar();
0159: } catch (java.io.IOException e) {
0160: return pos + 1;
0161: }
0162: return jjMoveNfa_0(state, pos + 1);
0163: }
0164:
0165: private final int jjMoveStringLiteralDfa0_0() {
0166: switch (curChar) {
0167: case 38:
0168: jjmatchedKind = 21;
0169: return jjMoveStringLiteralDfa1_0(0x8L);
0170: case 40:
0171: return jjStopAtPos(0, 28);
0172: case 41:
0173: return jjStopAtPos(0, 29);
0174: case 42:
0175: return jjStopAtPos(0, 25);
0176: case 43:
0177: return jjStopAtPos(0, 23);
0178: case 44:
0179: return jjStopAtPos(0, 22);
0180: case 45:
0181: return jjStopAtPos(0, 30);
0182: case 61:
0183: return jjStopAtPos(0, 2);
0184: case 62:
0185: return jjMoveStringLiteralDfa1_0(0x800000000000000L);
0186: case 63:
0187: return jjStopAtPos(0, 24);
0188: case 91:
0189: return jjStopAtPos(0, 1);
0190: case 93:
0191: return jjStopAtPos(0, 9);
0192: case 97:
0193: return jjMoveStringLiteralDfa1_0(0x8000000L);
0194: case 100:
0195: return jjMoveStringLiteralDfa1_0(0x14040L);
0196: case 101:
0197: return jjMoveStringLiteralDfa1_0(0x204020000L);
0198: case 103:
0199: return jjMoveStringLiteralDfa1_0(0x400L);
0200: case 105:
0201: return jjMoveStringLiteralDfa1_0(0x8080L);
0202: case 108:
0203: return jjMoveStringLiteralDfa1_0(0x80000000L);
0204: case 109:
0205: return jjMoveStringLiteralDfa1_0(0x100000000L);
0206: case 110:
0207: return jjMoveStringLiteralDfa1_0(0x82000L);
0208: case 112:
0209: return jjMoveStringLiteralDfa1_0(0x400000000L);
0210: case 115:
0211: return jjMoveStringLiteralDfa1_0(0x800000020L);
0212: case 116:
0213: return jjMoveStringLiteralDfa1_0(0x1000040000L);
0214: case 123:
0215: return jjStopAtPos(0, 11);
0216: case 124:
0217: jjmatchedKind = 20;
0218: return jjMoveStringLiteralDfa1_0(0x10L);
0219: case 125:
0220: return jjStopAtPos(0, 12);
0221: case 126:
0222: return jjStopAtPos(0, 8);
0223: default:
0224: return jjMoveNfa_0(3, 0);
0225: }
0226: }
0227:
0228: private final int jjMoveStringLiteralDfa1_0(long active0) {
0229: try {
0230: curChar = input_stream.readChar();
0231: } catch (java.io.IOException e) {
0232: jjStopStringLiteralDfa_0(0, active0);
0233: return 1;
0234: }
0235: switch (curChar) {
0236: case 61:
0237: if ((active0 & 0x8L) != 0L)
0238: return jjStopAtPos(1, 3);
0239: else if ((active0 & 0x10L) != 0L)
0240: return jjStopAtPos(1, 4);
0241: break;
0242: case 62:
0243: if ((active0 & 0x800000000000000L) != 0L)
0244: return jjStopAtPos(1, 59);
0245: break;
0246: case 97:
0247: return jjMoveStringLiteralDfa2_0(active0, 0x400012000L);
0248: case 101:
0249: return jjMoveStringLiteralDfa2_0(active0, 0x44000L);
0250: case 105:
0251: return jjMoveStringLiteralDfa2_0(active0, 0x180000040L);
0252: case 108:
0253: return jjMoveStringLiteralDfa2_0(active0, 0x4000000L);
0254: case 109:
0255: return jjMoveStringLiteralDfa2_0(active0, 0x20000L);
0256: case 110:
0257: return jjMoveStringLiteralDfa2_0(active0, 0x8080L);
0258: case 111:
0259: return jjMoveStringLiteralDfa2_0(active0, 0x1000080000L);
0260: case 114:
0261: return jjMoveStringLiteralDfa2_0(active0, 0x400L);
0262: case 116:
0263: return jjMoveStringLiteralDfa2_0(active0, 0x808000020L);
0264: case 120:
0265: return jjMoveStringLiteralDfa2_0(active0, 0x200000000L);
0266: default:
0267: break;
0268: }
0269: return jjStartNfa_0(0, active0);
0270: }
0271:
0272: private final int jjMoveStringLiteralDfa2_0(long old0, long active0) {
0273: if (((active0 &= old0)) == 0L)
0274: return jjStartNfa_0(0, old0);
0275: try {
0276: curChar = input_stream.readChar();
0277: } catch (java.io.IOException e) {
0278: jjStopStringLiteralDfa_0(1, active0);
0279: return 2;
0280: }
0281: switch (curChar) {
0282: case 97:
0283: return jjMoveStringLiteralDfa3_0(active0, 0x420L);
0284: case 99:
0285: return jjMoveStringLiteralDfa3_0(active0, 0x80L);
0286: case 101:
0287: return jjMoveStringLiteralDfa3_0(active0, 0x4000000L);
0288: case 102:
0289: return jjMoveStringLiteralDfa3_0(active0, 0x4000L);
0290: case 104:
0291: return jjMoveStringLiteralDfa3_0(active0, 0x8000L);
0292: case 107:
0293: return jjMoveStringLiteralDfa3_0(active0, 0x1000000000L);
0294: case 109:
0295: return jjMoveStringLiteralDfa3_0(active0, 0x2000L);
0296: case 112:
0297: return jjMoveStringLiteralDfa3_0(active0, 0x20000L);
0298: case 114:
0299: return jjMoveStringLiteralDfa3_0(active0, 0xc00000000L);
0300: case 115:
0301: return jjMoveStringLiteralDfa3_0(active0, 0x80000000L);
0302: case 116:
0303: return jjMoveStringLiteralDfa3_0(active0, 0x208090000L);
0304: case 118:
0305: if ((active0 & 0x40L) != 0L)
0306: return jjStartNfaWithStates_0(2, 6, 43);
0307: break;
0308: case 120:
0309: return jjMoveStringLiteralDfa3_0(active0, 0x100040000L);
0310: default:
0311: break;
0312: }
0313: return jjStartNfa_0(1, active0);
0314: }
0315:
0316: private final int jjMoveStringLiteralDfa3_0(long old0, long active0) {
0317: if (((active0 &= old0)) == 0L)
0318: return jjStartNfa_0(1, old0);
0319: try {
0320: curChar = input_stream.readChar();
0321: } catch (java.io.IOException e) {
0322: jjStopStringLiteralDfa_0(2, active0);
0323: return 3;
0324: }
0325: switch (curChar) {
0326: case 65:
0327: return jjMoveStringLiteralDfa4_0(active0, 0x80000L);
0328: case 97:
0329: return jjMoveStringLiteralDfa4_0(active0, 0x14000L);
0330: case 101:
0331: return jjMoveStringLiteralDfa4_0(active0, 0x170000a000L);
0332: case 105:
0333: return jjMoveStringLiteralDfa4_0(active0, 0x800000000L);
0334: case 108:
0335: return jjMoveStringLiteralDfa4_0(active0, 0x80L);
0336: case 109:
0337: return jjMoveStringLiteralDfa4_0(active0, 0x4000400L);
0338: case 114:
0339: return jjMoveStringLiteralDfa4_0(active0, 0x8000020L);
0340: case 116:
0341: if ((active0 & 0x40000L) != 0L)
0342: return jjStartNfaWithStates_0(3, 18, 43);
0343: else if ((active0 & 0x80000000L) != 0L)
0344: return jjStartNfaWithStates_0(3, 31, 43);
0345: return jjMoveStringLiteralDfa4_0(active0, 0x20000L);
0346: default:
0347: break;
0348: }
0349: return jjStartNfa_0(2, active0);
0350: }
0351:
0352: private final int jjMoveStringLiteralDfa4_0(long old0, long active0) {
0353: if (((active0 &= old0)) == 0L)
0354: return jjStartNfa_0(2, old0);
0355: try {
0356: curChar = input_stream.readChar();
0357: } catch (java.io.IOException e) {
0358: jjStopStringLiteralDfa_0(3, active0);
0359: return 4;
0360: }
0361: switch (curChar) {
0362: case 100:
0363: if ((active0 & 0x100000000L) != 0L)
0364: return jjStartNfaWithStates_0(4, 32, 43);
0365: break;
0366: case 101:
0367: return jjMoveStringLiteralDfa5_0(active0, 0x4000000L);
0368: case 105:
0369: return jjMoveStringLiteralDfa5_0(active0, 0x8000000L);
0370: case 108:
0371: return jjMoveStringLiteralDfa5_0(active0, 0x80000L);
0372: case 109:
0373: return jjMoveStringLiteralDfa5_0(active0, 0x400L);
0374: case 110:
0375: if ((active0 & 0x1000000000L) != 0L)
0376: return jjStartNfaWithStates_0(4, 36, 43);
0377: return jjMoveStringLiteralDfa5_0(active0, 0xc00000000L);
0378: case 114:
0379: return jjMoveStringLiteralDfa5_0(active0, 0x200008000L);
0380: case 115:
0381: return jjMoveStringLiteralDfa5_0(active0, 0x2000L);
0382: case 116:
0383: if ((active0 & 0x20L) != 0L)
0384: return jjStartNfaWithStates_0(4, 5, 43);
0385: return jjMoveStringLiteralDfa5_0(active0, 0x10000L);
0386: case 117:
0387: return jjMoveStringLiteralDfa5_0(active0, 0x4080L);
0388: case 121:
0389: if ((active0 & 0x20000L) != 0L)
0390: return jjStartNfaWithStates_0(4, 17, 43);
0391: break;
0392: default:
0393: break;
0394: }
0395: return jjStartNfa_0(3, active0);
0396: }
0397:
0398: private final int jjMoveStringLiteralDfa5_0(long old0, long active0) {
0399: if (((active0 &= old0)) == 0L)
0400: return jjStartNfa_0(3, old0);
0401: try {
0402: curChar = input_stream.readChar();
0403: } catch (java.io.IOException e) {
0404: jjStopStringLiteralDfa_0(4, active0);
0405: return 5;
0406: }
0407: switch (curChar) {
0408: case 97:
0409: return jjMoveStringLiteralDfa6_0(active0, 0x400L);
0410: case 98:
0411: return jjMoveStringLiteralDfa6_0(active0, 0x8000000L);
0412: case 100:
0413: return jjMoveStringLiteralDfa6_0(active0, 0x80L);
0414: case 103:
0415: if ((active0 & 0x800000000L) != 0L)
0416: return jjStartNfaWithStates_0(5, 35, 43);
0417: break;
0418: case 105:
0419: return jjMoveStringLiteralDfa6_0(active0, 0x8000L);
0420: case 108:
0421: return jjMoveStringLiteralDfa6_0(active0, 0x84000L);
0422: case 110:
0423: return jjMoveStringLiteralDfa6_0(active0, 0x204000000L);
0424: case 112:
0425: return jjMoveStringLiteralDfa6_0(active0, 0x2000L);
0426: case 116:
0427: if ((active0 & 0x400000000L) != 0L)
0428: return jjStartNfaWithStates_0(5, 34, 43);
0429: break;
0430: case 121:
0431: return jjMoveStringLiteralDfa6_0(active0, 0x10000L);
0432: default:
0433: break;
0434: }
0435: return jjStartNfa_0(4, active0);
0436: }
0437:
0438: private final int jjMoveStringLiteralDfa6_0(long old0, long active0) {
0439: if (((active0 &= old0)) == 0L)
0440: return jjStartNfa_0(4, old0);
0441: try {
0442: curChar = input_stream.readChar();
0443: } catch (java.io.IOException e) {
0444: jjStopStringLiteralDfa_0(5, active0);
0445: return 6;
0446: }
0447: switch (curChar) {
0448: case 97:
0449: return jjMoveStringLiteralDfa7_0(active0, 0x200002000L);
0450: case 101:
0451: if ((active0 & 0x80L) != 0L)
0452: return jjStartNfaWithStates_0(6, 7, 43);
0453: break;
0454: case 111:
0455: return jjMoveStringLiteralDfa7_0(active0, 0x80000L);
0456: case 112:
0457: return jjMoveStringLiteralDfa7_0(active0, 0x10000L);
0458: case 114:
0459: if ((active0 & 0x400L) != 0L)
0460: return jjStartNfaWithStates_0(6, 10, 43);
0461: break;
0462: case 116:
0463: if ((active0 & 0x4000L) != 0L)
0464: return jjStartNfaWithStates_0(6, 14, 43);
0465: else if ((active0 & 0x8000L) != 0L)
0466: return jjStartNfaWithStates_0(6, 15, 43);
0467: else if ((active0 & 0x4000000L) != 0L)
0468: return jjStartNfaWithStates_0(6, 26, 43);
0469: break;
0470: case 117:
0471: return jjMoveStringLiteralDfa7_0(active0, 0x8000000L);
0472: default:
0473: break;
0474: }
0475: return jjStartNfa_0(5, active0);
0476: }
0477:
0478: private final int jjMoveStringLiteralDfa7_0(long old0, long active0) {
0479: if (((active0 &= old0)) == 0L)
0480: return jjStartNfa_0(5, old0);
0481: try {
0482: curChar = input_stream.readChar();
0483: } catch (java.io.IOException e) {
0484: jjStopStringLiteralDfa_0(6, active0);
0485: return 7;
0486: }
0487: switch (curChar) {
0488: case 99:
0489: return jjMoveStringLiteralDfa8_0(active0, 0x2000L);
0490: case 101:
0491: return jjMoveStringLiteralDfa8_0(active0, 0x10000L);
0492: case 108:
0493: if ((active0 & 0x200000000L) != 0L)
0494: return jjStartNfaWithStates_0(7, 33, 43);
0495: break;
0496: case 116:
0497: return jjMoveStringLiteralDfa8_0(active0, 0x8000000L);
0498: case 119:
0499: return jjMoveStringLiteralDfa8_0(active0, 0x80000L);
0500: default:
0501: break;
0502: }
0503: return jjStartNfa_0(6, active0);
0504: }
0505:
0506: private final int jjMoveStringLiteralDfa8_0(long old0, long active0) {
0507: if (((active0 &= old0)) == 0L)
0508: return jjStartNfa_0(6, old0);
0509: try {
0510: curChar = input_stream.readChar();
0511: } catch (java.io.IOException e) {
0512: jjStopStringLiteralDfa_0(7, active0);
0513: return 8;
0514: }
0515: switch (curChar) {
0516: case 101:
0517: if ((active0 & 0x2000L) != 0L)
0518: return jjStartNfaWithStates_0(8, 13, 43);
0519: else if ((active0 & 0x8000000L) != 0L)
0520: return jjStartNfaWithStates_0(8, 27, 43);
0521: return jjMoveStringLiteralDfa9_0(active0, 0x80000L);
0522: case 115:
0523: if ((active0 & 0x10000L) != 0L)
0524: return jjStartNfaWithStates_0(8, 16, 43);
0525: break;
0526: default:
0527: break;
0528: }
0529: return jjStartNfa_0(7, active0);
0530: }
0531:
0532: private final int jjMoveStringLiteralDfa9_0(long old0, long active0) {
0533: if (((active0 &= old0)) == 0L)
0534: return jjStartNfa_0(7, old0);
0535: try {
0536: curChar = input_stream.readChar();
0537: } catch (java.io.IOException e) {
0538: jjStopStringLiteralDfa_0(8, active0);
0539: return 9;
0540: }
0541: switch (curChar) {
0542: case 100:
0543: if ((active0 & 0x80000L) != 0L)
0544: return jjStartNfaWithStates_0(9, 19, 43);
0545: break;
0546: default:
0547: break;
0548: }
0549: return jjStartNfa_0(8, active0);
0550: }
0551:
0552: private final void jjCheckNAdd(int state) {
0553: if (jjrounds[state] != jjround) {
0554: jjstateSet[jjnewStateCnt++] = state;
0555: jjrounds[state] = jjround;
0556: }
0557: }
0558:
0559: private final void jjAddStates(int start, int end) {
0560: do {
0561: jjstateSet[jjnewStateCnt++] = jjnextStates[start];
0562: } while (start++ != end);
0563: }
0564:
0565: private final void jjCheckNAddTwoStates(int state1, int state2) {
0566: jjCheckNAdd(state1);
0567: jjCheckNAdd(state2);
0568: }
0569:
0570: private final void jjCheckNAddStates(int start, int end) {
0571: do {
0572: jjCheckNAdd(jjnextStates[start]);
0573: } while (start++ != end);
0574: }
0575:
0576: private final void jjCheckNAddStates(int start) {
0577: jjCheckNAdd(jjnextStates[start]);
0578: jjCheckNAdd(jjnextStates[start + 1]);
0579: }
0580:
0581: static final long[] jjbitVec0 = { 0xfffffffffffffffeL,
0582: 0xffffffffffffffffL, 0xffffffffffffffffL,
0583: 0xffffffffffffffffL };
0584: static final long[] jjbitVec2 = { 0x0L, 0x0L, 0xffffffffffffffffL,
0585: 0xffffffffffffffffL };
0586: static final long[] jjbitVec3 = { 0x0L, 0xffffffffffffc000L,
0587: 0xfffff0007fffffffL, 0x7fffffL };
0588: static final long[] jjbitVec4 = { 0x0L, 0x0L, 0x0L,
0589: 0xff7fffffff7fffffL };
0590: static final long[] jjbitVec5 = { 0x7ff3ffffffffffffL,
0591: 0x7ffffffffffffdfeL, 0xffffffffffffffffL,
0592: 0xfc31ffffffffe00fL };
0593: static final long[] jjbitVec6 = { 0xffffffL, 0xffffffffffff0000L,
0594: 0xf80001ffffffffffL, 0x3L };
0595: static final long[] jjbitVec7 = { 0x0L, 0x0L, 0xfffffffbffffd740L,
0596: 0xffffd547f7fffL };
0597: static final long[] jjbitVec8 = { 0xffffffffffffdffeL,
0598: 0xffffffffdffeffffL, 0xffffffffffff0003L,
0599: 0x33fcfffffff199fL };
0600: static final long[] jjbitVec9 = { 0xfffe000000000000L,
0601: 0xfffffffe027fffffL, 0x7fL, 0x707ffffff0000L };
0602: static final long[] jjbitVec10 = { 0x7fffffe00000000L,
0603: 0xfffe0000000007feL, 0x7cffffffffffffffL, 0x60002f7fffL };
0604: static final long[] jjbitVec11 = { 0x23ffffffffffffe0L,
0605: 0x3ff000000L, 0x3c5fdfffff99fe0L, 0x30003b0000000L };
0606: static final long[] jjbitVec12 = { 0x36dfdfffff987e0L,
0607: 0x1c00005e000000L, 0x23edfdfffffbafe0L, 0x100000000L };
0608: static final long[] jjbitVec13 = { 0x23cdfdfffff99fe0L,
0609: 0x3b0000000L, 0x3bfc718d63dc7e0L, 0x0L };
0610: static final long[] jjbitVec14 = { 0x3effdfffffddfe0L,
0611: 0x300000000L, 0x3effdfffffddfe0L, 0x340000000L };
0612: static final long[] jjbitVec15 = { 0x3fffdfffffddfe0L,
0613: 0x300000000L, 0x0L, 0x0L };
0614: static final long[] jjbitVec16 = { 0xd7ffffffffffeL, 0x3fL,
0615: 0x200d6caefef02596L, 0x1fL };
0616: static final long[] jjbitVec17 = { 0x0L, 0x3fffffffeffL, 0x0L, 0x0L };
0617: static final long[] jjbitVec18 = { 0x0L, 0x0L, 0xffffffff00000000L,
0618: 0x7fffffffff003fL };
0619: static final long[] jjbitVec19 = { 0x500000000007daedL,
0620: 0x2c62ab82315001L, 0xf580c90040000000L, 0x201080000000007L };
0621: static final long[] jjbitVec20 = { 0xffffffffffffffffL,
0622: 0xffffffffffffffffL, 0xffffffff0fffffffL,
0623: 0x3ffffffffffffffL };
0624: static final long[] jjbitVec21 = { 0xffffffff3f3fffffL,
0625: 0x3fffffffaaff3f3fL, 0x5fdfffffffffffffL,
0626: 0x1fdc1fff0fcf1fdcL };
0627: static final long[] jjbitVec22 = { 0x4c4000000000L, 0x0L, 0x7L,
0628: 0x0L };
0629: static final long[] jjbitVec23 = { 0x3fe00000080L,
0630: 0xfffffffffffffffeL, 0xfffffffe001fffffL,
0631: 0x7ffffffffffffffL };
0632: static final long[] jjbitVec24 = { 0x1fffffffffe0L, 0x0L, 0x0L,
0633: 0x0L };
0634: static final long[] jjbitVec25 = { 0xffffffffffffffffL,
0635: 0xffffffffffffffffL, 0x3fffffffffL, 0x0L };
0636: static final long[] jjbitVec26 = { 0xffffffffffffffffL,
0637: 0xffffffffffffffffL, 0xfffffffffL, 0x0L };
0638: static final long[] jjbitVec27 = { 0x0L, 0x0L, 0x80000000000000L,
0639: 0xff7fffffff7fffffL };
0640: static final long[] jjbitVec28 = { 0xffffffL, 0xffffffffffff0000L,
0641: 0xf80001ffffffffffL, 0x30003L };
0642: static final long[] jjbitVec29 = { 0xffffffffffffffffL,
0643: 0x30000003fL, 0xfffffffbffffd7c0L, 0xffffd547f7fffL };
0644: static final long[] jjbitVec30 = { 0xffffffffffffdffeL,
0645: 0xffffffffdffeffffL, 0xffffffffffff007bL,
0646: 0x33fcfffffff199fL };
0647: static final long[] jjbitVec31 = { 0xfffe000000000000L,
0648: 0xfffffffe027fffffL, 0xbbfffffbfffe007fL, 0x707ffffff0016L };
0649: static final long[] jjbitVec32 = { 0x7fffffe00000000L,
0650: 0xffff03ff0007ffffL, 0x7cffffffffffffffL,
0651: 0x3ff3dffffef7fffL };
0652: static final long[] jjbitVec33 = { 0xf3ffffffffffffeeL,
0653: 0xffcfff1e3fffL, 0xd3c5fdfffff99feeL, 0x3ffcfb080399fL };
0654: static final long[] jjbitVec34 = { 0xd36dfdfffff987e4L,
0655: 0x1fffc05e003987L, 0xf3edfdfffffbafeeL, 0xffc100003bbfL };
0656: static final long[] jjbitVec35 = { 0xf3cdfdfffff99feeL,
0657: 0xffc3b0c0398fL, 0xc3bfc718d63dc7ecL, 0xff8000803dc7L };
0658: static final long[] jjbitVec36 = { 0xc3effdfffffddfeeL,
0659: 0xffc300603ddfL, 0xc3effdfffffddfecL, 0xffc340603ddfL };
0660: static final long[] jjbitVec37 = { 0xc3fffdfffffddfecL,
0661: 0xffc300803dcfL, 0x0L, 0x0L };
0662: static final long[] jjbitVec38 = { 0x7ff7ffffffffffeL, 0x3ff7fffL,
0663: 0x3bff6caefef02596L, 0x3ff3f5fL };
0664: static final long[] jjbitVec39 = { 0xc2a003ff03000000L,
0665: 0xfffe03fffffffeffL, 0x2fe3ffffebf0fdfL, 0x0L };
0666: static final long[] jjbitVec40 = { 0x0L, 0x0L, 0x0L, 0x21fff0000L };
0667: static final long[] jjbitVec41 = { 0x3efffe000000a0L,
0668: 0xfffffffffffffffeL, 0xfffffffe661fffffL,
0669: 0x77ffffffffffffffL };
0670:
0671: private final int jjMoveNfa_0(int startState, int curPos) {
0672: int[] nextStates;
0673: int startsAt = 0;
0674: jjnewStateCnt = 43;
0675: int i = 1;
0676: jjstateSet[0] = startState;
0677: int j, kind = 0x7fffffff;
0678: for (;;) {
0679: if (++jjround == 0x7fffffff)
0680: ReInitRounds();
0681: if (curChar < 64) {
0682: long l = 1L << curChar;
0683: MatchLoop: do {
0684: switch (jjstateSet[--i]) {
0685: case 3:
0686: if ((0xfffffffffffff9ffL & l) != 0L) {
0687: if (kind > 60)
0688: kind = 60;
0689: }
0690: if ((0x100000601L & l) != 0L) {
0691: if (kind > 39)
0692: kind = 39;
0693: jjCheckNAdd(0);
0694: } else if (curChar == 39)
0695: jjstateSet[jjnewStateCnt++] = 31;
0696: else if (curChar == 34)
0697: jjstateSet[jjnewStateCnt++] = 22;
0698: else if (curChar == 35) {
0699: if (kind > 42)
0700: kind = 42;
0701: jjCheckNAdd(5);
0702: }
0703: if (curChar == 39)
0704: jjCheckNAddTwoStates(13, 14);
0705: else if (curChar == 34)
0706: jjCheckNAddTwoStates(10, 11);
0707: else if (curChar == 35)
0708: jjstateSet[jjnewStateCnt++] = 1;
0709: break;
0710: case 43:
0711: if ((0x3ff600000000000L & l) != 0L)
0712: jjCheckNAddTwoStates(39, 40);
0713: else if (curChar == 58)
0714: jjstateSet[jjnewStateCnt++] = 41;
0715: if ((0x3ff600000000000L & l) != 0L)
0716: jjCheckNAddTwoStates(36, 38);
0717: else if (curChar == 58)
0718: jjstateSet[jjnewStateCnt++] = 37;
0719: if ((0x3ff600000000000L & l) != 0L) {
0720: if (kind > 54)
0721: kind = 54;
0722: jjCheckNAdd(35);
0723: }
0724: break;
0725: case 0:
0726: if ((0x100000601L & l) == 0L)
0727: break;
0728: if (kind > 39)
0729: kind = 39;
0730: jjCheckNAdd(0);
0731: break;
0732: case 1:
0733: if (curChar != 35)
0734: break;
0735: if (kind > 40)
0736: kind = 40;
0737: jjCheckNAdd(2);
0738: break;
0739: case 2:
0740: if ((0xfffffffffffffbfeL & l) == 0L)
0741: break;
0742: if (kind > 40)
0743: kind = 40;
0744: jjCheckNAdd(2);
0745: break;
0746: case 4:
0747: if (curChar != 35)
0748: break;
0749: if (kind > 42)
0750: kind = 42;
0751: jjCheckNAdd(5);
0752: break;
0753: case 5:
0754: if ((0xfffffffffffffbfeL & l) == 0L)
0755: break;
0756: if (kind > 42)
0757: kind = 42;
0758: jjCheckNAdd(5);
0759: break;
0760: case 8:
0761: if ((0x3ff600000000000L & l) == 0L)
0762: break;
0763: if (kind > 55)
0764: kind = 55;
0765: jjstateSet[jjnewStateCnt++] = 8;
0766: break;
0767: case 9:
0768: if (curChar == 34)
0769: jjCheckNAddTwoStates(10, 11);
0770: break;
0771: case 10:
0772: if ((0xfffffffbfffffffeL & l) != 0L)
0773: jjCheckNAddTwoStates(10, 11);
0774: break;
0775: case 11:
0776: case 20:
0777: if (curChar == 34 && kind > 58)
0778: kind = 58;
0779: break;
0780: case 12:
0781: if (curChar == 39)
0782: jjCheckNAddTwoStates(13, 14);
0783: break;
0784: case 13:
0785: if ((0xffffff7ffffffffeL & l) != 0L)
0786: jjCheckNAddTwoStates(13, 14);
0787: break;
0788: case 14:
0789: case 29:
0790: if (curChar == 39 && kind > 58)
0791: kind = 58;
0792: break;
0793: case 15:
0794: if (curChar == 34)
0795: jjCheckNAddStates(0, 2);
0796: break;
0797: case 16:
0798: if ((0xfffffffbffffffffL & l) != 0L)
0799: jjCheckNAddStates(0, 2);
0800: break;
0801: case 17:
0802: case 19:
0803: if (curChar == 34)
0804: jjCheckNAdd(16);
0805: break;
0806: case 18:
0807: if (curChar == 34)
0808: jjAddStates(3, 4);
0809: break;
0810: case 21:
0811: if (curChar == 34)
0812: jjstateSet[jjnewStateCnt++] = 20;
0813: break;
0814: case 22:
0815: if (curChar == 34)
0816: jjstateSet[jjnewStateCnt++] = 15;
0817: break;
0818: case 23:
0819: if (curChar == 34)
0820: jjstateSet[jjnewStateCnt++] = 22;
0821: break;
0822: case 24:
0823: if (curChar == 39)
0824: jjCheckNAddStates(5, 7);
0825: break;
0826: case 25:
0827: if ((0xffffff7fffffffffL & l) != 0L)
0828: jjCheckNAddStates(5, 7);
0829: break;
0830: case 26:
0831: case 28:
0832: if (curChar == 39)
0833: jjCheckNAdd(25);
0834: break;
0835: case 27:
0836: if (curChar == 39)
0837: jjAddStates(8, 9);
0838: break;
0839: case 30:
0840: if (curChar == 39)
0841: jjstateSet[jjnewStateCnt++] = 29;
0842: break;
0843: case 31:
0844: if (curChar == 39)
0845: jjstateSet[jjnewStateCnt++] = 24;
0846: break;
0847: case 32:
0848: if (curChar == 39)
0849: jjstateSet[jjnewStateCnt++] = 31;
0850: break;
0851: case 33:
0852: if ((0xfffffffffffff9ffL & l) != 0L
0853: && kind > 60)
0854: kind = 60;
0855: break;
0856: case 35:
0857: if ((0x3ff600000000000L & l) == 0L)
0858: break;
0859: if (kind > 54)
0860: kind = 54;
0861: jjCheckNAdd(35);
0862: break;
0863: case 36:
0864: if ((0x3ff600000000000L & l) != 0L)
0865: jjCheckNAddTwoStates(36, 38);
0866: break;
0867: case 37:
0868: if (curChar == 42 && kind > 56)
0869: kind = 56;
0870: break;
0871: case 38:
0872: if (curChar == 58)
0873: jjstateSet[jjnewStateCnt++] = 37;
0874: break;
0875: case 39:
0876: if ((0x3ff600000000000L & l) != 0L)
0877: jjCheckNAddTwoStates(39, 40);
0878: break;
0879: case 40:
0880: if (curChar == 58)
0881: jjstateSet[jjnewStateCnt++] = 41;
0882: break;
0883: case 42:
0884: if ((0x3ff600000000000L & l) == 0L)
0885: break;
0886: if (kind > 57)
0887: kind = 57;
0888: jjstateSet[jjnewStateCnt++] = 42;
0889: break;
0890: default:
0891: break;
0892: }
0893: } while (i != startsAt);
0894: } else if (curChar < 128) {
0895: long l = 1L << (curChar & 077);
0896: MatchLoop: do {
0897: switch (jjstateSet[--i]) {
0898: case 3:
0899: if (kind > 60)
0900: kind = 60;
0901: if ((0x7fffffe87fffffeL & l) != 0L) {
0902: if (kind > 54)
0903: kind = 54;
0904: jjCheckNAddStates(10, 14);
0905: } else if (curChar == 92)
0906: jjstateSet[jjnewStateCnt++] = 7;
0907: break;
0908: case 43:
0909: if ((0x7fffffe87fffffeL & l) != 0L)
0910: jjCheckNAddTwoStates(39, 40);
0911: if ((0x7fffffe87fffffeL & l) != 0L)
0912: jjCheckNAddTwoStates(36, 38);
0913: if ((0x7fffffe87fffffeL & l) != 0L) {
0914: if (kind > 54)
0915: kind = 54;
0916: jjCheckNAdd(35);
0917: }
0918: break;
0919: case 2:
0920: if (kind > 40)
0921: kind = 40;
0922: jjstateSet[jjnewStateCnt++] = 2;
0923: break;
0924: case 5:
0925: if (kind > 42)
0926: kind = 42;
0927: jjstateSet[jjnewStateCnt++] = 5;
0928: break;
0929: case 6:
0930: if (curChar == 92)
0931: jjstateSet[jjnewStateCnt++] = 7;
0932: break;
0933: case 7:
0934: case 8:
0935: if ((0x7fffffe87fffffeL & l) == 0L)
0936: break;
0937: if (kind > 55)
0938: kind = 55;
0939: jjCheckNAdd(8);
0940: break;
0941: case 10:
0942: jjAddStates(15, 16);
0943: break;
0944: case 13:
0945: jjAddStates(17, 18);
0946: break;
0947: case 16:
0948: jjAddStates(0, 2);
0949: break;
0950: case 25:
0951: jjAddStates(5, 7);
0952: break;
0953: case 33:
0954: if (kind > 60)
0955: kind = 60;
0956: break;
0957: case 34:
0958: if ((0x7fffffe87fffffeL & l) == 0L)
0959: break;
0960: if (kind > 54)
0961: kind = 54;
0962: jjCheckNAddStates(10, 14);
0963: break;
0964: case 35:
0965: if ((0x7fffffe87fffffeL & l) == 0L)
0966: break;
0967: if (kind > 54)
0968: kind = 54;
0969: jjCheckNAdd(35);
0970: break;
0971: case 36:
0972: if ((0x7fffffe87fffffeL & l) != 0L)
0973: jjCheckNAddTwoStates(36, 38);
0974: break;
0975: case 39:
0976: if ((0x7fffffe87fffffeL & l) != 0L)
0977: jjCheckNAddTwoStates(39, 40);
0978: break;
0979: case 41:
0980: case 42:
0981: if ((0x7fffffe87fffffeL & l) == 0L)
0982: break;
0983: if (kind > 57)
0984: kind = 57;
0985: jjCheckNAdd(42);
0986: break;
0987: default:
0988: break;
0989: }
0990: } while (i != startsAt);
0991: } else {
0992: int hiByte = (int) (curChar >> 8);
0993: int i1 = hiByte >> 6;
0994: long l1 = 1L << (hiByte & 077);
0995: int i2 = (curChar & 0xff) >> 6;
0996: long l2 = 1L << (curChar & 077);
0997: MatchLoop: do {
0998: switch (jjstateSet[--i]) {
0999: case 3:
1000: if (jjCanMove_0(hiByte, i1, i2, l1, l2)) {
1001: if (kind > 60)
1002: kind = 60;
1003: }
1004: if (jjCanMove_1(hiByte, i1, i2, l1, l2)) {
1005: if (kind > 54)
1006: kind = 54;
1007: jjCheckNAddStates(10, 14);
1008: }
1009: break;
1010: case 43:
1011: if (jjCanMove_2(hiByte, i1, i2, l1, l2)) {
1012: if (kind > 54)
1013: kind = 54;
1014: jjCheckNAdd(35);
1015: }
1016: if (jjCanMove_2(hiByte, i1, i2, l1, l2))
1017: jjCheckNAddTwoStates(36, 38);
1018: if (jjCanMove_2(hiByte, i1, i2, l1, l2))
1019: jjCheckNAddTwoStates(39, 40);
1020: break;
1021: case 2:
1022: if (!jjCanMove_0(hiByte, i1, i2, l1, l2))
1023: break;
1024: if (kind > 40)
1025: kind = 40;
1026: jjstateSet[jjnewStateCnt++] = 2;
1027: break;
1028: case 5:
1029: if (!jjCanMove_0(hiByte, i1, i2, l1, l2))
1030: break;
1031: if (kind > 42)
1032: kind = 42;
1033: jjstateSet[jjnewStateCnt++] = 5;
1034: break;
1035: case 7:
1036: if (!jjCanMove_1(hiByte, i1, i2, l1, l2))
1037: break;
1038: if (kind > 55)
1039: kind = 55;
1040: jjCheckNAdd(8);
1041: break;
1042: case 8:
1043: if (!jjCanMove_2(hiByte, i1, i2, l1, l2))
1044: break;
1045: if (kind > 55)
1046: kind = 55;
1047: jjCheckNAdd(8);
1048: break;
1049: case 10:
1050: if (jjCanMove_0(hiByte, i1, i2, l1, l2))
1051: jjAddStates(15, 16);
1052: break;
1053: case 13:
1054: if (jjCanMove_0(hiByte, i1, i2, l1, l2))
1055: jjAddStates(17, 18);
1056: break;
1057: case 16:
1058: if (jjCanMove_0(hiByte, i1, i2, l1, l2))
1059: jjAddStates(0, 2);
1060: break;
1061: case 25:
1062: if (jjCanMove_0(hiByte, i1, i2, l1, l2))
1063: jjAddStates(5, 7);
1064: break;
1065: case 33:
1066: if (jjCanMove_0(hiByte, i1, i2, l1, l2)
1067: && kind > 60)
1068: kind = 60;
1069: break;
1070: case 34:
1071: if (!jjCanMove_1(hiByte, i1, i2, l1, l2))
1072: break;
1073: if (kind > 54)
1074: kind = 54;
1075: jjCheckNAddStates(10, 14);
1076: break;
1077: case 35:
1078: if (!jjCanMove_2(hiByte, i1, i2, l1, l2))
1079: break;
1080: if (kind > 54)
1081: kind = 54;
1082: jjCheckNAdd(35);
1083: break;
1084: case 36:
1085: if (jjCanMove_2(hiByte, i1, i2, l1, l2))
1086: jjCheckNAddTwoStates(36, 38);
1087: break;
1088: case 39:
1089: if (jjCanMove_2(hiByte, i1, i2, l1, l2))
1090: jjCheckNAddTwoStates(39, 40);
1091: break;
1092: case 41:
1093: if (!jjCanMove_1(hiByte, i1, i2, l1, l2))
1094: break;
1095: if (kind > 57)
1096: kind = 57;
1097: jjCheckNAdd(42);
1098: break;
1099: case 42:
1100: if (!jjCanMove_2(hiByte, i1, i2, l1, l2))
1101: break;
1102: if (kind > 57)
1103: kind = 57;
1104: jjCheckNAdd(42);
1105: break;
1106: default:
1107: break;
1108: }
1109: } while (i != startsAt);
1110: }
1111: if (kind != 0x7fffffff) {
1112: jjmatchedKind = kind;
1113: jjmatchedPos = curPos;
1114: kind = 0x7fffffff;
1115: }
1116: ++curPos;
1117: if ((i = jjnewStateCnt) == (startsAt = 43 - (jjnewStateCnt = startsAt)))
1118: return curPos;
1119: try {
1120: curChar = input_stream.readChar();
1121: } catch (java.io.IOException e) {
1122: return curPos;
1123: }
1124: }
1125: }
1126:
1127: private final int jjMoveStringLiteralDfa0_1() {
1128: return jjMoveNfa_1(1, 0);
1129: }
1130:
1131: private final int jjMoveNfa_1(int startState, int curPos) {
1132: int[] nextStates;
1133: int startsAt = 0;
1134: jjnewStateCnt = 10;
1135: int i = 1;
1136: jjstateSet[0] = startState;
1137: int j, kind = 0x7fffffff;
1138: for (;;) {
1139: if (++jjround == 0x7fffffff)
1140: ReInitRounds();
1141: if (curChar < 64) {
1142: long l = 1L << curChar;
1143: MatchLoop: do {
1144: switch (jjstateSet[--i]) {
1145: case 1:
1146: if ((0xfffffffffffff9ffL & l) != 0L) {
1147: if (kind > 60)
1148: kind = 60;
1149: }
1150: if ((0x100000601L & l) != 0L) {
1151: if (kind > 39)
1152: kind = 39;
1153: jjCheckNAdd(0);
1154: }
1155: if ((0x401L & l) != 0L)
1156: jjCheckNAddStates(19, 22);
1157: break;
1158: case 0:
1159: if ((0x100000601L & l) == 0L)
1160: break;
1161: if (kind > 39)
1162: kind = 39;
1163: jjCheckNAdd(0);
1164: break;
1165: case 2:
1166: if ((0x401L & l) != 0L)
1167: jjCheckNAddStates(19, 22);
1168: break;
1169: case 3:
1170: if ((0x100000200L & l) != 0L)
1171: jjCheckNAddTwoStates(3, 6);
1172: break;
1173: case 4:
1174: if (curChar != 35)
1175: break;
1176: if (kind > 43)
1177: kind = 43;
1178: jjCheckNAdd(5);
1179: break;
1180: case 5:
1181: if ((0xfffffffffffffbfeL & l) == 0L)
1182: break;
1183: if (kind > 43)
1184: kind = 43;
1185: jjCheckNAdd(5);
1186: break;
1187: case 6:
1188: if (curChar == 35)
1189: jjstateSet[jjnewStateCnt++] = 4;
1190: break;
1191: case 7:
1192: if ((0x100000200L & l) != 0L)
1193: jjCheckNAddTwoStates(7, 8);
1194: break;
1195: case 8:
1196: if (curChar != 35)
1197: break;
1198: if (kind > 44)
1199: kind = 44;
1200: jjCheckNAdd(9);
1201: break;
1202: case 9:
1203: if ((0xfffffffffffffbfeL & l) == 0L)
1204: break;
1205: if (kind > 44)
1206: kind = 44;
1207: jjCheckNAdd(9);
1208: break;
1209: default:
1210: break;
1211: }
1212: } while (i != startsAt);
1213: } else if (curChar < 128) {
1214: long l = 1L << (curChar & 077);
1215: MatchLoop: do {
1216: switch (jjstateSet[--i]) {
1217: case 1:
1218: if (kind > 60)
1219: kind = 60;
1220: break;
1221: case 5:
1222: if (kind > 43)
1223: kind = 43;
1224: jjstateSet[jjnewStateCnt++] = 5;
1225: break;
1226: case 9:
1227: if (kind > 44)
1228: kind = 44;
1229: jjstateSet[jjnewStateCnt++] = 9;
1230: break;
1231: default:
1232: break;
1233: }
1234: } while (i != startsAt);
1235: } else {
1236: int hiByte = (int) (curChar >> 8);
1237: int i1 = hiByte >> 6;
1238: long l1 = 1L << (hiByte & 077);
1239: int i2 = (curChar & 0xff) >> 6;
1240: long l2 = 1L << (curChar & 077);
1241: MatchLoop: do {
1242: switch (jjstateSet[--i]) {
1243: case 1:
1244: if (jjCanMove_0(hiByte, i1, i2, l1, l2)
1245: && kind > 60)
1246: kind = 60;
1247: break;
1248: case 5:
1249: if (!jjCanMove_0(hiByte, i1, i2, l1, l2))
1250: break;
1251: if (kind > 43)
1252: kind = 43;
1253: jjstateSet[jjnewStateCnt++] = 5;
1254: break;
1255: case 9:
1256: if (!jjCanMove_0(hiByte, i1, i2, l1, l2))
1257: break;
1258: if (kind > 44)
1259: kind = 44;
1260: jjstateSet[jjnewStateCnt++] = 9;
1261: break;
1262: default:
1263: break;
1264: }
1265: } while (i != startsAt);
1266: }
1267: if (kind != 0x7fffffff) {
1268: jjmatchedKind = kind;
1269: jjmatchedPos = curPos;
1270: kind = 0x7fffffff;
1271: }
1272: ++curPos;
1273: if ((i = jjnewStateCnt) == (startsAt = 10 - (jjnewStateCnt = startsAt)))
1274: return curPos;
1275: try {
1276: curChar = input_stream.readChar();
1277: } catch (java.io.IOException e) {
1278: return curPos;
1279: }
1280: }
1281: }
1282:
1283: private final int jjMoveStringLiteralDfa0_2() {
1284: return jjMoveNfa_2(1, 0);
1285: }
1286:
1287: private final int jjMoveNfa_2(int startState, int curPos) {
1288: int[] nextStates;
1289: int startsAt = 0;
1290: jjnewStateCnt = 7;
1291: int i = 1;
1292: jjstateSet[0] = startState;
1293: int j, kind = 0x7fffffff;
1294: for (;;) {
1295: if (++jjround == 0x7fffffff)
1296: ReInitRounds();
1297: if (curChar < 64) {
1298: long l = 1L << curChar;
1299: MatchLoop: do {
1300: switch (jjstateSet[--i]) {
1301: case 1:
1302: if ((0xfffffffffffff9ffL & l) != 0L) {
1303: if (kind > 60)
1304: kind = 60;
1305: }
1306: if ((0x100000601L & l) != 0L) {
1307: if (kind > 39)
1308: kind = 39;
1309: jjCheckNAdd(0);
1310: }
1311: if ((0x401L & l) != 0L)
1312: jjCheckNAddTwoStates(2, 5);
1313: break;
1314: case 0:
1315: if ((0x100000601L & l) == 0L)
1316: break;
1317: if (kind > 39)
1318: kind = 39;
1319: jjCheckNAdd(0);
1320: break;
1321: case 2:
1322: if ((0x100000200L & l) != 0L)
1323: jjCheckNAddTwoStates(2, 5);
1324: break;
1325: case 3:
1326: if (curChar != 35)
1327: break;
1328: if (kind > 41)
1329: kind = 41;
1330: jjCheckNAdd(4);
1331: break;
1332: case 4:
1333: if ((0xfffffffffffffbfeL & l) == 0L)
1334: break;
1335: if (kind > 41)
1336: kind = 41;
1337: jjCheckNAdd(4);
1338: break;
1339: case 5:
1340: if (curChar == 35)
1341: jjstateSet[jjnewStateCnt++] = 3;
1342: break;
1343: case 6:
1344: if ((0xfffffffffffff9ffL & l) != 0L
1345: && kind > 60)
1346: kind = 60;
1347: break;
1348: default:
1349: break;
1350: }
1351: } while (i != startsAt);
1352: } else if (curChar < 128) {
1353: long l = 1L << (curChar & 077);
1354: MatchLoop: do {
1355: switch (jjstateSet[--i]) {
1356: case 1:
1357: if (kind > 60)
1358: kind = 60;
1359: break;
1360: case 4:
1361: if (kind > 41)
1362: kind = 41;
1363: jjstateSet[jjnewStateCnt++] = 4;
1364: break;
1365: default:
1366: break;
1367: }
1368: } while (i != startsAt);
1369: } else {
1370: int hiByte = (int) (curChar >> 8);
1371: int i1 = hiByte >> 6;
1372: long l1 = 1L << (hiByte & 077);
1373: int i2 = (curChar & 0xff) >> 6;
1374: long l2 = 1L << (curChar & 077);
1375: MatchLoop: do {
1376: switch (jjstateSet[--i]) {
1377: case 1:
1378: if (jjCanMove_0(hiByte, i1, i2, l1, l2)
1379: && kind > 60)
1380: kind = 60;
1381: break;
1382: case 4:
1383: if (!jjCanMove_0(hiByte, i1, i2, l1, l2))
1384: break;
1385: if (kind > 41)
1386: kind = 41;
1387: jjstateSet[jjnewStateCnt++] = 4;
1388: break;
1389: default:
1390: break;
1391: }
1392: } while (i != startsAt);
1393: }
1394: if (kind != 0x7fffffff) {
1395: jjmatchedKind = kind;
1396: jjmatchedPos = curPos;
1397: kind = 0x7fffffff;
1398: }
1399: ++curPos;
1400: if ((i = jjnewStateCnt) == (startsAt = 7 - (jjnewStateCnt = startsAt)))
1401: return curPos;
1402: try {
1403: curChar = input_stream.readChar();
1404: } catch (java.io.IOException e) {
1405: return curPos;
1406: }
1407: }
1408: }
1409:
1410: static final int[] jjnextStates = { 16, 17, 18, 19, 21, 25, 26, 27,
1411: 28, 30, 35, 36, 38, 39, 40, 10, 11, 13, 14, 3, 6, 7, 8, };
1412:
1413: private static final boolean jjCanMove_0(int hiByte, int i1,
1414: int i2, long l1, long l2) {
1415: switch (hiByte) {
1416: case 0:
1417: return ((jjbitVec2[i2] & l2) != 0L);
1418: default:
1419: if ((jjbitVec0[i1] & l1) != 0L)
1420: return true;
1421: return false;
1422: }
1423: }
1424:
1425: private static final boolean jjCanMove_1(int hiByte, int i1,
1426: int i2, long l1, long l2) {
1427: switch (hiByte) {
1428: case 0:
1429: return ((jjbitVec4[i2] & l2) != 0L);
1430: case 1:
1431: return ((jjbitVec5[i2] & l2) != 0L);
1432: case 2:
1433: return ((jjbitVec6[i2] & l2) != 0L);
1434: case 3:
1435: return ((jjbitVec7[i2] & l2) != 0L);
1436: case 4:
1437: return ((jjbitVec8[i2] & l2) != 0L);
1438: case 5:
1439: return ((jjbitVec9[i2] & l2) != 0L);
1440: case 6:
1441: return ((jjbitVec10[i2] & l2) != 0L);
1442: case 9:
1443: return ((jjbitVec11[i2] & l2) != 0L);
1444: case 10:
1445: return ((jjbitVec12[i2] & l2) != 0L);
1446: case 11:
1447: return ((jjbitVec13[i2] & l2) != 0L);
1448: case 12:
1449: return ((jjbitVec14[i2] & l2) != 0L);
1450: case 13:
1451: return ((jjbitVec15[i2] & l2) != 0L);
1452: case 14:
1453: return ((jjbitVec16[i2] & l2) != 0L);
1454: case 15:
1455: return ((jjbitVec17[i2] & l2) != 0L);
1456: case 16:
1457: return ((jjbitVec18[i2] & l2) != 0L);
1458: case 17:
1459: return ((jjbitVec19[i2] & l2) != 0L);
1460: case 30:
1461: return ((jjbitVec20[i2] & l2) != 0L);
1462: case 31:
1463: return ((jjbitVec21[i2] & l2) != 0L);
1464: case 33:
1465: return ((jjbitVec22[i2] & l2) != 0L);
1466: case 48:
1467: return ((jjbitVec23[i2] & l2) != 0L);
1468: case 49:
1469: return ((jjbitVec24[i2] & l2) != 0L);
1470: case 159:
1471: return ((jjbitVec25[i2] & l2) != 0L);
1472: case 215:
1473: return ((jjbitVec26[i2] & l2) != 0L);
1474: default:
1475: if ((jjbitVec3[i1] & l1) != 0L)
1476: return true;
1477: return false;
1478: }
1479: }
1480:
1481: private static final boolean jjCanMove_2(int hiByte, int i1,
1482: int i2, long l1, long l2) {
1483: switch (hiByte) {
1484: case 0:
1485: return ((jjbitVec27[i2] & l2) != 0L);
1486: case 1:
1487: return ((jjbitVec5[i2] & l2) != 0L);
1488: case 2:
1489: return ((jjbitVec28[i2] & l2) != 0L);
1490: case 3:
1491: return ((jjbitVec29[i2] & l2) != 0L);
1492: case 4:
1493: return ((jjbitVec30[i2] & l2) != 0L);
1494: case 5:
1495: return ((jjbitVec31[i2] & l2) != 0L);
1496: case 6:
1497: return ((jjbitVec32[i2] & l2) != 0L);
1498: case 9:
1499: return ((jjbitVec33[i2] & l2) != 0L);
1500: case 10:
1501: return ((jjbitVec34[i2] & l2) != 0L);
1502: case 11:
1503: return ((jjbitVec35[i2] & l2) != 0L);
1504: case 12:
1505: return ((jjbitVec36[i2] & l2) != 0L);
1506: case 13:
1507: return ((jjbitVec37[i2] & l2) != 0L);
1508: case 14:
1509: return ((jjbitVec38[i2] & l2) != 0L);
1510: case 15:
1511: return ((jjbitVec39[i2] & l2) != 0L);
1512: case 16:
1513: return ((jjbitVec18[i2] & l2) != 0L);
1514: case 17:
1515: return ((jjbitVec19[i2] & l2) != 0L);
1516: case 30:
1517: return ((jjbitVec20[i2] & l2) != 0L);
1518: case 31:
1519: return ((jjbitVec21[i2] & l2) != 0L);
1520: case 32:
1521: return ((jjbitVec40[i2] & l2) != 0L);
1522: case 33:
1523: return ((jjbitVec22[i2] & l2) != 0L);
1524: case 48:
1525: return ((jjbitVec41[i2] & l2) != 0L);
1526: case 49:
1527: return ((jjbitVec24[i2] & l2) != 0L);
1528: case 159:
1529: return ((jjbitVec25[i2] & l2) != 0L);
1530: case 215:
1531: return ((jjbitVec26[i2] & l2) != 0L);
1532: default:
1533: if ((jjbitVec3[i1] & l1) != 0L)
1534: return true;
1535: return false;
1536: }
1537: }
1538:
1539: public static final String[] jjstrLiteralImages = { "", "\133",
1540: "\75", "\46\75", "\174\75", "\163\164\141\162\164",
1541: "\144\151\166", "\151\156\143\154\165\144\145", "\176",
1542: "\135", "\147\162\141\155\155\141\162", "\173", "\175",
1543: "\156\141\155\145\163\160\141\143\145",
1544: "\144\145\146\141\165\154\164",
1545: "\151\156\150\145\162\151\164",
1546: "\144\141\164\141\164\171\160\145\163",
1547: "\145\155\160\164\171", "\164\145\170\164",
1548: "\156\157\164\101\154\154\157\167\145\144", "\174", "\46",
1549: "\54", "\53", "\77", "\52", "\145\154\145\155\145\156\164",
1550: "\141\164\164\162\151\142\165\164\145", "\50", "\51",
1551: "\55", "\154\151\163\164", "\155\151\170\145\144",
1552: "\145\170\164\145\162\156\141\154",
1553: "\160\141\162\145\156\164", "\163\164\162\151\156\147",
1554: "\164\157\153\145\156", null, null, null, null, null, null,
1555: null, null, null, null, null, null, null, null, null, null,
1556: null, null, null, null, null, null, "\76\76", null, };
1557: public static final String[] lexStateNames = { "DEFAULT",
1558: "AFTER_SINGLE_LINE_COMMENT", "AFTER_DOCUMENTATION", };
1559: public static final int[] jjnewLexState = { -1, -1, -1, -1, -1, -1,
1560: -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
1561: -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
1562: -1, -1, -1, 0, 2, -1, 1, 2, -1, -1, -1, -1, -1, -1, -1, -1,
1563: -1, -1, -1, -1, -1, -1, -1, -1, -1, };
1564: static final long[] jjtoToken = { 0x1fc00b1fffffffffL, };
1565: static final long[] jjtoSkip = { 0x148000000000L, };
1566: static final long[] jjtoSpecial = { 0x140000000000L, };
1567: protected JavaCharStream input_stream;
1568: private final int[] jjrounds = new int[43];
1569: private final int[] jjstateSet = new int[86];
1570: StringBuffer image;
1571: int jjimageLen;
1572: int lengthOfMatch;
1573: protected char curChar;
1574:
1575: public CompactSyntaxTokenManager(JavaCharStream stream) {
1576: if (JavaCharStream.staticFlag)
1577: throw new Error(
1578: "ERROR: Cannot use a static CharStream class with a non-static lexical analyzer.");
1579: input_stream = stream;
1580: }
1581:
1582: public CompactSyntaxTokenManager(JavaCharStream stream, int lexState) {
1583: this (stream);
1584: SwitchTo(lexState);
1585: }
1586:
1587: public void ReInit(JavaCharStream stream) {
1588: jjmatchedPos = jjnewStateCnt = 0;
1589: curLexState = defaultLexState;
1590: input_stream = stream;
1591: ReInitRounds();
1592: }
1593:
1594: private final void ReInitRounds() {
1595: int i;
1596: jjround = 0x80000001;
1597: for (i = 43; i-- > 0;)
1598: jjrounds[i] = 0x80000000;
1599: }
1600:
1601: public void ReInit(JavaCharStream stream, int lexState) {
1602: ReInit(stream);
1603: SwitchTo(lexState);
1604: }
1605:
1606: public void SwitchTo(int lexState) {
1607: if (lexState >= 3 || lexState < 0)
1608: throw new TokenMgrError(
1609: "Error: Ignoring invalid lexical state : "
1610: + lexState + ". State unchanged.",
1611: TokenMgrError.INVALID_LEXICAL_STATE);
1612: else
1613: curLexState = lexState;
1614: }
1615:
1616: protected Token jjFillToken() {
1617: Token t = Token.newToken(jjmatchedKind);
1618: t.kind = jjmatchedKind;
1619: String im = jjstrLiteralImages[jjmatchedKind];
1620: t.image = (im == null) ? input_stream.GetImage() : im;
1621: t.beginLine = input_stream.getBeginLine();
1622: t.beginColumn = input_stream.getBeginColumn();
1623: t.endLine = input_stream.getEndLine();
1624: t.endColumn = input_stream.getEndColumn();
1625: return t;
1626: }
1627:
1628: int curLexState = 0;
1629: int defaultLexState = 0;
1630: int jjnewStateCnt;
1631: int jjround;
1632: int jjmatchedPos;
1633: int jjmatchedKind;
1634:
1635: public Token getNextToken() {
1636: int kind;
1637: Token specialToken = null;
1638: Token matchedToken;
1639: int curPos = 0;
1640:
1641: EOFLoop: for (;;) {
1642: try {
1643: curChar = input_stream.BeginToken();
1644: } catch (java.io.IOException e) {
1645: jjmatchedKind = 0;
1646: matchedToken = jjFillToken();
1647: matchedToken.specialToken = specialToken;
1648: return matchedToken;
1649: }
1650: image = null;
1651: jjimageLen = 0;
1652:
1653: switch (curLexState) {
1654: case 0:
1655: jjmatchedKind = 0x7fffffff;
1656: jjmatchedPos = 0;
1657: curPos = jjMoveStringLiteralDfa0_0();
1658: break;
1659: case 1:
1660: jjmatchedKind = 0x7fffffff;
1661: jjmatchedPos = 0;
1662: curPos = jjMoveStringLiteralDfa0_1();
1663: break;
1664: case 2:
1665: jjmatchedKind = 0x7fffffff;
1666: jjmatchedPos = 0;
1667: curPos = jjMoveStringLiteralDfa0_2();
1668: break;
1669: }
1670: if (jjmatchedKind != 0x7fffffff) {
1671: if (jjmatchedPos + 1 < curPos)
1672: input_stream.backup(curPos - jjmatchedPos - 1);
1673: if ((jjtoToken[jjmatchedKind >> 6] & (1L << (jjmatchedKind & 077))) != 0L) {
1674: matchedToken = jjFillToken();
1675: matchedToken.specialToken = specialToken;
1676: if (jjnewLexState[jjmatchedKind] != -1)
1677: curLexState = jjnewLexState[jjmatchedKind];
1678: return matchedToken;
1679: } else {
1680: if ((jjtoSpecial[jjmatchedKind >> 6] & (1L << (jjmatchedKind & 077))) != 0L) {
1681: matchedToken = jjFillToken();
1682: if (specialToken == null)
1683: specialToken = matchedToken;
1684: else {
1685: matchedToken.specialToken = specialToken;
1686: specialToken = (specialToken.next = matchedToken);
1687: }
1688: SkipLexicalActions(matchedToken);
1689: } else
1690: SkipLexicalActions(null);
1691: if (jjnewLexState[jjmatchedKind] != -1)
1692: curLexState = jjnewLexState[jjmatchedKind];
1693: continue EOFLoop;
1694: }
1695: }
1696: int error_line = input_stream.getEndLine();
1697: int error_column = input_stream.getEndColumn();
1698: String error_after = null;
1699: boolean EOFSeen = false;
1700: try {
1701: input_stream.readChar();
1702: input_stream.backup(1);
1703: } catch (java.io.IOException e1) {
1704: EOFSeen = true;
1705: error_after = curPos <= 1 ? "" : input_stream
1706: .GetImage();
1707: if (curChar == '\n' || curChar == '\r') {
1708: error_line++;
1709: error_column = 0;
1710: } else
1711: error_column++;
1712: }
1713: if (!EOFSeen) {
1714: input_stream.backup(1);
1715: error_after = curPos <= 1 ? "" : input_stream
1716: .GetImage();
1717: }
1718: throw new TokenMgrError(EOFSeen, curLexState, error_line,
1719: error_column, error_after, curChar,
1720: TokenMgrError.LEXICAL_ERROR);
1721: }
1722: }
1723:
1724: void SkipLexicalActions(Token matchedToken) {
1725: switch (jjmatchedKind) {
1726: default:
1727: break;
1728: }
1729: }
1730: }
|