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