0001: // $ANTLR 2.7.5 (20050128): "java.g" -> "JavaLexer.java"$
0002:
0003: package xtc.lang.antlr;
0004:
0005: import java.io.InputStream;
0006: import antlr.TokenStreamException;
0007: import antlr.TokenStreamIOException;
0008: import antlr.TokenStreamRecognitionException;
0009: import antlr.CharStreamException;
0010: import antlr.CharStreamIOException;
0011: import antlr.ANTLRException;
0012: import java.io.Reader;
0013: import java.util.Hashtable;
0014: import antlr.CharScanner;
0015: import antlr.InputBuffer;
0016: import antlr.ByteBuffer;
0017: import antlr.CharBuffer;
0018: import antlr.Token;
0019: import antlr.CommonToken;
0020: import antlr.RecognitionException;
0021: import antlr.NoViableAltForCharException;
0022: import antlr.MismatchedCharException;
0023: import antlr.TokenStream;
0024: import antlr.ANTLRHashString;
0025: import antlr.LexerSharedInputState;
0026: import antlr.collections.impl.BitSet;
0027: import antlr.SemanticException;
0028:
0029: @SuppressWarnings({"unchecked","unused","cast"})
0030: public class JavaLexer extends antlr.CharScanner implements
0031: JavaTokenTypes, TokenStream {
0032: public JavaLexer(InputStream in) {
0033: this (new ByteBuffer(in));
0034: }
0035:
0036: public JavaLexer(Reader in) {
0037: this (new CharBuffer(in));
0038: }
0039:
0040: public JavaLexer(InputBuffer ib) {
0041: this (new LexerSharedInputState(ib));
0042: }
0043:
0044: public JavaLexer(LexerSharedInputState state) {
0045: super (state);
0046: caseSensitiveLiterals = true;
0047: setCaseSensitive(true);
0048: literals = new Hashtable();
0049: literals
0050: .put(new ANTLRHashString("byte", this ), new Integer(51));
0051: literals.put(new ANTLRHashString("public", this ), new Integer(
0052: 62));
0053: literals
0054: .put(new ANTLRHashString("case", this ), new Integer(94));
0055: literals.put(new ANTLRHashString("short", this ),
0056: new Integer(53));
0057: literals.put(new ANTLRHashString("break", this ),
0058: new Integer(89));
0059: literals.put(new ANTLRHashString("while", this ),
0060: new Integer(87));
0061: literals
0062: .put(new ANTLRHashString("new", this ), new Integer(137));
0063: literals.put(new ANTLRHashString("instanceof", this ),
0064: new Integer(122));
0065: literals.put(new ANTLRHashString("implements", this ),
0066: new Integer(76));
0067: literals.put(new ANTLRHashString("synchronized", this ),
0068: new Integer(68));
0069: literals.put(new ANTLRHashString("float", this ),
0070: new Integer(55));
0071: literals.put(new ANTLRHashString("package", this ), new Integer(
0072: 44));
0073: literals.put(new ANTLRHashString("return", this ), new Integer(
0074: 91));
0075: literals.put(new ANTLRHashString("throw", this ),
0076: new Integer(93));
0077: literals.put(new ANTLRHashString("null", this ),
0078: new Integer(136));
0079: literals.put(new ANTLRHashString("threadsafe", this ),
0080: new Integer(67));
0081: literals.put(new ANTLRHashString("protected", this ),
0082: new Integer(63));
0083: literals.put(new ANTLRHashString("class", this ),
0084: new Integer(70));
0085: literals.put(new ANTLRHashString("throws", this ), new Integer(
0086: 82));
0087: literals.put(new ANTLRHashString("do", this ), new Integer(88));
0088: literals.put(new ANTLRHashString("strictfp", this ),
0089: new Integer(41));
0090: literals.put(new ANTLRHashString("super", this ),
0091: new Integer(80));
0092: literals.put(new ANTLRHashString("transient", this ),
0093: new Integer(65));
0094: literals.put(new ANTLRHashString("native", this ), new Integer(
0095: 66));
0096: literals.put(new ANTLRHashString("interface", this ),
0097: new Integer(72));
0098: literals.put(new ANTLRHashString("final", this ),
0099: new Integer(39));
0100: literals.put(new ANTLRHashString("if", this ), new Integer(84));
0101: literals.put(new ANTLRHashString("double", this ), new Integer(
0102: 57));
0103: literals.put(new ANTLRHashString("volatile", this ),
0104: new Integer(69));
0105: literals.put(new ANTLRHashString("catch", this ),
0106: new Integer(98));
0107: literals.put(new ANTLRHashString("try", this ), new Integer(96));
0108: literals.put(new ANTLRHashString("int", this ), new Integer(54));
0109: literals.put(new ANTLRHashString("for", this ), new Integer(86));
0110: literals.put(new ANTLRHashString("extends", this ), new Integer(
0111: 71));
0112: literals.put(new ANTLRHashString("boolean", this ), new Integer(
0113: 50));
0114: literals
0115: .put(new ANTLRHashString("char", this ), new Integer(52));
0116: literals.put(new ANTLRHashString("private", this ), new Integer(
0117: 61));
0118: literals.put(new ANTLRHashString("default", this ), new Integer(
0119: 95));
0120: literals.put(new ANTLRHashString("false", this ), new Integer(
0121: 135));
0122: literals
0123: .put(new ANTLRHashString("this", this ), new Integer(79));
0124: literals.put(new ANTLRHashString("static", this ), new Integer(
0125: 64));
0126: literals.put(new ANTLRHashString("abstract", this ),
0127: new Integer(40));
0128: literals.put(new ANTLRHashString("continue", this ),
0129: new Integer(90));
0130: literals.put(new ANTLRHashString("finally", this ), new Integer(
0131: 97));
0132: literals
0133: .put(new ANTLRHashString("else", this ), new Integer(85));
0134: literals.put(new ANTLRHashString("import", this ), new Integer(
0135: 46));
0136: literals
0137: .put(new ANTLRHashString("void", this ), new Integer(49));
0138: literals.put(new ANTLRHashString("switch", this ), new Integer(
0139: 92));
0140: literals.put(new ANTLRHashString("true", this ),
0141: new Integer(134));
0142: literals
0143: .put(new ANTLRHashString("long", this ), new Integer(56));
0144: }
0145:
0146: public Token nextToken() throws TokenStreamException {
0147: Token theRetToken = null;
0148: tryAgain: for (;;) {
0149: Token _token = null;
0150: int _ttype = Token.INVALID_TYPE;
0151: resetText();
0152: try { // for char stream error handling
0153: try { // for lexical error handling
0154: switch (LA(1)) {
0155: case '?': {
0156: mQUESTION(true);
0157: theRetToken = _returnToken;
0158: break;
0159: }
0160: case '(': {
0161: mLPAREN(true);
0162: theRetToken = _returnToken;
0163: break;
0164: }
0165: case ')': {
0166: mRPAREN(true);
0167: theRetToken = _returnToken;
0168: break;
0169: }
0170: case '[': {
0171: mLBRACK(true);
0172: theRetToken = _returnToken;
0173: break;
0174: }
0175: case ']': {
0176: mRBRACK(true);
0177: theRetToken = _returnToken;
0178: break;
0179: }
0180: case '{': {
0181: mLCURLY(true);
0182: theRetToken = _returnToken;
0183: break;
0184: }
0185: case '}': {
0186: mRCURLY(true);
0187: theRetToken = _returnToken;
0188: break;
0189: }
0190: case ':': {
0191: mCOLON(true);
0192: theRetToken = _returnToken;
0193: break;
0194: }
0195: case ',': {
0196: mCOMMA(true);
0197: theRetToken = _returnToken;
0198: break;
0199: }
0200: case '~': {
0201: mBNOT(true);
0202: theRetToken = _returnToken;
0203: break;
0204: }
0205: case ';': {
0206: mSEMI(true);
0207: theRetToken = _returnToken;
0208: break;
0209: }
0210: case '\t':
0211: case '\n':
0212: case '\u000c':
0213: case '\r':
0214: case ' ': {
0215: mWS(true);
0216: theRetToken = _returnToken;
0217: break;
0218: }
0219: case '\'': {
0220: mCHAR_LITERAL(true);
0221: theRetToken = _returnToken;
0222: break;
0223: }
0224: case '"': {
0225: mSTRING_LITERAL(true);
0226: theRetToken = _returnToken;
0227: break;
0228: }
0229: case '$':
0230: case 'A':
0231: case 'B':
0232: case 'C':
0233: case 'D':
0234: case 'E':
0235: case 'F':
0236: case 'G':
0237: case 'H':
0238: case 'I':
0239: case 'J':
0240: case 'K':
0241: case 'L':
0242: case 'M':
0243: case 'N':
0244: case 'O':
0245: case 'P':
0246: case 'Q':
0247: case 'R':
0248: case 'S':
0249: case 'T':
0250: case 'U':
0251: case 'V':
0252: case 'W':
0253: case 'X':
0254: case 'Y':
0255: case 'Z':
0256: case '_':
0257: case 'a':
0258: case 'b':
0259: case 'c':
0260: case 'd':
0261: case 'e':
0262: case 'f':
0263: case 'g':
0264: case 'h':
0265: case 'i':
0266: case 'j':
0267: case 'k':
0268: case 'l':
0269: case 'm':
0270: case 'n':
0271: case 'o':
0272: case 'p':
0273: case 'q':
0274: case 'r':
0275: case 's':
0276: case 't':
0277: case 'u':
0278: case 'v':
0279: case 'w':
0280: case 'x':
0281: case 'y':
0282: case 'z': {
0283: mIDENT(true);
0284: theRetToken = _returnToken;
0285: break;
0286: }
0287: case '.':
0288: case '0':
0289: case '1':
0290: case '2':
0291: case '3':
0292: case '4':
0293: case '5':
0294: case '6':
0295: case '7':
0296: case '8':
0297: case '9': {
0298: mNUM_INT(true);
0299: theRetToken = _returnToken;
0300: break;
0301: }
0302: default:
0303: if ((LA(1) == '>') && (LA(2) == '>')
0304: && (LA(3) == '>') && (LA(4) == '=')) {
0305: mBSR_ASSIGN(true);
0306: theRetToken = _returnToken;
0307: } else if ((LA(1) == '>') && (LA(2) == '>')
0308: && (LA(3) == '=')) {
0309: mSR_ASSIGN(true);
0310: theRetToken = _returnToken;
0311: } else if ((LA(1) == '>') && (LA(2) == '>')
0312: && (LA(3) == '>') && (true)) {
0313: mBSR(true);
0314: theRetToken = _returnToken;
0315: } else if ((LA(1) == '<') && (LA(2) == '<')
0316: && (LA(3) == '=')) {
0317: mSL_ASSIGN(true);
0318: theRetToken = _returnToken;
0319: } else if ((LA(1) == '=') && (LA(2) == '=')) {
0320: mEQUAL(true);
0321: theRetToken = _returnToken;
0322: } else if ((LA(1) == '!') && (LA(2) == '=')) {
0323: mNOT_EQUAL(true);
0324: theRetToken = _returnToken;
0325: } else if ((LA(1) == '/') && (LA(2) == '=')) {
0326: mDIV_ASSIGN(true);
0327: theRetToken = _returnToken;
0328: } else if ((LA(1) == '+') && (LA(2) == '=')) {
0329: mPLUS_ASSIGN(true);
0330: theRetToken = _returnToken;
0331: } else if ((LA(1) == '+') && (LA(2) == '+')) {
0332: mINC(true);
0333: theRetToken = _returnToken;
0334: } else if ((LA(1) == '-') && (LA(2) == '=')) {
0335: mMINUS_ASSIGN(true);
0336: theRetToken = _returnToken;
0337: } else if ((LA(1) == '-') && (LA(2) == '-')) {
0338: mDEC(true);
0339: theRetToken = _returnToken;
0340: } else if ((LA(1) == '*') && (LA(2) == '=')) {
0341: mSTAR_ASSIGN(true);
0342: theRetToken = _returnToken;
0343: } else if ((LA(1) == '%') && (LA(2) == '=')) {
0344: mMOD_ASSIGN(true);
0345: theRetToken = _returnToken;
0346: } else if ((LA(1) == '>') && (LA(2) == '>')
0347: && (true)) {
0348: mSR(true);
0349: theRetToken = _returnToken;
0350: } else if ((LA(1) == '>') && (LA(2) == '=')) {
0351: mGE(true);
0352: theRetToken = _returnToken;
0353: } else if ((LA(1) == '<') && (LA(2) == '<')
0354: && (true)) {
0355: mSL(true);
0356: theRetToken = _returnToken;
0357: } else if ((LA(1) == '<') && (LA(2) == '=')) {
0358: mLE(true);
0359: theRetToken = _returnToken;
0360: } else if ((LA(1) == '^') && (LA(2) == '=')) {
0361: mBXOR_ASSIGN(true);
0362: theRetToken = _returnToken;
0363: } else if ((LA(1) == '|') && (LA(2) == '=')) {
0364: mBOR_ASSIGN(true);
0365: theRetToken = _returnToken;
0366: } else if ((LA(1) == '|') && (LA(2) == '|')) {
0367: mLOR(true);
0368: theRetToken = _returnToken;
0369: } else if ((LA(1) == '&') && (LA(2) == '=')) {
0370: mBAND_ASSIGN(true);
0371: theRetToken = _returnToken;
0372: } else if ((LA(1) == '&') && (LA(2) == '&')) {
0373: mLAND(true);
0374: theRetToken = _returnToken;
0375: } else if ((LA(1) == '/') && (LA(2) == '/')) {
0376: mSL_COMMENT(true);
0377: theRetToken = _returnToken;
0378: } else if ((LA(1) == '/') && (LA(2) == '*')) {
0379: mML_COMMENT(true);
0380: theRetToken = _returnToken;
0381: } else if ((LA(1) == '=') && (true)) {
0382: mASSIGN(true);
0383: theRetToken = _returnToken;
0384: } else if ((LA(1) == '!') && (true)) {
0385: mLNOT(true);
0386: theRetToken = _returnToken;
0387: } else if ((LA(1) == '/') && (true)) {
0388: mDIV(true);
0389: theRetToken = _returnToken;
0390: } else if ((LA(1) == '+') && (true)) {
0391: mPLUS(true);
0392: theRetToken = _returnToken;
0393: } else if ((LA(1) == '-') && (true)) {
0394: mMINUS(true);
0395: theRetToken = _returnToken;
0396: } else if ((LA(1) == '*') && (true)) {
0397: mSTAR(true);
0398: theRetToken = _returnToken;
0399: } else if ((LA(1) == '%') && (true)) {
0400: mMOD(true);
0401: theRetToken = _returnToken;
0402: } else if ((LA(1) == '>') && (true)) {
0403: mGT(true);
0404: theRetToken = _returnToken;
0405: } else if ((LA(1) == '<') && (true)) {
0406: mLT(true);
0407: theRetToken = _returnToken;
0408: } else if ((LA(1) == '^') && (true)) {
0409: mBXOR(true);
0410: theRetToken = _returnToken;
0411: } else if ((LA(1) == '|') && (true)) {
0412: mBOR(true);
0413: theRetToken = _returnToken;
0414: } else if ((LA(1) == '&') && (true)) {
0415: mBAND(true);
0416: theRetToken = _returnToken;
0417: } else {
0418: if (LA(1) == EOF_CHAR) {
0419: uponEOF();
0420: _returnToken = makeToken(Token.EOF_TYPE);
0421: } else {
0422: throw new NoViableAltForCharException(
0423: (char) LA(1), getFilename(),
0424: getLine(), getColumn());
0425: }
0426: }
0427: }
0428: if (_returnToken == null)
0429: continue tryAgain; // found SKIP token
0430: _ttype = _returnToken.getType();
0431: _returnToken.setType(_ttype);
0432: return _returnToken;
0433: } catch (RecognitionException e) {
0434: throw new TokenStreamRecognitionException(e);
0435: }
0436: } catch (CharStreamException cse) {
0437: if (cse instanceof CharStreamIOException) {
0438: throw new TokenStreamIOException(
0439: ((CharStreamIOException) cse).io);
0440: } else {
0441: throw new TokenStreamException(cse.getMessage());
0442: }
0443: }
0444: }
0445: }
0446:
0447: public final void mQUESTION(boolean _createToken)
0448: throws RecognitionException, CharStreamException,
0449: TokenStreamException {
0450: int _ttype;
0451: Token _token = null;
0452: int _begin = text.length();
0453: _ttype = QUESTION;
0454: int _saveIndex;
0455:
0456: match('?');
0457: if (_createToken && _token == null && _ttype != Token.SKIP) {
0458: _token = makeToken(_ttype);
0459: _token.setText(new String(text.getBuffer(), _begin, text
0460: .length()
0461: - _begin));
0462: }
0463: _returnToken = _token;
0464: }
0465:
0466: public final void mLPAREN(boolean _createToken)
0467: throws RecognitionException, CharStreamException,
0468: TokenStreamException {
0469: int _ttype;
0470: Token _token = null;
0471: int _begin = text.length();
0472: _ttype = LPAREN;
0473: int _saveIndex;
0474:
0475: match('(');
0476: if (_createToken && _token == null && _ttype != Token.SKIP) {
0477: _token = makeToken(_ttype);
0478: _token.setText(new String(text.getBuffer(), _begin, text
0479: .length()
0480: - _begin));
0481: }
0482: _returnToken = _token;
0483: }
0484:
0485: public final void mRPAREN(boolean _createToken)
0486: throws RecognitionException, CharStreamException,
0487: TokenStreamException {
0488: int _ttype;
0489: Token _token = null;
0490: int _begin = text.length();
0491: _ttype = RPAREN;
0492: int _saveIndex;
0493:
0494: match(')');
0495: if (_createToken && _token == null && _ttype != Token.SKIP) {
0496: _token = makeToken(_ttype);
0497: _token.setText(new String(text.getBuffer(), _begin, text
0498: .length()
0499: - _begin));
0500: }
0501: _returnToken = _token;
0502: }
0503:
0504: public final void mLBRACK(boolean _createToken)
0505: throws RecognitionException, CharStreamException,
0506: TokenStreamException {
0507: int _ttype;
0508: Token _token = null;
0509: int _begin = text.length();
0510: _ttype = LBRACK;
0511: int _saveIndex;
0512:
0513: match('[');
0514: if (_createToken && _token == null && _ttype != Token.SKIP) {
0515: _token = makeToken(_ttype);
0516: _token.setText(new String(text.getBuffer(), _begin, text
0517: .length()
0518: - _begin));
0519: }
0520: _returnToken = _token;
0521: }
0522:
0523: public final void mRBRACK(boolean _createToken)
0524: throws RecognitionException, CharStreamException,
0525: TokenStreamException {
0526: int _ttype;
0527: Token _token = null;
0528: int _begin = text.length();
0529: _ttype = RBRACK;
0530: int _saveIndex;
0531:
0532: match(']');
0533: if (_createToken && _token == null && _ttype != Token.SKIP) {
0534: _token = makeToken(_ttype);
0535: _token.setText(new String(text.getBuffer(), _begin, text
0536: .length()
0537: - _begin));
0538: }
0539: _returnToken = _token;
0540: }
0541:
0542: public final void mLCURLY(boolean _createToken)
0543: throws RecognitionException, CharStreamException,
0544: TokenStreamException {
0545: int _ttype;
0546: Token _token = null;
0547: int _begin = text.length();
0548: _ttype = LCURLY;
0549: int _saveIndex;
0550:
0551: match('{');
0552: if (_createToken && _token == null && _ttype != Token.SKIP) {
0553: _token = makeToken(_ttype);
0554: _token.setText(new String(text.getBuffer(), _begin, text
0555: .length()
0556: - _begin));
0557: }
0558: _returnToken = _token;
0559: }
0560:
0561: public final void mRCURLY(boolean _createToken)
0562: throws RecognitionException, CharStreamException,
0563: TokenStreamException {
0564: int _ttype;
0565: Token _token = null;
0566: int _begin = text.length();
0567: _ttype = RCURLY;
0568: int _saveIndex;
0569:
0570: match('}');
0571: if (_createToken && _token == null && _ttype != Token.SKIP) {
0572: _token = makeToken(_ttype);
0573: _token.setText(new String(text.getBuffer(), _begin, text
0574: .length()
0575: - _begin));
0576: }
0577: _returnToken = _token;
0578: }
0579:
0580: public final void mCOLON(boolean _createToken)
0581: throws RecognitionException, CharStreamException,
0582: TokenStreamException {
0583: int _ttype;
0584: Token _token = null;
0585: int _begin = text.length();
0586: _ttype = COLON;
0587: int _saveIndex;
0588:
0589: match(':');
0590: if (_createToken && _token == null && _ttype != Token.SKIP) {
0591: _token = makeToken(_ttype);
0592: _token.setText(new String(text.getBuffer(), _begin, text
0593: .length()
0594: - _begin));
0595: }
0596: _returnToken = _token;
0597: }
0598:
0599: public final void mCOMMA(boolean _createToken)
0600: throws RecognitionException, CharStreamException,
0601: TokenStreamException {
0602: int _ttype;
0603: Token _token = null;
0604: int _begin = text.length();
0605: _ttype = COMMA;
0606: int _saveIndex;
0607:
0608: match(',');
0609: if (_createToken && _token == null && _ttype != Token.SKIP) {
0610: _token = makeToken(_ttype);
0611: _token.setText(new String(text.getBuffer(), _begin, text
0612: .length()
0613: - _begin));
0614: }
0615: _returnToken = _token;
0616: }
0617:
0618: public final void mASSIGN(boolean _createToken)
0619: throws RecognitionException, CharStreamException,
0620: TokenStreamException {
0621: int _ttype;
0622: Token _token = null;
0623: int _begin = text.length();
0624: _ttype = ASSIGN;
0625: int _saveIndex;
0626:
0627: match('=');
0628: if (_createToken && _token == null && _ttype != Token.SKIP) {
0629: _token = makeToken(_ttype);
0630: _token.setText(new String(text.getBuffer(), _begin, text
0631: .length()
0632: - _begin));
0633: }
0634: _returnToken = _token;
0635: }
0636:
0637: public final void mEQUAL(boolean _createToken)
0638: throws RecognitionException, CharStreamException,
0639: TokenStreamException {
0640: int _ttype;
0641: Token _token = null;
0642: int _begin = text.length();
0643: _ttype = EQUAL;
0644: int _saveIndex;
0645:
0646: match("==");
0647: if (_createToken && _token == null && _ttype != Token.SKIP) {
0648: _token = makeToken(_ttype);
0649: _token.setText(new String(text.getBuffer(), _begin, text
0650: .length()
0651: - _begin));
0652: }
0653: _returnToken = _token;
0654: }
0655:
0656: public final void mLNOT(boolean _createToken)
0657: throws RecognitionException, CharStreamException,
0658: TokenStreamException {
0659: int _ttype;
0660: Token _token = null;
0661: int _begin = text.length();
0662: _ttype = LNOT;
0663: int _saveIndex;
0664:
0665: match('!');
0666: if (_createToken && _token == null && _ttype != Token.SKIP) {
0667: _token = makeToken(_ttype);
0668: _token.setText(new String(text.getBuffer(), _begin, text
0669: .length()
0670: - _begin));
0671: }
0672: _returnToken = _token;
0673: }
0674:
0675: public final void mBNOT(boolean _createToken)
0676: throws RecognitionException, CharStreamException,
0677: TokenStreamException {
0678: int _ttype;
0679: Token _token = null;
0680: int _begin = text.length();
0681: _ttype = BNOT;
0682: int _saveIndex;
0683:
0684: match('~');
0685: if (_createToken && _token == null && _ttype != Token.SKIP) {
0686: _token = makeToken(_ttype);
0687: _token.setText(new String(text.getBuffer(), _begin, text
0688: .length()
0689: - _begin));
0690: }
0691: _returnToken = _token;
0692: }
0693:
0694: public final void mNOT_EQUAL(boolean _createToken)
0695: throws RecognitionException, CharStreamException,
0696: TokenStreamException {
0697: int _ttype;
0698: Token _token = null;
0699: int _begin = text.length();
0700: _ttype = NOT_EQUAL;
0701: int _saveIndex;
0702:
0703: match("!=");
0704: if (_createToken && _token == null && _ttype != Token.SKIP) {
0705: _token = makeToken(_ttype);
0706: _token.setText(new String(text.getBuffer(), _begin, text
0707: .length()
0708: - _begin));
0709: }
0710: _returnToken = _token;
0711: }
0712:
0713: public final void mDIV(boolean _createToken)
0714: throws RecognitionException, CharStreamException,
0715: TokenStreamException {
0716: int _ttype;
0717: Token _token = null;
0718: int _begin = text.length();
0719: _ttype = DIV;
0720: int _saveIndex;
0721:
0722: match('/');
0723: if (_createToken && _token == null && _ttype != Token.SKIP) {
0724: _token = makeToken(_ttype);
0725: _token.setText(new String(text.getBuffer(), _begin, text
0726: .length()
0727: - _begin));
0728: }
0729: _returnToken = _token;
0730: }
0731:
0732: public final void mDIV_ASSIGN(boolean _createToken)
0733: throws RecognitionException, CharStreamException,
0734: TokenStreamException {
0735: int _ttype;
0736: Token _token = null;
0737: int _begin = text.length();
0738: _ttype = DIV_ASSIGN;
0739: int _saveIndex;
0740:
0741: match("/=");
0742: if (_createToken && _token == null && _ttype != Token.SKIP) {
0743: _token = makeToken(_ttype);
0744: _token.setText(new String(text.getBuffer(), _begin, text
0745: .length()
0746: - _begin));
0747: }
0748: _returnToken = _token;
0749: }
0750:
0751: public final void mPLUS(boolean _createToken)
0752: throws RecognitionException, CharStreamException,
0753: TokenStreamException {
0754: int _ttype;
0755: Token _token = null;
0756: int _begin = text.length();
0757: _ttype = PLUS;
0758: int _saveIndex;
0759:
0760: match('+');
0761: if (_createToken && _token == null && _ttype != Token.SKIP) {
0762: _token = makeToken(_ttype);
0763: _token.setText(new String(text.getBuffer(), _begin, text
0764: .length()
0765: - _begin));
0766: }
0767: _returnToken = _token;
0768: }
0769:
0770: public final void mPLUS_ASSIGN(boolean _createToken)
0771: throws RecognitionException, CharStreamException,
0772: TokenStreamException {
0773: int _ttype;
0774: Token _token = null;
0775: int _begin = text.length();
0776: _ttype = PLUS_ASSIGN;
0777: int _saveIndex;
0778:
0779: match("+=");
0780: if (_createToken && _token == null && _ttype != Token.SKIP) {
0781: _token = makeToken(_ttype);
0782: _token.setText(new String(text.getBuffer(), _begin, text
0783: .length()
0784: - _begin));
0785: }
0786: _returnToken = _token;
0787: }
0788:
0789: public final void mINC(boolean _createToken)
0790: throws RecognitionException, CharStreamException,
0791: TokenStreamException {
0792: int _ttype;
0793: Token _token = null;
0794: int _begin = text.length();
0795: _ttype = INC;
0796: int _saveIndex;
0797:
0798: match("++");
0799: if (_createToken && _token == null && _ttype != Token.SKIP) {
0800: _token = makeToken(_ttype);
0801: _token.setText(new String(text.getBuffer(), _begin, text
0802: .length()
0803: - _begin));
0804: }
0805: _returnToken = _token;
0806: }
0807:
0808: public final void mMINUS(boolean _createToken)
0809: throws RecognitionException, CharStreamException,
0810: TokenStreamException {
0811: int _ttype;
0812: Token _token = null;
0813: int _begin = text.length();
0814: _ttype = MINUS;
0815: int _saveIndex;
0816:
0817: match('-');
0818: if (_createToken && _token == null && _ttype != Token.SKIP) {
0819: _token = makeToken(_ttype);
0820: _token.setText(new String(text.getBuffer(), _begin, text
0821: .length()
0822: - _begin));
0823: }
0824: _returnToken = _token;
0825: }
0826:
0827: public final void mMINUS_ASSIGN(boolean _createToken)
0828: throws RecognitionException, CharStreamException,
0829: TokenStreamException {
0830: int _ttype;
0831: Token _token = null;
0832: int _begin = text.length();
0833: _ttype = MINUS_ASSIGN;
0834: int _saveIndex;
0835:
0836: match("-=");
0837: if (_createToken && _token == null && _ttype != Token.SKIP) {
0838: _token = makeToken(_ttype);
0839: _token.setText(new String(text.getBuffer(), _begin, text
0840: .length()
0841: - _begin));
0842: }
0843: _returnToken = _token;
0844: }
0845:
0846: public final void mDEC(boolean _createToken)
0847: throws RecognitionException, CharStreamException,
0848: TokenStreamException {
0849: int _ttype;
0850: Token _token = null;
0851: int _begin = text.length();
0852: _ttype = DEC;
0853: int _saveIndex;
0854:
0855: match("--");
0856: if (_createToken && _token == null && _ttype != Token.SKIP) {
0857: _token = makeToken(_ttype);
0858: _token.setText(new String(text.getBuffer(), _begin, text
0859: .length()
0860: - _begin));
0861: }
0862: _returnToken = _token;
0863: }
0864:
0865: public final void mSTAR(boolean _createToken)
0866: throws RecognitionException, CharStreamException,
0867: TokenStreamException {
0868: int _ttype;
0869: Token _token = null;
0870: int _begin = text.length();
0871: _ttype = STAR;
0872: int _saveIndex;
0873:
0874: match('*');
0875: if (_createToken && _token == null && _ttype != Token.SKIP) {
0876: _token = makeToken(_ttype);
0877: _token.setText(new String(text.getBuffer(), _begin, text
0878: .length()
0879: - _begin));
0880: }
0881: _returnToken = _token;
0882: }
0883:
0884: public final void mSTAR_ASSIGN(boolean _createToken)
0885: throws RecognitionException, CharStreamException,
0886: TokenStreamException {
0887: int _ttype;
0888: Token _token = null;
0889: int _begin = text.length();
0890: _ttype = STAR_ASSIGN;
0891: int _saveIndex;
0892:
0893: match("*=");
0894: if (_createToken && _token == null && _ttype != Token.SKIP) {
0895: _token = makeToken(_ttype);
0896: _token.setText(new String(text.getBuffer(), _begin, text
0897: .length()
0898: - _begin));
0899: }
0900: _returnToken = _token;
0901: }
0902:
0903: public final void mMOD(boolean _createToken)
0904: throws RecognitionException, CharStreamException,
0905: TokenStreamException {
0906: int _ttype;
0907: Token _token = null;
0908: int _begin = text.length();
0909: _ttype = MOD;
0910: int _saveIndex;
0911:
0912: match('%');
0913: if (_createToken && _token == null && _ttype != Token.SKIP) {
0914: _token = makeToken(_ttype);
0915: _token.setText(new String(text.getBuffer(), _begin, text
0916: .length()
0917: - _begin));
0918: }
0919: _returnToken = _token;
0920: }
0921:
0922: public final void mMOD_ASSIGN(boolean _createToken)
0923: throws RecognitionException, CharStreamException,
0924: TokenStreamException {
0925: int _ttype;
0926: Token _token = null;
0927: int _begin = text.length();
0928: _ttype = MOD_ASSIGN;
0929: int _saveIndex;
0930:
0931: match("%=");
0932: if (_createToken && _token == null && _ttype != Token.SKIP) {
0933: _token = makeToken(_ttype);
0934: _token.setText(new String(text.getBuffer(), _begin, text
0935: .length()
0936: - _begin));
0937: }
0938: _returnToken = _token;
0939: }
0940:
0941: public final void mSR(boolean _createToken)
0942: throws RecognitionException, CharStreamException,
0943: TokenStreamException {
0944: int _ttype;
0945: Token _token = null;
0946: int _begin = text.length();
0947: _ttype = SR;
0948: int _saveIndex;
0949:
0950: match(">>");
0951: if (_createToken && _token == null && _ttype != Token.SKIP) {
0952: _token = makeToken(_ttype);
0953: _token.setText(new String(text.getBuffer(), _begin, text
0954: .length()
0955: - _begin));
0956: }
0957: _returnToken = _token;
0958: }
0959:
0960: public final void mSR_ASSIGN(boolean _createToken)
0961: throws RecognitionException, CharStreamException,
0962: TokenStreamException {
0963: int _ttype;
0964: Token _token = null;
0965: int _begin = text.length();
0966: _ttype = SR_ASSIGN;
0967: int _saveIndex;
0968:
0969: match(">>=");
0970: if (_createToken && _token == null && _ttype != Token.SKIP) {
0971: _token = makeToken(_ttype);
0972: _token.setText(new String(text.getBuffer(), _begin, text
0973: .length()
0974: - _begin));
0975: }
0976: _returnToken = _token;
0977: }
0978:
0979: public final void mBSR(boolean _createToken)
0980: throws RecognitionException, CharStreamException,
0981: TokenStreamException {
0982: int _ttype;
0983: Token _token = null;
0984: int _begin = text.length();
0985: _ttype = BSR;
0986: int _saveIndex;
0987:
0988: match(">>>");
0989: if (_createToken && _token == null && _ttype != Token.SKIP) {
0990: _token = makeToken(_ttype);
0991: _token.setText(new String(text.getBuffer(), _begin, text
0992: .length()
0993: - _begin));
0994: }
0995: _returnToken = _token;
0996: }
0997:
0998: public final void mBSR_ASSIGN(boolean _createToken)
0999: throws RecognitionException, CharStreamException,
1000: TokenStreamException {
1001: int _ttype;
1002: Token _token = null;
1003: int _begin = text.length();
1004: _ttype = BSR_ASSIGN;
1005: int _saveIndex;
1006:
1007: match(">>>=");
1008: if (_createToken && _token == null && _ttype != Token.SKIP) {
1009: _token = makeToken(_ttype);
1010: _token.setText(new String(text.getBuffer(), _begin, text
1011: .length()
1012: - _begin));
1013: }
1014: _returnToken = _token;
1015: }
1016:
1017: public final void mGE(boolean _createToken)
1018: throws RecognitionException, CharStreamException,
1019: TokenStreamException {
1020: int _ttype;
1021: Token _token = null;
1022: int _begin = text.length();
1023: _ttype = GE;
1024: int _saveIndex;
1025:
1026: match(">=");
1027: if (_createToken && _token == null && _ttype != Token.SKIP) {
1028: _token = makeToken(_ttype);
1029: _token.setText(new String(text.getBuffer(), _begin, text
1030: .length()
1031: - _begin));
1032: }
1033: _returnToken = _token;
1034: }
1035:
1036: public final void mGT(boolean _createToken)
1037: throws RecognitionException, CharStreamException,
1038: TokenStreamException {
1039: int _ttype;
1040: Token _token = null;
1041: int _begin = text.length();
1042: _ttype = GT;
1043: int _saveIndex;
1044:
1045: match(">");
1046: if (_createToken && _token == null && _ttype != Token.SKIP) {
1047: _token = makeToken(_ttype);
1048: _token.setText(new String(text.getBuffer(), _begin, text
1049: .length()
1050: - _begin));
1051: }
1052: _returnToken = _token;
1053: }
1054:
1055: public final void mSL(boolean _createToken)
1056: throws RecognitionException, CharStreamException,
1057: TokenStreamException {
1058: int _ttype;
1059: Token _token = null;
1060: int _begin = text.length();
1061: _ttype = SL;
1062: int _saveIndex;
1063:
1064: match("<<");
1065: if (_createToken && _token == null && _ttype != Token.SKIP) {
1066: _token = makeToken(_ttype);
1067: _token.setText(new String(text.getBuffer(), _begin, text
1068: .length()
1069: - _begin));
1070: }
1071: _returnToken = _token;
1072: }
1073:
1074: public final void mSL_ASSIGN(boolean _createToken)
1075: throws RecognitionException, CharStreamException,
1076: TokenStreamException {
1077: int _ttype;
1078: Token _token = null;
1079: int _begin = text.length();
1080: _ttype = SL_ASSIGN;
1081: int _saveIndex;
1082:
1083: match("<<=");
1084: if (_createToken && _token == null && _ttype != Token.SKIP) {
1085: _token = makeToken(_ttype);
1086: _token.setText(new String(text.getBuffer(), _begin, text
1087: .length()
1088: - _begin));
1089: }
1090: _returnToken = _token;
1091: }
1092:
1093: public final void mLE(boolean _createToken)
1094: throws RecognitionException, CharStreamException,
1095: TokenStreamException {
1096: int _ttype;
1097: Token _token = null;
1098: int _begin = text.length();
1099: _ttype = LE;
1100: int _saveIndex;
1101:
1102: match("<=");
1103: if (_createToken && _token == null && _ttype != Token.SKIP) {
1104: _token = makeToken(_ttype);
1105: _token.setText(new String(text.getBuffer(), _begin, text
1106: .length()
1107: - _begin));
1108: }
1109: _returnToken = _token;
1110: }
1111:
1112: public final void mLT(boolean _createToken)
1113: throws RecognitionException, CharStreamException,
1114: TokenStreamException {
1115: int _ttype;
1116: Token _token = null;
1117: int _begin = text.length();
1118: _ttype = LT;
1119: int _saveIndex;
1120:
1121: match('<');
1122: if (_createToken && _token == null && _ttype != Token.SKIP) {
1123: _token = makeToken(_ttype);
1124: _token.setText(new String(text.getBuffer(), _begin, text
1125: .length()
1126: - _begin));
1127: }
1128: _returnToken = _token;
1129: }
1130:
1131: public final void mBXOR(boolean _createToken)
1132: throws RecognitionException, CharStreamException,
1133: TokenStreamException {
1134: int _ttype;
1135: Token _token = null;
1136: int _begin = text.length();
1137: _ttype = BXOR;
1138: int _saveIndex;
1139:
1140: match('^');
1141: if (_createToken && _token == null && _ttype != Token.SKIP) {
1142: _token = makeToken(_ttype);
1143: _token.setText(new String(text.getBuffer(), _begin, text
1144: .length()
1145: - _begin));
1146: }
1147: _returnToken = _token;
1148: }
1149:
1150: public final void mBXOR_ASSIGN(boolean _createToken)
1151: throws RecognitionException, CharStreamException,
1152: TokenStreamException {
1153: int _ttype;
1154: Token _token = null;
1155: int _begin = text.length();
1156: _ttype = BXOR_ASSIGN;
1157: int _saveIndex;
1158:
1159: match("^=");
1160: if (_createToken && _token == null && _ttype != Token.SKIP) {
1161: _token = makeToken(_ttype);
1162: _token.setText(new String(text.getBuffer(), _begin, text
1163: .length()
1164: - _begin));
1165: }
1166: _returnToken = _token;
1167: }
1168:
1169: public final void mBOR(boolean _createToken)
1170: throws RecognitionException, CharStreamException,
1171: TokenStreamException {
1172: int _ttype;
1173: Token _token = null;
1174: int _begin = text.length();
1175: _ttype = BOR;
1176: int _saveIndex;
1177:
1178: match('|');
1179: if (_createToken && _token == null && _ttype != Token.SKIP) {
1180: _token = makeToken(_ttype);
1181: _token.setText(new String(text.getBuffer(), _begin, text
1182: .length()
1183: - _begin));
1184: }
1185: _returnToken = _token;
1186: }
1187:
1188: public final void mBOR_ASSIGN(boolean _createToken)
1189: throws RecognitionException, CharStreamException,
1190: TokenStreamException {
1191: int _ttype;
1192: Token _token = null;
1193: int _begin = text.length();
1194: _ttype = BOR_ASSIGN;
1195: int _saveIndex;
1196:
1197: match("|=");
1198: if (_createToken && _token == null && _ttype != Token.SKIP) {
1199: _token = makeToken(_ttype);
1200: _token.setText(new String(text.getBuffer(), _begin, text
1201: .length()
1202: - _begin));
1203: }
1204: _returnToken = _token;
1205: }
1206:
1207: public final void mLOR(boolean _createToken)
1208: throws RecognitionException, CharStreamException,
1209: TokenStreamException {
1210: int _ttype;
1211: Token _token = null;
1212: int _begin = text.length();
1213: _ttype = LOR;
1214: int _saveIndex;
1215:
1216: match("||");
1217: if (_createToken && _token == null && _ttype != Token.SKIP) {
1218: _token = makeToken(_ttype);
1219: _token.setText(new String(text.getBuffer(), _begin, text
1220: .length()
1221: - _begin));
1222: }
1223: _returnToken = _token;
1224: }
1225:
1226: public final void mBAND(boolean _createToken)
1227: throws RecognitionException, CharStreamException,
1228: TokenStreamException {
1229: int _ttype;
1230: Token _token = null;
1231: int _begin = text.length();
1232: _ttype = BAND;
1233: int _saveIndex;
1234:
1235: match('&');
1236: if (_createToken && _token == null && _ttype != Token.SKIP) {
1237: _token = makeToken(_ttype);
1238: _token.setText(new String(text.getBuffer(), _begin, text
1239: .length()
1240: - _begin));
1241: }
1242: _returnToken = _token;
1243: }
1244:
1245: public final void mBAND_ASSIGN(boolean _createToken)
1246: throws RecognitionException, CharStreamException,
1247: TokenStreamException {
1248: int _ttype;
1249: Token _token = null;
1250: int _begin = text.length();
1251: _ttype = BAND_ASSIGN;
1252: int _saveIndex;
1253:
1254: match("&=");
1255: if (_createToken && _token == null && _ttype != Token.SKIP) {
1256: _token = makeToken(_ttype);
1257: _token.setText(new String(text.getBuffer(), _begin, text
1258: .length()
1259: - _begin));
1260: }
1261: _returnToken = _token;
1262: }
1263:
1264: public final void mLAND(boolean _createToken)
1265: throws RecognitionException, CharStreamException,
1266: TokenStreamException {
1267: int _ttype;
1268: Token _token = null;
1269: int _begin = text.length();
1270: _ttype = LAND;
1271: int _saveIndex;
1272:
1273: match("&&");
1274: if (_createToken && _token == null && _ttype != Token.SKIP) {
1275: _token = makeToken(_ttype);
1276: _token.setText(new String(text.getBuffer(), _begin, text
1277: .length()
1278: - _begin));
1279: }
1280: _returnToken = _token;
1281: }
1282:
1283: public final void mSEMI(boolean _createToken)
1284: throws RecognitionException, CharStreamException,
1285: TokenStreamException {
1286: int _ttype;
1287: Token _token = null;
1288: int _begin = text.length();
1289: _ttype = SEMI;
1290: int _saveIndex;
1291:
1292: match(';');
1293: if (_createToken && _token == null && _ttype != Token.SKIP) {
1294: _token = makeToken(_ttype);
1295: _token.setText(new String(text.getBuffer(), _begin, text
1296: .length()
1297: - _begin));
1298: }
1299: _returnToken = _token;
1300: }
1301:
1302: public final void mWS(boolean _createToken)
1303: throws RecognitionException, CharStreamException,
1304: TokenStreamException {
1305: int _ttype;
1306: Token _token = null;
1307: int _begin = text.length();
1308: _ttype = WS;
1309: int _saveIndex;
1310:
1311: {
1312: int _cnt246 = 0;
1313: _loop246: do {
1314: switch (LA(1)) {
1315: case ' ': {
1316: match(' ');
1317: break;
1318: }
1319: case '\t': {
1320: match('\t');
1321: break;
1322: }
1323: case '\u000c': {
1324: match('\f');
1325: break;
1326: }
1327: case '\n':
1328: case '\r': {
1329: {
1330: if ((LA(1) == '\r') && (LA(2) == '\n')
1331: && (true) && (true)) {
1332: match("\r\n");
1333: } else if ((LA(1) == '\r') && (true) && (true) && (true)) {
1334: match('\r');
1335: } else if ((LA(1) == '\n')) {
1336: match('\n');
1337: } else {
1338: throw new NoViableAltForCharException(
1339: (char) LA(1), getFilename(),
1340: getLine(), getColumn());
1341: }
1342:
1343: }
1344: if (inputState.guessing == 0) {
1345: newline();
1346: }
1347: break;
1348: }
1349: default: {
1350: if (_cnt246 >= 1) {
1351: break _loop246;
1352: } else {
1353: throw new NoViableAltForCharException(
1354: (char) LA(1), getFilename(), getLine(),
1355: getColumn());
1356: }
1357: }
1358: }
1359: _cnt246++;
1360: } while (true);
1361: }
1362: if (inputState.guessing == 0) {
1363: _ttype = Token.SKIP;
1364: }
1365: if (_createToken && _token == null && _ttype != Token.SKIP) {
1366: _token = makeToken(_ttype);
1367: _token.setText(new String(text.getBuffer(), _begin, text
1368: .length()
1369: - _begin));
1370: }
1371: _returnToken = _token;
1372: }
1373:
1374: public final void mSL_COMMENT(boolean _createToken)
1375: throws RecognitionException, CharStreamException,
1376: TokenStreamException {
1377: int _ttype;
1378: Token _token = null;
1379: int _begin = text.length();
1380: _ttype = SL_COMMENT;
1381: int _saveIndex;
1382:
1383: match("//");
1384: {
1385: _loop250: do {
1386: if ((_tokenSet_0.member(LA(1)))) {
1387: {
1388: match(_tokenSet_0);
1389: }
1390: } else {
1391: break _loop250;
1392: }
1393:
1394: } while (true);
1395: }
1396: {
1397: switch (LA(1)) {
1398: case '\n': {
1399: match('\n');
1400: break;
1401: }
1402: case '\r': {
1403: match('\r');
1404: {
1405: if ((LA(1) == '\n')) {
1406: match('\n');
1407: } else {
1408: }
1409:
1410: }
1411: break;
1412: }
1413: default: {
1414: throw new NoViableAltForCharException((char) LA(1),
1415: getFilename(), getLine(), getColumn());
1416: }
1417: }
1418: }
1419: if (inputState.guessing == 0) {
1420: _ttype = Token.SKIP;
1421: newline();
1422: }
1423: if (_createToken && _token == null && _ttype != Token.SKIP) {
1424: _token = makeToken(_ttype);
1425: _token.setText(new String(text.getBuffer(), _begin, text
1426: .length()
1427: - _begin));
1428: }
1429: _returnToken = _token;
1430: }
1431:
1432: public final void mML_COMMENT(boolean _createToken)
1433: throws RecognitionException, CharStreamException,
1434: TokenStreamException {
1435: int _ttype;
1436: Token _token = null;
1437: int _begin = text.length();
1438: _ttype = ML_COMMENT;
1439: int _saveIndex;
1440:
1441: match("/*");
1442: {
1443: _loop256: do {
1444: if ((LA(1) == '\r') && (LA(2) == '\n')
1445: && ((LA(3) >= '\u0003' && LA(3) <= '\uffff'))
1446: && ((LA(4) >= '\u0003' && LA(4) <= '\uffff'))) {
1447: match('\r');
1448: match('\n');
1449: if (inputState.guessing == 0) {
1450: newline();
1451: }
1452: } else if (((LA(1) == '*')
1453: && ((LA(2) >= '\u0003' && LA(2) <= '\uffff')) && ((LA(3) >= '\u0003' && LA(3) <= '\uffff')))
1454: && (LA(2) != '/')) {
1455: match('*');
1456: } else if ((LA(1) == '\r')
1457: && ((LA(2) >= '\u0003' && LA(2) <= '\uffff'))
1458: && ((LA(3) >= '\u0003' && LA(3) <= '\uffff'))
1459: && (true)) {
1460: match('\r');
1461: if (inputState.guessing == 0) {
1462: newline();
1463: }
1464: } else if ((LA(1) == '\n')) {
1465: match('\n');
1466: if (inputState.guessing == 0) {
1467: newline();
1468: }
1469: } else if ((_tokenSet_1.member(LA(1)))) {
1470: {
1471: match(_tokenSet_1);
1472: }
1473: } else {
1474: break _loop256;
1475: }
1476:
1477: } while (true);
1478: }
1479: match("*/");
1480: if (inputState.guessing == 0) {
1481: _ttype = Token.SKIP;
1482: }
1483: if (_createToken && _token == null && _ttype != Token.SKIP) {
1484: _token = makeToken(_ttype);
1485: _token.setText(new String(text.getBuffer(), _begin, text
1486: .length()
1487: - _begin));
1488: }
1489: _returnToken = _token;
1490: }
1491:
1492: public final void mCHAR_LITERAL(boolean _createToken)
1493: throws RecognitionException, CharStreamException,
1494: TokenStreamException {
1495: int _ttype;
1496: Token _token = null;
1497: int _begin = text.length();
1498: _ttype = CHAR_LITERAL;
1499: int _saveIndex;
1500:
1501: match('\'');
1502: {
1503: if ((LA(1) == '\\')) {
1504: mESC(false);
1505: } else if ((_tokenSet_2.member(LA(1)))) {
1506: {
1507: match(_tokenSet_2);
1508: }
1509: } else {
1510: throw new NoViableAltForCharException((char) LA(1),
1511: getFilename(), getLine(), getColumn());
1512: }
1513:
1514: }
1515: match('\'');
1516: if (_createToken && _token == null && _ttype != Token.SKIP) {
1517: _token = makeToken(_ttype);
1518: _token.setText(new String(text.getBuffer(), _begin, text
1519: .length()
1520: - _begin));
1521: }
1522: _returnToken = _token;
1523: }
1524:
1525: protected final void mESC(boolean _createToken)
1526: throws RecognitionException, CharStreamException,
1527: TokenStreamException {
1528: int _ttype;
1529: Token _token = null;
1530: int _begin = text.length();
1531: _ttype = ESC;
1532: int _saveIndex;
1533:
1534: match('\\');
1535: {
1536: switch (LA(1)) {
1537: case 'n': {
1538: match('n');
1539: break;
1540: }
1541: case 'r': {
1542: match('r');
1543: break;
1544: }
1545: case 't': {
1546: match('t');
1547: break;
1548: }
1549: case 'b': {
1550: match('b');
1551: break;
1552: }
1553: case 'f': {
1554: match('f');
1555: break;
1556: }
1557: case '"': {
1558: match('"');
1559: break;
1560: }
1561: case '\'': {
1562: match('\'');
1563: break;
1564: }
1565: case '\\': {
1566: match('\\');
1567: break;
1568: }
1569: case 'u': {
1570: {
1571: int _cnt267 = 0;
1572: _loop267: do {
1573: if ((LA(1) == 'u')) {
1574: match('u');
1575: } else {
1576: if (_cnt267 >= 1) {
1577: break _loop267;
1578: } else {
1579: throw new NoViableAltForCharException(
1580: (char) LA(1), getFilename(),
1581: getLine(), getColumn());
1582: }
1583: }
1584:
1585: _cnt267++;
1586: } while (true);
1587: }
1588: mHEX_DIGIT(false);
1589: mHEX_DIGIT(false);
1590: mHEX_DIGIT(false);
1591: mHEX_DIGIT(false);
1592: break;
1593: }
1594: case '0':
1595: case '1':
1596: case '2':
1597: case '3': {
1598: matchRange('0', '3');
1599: {
1600: if (((LA(1) >= '0' && LA(1) <= '7'))
1601: && (_tokenSet_0.member(LA(2))) && (true)
1602: && (true)) {
1603: matchRange('0', '7');
1604: {
1605: if (((LA(1) >= '0' && LA(1) <= '7'))
1606: && (_tokenSet_0.member(LA(2)))
1607: && (true) && (true)) {
1608: matchRange('0', '7');
1609: } else if ((_tokenSet_0.member(LA(1))) && (true) && (true) && (true)) {
1610: } else {
1611: throw new NoViableAltForCharException(
1612: (char) LA(1), getFilename(),
1613: getLine(), getColumn());
1614: }
1615:
1616: }
1617: } else if ((_tokenSet_0.member(LA(1))) && (true) && (true) && (true)) {
1618: } else {
1619: throw new NoViableAltForCharException(
1620: (char) LA(1), getFilename(), getLine(),
1621: getColumn());
1622: }
1623:
1624: }
1625: break;
1626: }
1627: case '4':
1628: case '5':
1629: case '6':
1630: case '7': {
1631: matchRange('4', '7');
1632: {
1633: if (((LA(1) >= '0' && LA(1) <= '7'))
1634: && (_tokenSet_0.member(LA(2))) && (true)
1635: && (true)) {
1636: matchRange('0', '7');
1637: } else if ((_tokenSet_0.member(LA(1))) && (true) && (true) && (true)) {
1638: } else {
1639: throw new NoViableAltForCharException(
1640: (char) LA(1), getFilename(), getLine(),
1641: getColumn());
1642: }
1643:
1644: }
1645: break;
1646: }
1647: default: {
1648: throw new NoViableAltForCharException((char) LA(1),
1649: getFilename(), getLine(), getColumn());
1650: }
1651: }
1652: }
1653: if (_createToken && _token == null && _ttype != Token.SKIP) {
1654: _token = makeToken(_ttype);
1655: _token.setText(new String(text.getBuffer(), _begin, text
1656: .length()
1657: - _begin));
1658: }
1659: _returnToken = _token;
1660: }
1661:
1662: public final void mSTRING_LITERAL(boolean _createToken)
1663: throws RecognitionException, CharStreamException,
1664: TokenStreamException {
1665: int _ttype;
1666: Token _token = null;
1667: int _begin = text.length();
1668: _ttype = STRING_LITERAL;
1669: int _saveIndex;
1670:
1671: match('"');
1672: {
1673: _loop263: do {
1674: if ((LA(1) == '\\')) {
1675: mESC(false);
1676: } else if ((_tokenSet_3.member(LA(1)))) {
1677: {
1678: match(_tokenSet_3);
1679: }
1680: } else {
1681: break _loop263;
1682: }
1683:
1684: } while (true);
1685: }
1686: match('"');
1687: if (_createToken && _token == null && _ttype != Token.SKIP) {
1688: _token = makeToken(_ttype);
1689: _token.setText(new String(text.getBuffer(), _begin, text
1690: .length()
1691: - _begin));
1692: }
1693: _returnToken = _token;
1694: }
1695:
1696: protected final void mHEX_DIGIT(boolean _createToken)
1697: throws RecognitionException, CharStreamException,
1698: TokenStreamException {
1699: int _ttype;
1700: Token _token = null;
1701: int _begin = text.length();
1702: _ttype = HEX_DIGIT;
1703: int _saveIndex;
1704:
1705: {
1706: switch (LA(1)) {
1707: case '0':
1708: case '1':
1709: case '2':
1710: case '3':
1711: case '4':
1712: case '5':
1713: case '6':
1714: case '7':
1715: case '8':
1716: case '9': {
1717: matchRange('0', '9');
1718: break;
1719: }
1720: case 'A':
1721: case 'B':
1722: case 'C':
1723: case 'D':
1724: case 'E':
1725: case 'F': {
1726: matchRange('A', 'F');
1727: break;
1728: }
1729: case 'a':
1730: case 'b':
1731: case 'c':
1732: case 'd':
1733: case 'e':
1734: case 'f': {
1735: matchRange('a', 'f');
1736: break;
1737: }
1738: default: {
1739: throw new NoViableAltForCharException((char) LA(1),
1740: getFilename(), getLine(), getColumn());
1741: }
1742: }
1743: }
1744: if (_createToken && _token == null && _ttype != Token.SKIP) {
1745: _token = makeToken(_ttype);
1746: _token.setText(new String(text.getBuffer(), _begin, text
1747: .length()
1748: - _begin));
1749: }
1750: _returnToken = _token;
1751: }
1752:
1753: protected final void mVOCAB(boolean _createToken)
1754: throws RecognitionException, CharStreamException,
1755: TokenStreamException {
1756: int _ttype;
1757: Token _token = null;
1758: int _begin = text.length();
1759: _ttype = VOCAB;
1760: int _saveIndex;
1761:
1762: matchRange('\3', '\377');
1763: if (_createToken && _token == null && _ttype != Token.SKIP) {
1764: _token = makeToken(_ttype);
1765: _token.setText(new String(text.getBuffer(), _begin, text
1766: .length()
1767: - _begin));
1768: }
1769: _returnToken = _token;
1770: }
1771:
1772: public final void mIDENT(boolean _createToken)
1773: throws RecognitionException, CharStreamException,
1774: TokenStreamException {
1775: int _ttype;
1776: Token _token = null;
1777: int _begin = text.length();
1778: _ttype = IDENT;
1779: int _saveIndex;
1780:
1781: {
1782: switch (LA(1)) {
1783: case 'a':
1784: case 'b':
1785: case 'c':
1786: case 'd':
1787: case 'e':
1788: case 'f':
1789: case 'g':
1790: case 'h':
1791: case 'i':
1792: case 'j':
1793: case 'k':
1794: case 'l':
1795: case 'm':
1796: case 'n':
1797: case 'o':
1798: case 'p':
1799: case 'q':
1800: case 'r':
1801: case 's':
1802: case 't':
1803: case 'u':
1804: case 'v':
1805: case 'w':
1806: case 'x':
1807: case 'y':
1808: case 'z': {
1809: matchRange('a', 'z');
1810: break;
1811: }
1812: case 'A':
1813: case 'B':
1814: case 'C':
1815: case 'D':
1816: case 'E':
1817: case 'F':
1818: case 'G':
1819: case 'H':
1820: case 'I':
1821: case 'J':
1822: case 'K':
1823: case 'L':
1824: case 'M':
1825: case 'N':
1826: case 'O':
1827: case 'P':
1828: case 'Q':
1829: case 'R':
1830: case 'S':
1831: case 'T':
1832: case 'U':
1833: case 'V':
1834: case 'W':
1835: case 'X':
1836: case 'Y':
1837: case 'Z': {
1838: matchRange('A', 'Z');
1839: break;
1840: }
1841: case '_': {
1842: match('_');
1843: break;
1844: }
1845: case '$': {
1846: match('$');
1847: break;
1848: }
1849: default: {
1850: throw new NoViableAltForCharException((char) LA(1),
1851: getFilename(), getLine(), getColumn());
1852: }
1853: }
1854: }
1855: {
1856: _loop277: do {
1857: switch (LA(1)) {
1858: case 'a':
1859: case 'b':
1860: case 'c':
1861: case 'd':
1862: case 'e':
1863: case 'f':
1864: case 'g':
1865: case 'h':
1866: case 'i':
1867: case 'j':
1868: case 'k':
1869: case 'l':
1870: case 'm':
1871: case 'n':
1872: case 'o':
1873: case 'p':
1874: case 'q':
1875: case 'r':
1876: case 's':
1877: case 't':
1878: case 'u':
1879: case 'v':
1880: case 'w':
1881: case 'x':
1882: case 'y':
1883: case 'z': {
1884: matchRange('a', 'z');
1885: break;
1886: }
1887: case 'A':
1888: case 'B':
1889: case 'C':
1890: case 'D':
1891: case 'E':
1892: case 'F':
1893: case 'G':
1894: case 'H':
1895: case 'I':
1896: case 'J':
1897: case 'K':
1898: case 'L':
1899: case 'M':
1900: case 'N':
1901: case 'O':
1902: case 'P':
1903: case 'Q':
1904: case 'R':
1905: case 'S':
1906: case 'T':
1907: case 'U':
1908: case 'V':
1909: case 'W':
1910: case 'X':
1911: case 'Y':
1912: case 'Z': {
1913: matchRange('A', 'Z');
1914: break;
1915: }
1916: case '_': {
1917: match('_');
1918: break;
1919: }
1920: case '0':
1921: case '1':
1922: case '2':
1923: case '3':
1924: case '4':
1925: case '5':
1926: case '6':
1927: case '7':
1928: case '8':
1929: case '9': {
1930: matchRange('0', '9');
1931: break;
1932: }
1933: case '$': {
1934: match('$');
1935: break;
1936: }
1937: default: {
1938: break _loop277;
1939: }
1940: }
1941: } while (true);
1942: }
1943: _ttype = testLiteralsTable(_ttype);
1944: if (_createToken && _token == null && _ttype != Token.SKIP) {
1945: _token = makeToken(_ttype);
1946: _token.setText(new String(text.getBuffer(), _begin, text
1947: .length()
1948: - _begin));
1949: }
1950: _returnToken = _token;
1951: }
1952:
1953: public final void mNUM_INT(boolean _createToken)
1954: throws RecognitionException, CharStreamException,
1955: TokenStreamException {
1956: int _ttype;
1957: Token _token = null;
1958: int _begin = text.length();
1959: _ttype = NUM_INT;
1960: int _saveIndex;
1961: Token f1 = null;
1962: Token f2 = null;
1963: Token f3 = null;
1964: Token f4 = null;
1965: boolean isDecimal = false;
1966: Token t = null;
1967:
1968: switch (LA(1)) {
1969: case '.': {
1970: match('.');
1971: if (inputState.guessing == 0) {
1972: _ttype = DOT;
1973: }
1974: {
1975: if (((LA(1) >= '0' && LA(1) <= '9'))) {
1976: {
1977: int _cnt281 = 0;
1978: _loop281: do {
1979: if (((LA(1) >= '0' && LA(1) <= '9'))) {
1980: matchRange('0', '9');
1981: } else {
1982: if (_cnt281 >= 1) {
1983: break _loop281;
1984: } else {
1985: throw new NoViableAltForCharException(
1986: (char) LA(1),
1987: getFilename(), getLine(),
1988: getColumn());
1989: }
1990: }
1991:
1992: _cnt281++;
1993: } while (true);
1994: }
1995: {
1996: if ((LA(1) == 'E' || LA(1) == 'e')) {
1997: mEXPONENT(false);
1998: } else {
1999: }
2000:
2001: }
2002: {
2003: if ((LA(1) == 'D' || LA(1) == 'F'
2004: || LA(1) == 'd' || LA(1) == 'f')) {
2005: mFLOAT_SUFFIX(true);
2006: f1 = _returnToken;
2007: if (inputState.guessing == 0) {
2008: t = f1;
2009: }
2010: } else {
2011: }
2012:
2013: }
2014: if (inputState.guessing == 0) {
2015:
2016: if (t != null
2017: && t.getText().toUpperCase().indexOf(
2018: 'F') >= 0) {
2019: _ttype = NUM_FLOAT;
2020: } else {
2021: _ttype = NUM_DOUBLE; // assume double
2022: }
2023:
2024: }
2025: } else {
2026: }
2027:
2028: }
2029: break;
2030: }
2031: case '0':
2032: case '1':
2033: case '2':
2034: case '3':
2035: case '4':
2036: case '5':
2037: case '6':
2038: case '7':
2039: case '8':
2040: case '9': {
2041: {
2042: switch (LA(1)) {
2043: case '0': {
2044: match('0');
2045: if (inputState.guessing == 0) {
2046: isDecimal = true;
2047: }
2048: {
2049: if ((LA(1) == 'X' || LA(1) == 'x')) {
2050: {
2051: switch (LA(1)) {
2052: case 'x': {
2053: match('x');
2054: break;
2055: }
2056: case 'X': {
2057: match('X');
2058: break;
2059: }
2060: default: {
2061: throw new NoViableAltForCharException(
2062: (char) LA(1),
2063: getFilename(), getLine(),
2064: getColumn());
2065: }
2066: }
2067: }
2068: {
2069: int _cnt288 = 0;
2070: _loop288: do {
2071: if ((_tokenSet_4.member(LA(1))) && (true) && (true) && (true)) {
2072: mHEX_DIGIT(false);
2073: } else {
2074: if (_cnt288 >= 1) {
2075: break _loop288;
2076: } else {
2077: throw new NoViableAltForCharException(
2078: (char) LA(1),
2079: getFilename(),
2080: getLine(),
2081: getColumn());
2082: }
2083: }
2084:
2085: _cnt288++;
2086: } while (true);
2087: }
2088: } else {
2089: boolean synPredMatched293 = false;
2090: if ((((LA(1) >= '0' && LA(1) <= '9')) && (true) && (true) && (true))) {
2091: int _m293 = mark();
2092: synPredMatched293 = true;
2093: inputState.guessing++;
2094: try {
2095: {
2096: {
2097: int _cnt291 = 0;
2098: _loop291: do {
2099: if (((LA(1) >= '0' && LA(1) <= '9'))) {
2100: matchRange('0', '9');
2101: } else {
2102: if (_cnt291 >= 1) {
2103: break _loop291;
2104: } else {
2105: throw new NoViableAltForCharException(
2106: (char) LA(1),
2107: getFilename(),
2108: getLine(),
2109: getColumn());
2110: }
2111: }
2112:
2113: _cnt291++;
2114: } while (true);
2115: }
2116: {
2117: switch (LA(1)) {
2118: case '.': {
2119: match('.');
2120: break;
2121: }
2122: case 'E':
2123: case 'e': {
2124: mEXPONENT(false);
2125: break;
2126: }
2127: case 'D':
2128: case 'F':
2129: case 'd':
2130: case 'f': {
2131: mFLOAT_SUFFIX(false);
2132: break;
2133: }
2134: default: {
2135: throw new NoViableAltForCharException(
2136: (char) LA(1),
2137: getFilename(),
2138: getLine(),
2139: getColumn());
2140: }
2141: }
2142: }
2143: }
2144: } catch (RecognitionException pe) {
2145: synPredMatched293 = false;
2146: }
2147: rewind(_m293);
2148: inputState.guessing--;
2149: }
2150: if (synPredMatched293) {
2151: {
2152: int _cnt295 = 0;
2153: _loop295: do {
2154: if (((LA(1) >= '0' && LA(1) <= '9'))) {
2155: matchRange('0', '9');
2156: } else {
2157: if (_cnt295 >= 1) {
2158: break _loop295;
2159: } else {
2160: throw new NoViableAltForCharException(
2161: (char) LA(1),
2162: getFilename(),
2163: getLine(),
2164: getColumn());
2165: }
2166: }
2167:
2168: _cnt295++;
2169: } while (true);
2170: }
2171: } else if (((LA(1) >= '0' && LA(1) <= '7')) && (true) && (true) && (true)) {
2172: {
2173: int _cnt297 = 0;
2174: _loop297: do {
2175: if (((LA(1) >= '0' && LA(1) <= '7'))) {
2176: matchRange('0', '7');
2177: } else {
2178: if (_cnt297 >= 1) {
2179: break _loop297;
2180: } else {
2181: throw new NoViableAltForCharException(
2182: (char) LA(1),
2183: getFilename(),
2184: getLine(),
2185: getColumn());
2186: }
2187: }
2188:
2189: _cnt297++;
2190: } while (true);
2191: }
2192: } else {
2193: }
2194: }
2195: }
2196: break;
2197: }
2198: case '1':
2199: case '2':
2200: case '3':
2201: case '4':
2202: case '5':
2203: case '6':
2204: case '7':
2205: case '8':
2206: case '9': {
2207: {
2208: matchRange('1', '9');
2209: }
2210: {
2211: _loop300: do {
2212: if (((LA(1) >= '0' && LA(1) <= '9'))) {
2213: matchRange('0', '9');
2214: } else {
2215: break _loop300;
2216: }
2217:
2218: } while (true);
2219: }
2220: if (inputState.guessing == 0) {
2221: isDecimal = true;
2222: }
2223: break;
2224: }
2225: default: {
2226: throw new NoViableAltForCharException((char) LA(1),
2227: getFilename(), getLine(), getColumn());
2228: }
2229: }
2230: }
2231: {
2232: if ((LA(1) == 'L' || LA(1) == 'l')) {
2233: {
2234: switch (LA(1)) {
2235: case 'l': {
2236: match('l');
2237: break;
2238: }
2239: case 'L': {
2240: match('L');
2241: break;
2242: }
2243: default: {
2244: throw new NoViableAltForCharException(
2245: (char) LA(1), getFilename(),
2246: getLine(), getColumn());
2247: }
2248: }
2249: }
2250: if (inputState.guessing == 0) {
2251: _ttype = NUM_LONG;
2252: }
2253: } else if (((LA(1) == '.' || LA(1) == 'D'
2254: || LA(1) == 'E' || LA(1) == 'F' || LA(1) == 'd'
2255: || LA(1) == 'e' || LA(1) == 'f'))
2256: && (isDecimal)) {
2257: {
2258: switch (LA(1)) {
2259: case '.': {
2260: match('.');
2261: {
2262: _loop305: do {
2263: if (((LA(1) >= '0' && LA(1) <= '9'))) {
2264: matchRange('0', '9');
2265: } else {
2266: break _loop305;
2267: }
2268:
2269: } while (true);
2270: }
2271: {
2272: if ((LA(1) == 'E' || LA(1) == 'e')) {
2273: mEXPONENT(false);
2274: } else {
2275: }
2276:
2277: }
2278: {
2279: if ((LA(1) == 'D' || LA(1) == 'F'
2280: || LA(1) == 'd' || LA(1) == 'f')) {
2281: mFLOAT_SUFFIX(true);
2282: f2 = _returnToken;
2283: if (inputState.guessing == 0) {
2284: t = f2;
2285: }
2286: } else {
2287: }
2288:
2289: }
2290: break;
2291: }
2292: case 'E':
2293: case 'e': {
2294: mEXPONENT(false);
2295: {
2296: if ((LA(1) == 'D' || LA(1) == 'F'
2297: || LA(1) == 'd' || LA(1) == 'f')) {
2298: mFLOAT_SUFFIX(true);
2299: f3 = _returnToken;
2300: if (inputState.guessing == 0) {
2301: t = f3;
2302: }
2303: } else {
2304: }
2305:
2306: }
2307: break;
2308: }
2309: case 'D':
2310: case 'F':
2311: case 'd':
2312: case 'f': {
2313: mFLOAT_SUFFIX(true);
2314: f4 = _returnToken;
2315: if (inputState.guessing == 0) {
2316: t = f4;
2317: }
2318: break;
2319: }
2320: default: {
2321: throw new NoViableAltForCharException(
2322: (char) LA(1), getFilename(),
2323: getLine(), getColumn());
2324: }
2325: }
2326: }
2327: if (inputState.guessing == 0) {
2328:
2329: if (t != null
2330: && t.getText().toUpperCase().indexOf(
2331: 'F') >= 0) {
2332: _ttype = NUM_FLOAT;
2333: } else {
2334: _ttype = NUM_DOUBLE; // assume double
2335: }
2336:
2337: }
2338: } else {
2339: }
2340:
2341: }
2342: break;
2343: }
2344: default: {
2345: throw new NoViableAltForCharException((char) LA(1),
2346: getFilename(), getLine(), getColumn());
2347: }
2348: }
2349: if (_createToken && _token == null && _ttype != Token.SKIP) {
2350: _token = makeToken(_ttype);
2351: _token.setText(new String(text.getBuffer(), _begin, text
2352: .length()
2353: - _begin));
2354: }
2355: _returnToken = _token;
2356: }
2357:
2358: protected final void mEXPONENT(boolean _createToken)
2359: throws RecognitionException, CharStreamException,
2360: TokenStreamException {
2361: int _ttype;
2362: Token _token = null;
2363: int _begin = text.length();
2364: _ttype = EXPONENT;
2365: int _saveIndex;
2366:
2367: {
2368: switch (LA(1)) {
2369: case 'e': {
2370: match('e');
2371: break;
2372: }
2373: case 'E': {
2374: match('E');
2375: break;
2376: }
2377: default: {
2378: throw new NoViableAltForCharException((char) LA(1),
2379: getFilename(), getLine(), getColumn());
2380: }
2381: }
2382: }
2383: {
2384: switch (LA(1)) {
2385: case '+': {
2386: match('+');
2387: break;
2388: }
2389: case '-': {
2390: match('-');
2391: break;
2392: }
2393: case '0':
2394: case '1':
2395: case '2':
2396: case '3':
2397: case '4':
2398: case '5':
2399: case '6':
2400: case '7':
2401: case '8':
2402: case '9': {
2403: break;
2404: }
2405: default: {
2406: throw new NoViableAltForCharException((char) LA(1),
2407: getFilename(), getLine(), getColumn());
2408: }
2409: }
2410: }
2411: {
2412: int _cnt313 = 0;
2413: _loop313: do {
2414: if (((LA(1) >= '0' && LA(1) <= '9'))) {
2415: matchRange('0', '9');
2416: } else {
2417: if (_cnt313 >= 1) {
2418: break _loop313;
2419: } else {
2420: throw new NoViableAltForCharException(
2421: (char) LA(1), getFilename(), getLine(),
2422: getColumn());
2423: }
2424: }
2425:
2426: _cnt313++;
2427: } while (true);
2428: }
2429: if (_createToken && _token == null && _ttype != Token.SKIP) {
2430: _token = makeToken(_ttype);
2431: _token.setText(new String(text.getBuffer(), _begin, text
2432: .length()
2433: - _begin));
2434: }
2435: _returnToken = _token;
2436: }
2437:
2438: protected final void mFLOAT_SUFFIX(boolean _createToken)
2439: throws RecognitionException, CharStreamException,
2440: TokenStreamException {
2441: int _ttype;
2442: Token _token = null;
2443: int _begin = text.length();
2444: _ttype = FLOAT_SUFFIX;
2445: int _saveIndex;
2446:
2447: switch (LA(1)) {
2448: case 'f': {
2449: match('f');
2450: break;
2451: }
2452: case 'F': {
2453: match('F');
2454: break;
2455: }
2456: case 'd': {
2457: match('d');
2458: break;
2459: }
2460: case 'D': {
2461: match('D');
2462: break;
2463: }
2464: default: {
2465: throw new NoViableAltForCharException((char) LA(1),
2466: getFilename(), getLine(), getColumn());
2467: }
2468: }
2469: if (_createToken && _token == null && _ttype != Token.SKIP) {
2470: _token = makeToken(_ttype);
2471: _token.setText(new String(text.getBuffer(), _begin, text
2472: .length()
2473: - _begin));
2474: }
2475: _returnToken = _token;
2476: }
2477:
2478: private static final long[] mk_tokenSet_0() {
2479: long[] data = new long[2048];
2480: data[0] = -9224L;
2481: for (int i = 1; i <= 1023; i++) {
2482: data[i] = -1L;
2483: }
2484: return data;
2485: }
2486:
2487: public static final BitSet _tokenSet_0 = new BitSet(mk_tokenSet_0());
2488:
2489: private static final long[] mk_tokenSet_1() {
2490: long[] data = new long[2048];
2491: data[0] = -4398046520328L;
2492: for (int i = 1; i <= 1023; i++) {
2493: data[i] = -1L;
2494: }
2495: return data;
2496: }
2497:
2498: public static final BitSet _tokenSet_1 = new BitSet(mk_tokenSet_1());
2499:
2500: private static final long[] mk_tokenSet_2() {
2501: long[] data = new long[2048];
2502: data[0] = -549755823112L;
2503: data[1] = -268435457L;
2504: for (int i = 2; i <= 1023; i++) {
2505: data[i] = -1L;
2506: }
2507: return data;
2508: }
2509:
2510: public static final BitSet _tokenSet_2 = new BitSet(mk_tokenSet_2());
2511:
2512: private static final long[] mk_tokenSet_3() {
2513: long[] data = new long[2048];
2514: data[0] = -17179878408L;
2515: data[1] = -268435457L;
2516: for (int i = 2; i <= 1023; i++) {
2517: data[i] = -1L;
2518: }
2519: return data;
2520: }
2521:
2522: public static final BitSet _tokenSet_3 = new BitSet(mk_tokenSet_3());
2523:
2524: private static final long[] mk_tokenSet_4() {
2525: long[] data = new long[1025];
2526: data[0] = 287948901175001088L;
2527: data[1] = 541165879422L;
2528: return data;
2529: }
2530:
2531: public static final BitSet _tokenSet_4 = new BitSet(mk_tokenSet_4());
2532:
2533: }
|