You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
647 lines
15 KiB
647 lines
15 KiB
// $ANTLR : "tokdef.g" -> "ANTLRTokdefLexer.java"$ |
|
package com.fr.third.antlr; |
|
import java.io.InputStream; |
|
import java.io.Reader; |
|
import java.util.Hashtable; |
|
|
|
import com.fr.third.antlr.collections.impl.BitSet; |
|
|
|
|
|
public class ANTLRTokdefLexer extends com.fr.third.antlr.CharScanner implements ANTLRTokdefParserTokenTypes, TokenStream |
|
{ |
|
public ANTLRTokdefLexer(InputStream in) { |
|
this(new ByteBuffer(in)); |
|
} |
|
public ANTLRTokdefLexer(Reader in) { |
|
this(new CharBuffer(in)); |
|
} |
|
public ANTLRTokdefLexer(InputBuffer ib) { |
|
this(new LexerSharedInputState(ib)); |
|
} |
|
public ANTLRTokdefLexer(LexerSharedInputState state) { |
|
super(state); |
|
caseSensitiveLiterals = true; |
|
setCaseSensitive(true); |
|
literals = new Hashtable(); |
|
} |
|
|
|
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 '\t': case '\n': case '\r': case ' ': |
|
{ |
|
mWS(true); |
|
theRetToken=_returnToken; |
|
break; |
|
} |
|
case '(': |
|
{ |
|
mLPAREN(true); |
|
theRetToken=_returnToken; |
|
break; |
|
} |
|
case ')': |
|
{ |
|
mRPAREN(true); |
|
theRetToken=_returnToken; |
|
break; |
|
} |
|
case '=': |
|
{ |
|
mASSIGN(true); |
|
theRetToken=_returnToken; |
|
break; |
|
} |
|
case '"': |
|
{ |
|
mSTRING(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 '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(true); |
|
theRetToken=_returnToken; |
|
break; |
|
} |
|
default: |
|
if ((LA(1)=='/') && (LA(2)=='/')) { |
|
mSL_COMMENT(true); |
|
theRetToken=_returnToken; |
|
} |
|
else if ((LA(1)=='/') && (LA(2)=='*')) { |
|
mML_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 mWS(boolean _createToken) throws RecognitionException, CharStreamException, TokenStreamException { |
|
int _ttype; Token _token=null; int _begin=text.length(); |
|
_ttype = WS; |
|
int _saveIndex; |
|
|
|
{ |
|
switch ( LA(1)) { |
|
case ' ': |
|
{ |
|
match(' '); |
|
break; |
|
} |
|
case '\t': |
|
{ |
|
match('\t'); |
|
break; |
|
} |
|
case '\r': |
|
{ |
|
match('\r'); |
|
{ |
|
if ((LA(1)=='\n')) { |
|
match('\n'); |
|
} |
|
else { |
|
} |
|
|
|
} |
|
newline(); |
|
break; |
|
} |
|
case '\n': |
|
{ |
|
match('\n'); |
|
newline(); |
|
break; |
|
} |
|
default: |
|
{ |
|
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; |
|
} |
|
|
|
public final void mSL_COMMENT(boolean _createToken) throws RecognitionException, CharStreamException, TokenStreamException { |
|
int _ttype; Token _token=null; int _begin=text.length(); |
|
_ttype = SL_COMMENT; |
|
int _saveIndex; |
|
|
|
match("//"); |
|
{ |
|
_loop234: |
|
do { |
|
if ((_tokenSet_0.member(LA(1)))) { |
|
{ |
|
match(_tokenSet_0); |
|
} |
|
} |
|
else { |
|
break _loop234; |
|
} |
|
|
|
} while (true); |
|
} |
|
{ |
|
switch ( LA(1)) { |
|
case '\n': |
|
{ |
|
match('\n'); |
|
break; |
|
} |
|
case '\r': |
|
{ |
|
match('\r'); |
|
{ |
|
if ((LA(1)=='\n')) { |
|
match('\n'); |
|
} |
|
else { |
|
} |
|
|
|
} |
|
break; |
|
} |
|
default: |
|
{ |
|
throw new NoViableAltForCharException((char)LA(1), getFilename(), getLine(), getColumn()); |
|
} |
|
} |
|
} |
|
_ttype = Token.SKIP; newline(); |
|
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 mML_COMMENT(boolean _createToken) throws RecognitionException, CharStreamException, TokenStreamException { |
|
int _ttype; Token _token=null; int _begin=text.length(); |
|
_ttype = ML_COMMENT; |
|
int _saveIndex; |
|
|
|
match("/*"); |
|
{ |
|
_loop239: |
|
do { |
|
if ((LA(1)=='*') && (_tokenSet_1.member(LA(2)))) { |
|
match('*'); |
|
matchNot('/'); |
|
} |
|
else if ((LA(1)=='\n')) { |
|
match('\n'); |
|
newline(); |
|
} |
|
else if ((_tokenSet_2.member(LA(1)))) { |
|
matchNot('*'); |
|
} |
|
else { |
|
break _loop239; |
|
} |
|
|
|
} while (true); |
|
} |
|
match("*/"); |
|
_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 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 mASSIGN(boolean _createToken) throws RecognitionException, CharStreamException, TokenStreamException { |
|
int _ttype; Token _token=null; int _begin=text.length(); |
|
_ttype = ASSIGN; |
|
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(boolean _createToken) throws RecognitionException, CharStreamException, TokenStreamException { |
|
int _ttype; Token _token=null; int _begin=text.length(); |
|
_ttype = STRING; |
|
int _saveIndex; |
|
|
|
match('"'); |
|
{ |
|
_loop245: |
|
do { |
|
if ((LA(1)=='\\')) { |
|
mESC(false); |
|
} |
|
else if ((_tokenSet_3.member(LA(1)))) { |
|
matchNot('"'); |
|
} |
|
else { |
|
break _loop245; |
|
} |
|
|
|
} 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 'n': |
|
{ |
|
match('n'); |
|
break; |
|
} |
|
case 'r': |
|
{ |
|
match('r'); |
|
break; |
|
} |
|
case 't': |
|
{ |
|
match('t'); |
|
break; |
|
} |
|
case 'b': |
|
{ |
|
match('b'); |
|
break; |
|
} |
|
case 'f': |
|
{ |
|
match('f'); |
|
break; |
|
} |
|
case '"': |
|
{ |
|
match('"'); |
|
break; |
|
} |
|
case '\'': |
|
{ |
|
match('\''); |
|
break; |
|
} |
|
case '\\': |
|
{ |
|
match('\\'); |
|
break; |
|
} |
|
case '0': case '1': case '2': case '3': |
|
{ |
|
{ |
|
matchRange('0','3'); |
|
} |
|
{ |
|
if (((LA(1) >= '0' && LA(1) <= '9')) && ((LA(2) >= '\u0003' && LA(2) <= '\u00ff'))) { |
|
mDIGIT(false); |
|
{ |
|
if (((LA(1) >= '0' && LA(1) <= '9')) && ((LA(2) >= '\u0003' && LA(2) <= '\u00ff'))) { |
|
mDIGIT(false); |
|
} |
|
else if (((LA(1) >= '\u0003' && LA(1) <= '\u00ff')) && (true)) { |
|
} |
|
else { |
|
throw new NoViableAltForCharException((char)LA(1), getFilename(), getLine(), getColumn()); |
|
} |
|
|
|
} |
|
} |
|
else if (((LA(1) >= '\u0003' && LA(1) <= '\u00ff')) && (true)) { |
|
} |
|
else { |
|
throw new NoViableAltForCharException((char)LA(1), getFilename(), getLine(), getColumn()); |
|
} |
|
|
|
} |
|
break; |
|
} |
|
case '4': case '5': case '6': case '7': |
|
{ |
|
{ |
|
matchRange('4','7'); |
|
} |
|
{ |
|
if (((LA(1) >= '0' && LA(1) <= '9')) && ((LA(2) >= '\u0003' && LA(2) <= '\u00ff'))) { |
|
mDIGIT(false); |
|
} |
|
else if (((LA(1) >= '\u0003' && LA(1) <= '\u00ff')) && (true)) { |
|
} |
|
else { |
|
throw new NoViableAltForCharException((char)LA(1), getFilename(), getLine(), getColumn()); |
|
} |
|
|
|
} |
|
break; |
|
} |
|
case 'u': |
|
{ |
|
match('u'); |
|
mXDIGIT(false); |
|
mXDIGIT(false); |
|
mXDIGIT(false); |
|
mXDIGIT(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; |
|
} |
|
|
|
protected final void mXDIGIT(boolean _createToken) throws RecognitionException, CharStreamException, TokenStreamException { |
|
int _ttype; Token _token=null; int _begin=text.length(); |
|
_ttype = XDIGIT; |
|
int _saveIndex; |
|
|
|
switch ( LA(1)) { |
|
case '0': case '1': case '2': case '3': |
|
case '4': case '5': case '6': case '7': |
|
case '8': case '9': |
|
{ |
|
matchRange('0','9'); |
|
break; |
|
} |
|
case 'a': case 'b': case 'c': case 'd': |
|
case 'e': case 'f': |
|
{ |
|
matchRange('a','f'); |
|
break; |
|
} |
|
case 'A': case 'B': case 'C': case 'D': |
|
case 'E': case 'F': |
|
{ |
|
matchRange('A','F'); |
|
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; |
|
} |
|
|
|
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; |
|
} |
|
default: |
|
{ |
|
throw new NoViableAltForCharException((char)LA(1), getFilename(), getLine(), getColumn()); |
|
} |
|
} |
|
} |
|
{ |
|
_loop258: |
|
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': |
|
{ |
|
matchRange('0','9'); |
|
break; |
|
} |
|
default: |
|
{ |
|
break _loop258; |
|
} |
|
} |
|
} 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 mINT(boolean _createToken) throws RecognitionException, CharStreamException, TokenStreamException { |
|
int _ttype; Token _token=null; int _begin=text.length(); |
|
_ttype = INT; |
|
int _saveIndex; |
|
|
|
{ |
|
int _cnt261=0; |
|
_loop261: |
|
do { |
|
if (((LA(1) >= '0' && LA(1) <= '9'))) { |
|
mDIGIT(false); |
|
} |
|
else { |
|
if ( _cnt261>=1 ) { break _loop261; } else {throw new NoViableAltForCharException((char)LA(1), getFilename(), getLine(), getColumn());} |
|
} |
|
|
|
_cnt261++; |
|
} while (true); |
|
} |
|
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]=-9224L; |
|
for (int i = 1; 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]=-140737488355336L; |
|
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]=-4398046512136L; |
|
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]=-17179869192L; |
|
data[1]=-268435457L; |
|
for (int i = 2; i<=3; i++) { data[i]=-1L; } |
|
return data; |
|
} |
|
public static final BitSet _tokenSet_3 = new BitSet(mk_tokenSet_3()); |
|
|
|
}
|
|
|