| /******************************************************************************* |
| * Copyright (c) 2004, 2006 IBM Corporation and others. |
| * All rights reserved. This program and the accompanying materials |
| * are made available under the terms of the Eclipse Public License v1.0 |
| * which accompanies this distribution, and is available at |
| * http://www.eclipse.org/legal/epl-v10.html |
| * |
| * Contributors: |
| * IBM Corporation - initial API and implementation |
| *******************************************************************************/ |
| // $ANTLR : "Gymnast.g" -> "GymnastLexer.java"$ |
| |
| package org.eclipse.gymnast.generator.core.parser; |
| import java.io.InputStream; |
| import java.io.Reader; |
| import java.util.Hashtable; |
| |
| import antlr.ANTLRHashString; |
| import antlr.ByteBuffer; |
| import antlr.CharBuffer; |
| import antlr.CharStreamException; |
| import antlr.CharStreamIOException; |
| import antlr.InputBuffer; |
| import antlr.LexerSharedInputState; |
| import antlr.NoViableAltForCharException; |
| import antlr.RecognitionException; |
| import antlr.Token; |
| import antlr.TokenStream; |
| import antlr.TokenStreamException; |
| import antlr.TokenStreamIOException; |
| import antlr.TokenStreamRecognitionException; |
| import antlr.collections.impl.BitSet; |
| |
| public class GymnastLexer extends antlr.CharScanner implements GymnastParserTokenTypes, TokenStream |
| { |
| public GymnastLexer(InputStream in) { |
| this(new ByteBuffer(in)); |
| } |
| public GymnastLexer(Reader in) { |
| this(new CharBuffer(in)); |
| } |
| public GymnastLexer(InputBuffer ib) { |
| this(new LexerSharedInputState(ib)); |
| } |
| public GymnastLexer(LexerSharedInputState state) { |
| super(state); |
| caseSensitiveLiterals = true; |
| setCaseSensitive(true); |
| literals = new Hashtable(); |
| literals.put(new ANTLRHashString("container", this), new Integer(15)); |
| literals.put(new ANTLRHashString("token", this), new Integer(24)); |
| literals.put(new ANTLRHashString("abstract", this), new Integer(14)); |
| literals.put(new ANTLRHashString("sequence", this), new Integer(23)); |
| literals.put(new ANTLRHashString("language", this), new Integer(4)); |
| literals.put(new ANTLRHashString("interface", this), new Integer(16)); |
| literals.put(new ANTLRHashString("options", this), new Integer(6)); |
| literals.put(new ANTLRHashString("list", this), new Integer(20)); |
| } |
| |
| public Token nextToken() throws TokenStreamException { |
| Token theRetToken=null; |
| tryAgain: |
| for (;;) { |
| Token _token = null; |
| int _ttype = Token.INVALID_TYPE; |
| resetText(); |
| try { // for char stream error handling |
| try { // for lexical error handling |
| switch ( LA(1)) { |
| case '{': |
| { |
| mLCURLY(true); |
| theRetToken=_returnToken; |
| break; |
| } |
| case '}': |
| { |
| mRCURLY(true); |
| theRetToken=_returnToken; |
| break; |
| } |
| case '[': |
| { |
| mLSQUARE(true); |
| theRetToken=_returnToken; |
| break; |
| } |
| case ']': |
| { |
| mRSQUARE(true); |
| theRetToken=_returnToken; |
| break; |
| } |
| case '(': |
| { |
| mLPAREN(true); |
| theRetToken=_returnToken; |
| break; |
| } |
| case ')': |
| { |
| mRPAREN(true); |
| theRetToken=_returnToken; |
| break; |
| } |
| case '.': |
| { |
| mDOT(true); |
| theRetToken=_returnToken; |
| break; |
| } |
| case ',': |
| { |
| mCOMMA(true); |
| theRetToken=_returnToken; |
| break; |
| } |
| case ':': |
| { |
| mCOLON(true); |
| theRetToken=_returnToken; |
| break; |
| } |
| case ';': |
| { |
| mSEMI(true); |
| theRetToken=_returnToken; |
| break; |
| } |
| case '|': |
| { |
| mPIPE(true); |
| theRetToken=_returnToken; |
| break; |
| } |
| case '*': |
| { |
| mSTAR(true); |
| theRetToken=_returnToken; |
| break; |
| } |
| case '+': |
| { |
| mPLUS(true); |
| theRetToken=_returnToken; |
| break; |
| } |
| case '=': |
| { |
| mEQUALS(true); |
| theRetToken=_returnToken; |
| break; |
| } |
| case '?': |
| { |
| mQMARK(true); |
| theRetToken=_returnToken; |
| break; |
| } |
| case '!': |
| { |
| mBANG(true); |
| theRetToken=_returnToken; |
| break; |
| } |
| case '"': |
| { |
| mSTRING_LITERAL(true); |
| theRetToken=_returnToken; |
| break; |
| } |
| case 'A': case 'B': case 'C': case 'D': |
| case 'E': case 'F': case 'G': case 'H': |
| case 'I': case 'J': case 'K': case 'L': |
| case 'M': case 'N': case 'O': case 'P': |
| case 'Q': case 'R': case 'S': case 'T': |
| case 'U': case 'V': case 'W': case 'X': |
| case 'Y': case 'Z': case '_': case 'a': |
| case 'b': case 'c': case 'd': case 'e': |
| case 'f': case 'g': case 'h': case 'i': |
| case 'j': case 'k': case 'l': case 'm': |
| case 'n': case 'o': case 'p': case 'q': |
| case 'r': case 's': case 't': case 'u': |
| case 'v': case 'w': case 'x': case 'y': |
| case 'z': |
| { |
| mID(true); |
| theRetToken=_returnToken; |
| break; |
| } |
| case '0': case '1': case '2': case '3': |
| case '4': case '5': case '6': case '7': |
| case '8': case '9': |
| { |
| mINT_LITERAL(true); |
| theRetToken=_returnToken; |
| break; |
| } |
| case '\t': case '\n': case '\u000c': case '\r': |
| case ' ': |
| { |
| mWS(true); |
| theRetToken=_returnToken; |
| break; |
| } |
| default: |
| if ((LA(1)=='/') && (LA(2)=='/')) { |
| mSINGLE_LINE_COMMENT(true); |
| theRetToken=_returnToken; |
| } |
| else if ((LA(1)=='/') && (LA(2)=='*')) { |
| mMULTI_LINE_COMMENT(true); |
| theRetToken=_returnToken; |
| } |
| else { |
| if (LA(1)==EOF_CHAR) {uponEOF(); _returnToken = makeToken(Token.EOF_TYPE);} |
| else {throw new NoViableAltForCharException((char)LA(1), getFilename(), getLine(), getColumn());} |
| } |
| } |
| if ( _returnToken==null ) continue tryAgain; // found SKIP token |
| _ttype = _returnToken.getType(); |
| _returnToken.setType(_ttype); |
| return _returnToken; |
| } |
| catch (RecognitionException e) { |
| throw new TokenStreamRecognitionException(e); |
| } |
| } |
| catch (CharStreamException cse) { |
| if ( cse instanceof CharStreamIOException ) { |
| throw new TokenStreamIOException(((CharStreamIOException)cse).io); |
| } |
| else { |
| throw new TokenStreamException(cse.getMessage()); |
| } |
| } |
| } |
| } |
| |
| public final void mLCURLY(boolean _createToken) throws RecognitionException, CharStreamException, TokenStreamException { |
| int _ttype; Token _token=null; int _begin=text.length(); |
| _ttype = LCURLY; |
| int _saveIndex; |
| |
| match('{'); |
| if ( _createToken && _token==null && _ttype!=Token.SKIP ) { |
| _token = makeToken(_ttype); |
| _token.setText(new String(text.getBuffer(), _begin, text.length()-_begin)); |
| } |
| _returnToken = _token; |
| } |
| |
| public final void mRCURLY(boolean _createToken) throws RecognitionException, CharStreamException, TokenStreamException { |
| int _ttype; Token _token=null; int _begin=text.length(); |
| _ttype = RCURLY; |
| int _saveIndex; |
| |
| match('}'); |
| if ( _createToken && _token==null && _ttype!=Token.SKIP ) { |
| _token = makeToken(_ttype); |
| _token.setText(new String(text.getBuffer(), _begin, text.length()-_begin)); |
| } |
| _returnToken = _token; |
| } |
| |
| public final void mLSQUARE(boolean _createToken) throws RecognitionException, CharStreamException, TokenStreamException { |
| int _ttype; Token _token=null; int _begin=text.length(); |
| _ttype = LSQUARE; |
| int _saveIndex; |
| |
| match('['); |
| if ( _createToken && _token==null && _ttype!=Token.SKIP ) { |
| _token = makeToken(_ttype); |
| _token.setText(new String(text.getBuffer(), _begin, text.length()-_begin)); |
| } |
| _returnToken = _token; |
| } |
| |
| public final void mRSQUARE(boolean _createToken) throws RecognitionException, CharStreamException, TokenStreamException { |
| int _ttype; Token _token=null; int _begin=text.length(); |
| _ttype = RSQUARE; |
| int _saveIndex; |
| |
| match(']'); |
| if ( _createToken && _token==null && _ttype!=Token.SKIP ) { |
| _token = makeToken(_ttype); |
| _token.setText(new String(text.getBuffer(), _begin, text.length()-_begin)); |
| } |
| _returnToken = _token; |
| } |
| |
| public final void mLPAREN(boolean _createToken) throws RecognitionException, CharStreamException, TokenStreamException { |
| int _ttype; Token _token=null; int _begin=text.length(); |
| _ttype = LPAREN; |
| int _saveIndex; |
| |
| match('('); |
| if ( _createToken && _token==null && _ttype!=Token.SKIP ) { |
| _token = makeToken(_ttype); |
| _token.setText(new String(text.getBuffer(), _begin, text.length()-_begin)); |
| } |
| _returnToken = _token; |
| } |
| |
| public final void mRPAREN(boolean _createToken) throws RecognitionException, CharStreamException, TokenStreamException { |
| int _ttype; Token _token=null; int _begin=text.length(); |
| _ttype = RPAREN; |
| int _saveIndex; |
| |
| match(')'); |
| if ( _createToken && _token==null && _ttype!=Token.SKIP ) { |
| _token = makeToken(_ttype); |
| _token.setText(new String(text.getBuffer(), _begin, text.length()-_begin)); |
| } |
| _returnToken = _token; |
| } |
| |
| public final void mDOT(boolean _createToken) throws RecognitionException, CharStreamException, TokenStreamException { |
| int _ttype; Token _token=null; int _begin=text.length(); |
| _ttype = DOT; |
| int _saveIndex; |
| |
| match('.'); |
| if ( _createToken && _token==null && _ttype!=Token.SKIP ) { |
| _token = makeToken(_ttype); |
| _token.setText(new String(text.getBuffer(), _begin, text.length()-_begin)); |
| } |
| _returnToken = _token; |
| } |
| |
| public final void mCOMMA(boolean _createToken) throws RecognitionException, CharStreamException, TokenStreamException { |
| int _ttype; Token _token=null; int _begin=text.length(); |
| _ttype = COMMA; |
| int _saveIndex; |
| |
| match(','); |
| if ( _createToken && _token==null && _ttype!=Token.SKIP ) { |
| _token = makeToken(_ttype); |
| _token.setText(new String(text.getBuffer(), _begin, text.length()-_begin)); |
| } |
| _returnToken = _token; |
| } |
| |
| public final void mCOLON(boolean _createToken) throws RecognitionException, CharStreamException, TokenStreamException { |
| int _ttype; Token _token=null; int _begin=text.length(); |
| _ttype = COLON; |
| int _saveIndex; |
| |
| match(':'); |
| if ( _createToken && _token==null && _ttype!=Token.SKIP ) { |
| _token = makeToken(_ttype); |
| _token.setText(new String(text.getBuffer(), _begin, text.length()-_begin)); |
| } |
| _returnToken = _token; |
| } |
| |
| public final void mSEMI(boolean _createToken) throws RecognitionException, CharStreamException, TokenStreamException { |
| int _ttype; Token _token=null; int _begin=text.length(); |
| _ttype = SEMI; |
| int _saveIndex; |
| |
| match(';'); |
| if ( _createToken && _token==null && _ttype!=Token.SKIP ) { |
| _token = makeToken(_ttype); |
| _token.setText(new String(text.getBuffer(), _begin, text.length()-_begin)); |
| } |
| _returnToken = _token; |
| } |
| |
| public final void mPIPE(boolean _createToken) throws RecognitionException, CharStreamException, TokenStreamException { |
| int _ttype; Token _token=null; int _begin=text.length(); |
| _ttype = PIPE; |
| int _saveIndex; |
| |
| match('|'); |
| if ( _createToken && _token==null && _ttype!=Token.SKIP ) { |
| _token = makeToken(_ttype); |
| _token.setText(new String(text.getBuffer(), _begin, text.length()-_begin)); |
| } |
| _returnToken = _token; |
| } |
| |
| public final void mSTAR(boolean _createToken) throws RecognitionException, CharStreamException, TokenStreamException { |
| int _ttype; Token _token=null; int _begin=text.length(); |
| _ttype = STAR; |
| int _saveIndex; |
| |
| match('*'); |
| if ( _createToken && _token==null && _ttype!=Token.SKIP ) { |
| _token = makeToken(_ttype); |
| _token.setText(new String(text.getBuffer(), _begin, text.length()-_begin)); |
| } |
| _returnToken = _token; |
| } |
| |
| public final void mPLUS(boolean _createToken) throws RecognitionException, CharStreamException, TokenStreamException { |
| int _ttype; Token _token=null; int _begin=text.length(); |
| _ttype = PLUS; |
| int _saveIndex; |
| |
| match('+'); |
| if ( _createToken && _token==null && _ttype!=Token.SKIP ) { |
| _token = makeToken(_ttype); |
| _token.setText(new String(text.getBuffer(), _begin, text.length()-_begin)); |
| } |
| _returnToken = _token; |
| } |
| |
| public final void mEQUALS(boolean _createToken) throws RecognitionException, CharStreamException, TokenStreamException { |
| int _ttype; Token _token=null; int _begin=text.length(); |
| _ttype = EQUALS; |
| int _saveIndex; |
| |
| match('='); |
| if ( _createToken && _token==null && _ttype!=Token.SKIP ) { |
| _token = makeToken(_ttype); |
| _token.setText(new String(text.getBuffer(), _begin, text.length()-_begin)); |
| } |
| _returnToken = _token; |
| } |
| |
| public final void mQMARK(boolean _createToken) throws RecognitionException, CharStreamException, TokenStreamException { |
| int _ttype; Token _token=null; int _begin=text.length(); |
| _ttype = QMARK; |
| int _saveIndex; |
| |
| match('?'); |
| if ( _createToken && _token==null && _ttype!=Token.SKIP ) { |
| _token = makeToken(_ttype); |
| _token.setText(new String(text.getBuffer(), _begin, text.length()-_begin)); |
| } |
| _returnToken = _token; |
| } |
| |
| public final void mBANG(boolean _createToken) throws RecognitionException, CharStreamException, TokenStreamException { |
| int _ttype; Token _token=null; int _begin=text.length(); |
| _ttype = BANG; |
| int _saveIndex; |
| |
| match('!'); |
| if ( _createToken && _token==null && _ttype!=Token.SKIP ) { |
| _token = makeToken(_ttype); |
| _token.setText(new String(text.getBuffer(), _begin, text.length()-_begin)); |
| } |
| _returnToken = _token; |
| } |
| |
| public final void mSTRING_LITERAL(boolean _createToken) throws RecognitionException, CharStreamException, TokenStreamException { |
| int _ttype; Token _token=null; int _begin=text.length(); |
| _ttype = STRING_LITERAL; |
| int _saveIndex; |
| |
| match('"'); |
| { |
| _loop76: |
| do { |
| if ((LA(1)=='\\')) { |
| mESC(false); |
| } |
| else if ((_tokenSet_0.member(LA(1)))) { |
| matchNot('"'); |
| } |
| else { |
| break _loop76; |
| } |
| |
| } while (true); |
| } |
| match('"'); |
| if ( _createToken && _token==null && _ttype!=Token.SKIP ) { |
| _token = makeToken(_ttype); |
| _token.setText(new String(text.getBuffer(), _begin, text.length()-_begin)); |
| } |
| _returnToken = _token; |
| } |
| |
| protected final void mESC(boolean _createToken) throws RecognitionException, CharStreamException, TokenStreamException { |
| int _ttype; Token _token=null; int _begin=text.length(); |
| _ttype = ESC; |
| int _saveIndex; |
| |
| match('\\'); |
| { |
| switch ( LA(1)) { |
| case 't': |
| { |
| match('t'); |
| break; |
| } |
| case 'f': |
| { |
| match('f'); |
| break; |
| } |
| case 'r': |
| { |
| match('r'); |
| break; |
| } |
| case 'n': |
| { |
| match('n'); |
| break; |
| } |
| case '"': |
| { |
| match('"'); |
| break; |
| } |
| case '\'': |
| { |
| match('\''); |
| break; |
| } |
| case '\\': |
| { |
| match('\\'); |
| break; |
| } |
| case '0': case '1': case '2': case '3': |
| case '4': case '5': case '6': case '7': |
| case '8': case '9': |
| { |
| { |
| mDIGIT(false); |
| mDIGIT(false); |
| mDIGIT(false); |
| } |
| break; |
| } |
| default: |
| { |
| throw new NoViableAltForCharException((char)LA(1), getFilename(), getLine(), getColumn()); |
| } |
| } |
| } |
| if ( _createToken && _token==null && _ttype!=Token.SKIP ) { |
| _token = makeToken(_ttype); |
| _token.setText(new String(text.getBuffer(), _begin, text.length()-_begin)); |
| } |
| _returnToken = _token; |
| } |
| |
| protected final void mDIGIT(boolean _createToken) throws RecognitionException, CharStreamException, TokenStreamException { |
| int _ttype; Token _token=null; int _begin=text.length(); |
| _ttype = DIGIT; |
| int _saveIndex; |
| |
| matchRange('0','9'); |
| if ( _createToken && _token==null && _ttype!=Token.SKIP ) { |
| _token = makeToken(_ttype); |
| _token.setText(new String(text.getBuffer(), _begin, text.length()-_begin)); |
| } |
| _returnToken = _token; |
| } |
| |
| public final void mID(boolean _createToken) throws RecognitionException, CharStreamException, TokenStreamException { |
| int _ttype; Token _token=null; int _begin=text.length(); |
| _ttype = ID; |
| int _saveIndex; |
| |
| { |
| switch ( LA(1)) { |
| case 'a': case 'b': case 'c': case 'd': |
| case 'e': case 'f': case 'g': case 'h': |
| case 'i': case 'j': case 'k': case 'l': |
| case 'm': case 'n': case 'o': case 'p': |
| case 'q': case 'r': case 's': case 't': |
| case 'u': case 'v': case 'w': case 'x': |
| case 'y': case 'z': |
| { |
| matchRange('a','z'); |
| break; |
| } |
| case 'A': case 'B': case 'C': case 'D': |
| case 'E': case 'F': case 'G': case 'H': |
| case 'I': case 'J': case 'K': case 'L': |
| case 'M': case 'N': case 'O': case 'P': |
| case 'Q': case 'R': case 'S': case 'T': |
| case 'U': case 'V': case 'W': case 'X': |
| case 'Y': case 'Z': |
| { |
| matchRange('A','Z'); |
| break; |
| } |
| case '_': |
| { |
| match('_'); |
| break; |
| } |
| default: |
| { |
| throw new NoViableAltForCharException((char)LA(1), getFilename(), getLine(), getColumn()); |
| } |
| } |
| } |
| { |
| _loop83: |
| do { |
| switch ( LA(1)) { |
| case 'a': case 'b': case 'c': case 'd': |
| case 'e': case 'f': case 'g': case 'h': |
| case 'i': case 'j': case 'k': case 'l': |
| case 'm': case 'n': case 'o': case 'p': |
| case 'q': case 'r': case 's': case 't': |
| case 'u': case 'v': case 'w': case 'x': |
| case 'y': case 'z': |
| { |
| matchRange('a','z'); |
| break; |
| } |
| case 'A': case 'B': case 'C': case 'D': |
| case 'E': case 'F': case 'G': case 'H': |
| case 'I': case 'J': case 'K': case 'L': |
| case 'M': case 'N': case 'O': case 'P': |
| case 'Q': case 'R': case 'S': case 'T': |
| case 'U': case 'V': case 'W': case 'X': |
| case 'Y': case 'Z': |
| { |
| matchRange('A','Z'); |
| break; |
| } |
| case '_': |
| { |
| match('_'); |
| break; |
| } |
| case '0': case '1': case '2': case '3': |
| case '4': case '5': case '6': case '7': |
| case '8': case '9': |
| { |
| mDIGIT(false); |
| break; |
| } |
| default: |
| { |
| break _loop83; |
| } |
| } |
| } while (true); |
| } |
| _ttype = testLiteralsTable(_ttype); |
| if ( _createToken && _token==null && _ttype!=Token.SKIP ) { |
| _token = makeToken(_ttype); |
| _token.setText(new String(text.getBuffer(), _begin, text.length()-_begin)); |
| } |
| _returnToken = _token; |
| } |
| |
| public final void mINT_LITERAL(boolean _createToken) throws RecognitionException, CharStreamException, TokenStreamException { |
| int _ttype; Token _token=null; int _begin=text.length(); |
| _ttype = INT_LITERAL; |
| int _saveIndex; |
| |
| { |
| int _cnt86=0; |
| _loop86: |
| do { |
| if (((LA(1) >= '0' && LA(1) <= '9'))) { |
| mDIGIT(false); |
| } |
| else { |
| if ( _cnt86>=1 ) { break _loop86; } else {throw new NoViableAltForCharException((char)LA(1), getFilename(), getLine(), getColumn());} |
| } |
| |
| _cnt86++; |
| } while (true); |
| } |
| if ( _createToken && _token==null && _ttype!=Token.SKIP ) { |
| _token = makeToken(_ttype); |
| _token.setText(new String(text.getBuffer(), _begin, text.length()-_begin)); |
| } |
| _returnToken = _token; |
| } |
| |
| public final void mWS(boolean _createToken) throws RecognitionException, CharStreamException, TokenStreamException { |
| int _ttype; Token _token=null; int _begin=text.length(); |
| _ttype = WS; |
| int _saveIndex; |
| |
| { |
| int _cnt90=0; |
| _loop90: |
| do { |
| switch ( LA(1)) { |
| case ' ': |
| { |
| match(' '); |
| break; |
| } |
| case '\t': |
| { |
| match('\t'); |
| break; |
| } |
| case '\u000c': |
| { |
| match('\f'); |
| break; |
| } |
| case '\r': |
| { |
| match('\r'); |
| break; |
| } |
| case '\n': |
| { |
| match('\n'); |
| break; |
| } |
| default: |
| { |
| if ( _cnt90>=1 ) { break _loop90; } else {throw new NoViableAltForCharException((char)LA(1), getFilename(), getLine(), getColumn());} |
| } |
| } |
| _cnt90++; |
| } while (true); |
| } |
| _ttype = Token.SKIP; |
| if ( _createToken && _token==null && _ttype!=Token.SKIP ) { |
| _token = makeToken(_ttype); |
| _token.setText(new String(text.getBuffer(), _begin, text.length()-_begin)); |
| } |
| _returnToken = _token; |
| } |
| |
| public final void mSINGLE_LINE_COMMENT(boolean _createToken) throws RecognitionException, CharStreamException, TokenStreamException { |
| int _ttype; Token _token=null; int _begin=text.length(); |
| _ttype = SINGLE_LINE_COMMENT; |
| int _saveIndex; |
| |
| match("//"); |
| { |
| _loop94: |
| do { |
| if ((_tokenSet_1.member(LA(1)))) { |
| { |
| match(_tokenSet_1); |
| } |
| } |
| else { |
| break _loop94; |
| } |
| |
| } while (true); |
| } |
| { |
| switch ( LA(1)) { |
| case '\n': |
| { |
| match('\n'); |
| break; |
| } |
| case '\r': |
| { |
| match('\r'); |
| break; |
| } |
| default: |
| { |
| } |
| } |
| } |
| _ttype = Token.SKIP; |
| if ( _createToken && _token==null && _ttype!=Token.SKIP ) { |
| _token = makeToken(_ttype); |
| _token.setText(new String(text.getBuffer(), _begin, text.length()-_begin)); |
| } |
| _returnToken = _token; |
| } |
| |
| public final void mMULTI_LINE_COMMENT(boolean _createToken) throws RecognitionException, CharStreamException, TokenStreamException { |
| int _ttype; Token _token=null; int _begin=text.length(); |
| _ttype = MULTI_LINE_COMMENT; |
| int _saveIndex; |
| |
| match("/*"); |
| { |
| if ((_tokenSet_2.member(LA(1))) && ((LA(2) >= '\u0003' && LA(2) <= '\u00ff')) && ((LA(3) >= '\u0003' && LA(3) <= '\u00ff'))) { |
| { |
| matchNot('!'); |
| { |
| _loop100: |
| do { |
| if ((LA(1)=='*') && (_tokenSet_3.member(LA(2)))) { |
| match('*'); |
| matchNot('/'); |
| } |
| else if ((_tokenSet_4.member(LA(1)))) { |
| matchNot('*'); |
| } |
| else { |
| break _loop100; |
| } |
| |
| } while (true); |
| } |
| match("*/"); |
| } |
| } |
| else if ((LA(1)=='*') && (LA(2)=='/') && (true)) { |
| match("*/"); |
| } |
| else { |
| throw new NoViableAltForCharException((char)LA(1), getFilename(), getLine(), getColumn()); |
| } |
| |
| } |
| _ttype = Token.SKIP; |
| if ( _createToken && _token==null && _ttype!=Token.SKIP ) { |
| _token = makeToken(_ttype); |
| _token.setText(new String(text.getBuffer(), _begin, text.length()-_begin)); |
| } |
| _returnToken = _token; |
| } |
| |
| |
| private static final long[] mk_tokenSet_0() { |
| long[] data = new long[8]; |
| data[0]=-17179869192L; |
| data[1]=-268435457L; |
| for (int i = 2; i<=3; i++) { data[i]=-1L; } |
| return data; |
| } |
| public static final BitSet _tokenSet_0 = new BitSet(mk_tokenSet_0()); |
| private static final long[] mk_tokenSet_1() { |
| long[] data = new long[8]; |
| data[0]=-9224L; |
| for (int i = 1; i<=3; i++) { data[i]=-1L; } |
| return data; |
| } |
| public static final BitSet _tokenSet_1 = new BitSet(mk_tokenSet_1()); |
| private static final long[] mk_tokenSet_2() { |
| long[] data = new long[8]; |
| data[0]=-8589934600L; |
| for (int i = 1; i<=3; i++) { data[i]=-1L; } |
| return data; |
| } |
| public static final BitSet _tokenSet_2 = new BitSet(mk_tokenSet_2()); |
| private static final long[] mk_tokenSet_3() { |
| long[] data = new long[8]; |
| data[0]=-140737488355336L; |
| for (int i = 1; i<=3; i++) { data[i]=-1L; } |
| return data; |
| } |
| public static final BitSet _tokenSet_3 = new BitSet(mk_tokenSet_3()); |
| private static final long[] mk_tokenSet_4() { |
| long[] data = new long[8]; |
| data[0]=-4398046511112L; |
| for (int i = 1; i<=3; i++) { data[i]=-1L; } |
| return data; |
| } |
| public static final BitSet _tokenSet_4 = new BitSet(mk_tokenSet_4()); |
| |
| } |