0001: // $ANTLR 2.7.5 (20050128): "sjava.g" -> "JavaLexer.java"$
0002:
0003: package biz.hammurapi.codegen;
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: public class JavaLexer extends antlr.CharScanner implements
0030: JavaTokenTypes, TokenStream {
0031: public JavaLexer(InputStream in) {
0032: this (new ByteBuffer(in));
0033: }
0034:
0035: public JavaLexer(Reader in) {
0036: this (new CharBuffer(in));
0037: }
0038:
0039: public JavaLexer(InputBuffer ib) {
0040: this (new LexerSharedInputState(ib));
0041: }
0042:
0043: public JavaLexer(LexerSharedInputState state) {
0044: super (state);
0045: caseSensitiveLiterals = true;
0046: setCaseSensitive(true);
0047: literals = new Hashtable();
0048: literals.put(new ANTLRHashString("public", this ), new Integer(
0049: 33));
0050: literals.put(new ANTLRHashString("static", this ), new Integer(
0051: 35));
0052: literals.put(new ANTLRHashString("threadsafe", this ),
0053: new Integer(38));
0054: literals.put(new ANTLRHashString("synchronized", this ),
0055: new Integer(39));
0056: literals.put(new ANTLRHashString("short", this ),
0057: new Integer(25));
0058: literals.put(new ANTLRHashString("boolean", this ), new Integer(
0059: 22));
0060: literals.put(new ANTLRHashString("abstract", this ),
0061: new Integer(17));
0062: literals.put(new ANTLRHashString("class", this ),
0063: new Integer(41));
0064: literals.put(new ANTLRHashString("float", this ),
0065: new Integer(27));
0066: literals.put(new ANTLRHashString("throws", this ), new Integer(
0067: 49));
0068: literals.put(new ANTLRHashString("final", this ),
0069: new Integer(16));
0070: literals
0071: .put(new ANTLRHashString("char", this ), new Integer(24));
0072: literals.put(new ANTLRHashString("native", this ), new Integer(
0073: 37));
0074: literals.put(new ANTLRHashString("strictfp", this ),
0075: new Integer(18));
0076: literals.put(new ANTLRHashString("transient", this ),
0077: new Integer(36));
0078: literals.put(new ANTLRHashString("private", this ), new Integer(
0079: 32));
0080: literals.put(new ANTLRHashString("double", this ), new Integer(
0081: 29));
0082: literals.put(new ANTLRHashString("extends", this ), new Integer(
0083: 42));
0084: literals.put(new ANTLRHashString("protected", this ),
0085: new Integer(34));
0086: literals
0087: .put(new ANTLRHashString("byte", this ), new Integer(23));
0088: literals
0089: .put(new ANTLRHashString("void", this ), new Integer(21));
0090: literals.put(new ANTLRHashString("implements", this ),
0091: new Integer(45));
0092: literals.put(new ANTLRHashString("interface", this ),
0093: new Integer(43));
0094: literals
0095: .put(new ANTLRHashString("long", this ), new Integer(28));
0096: literals.put(new ANTLRHashString("int", this ), new Integer(26));
0097: literals.put(new ANTLRHashString("volatile", this ),
0098: new Integer(40));
0099: }
0100:
0101: public Token nextToken() throws TokenStreamException {
0102: Token theRetToken = null;
0103: tryAgain: for (;;) {
0104: Token _token = null;
0105: int _ttype = Token.INVALID_TYPE;
0106: resetText();
0107: try { // for char stream error handling
0108: try { // for lexical error handling
0109: switch (LA(1)) {
0110: case '(': {
0111: mLPAREN(true);
0112: theRetToken = _returnToken;
0113: break;
0114: }
0115: case ')': {
0116: mRPAREN(true);
0117: theRetToken = _returnToken;
0118: break;
0119: }
0120: case '[': {
0121: mLBRACK(true);
0122: theRetToken = _returnToken;
0123: break;
0124: }
0125: case ']': {
0126: mRBRACK(true);
0127: theRetToken = _returnToken;
0128: break;
0129: }
0130: case ':': {
0131: mCOLON(true);
0132: theRetToken = _returnToken;
0133: break;
0134: }
0135: case ',': {
0136: mCOMMA(true);
0137: theRetToken = _returnToken;
0138: break;
0139: }
0140: case '.': {
0141: mDOT(true);
0142: theRetToken = _returnToken;
0143: break;
0144: }
0145: case '*': {
0146: mSTAR(true);
0147: theRetToken = _returnToken;
0148: break;
0149: }
0150: case ';': {
0151: mSEMI(true);
0152: theRetToken = _returnToken;
0153: break;
0154: }
0155: case '<': {
0156: mINIT(true);
0157: theRetToken = _returnToken;
0158: break;
0159: }
0160: case '\t':
0161: case '\n':
0162: case '\u000c':
0163: case '\r':
0164: case ' ': {
0165: mWS(true);
0166: theRetToken = _returnToken;
0167: break;
0168: }
0169: case '\'': {
0170: mCHAR_LITERAL(true);
0171: theRetToken = _returnToken;
0172: break;
0173: }
0174: case '"': {
0175: mSTRING_LITERAL(true);
0176: theRetToken = _returnToken;
0177: break;
0178: }
0179: case '$':
0180: case 'A':
0181: case 'B':
0182: case 'C':
0183: case 'D':
0184: case 'E':
0185: case 'F':
0186: case 'G':
0187: case 'H':
0188: case 'I':
0189: case 'J':
0190: case 'K':
0191: case 'L':
0192: case 'M':
0193: case 'N':
0194: case 'O':
0195: case 'P':
0196: case 'Q':
0197: case 'R':
0198: case 'S':
0199: case 'T':
0200: case 'U':
0201: case 'V':
0202: case 'W':
0203: case 'X':
0204: case 'Y':
0205: case 'Z':
0206: case '_':
0207: case 'a':
0208: case 'b':
0209: case 'c':
0210: case 'd':
0211: case 'e':
0212: case 'f':
0213: case 'g':
0214: case 'h':
0215: case 'i':
0216: case 'j':
0217: case 'k':
0218: case 'l':
0219: case 'm':
0220: case 'n':
0221: case 'o':
0222: case 'p':
0223: case 'q':
0224: case 'r':
0225: case 's':
0226: case 't':
0227: case 'u':
0228: case 'v':
0229: case 'w':
0230: case 'x':
0231: case 'y':
0232: case 'z': {
0233: mIDENT(true);
0234: theRetToken = _returnToken;
0235: break;
0236: }
0237: default: {
0238: if (LA(1) == EOF_CHAR) {
0239: uponEOF();
0240: _returnToken = makeToken(Token.EOF_TYPE);
0241: } else {
0242: throw new NoViableAltForCharException(
0243: (char) LA(1), getFilename(),
0244: getLine(), getColumn());
0245: }
0246: }
0247: }
0248: if (_returnToken == null)
0249: continue tryAgain; // found SKIP token
0250: _ttype = _returnToken.getType();
0251: _returnToken.setType(_ttype);
0252: return _returnToken;
0253: } catch (RecognitionException e) {
0254: throw new TokenStreamRecognitionException(e);
0255: }
0256: } catch (CharStreamException cse) {
0257: if (cse instanceof CharStreamIOException) {
0258: throw new TokenStreamIOException(
0259: ((CharStreamIOException) cse).io);
0260: } else {
0261: throw new TokenStreamException(cse.getMessage());
0262: }
0263: }
0264: }
0265: }
0266:
0267: public final void mLPAREN(boolean _createToken)
0268: throws RecognitionException, CharStreamException,
0269: TokenStreamException {
0270: int _ttype;
0271: Token _token = null;
0272: int _begin = text.length();
0273: _ttype = LPAREN;
0274: int _saveIndex;
0275:
0276: match('(');
0277: if (_createToken && _token == null && _ttype != Token.SKIP) {
0278: _token = makeToken(_ttype);
0279: _token.setText(new String(text.getBuffer(), _begin, text
0280: .length()
0281: - _begin));
0282: }
0283: _returnToken = _token;
0284: }
0285:
0286: public final void mRPAREN(boolean _createToken)
0287: throws RecognitionException, CharStreamException,
0288: TokenStreamException {
0289: int _ttype;
0290: Token _token = null;
0291: int _begin = text.length();
0292: _ttype = RPAREN;
0293: int _saveIndex;
0294:
0295: match(')');
0296: if (_createToken && _token == null && _ttype != Token.SKIP) {
0297: _token = makeToken(_ttype);
0298: _token.setText(new String(text.getBuffer(), _begin, text
0299: .length()
0300: - _begin));
0301: }
0302: _returnToken = _token;
0303: }
0304:
0305: public final void mLBRACK(boolean _createToken)
0306: throws RecognitionException, CharStreamException,
0307: TokenStreamException {
0308: int _ttype;
0309: Token _token = null;
0310: int _begin = text.length();
0311: _ttype = LBRACK;
0312: int _saveIndex;
0313:
0314: match('[');
0315: if (_createToken && _token == null && _ttype != Token.SKIP) {
0316: _token = makeToken(_ttype);
0317: _token.setText(new String(text.getBuffer(), _begin, text
0318: .length()
0319: - _begin));
0320: }
0321: _returnToken = _token;
0322: }
0323:
0324: public final void mRBRACK(boolean _createToken)
0325: throws RecognitionException, CharStreamException,
0326: TokenStreamException {
0327: int _ttype;
0328: Token _token = null;
0329: int _begin = text.length();
0330: _ttype = RBRACK;
0331: int _saveIndex;
0332:
0333: match(']');
0334: if (_createToken && _token == null && _ttype != Token.SKIP) {
0335: _token = makeToken(_ttype);
0336: _token.setText(new String(text.getBuffer(), _begin, text
0337: .length()
0338: - _begin));
0339: }
0340: _returnToken = _token;
0341: }
0342:
0343: public final void mCOLON(boolean _createToken)
0344: throws RecognitionException, CharStreamException,
0345: TokenStreamException {
0346: int _ttype;
0347: Token _token = null;
0348: int _begin = text.length();
0349: _ttype = COLON;
0350: int _saveIndex;
0351:
0352: match(':');
0353: if (_createToken && _token == null && _ttype != Token.SKIP) {
0354: _token = makeToken(_ttype);
0355: _token.setText(new String(text.getBuffer(), _begin, text
0356: .length()
0357: - _begin));
0358: }
0359: _returnToken = _token;
0360: }
0361:
0362: public final void mCOMMA(boolean _createToken)
0363: throws RecognitionException, CharStreamException,
0364: TokenStreamException {
0365: int _ttype;
0366: Token _token = null;
0367: int _begin = text.length();
0368: _ttype = COMMA;
0369: int _saveIndex;
0370:
0371: match(',');
0372: if (_createToken && _token == null && _ttype != Token.SKIP) {
0373: _token = makeToken(_ttype);
0374: _token.setText(new String(text.getBuffer(), _begin, text
0375: .length()
0376: - _begin));
0377: }
0378: _returnToken = _token;
0379: }
0380:
0381: public final void mDOT(boolean _createToken)
0382: throws RecognitionException, CharStreamException,
0383: TokenStreamException {
0384: int _ttype;
0385: Token _token = null;
0386: int _begin = text.length();
0387: _ttype = DOT;
0388: int _saveIndex;
0389:
0390: match('.');
0391: if (_createToken && _token == null && _ttype != Token.SKIP) {
0392: _token = makeToken(_ttype);
0393: _token.setText(new String(text.getBuffer(), _begin, text
0394: .length()
0395: - _begin));
0396: }
0397: _returnToken = _token;
0398: }
0399:
0400: public final void mSTAR(boolean _createToken)
0401: throws RecognitionException, CharStreamException,
0402: TokenStreamException {
0403: int _ttype;
0404: Token _token = null;
0405: int _begin = text.length();
0406: _ttype = STAR;
0407: int _saveIndex;
0408:
0409: match('*');
0410: if (_createToken && _token == null && _ttype != Token.SKIP) {
0411: _token = makeToken(_ttype);
0412: _token.setText(new String(text.getBuffer(), _begin, text
0413: .length()
0414: - _begin));
0415: }
0416: _returnToken = _token;
0417: }
0418:
0419: public final void mSEMI(boolean _createToken)
0420: throws RecognitionException, CharStreamException,
0421: TokenStreamException {
0422: int _ttype;
0423: Token _token = null;
0424: int _begin = text.length();
0425: _ttype = SEMI;
0426: int _saveIndex;
0427:
0428: match(';');
0429: if (_createToken && _token == null && _ttype != Token.SKIP) {
0430: _token = makeToken(_ttype);
0431: _token.setText(new String(text.getBuffer(), _begin, text
0432: .length()
0433: - _begin));
0434: }
0435: _returnToken = _token;
0436: }
0437:
0438: public final void mINIT(boolean _createToken)
0439: throws RecognitionException, CharStreamException,
0440: TokenStreamException {
0441: int _ttype;
0442: Token _token = null;
0443: int _begin = text.length();
0444: _ttype = INIT;
0445: int _saveIndex;
0446:
0447: match("<init>");
0448: if (_createToken && _token == null && _ttype != Token.SKIP) {
0449: _token = makeToken(_ttype);
0450: _token.setText(new String(text.getBuffer(), _begin, text
0451: .length()
0452: - _begin));
0453: }
0454: _returnToken = _token;
0455: }
0456:
0457: public final void mWS(boolean _createToken)
0458: throws RecognitionException, CharStreamException,
0459: TokenStreamException {
0460: int _ttype;
0461: Token _token = null;
0462: int _begin = text.length();
0463: _ttype = WS;
0464: int _saveIndex;
0465:
0466: {
0467: int _cnt78 = 0;
0468: _loop78: do {
0469: switch (LA(1)) {
0470: case ' ': {
0471: match(' ');
0472: break;
0473: }
0474: case '\t': {
0475: match('\t');
0476: break;
0477: }
0478: case '\u000c': {
0479: match('\f');
0480: break;
0481: }
0482: case '\n':
0483: case '\r': {
0484: {
0485: if ((LA(1) == '\r') && (LA(2) == '\n')
0486: && (true) && (true)) {
0487: match("\r\n");
0488: } else if ((LA(1) == '\r') && (true) && (true) && (true)) {
0489: match('\r');
0490: } else if ((LA(1) == '\n')) {
0491: match('\n');
0492: } else {
0493: throw new NoViableAltForCharException(
0494: (char) LA(1), getFilename(),
0495: getLine(), getColumn());
0496: }
0497:
0498: }
0499: newline();
0500: break;
0501: }
0502: default: {
0503: if (_cnt78 >= 1) {
0504: break _loop78;
0505: } else {
0506: throw new NoViableAltForCharException(
0507: (char) LA(1), getFilename(), getLine(),
0508: getColumn());
0509: }
0510: }
0511: }
0512: _cnt78++;
0513: } while (true);
0514: }
0515: _ttype = Token.SKIP;
0516: if (_createToken && _token == null && _ttype != Token.SKIP) {
0517: _token = makeToken(_ttype);
0518: _token.setText(new String(text.getBuffer(), _begin, text
0519: .length()
0520: - _begin));
0521: }
0522: _returnToken = _token;
0523: }
0524:
0525: public final void mCHAR_LITERAL(boolean _createToken)
0526: throws RecognitionException, CharStreamException,
0527: TokenStreamException {
0528: int _ttype;
0529: Token _token = null;
0530: int _begin = text.length();
0531: _ttype = CHAR_LITERAL;
0532: int _saveIndex;
0533:
0534: match('\'');
0535: {
0536: if ((LA(1) == '\\')) {
0537: mESC(false);
0538: } else if ((_tokenSet_0.member(LA(1)))) {
0539: matchNot('\'');
0540: } else {
0541: throw new NoViableAltForCharException((char) LA(1),
0542: getFilename(), getLine(), getColumn());
0543: }
0544:
0545: }
0546: match('\'');
0547: if (_createToken && _token == null && _ttype != Token.SKIP) {
0548: _token = makeToken(_ttype);
0549: _token.setText(new String(text.getBuffer(), _begin, text
0550: .length()
0551: - _begin));
0552: }
0553: _returnToken = _token;
0554: }
0555:
0556: protected final void mESC(boolean _createToken)
0557: throws RecognitionException, CharStreamException,
0558: TokenStreamException {
0559: int _ttype;
0560: Token _token = null;
0561: int _begin = text.length();
0562: _ttype = ESC;
0563: int _saveIndex;
0564:
0565: match('\\');
0566: {
0567: switch (LA(1)) {
0568: case 'n': {
0569: match('n');
0570: break;
0571: }
0572: case 'r': {
0573: match('r');
0574: break;
0575: }
0576: case 't': {
0577: match('t');
0578: break;
0579: }
0580: case 'b': {
0581: match('b');
0582: break;
0583: }
0584: case 'f': {
0585: match('f');
0586: break;
0587: }
0588: case '"': {
0589: match('"');
0590: break;
0591: }
0592: case '\'': {
0593: match('\'');
0594: break;
0595: }
0596: case '\\': {
0597: match('\\');
0598: break;
0599: }
0600: case 'u': {
0601: {
0602: int _cnt88 = 0;
0603: _loop88: do {
0604: if ((LA(1) == 'u')) {
0605: match('u');
0606: } else {
0607: if (_cnt88 >= 1) {
0608: break _loop88;
0609: } else {
0610: throw new NoViableAltForCharException(
0611: (char) LA(1), getFilename(),
0612: getLine(), getColumn());
0613: }
0614: }
0615:
0616: _cnt88++;
0617: } while (true);
0618: }
0619: mHEX_DIGIT(false);
0620: mHEX_DIGIT(false);
0621: mHEX_DIGIT(false);
0622: mHEX_DIGIT(false);
0623: break;
0624: }
0625: case '0':
0626: case '1':
0627: case '2':
0628: case '3': {
0629: matchRange('0', '3');
0630: {
0631: if (((LA(1) >= '0' && LA(1) <= '7'))
0632: && ((LA(2) >= '\u0003' && LA(2) <= '\uffff'))
0633: && (true) && (true)) {
0634: matchRange('0', '7');
0635: {
0636: if (((LA(1) >= '0' && LA(1) <= '7'))
0637: && ((LA(2) >= '\u0003' && LA(2) <= '\uffff'))
0638: && (true) && (true)) {
0639: matchRange('0', '7');
0640: } else if (((LA(1) >= '\u0003' && LA(1) <= '\uffff')) && (true) && (true) && (true)) {
0641: } else {
0642: throw new NoViableAltForCharException(
0643: (char) LA(1), getFilename(),
0644: getLine(), getColumn());
0645: }
0646:
0647: }
0648: } else if (((LA(1) >= '\u0003' && LA(1) <= '\uffff')) && (true) && (true) && (true)) {
0649: } else {
0650: throw new NoViableAltForCharException(
0651: (char) LA(1), getFilename(), getLine(),
0652: getColumn());
0653: }
0654:
0655: }
0656: break;
0657: }
0658: case '4':
0659: case '5':
0660: case '6':
0661: case '7': {
0662: matchRange('4', '7');
0663: {
0664: if (((LA(1) >= '0' && LA(1) <= '7'))
0665: && ((LA(2) >= '\u0003' && LA(2) <= '\uffff'))
0666: && (true) && (true)) {
0667: matchRange('0', '7');
0668: } else if (((LA(1) >= '\u0003' && LA(1) <= '\uffff')) && (true) && (true) && (true)) {
0669: } else {
0670: throw new NoViableAltForCharException(
0671: (char) LA(1), getFilename(), getLine(),
0672: getColumn());
0673: }
0674:
0675: }
0676: break;
0677: }
0678: default: {
0679: throw new NoViableAltForCharException((char) LA(1),
0680: getFilename(), getLine(), getColumn());
0681: }
0682: }
0683: }
0684: if (_createToken && _token == null && _ttype != Token.SKIP) {
0685: _token = makeToken(_ttype);
0686: _token.setText(new String(text.getBuffer(), _begin, text
0687: .length()
0688: - _begin));
0689: }
0690: _returnToken = _token;
0691: }
0692:
0693: public final void mSTRING_LITERAL(boolean _createToken)
0694: throws RecognitionException, CharStreamException,
0695: TokenStreamException {
0696: int _ttype;
0697: Token _token = null;
0698: int _begin = text.length();
0699: _ttype = STRING_LITERAL;
0700: int _saveIndex;
0701:
0702: match('"');
0703: {
0704: _loop84: do {
0705: if ((LA(1) == '\\')) {
0706: mESC(false);
0707: } else if ((_tokenSet_1.member(LA(1)))) {
0708: {
0709: match(_tokenSet_1);
0710: }
0711: } else {
0712: break _loop84;
0713: }
0714:
0715: } while (true);
0716: }
0717: match('"');
0718: if (_createToken && _token == null && _ttype != Token.SKIP) {
0719: _token = makeToken(_ttype);
0720: _token.setText(new String(text.getBuffer(), _begin, text
0721: .length()
0722: - _begin));
0723: }
0724: _returnToken = _token;
0725: }
0726:
0727: protected final void mHEX_DIGIT(boolean _createToken)
0728: throws RecognitionException, CharStreamException,
0729: TokenStreamException {
0730: int _ttype;
0731: Token _token = null;
0732: int _begin = text.length();
0733: _ttype = HEX_DIGIT;
0734: int _saveIndex;
0735:
0736: {
0737: switch (LA(1)) {
0738: case '0':
0739: case '1':
0740: case '2':
0741: case '3':
0742: case '4':
0743: case '5':
0744: case '6':
0745: case '7':
0746: case '8':
0747: case '9': {
0748: matchRange('0', '9');
0749: break;
0750: }
0751: case 'A':
0752: case 'B':
0753: case 'C':
0754: case 'D':
0755: case 'E':
0756: case 'F': {
0757: matchRange('A', 'F');
0758: break;
0759: }
0760: case 'a':
0761: case 'b':
0762: case 'c':
0763: case 'd':
0764: case 'e':
0765: case 'f': {
0766: matchRange('a', 'f');
0767: break;
0768: }
0769: default: {
0770: throw new NoViableAltForCharException((char) LA(1),
0771: getFilename(), getLine(), getColumn());
0772: }
0773: }
0774: }
0775: if (_createToken && _token == null && _ttype != Token.SKIP) {
0776: _token = makeToken(_ttype);
0777: _token.setText(new String(text.getBuffer(), _begin, text
0778: .length()
0779: - _begin));
0780: }
0781: _returnToken = _token;
0782: }
0783:
0784: protected final void mVOCAB(boolean _createToken)
0785: throws RecognitionException, CharStreamException,
0786: TokenStreamException {
0787: int _ttype;
0788: Token _token = null;
0789: int _begin = text.length();
0790: _ttype = VOCAB;
0791: int _saveIndex;
0792:
0793: matchRange('\u0003', '\uFFFF');
0794: if (_createToken && _token == null && _ttype != Token.SKIP) {
0795: _token = makeToken(_ttype);
0796: _token.setText(new String(text.getBuffer(), _begin, text
0797: .length()
0798: - _begin));
0799: }
0800: _returnToken = _token;
0801: }
0802:
0803: public final void mIDENT(boolean _createToken)
0804: throws RecognitionException, CharStreamException,
0805: TokenStreamException {
0806: int _ttype;
0807: Token _token = null;
0808: int _begin = text.length();
0809: _ttype = IDENT;
0810: int _saveIndex;
0811:
0812: {
0813: switch (LA(1)) {
0814: case 'a':
0815: case 'b':
0816: case 'c':
0817: case 'd':
0818: case 'e':
0819: case 'f':
0820: case 'g':
0821: case 'h':
0822: case 'i':
0823: case 'j':
0824: case 'k':
0825: case 'l':
0826: case 'm':
0827: case 'n':
0828: case 'o':
0829: case 'p':
0830: case 'q':
0831: case 'r':
0832: case 's':
0833: case 't':
0834: case 'u':
0835: case 'v':
0836: case 'w':
0837: case 'x':
0838: case 'y':
0839: case 'z': {
0840: matchRange('a', 'z');
0841: break;
0842: }
0843: case 'A':
0844: case 'B':
0845: case 'C':
0846: case 'D':
0847: case 'E':
0848: case 'F':
0849: case 'G':
0850: case 'H':
0851: case 'I':
0852: case 'J':
0853: case 'K':
0854: case 'L':
0855: case 'M':
0856: case 'N':
0857: case 'O':
0858: case 'P':
0859: case 'Q':
0860: case 'R':
0861: case 'S':
0862: case 'T':
0863: case 'U':
0864: case 'V':
0865: case 'W':
0866: case 'X':
0867: case 'Y':
0868: case 'Z': {
0869: matchRange('A', 'Z');
0870: break;
0871: }
0872: case '_': {
0873: match('_');
0874: break;
0875: }
0876: case '$': {
0877: match('$');
0878: break;
0879: }
0880: default: {
0881: throw new NoViableAltForCharException((char) LA(1),
0882: getFilename(), getLine(), getColumn());
0883: }
0884: }
0885: }
0886: {
0887: _loop98: do {
0888: switch (LA(1)) {
0889: case 'a':
0890: case 'b':
0891: case 'c':
0892: case 'd':
0893: case 'e':
0894: case 'f':
0895: case 'g':
0896: case 'h':
0897: case 'i':
0898: case 'j':
0899: case 'k':
0900: case 'l':
0901: case 'm':
0902: case 'n':
0903: case 'o':
0904: case 'p':
0905: case 'q':
0906: case 'r':
0907: case 's':
0908: case 't':
0909: case 'u':
0910: case 'v':
0911: case 'w':
0912: case 'x':
0913: case 'y':
0914: case 'z': {
0915: matchRange('a', 'z');
0916: break;
0917: }
0918: case 'A':
0919: case 'B':
0920: case 'C':
0921: case 'D':
0922: case 'E':
0923: case 'F':
0924: case 'G':
0925: case 'H':
0926: case 'I':
0927: case 'J':
0928: case 'K':
0929: case 'L':
0930: case 'M':
0931: case 'N':
0932: case 'O':
0933: case 'P':
0934: case 'Q':
0935: case 'R':
0936: case 'S':
0937: case 'T':
0938: case 'U':
0939: case 'V':
0940: case 'W':
0941: case 'X':
0942: case 'Y':
0943: case 'Z': {
0944: matchRange('A', 'Z');
0945: break;
0946: }
0947: case '_': {
0948: match('_');
0949: break;
0950: }
0951: case '0':
0952: case '1':
0953: case '2':
0954: case '3':
0955: case '4':
0956: case '5':
0957: case '6':
0958: case '7':
0959: case '8':
0960: case '9': {
0961: matchRange('0', '9');
0962: break;
0963: }
0964: case '$': {
0965: match('$');
0966: break;
0967: }
0968: default: {
0969: break _loop98;
0970: }
0971: }
0972: } while (true);
0973: }
0974: _ttype = testLiteralsTable(_ttype);
0975: if (_createToken && _token == null && _ttype != Token.SKIP) {
0976: _token = makeToken(_ttype);
0977: _token.setText(new String(text.getBuffer(), _begin, text
0978: .length()
0979: - _begin));
0980: }
0981: _returnToken = _token;
0982: }
0983:
0984: private static final long[] mk_tokenSet_0() {
0985: long[] data = new long[2048];
0986: data[0] = -549755813896L;
0987: data[1] = -268435457L;
0988: for (int i = 2; i <= 1023; i++) {
0989: data[i] = -1L;
0990: }
0991: return data;
0992: }
0993:
0994: public static final BitSet _tokenSet_0 = new BitSet(mk_tokenSet_0());
0995:
0996: private static final long[] mk_tokenSet_1() {
0997: long[] data = new long[2048];
0998: data[0] = -17179869192L;
0999: data[1] = -268435457L;
1000: for (int i = 2; i <= 1023; i++) {
1001: data[i] = -1L;
1002: }
1003: return data;
1004: }
1005:
1006: public static final BitSet _tokenSet_1 = new BitSet(mk_tokenSet_1());
1007:
1008: }
|