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.
1451 lines
36 KiB
1451 lines
36 KiB
// $ANTLR 2.7.3rc3: "antlr.g" -> "ANTLRLexer.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 ANTLRLexer extends com.fr.third.antlr.CharScanner implements ANTLRTokenTypes, TokenStream |
|
{ |
|
|
|
/**Convert 'c' to an integer char value. */ |
|
public static int escapeCharValue(String cs) { |
|
//System.out.println("escapeCharValue("+cs+")"); |
|
if ( cs.charAt(1)!='\\' ) return 0; |
|
switch ( cs.charAt(2) ) { |
|
case 'b' : return '\b'; |
|
case 'r' : return '\r'; |
|
case 't' : return '\t'; |
|
case 'n' : return '\n'; |
|
case 'f' : return '\f'; |
|
case '"' : return '\"'; |
|
case '\'' :return '\''; |
|
case '\\' :return '\\'; |
|
|
|
case 'u' : |
|
// Unicode char |
|
if (cs.length() != 8) { |
|
return 0; |
|
} |
|
else { |
|
return |
|
Character.digit(cs.charAt(3), 16) * 16 * 16 * 16 + |
|
Character.digit(cs.charAt(4), 16) * 16 * 16 + |
|
Character.digit(cs.charAt(5), 16) * 16 + |
|
Character.digit(cs.charAt(6), 16); |
|
} |
|
|
|
case '0' : |
|
case '1' : |
|
case '2' : |
|
case '3' : |
|
if ( cs.length()>5 && Character.isDigit(cs.charAt(4)) ) { |
|
return (cs.charAt(2)-'0')*8*8 + (cs.charAt(3)-'0')*8 + (cs.charAt(4)-'0'); |
|
} |
|
if ( cs.length()>4 && Character.isDigit(cs.charAt(3)) ) { |
|
return (cs.charAt(2)-'0')*8 + (cs.charAt(3)-'0'); |
|
} |
|
return cs.charAt(2)-'0'; |
|
|
|
case '4' : |
|
case '5' : |
|
case '6' : |
|
case '7' : |
|
if ( cs.length()>4 && Character.isDigit(cs.charAt(3)) ) { |
|
return (cs.charAt(2)-'0')*8 + (cs.charAt(3)-'0'); |
|
} |
|
return cs.charAt(2)-'0'; |
|
|
|
default : |
|
return 0; |
|
} |
|
} |
|
|
|
public static int tokenTypeForCharLiteral(String lit) { |
|
if ( lit.length()>3 ) { // does char contain escape? |
|
return escapeCharValue(lit); |
|
} |
|
else { |
|
return lit.charAt(1); |
|
} |
|
} |
|
public ANTLRLexer(InputStream in) { |
|
this(new ByteBuffer(in)); |
|
} |
|
public ANTLRLexer(Reader in) { |
|
this(new CharBuffer(in)); |
|
} |
|
public ANTLRLexer(InputBuffer ib) { |
|
this(new LexerSharedInputState(ib)); |
|
} |
|
public ANTLRLexer(LexerSharedInputState state) { |
|
super(state); |
|
caseSensitiveLiterals = true; |
|
setCaseSensitive(true); |
|
literals = new Hashtable(); |
|
literals.put(new ANTLRHashString("public", this), new Integer(31)); |
|
literals.put(new ANTLRHashString("class", this), new Integer(10)); |
|
literals.put(new ANTLRHashString("header", this), new Integer(5)); |
|
literals.put(new ANTLRHashString("throws", this), new Integer(37)); |
|
literals.put(new ANTLRHashString("lexclass", this), new Integer(9)); |
|
literals.put(new ANTLRHashString("catch", this), new Integer(40)); |
|
literals.put(new ANTLRHashString("private", this), new Integer(32)); |
|
literals.put(new ANTLRHashString("options", this), new Integer(51)); |
|
literals.put(new ANTLRHashString("extends", this), new Integer(11)); |
|
literals.put(new ANTLRHashString("protected", this), new Integer(30)); |
|
literals.put(new ANTLRHashString("TreeParser", this), new Integer(13)); |
|
literals.put(new ANTLRHashString("Parser", this), new Integer(29)); |
|
literals.put(new ANTLRHashString("Lexer", this), new Integer(12)); |
|
literals.put(new ANTLRHashString("returns", this), new Integer(35)); |
|
literals.put(new ANTLRHashString("charVocabulary", this), new Integer(18)); |
|
literals.put(new ANTLRHashString("tokens", this), new Integer(4)); |
|
literals.put(new ANTLRHashString("exception", this), new Integer(39)); |
|
} |
|
|
|
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 '/': |
|
{ |
|
mCOMMENT(true); |
|
theRetToken=_returnToken; |
|
break; |
|
} |
|
case '<': |
|
{ |
|
mOPEN_ELEMENT_OPTION(true); |
|
theRetToken=_returnToken; |
|
break; |
|
} |
|
case '>': |
|
{ |
|
mCLOSE_ELEMENT_OPTION(true); |
|
theRetToken=_returnToken; |
|
break; |
|
} |
|
case ',': |
|
{ |
|
mCOMMA(true); |
|
theRetToken=_returnToken; |
|
break; |
|
} |
|
case '?': |
|
{ |
|
mQUESTION(true); |
|
theRetToken=_returnToken; |
|
break; |
|
} |
|
case '#': |
|
{ |
|
mTREE_BEGIN(true); |
|
theRetToken=_returnToken; |
|
break; |
|
} |
|
case '(': |
|
{ |
|
mLPAREN(true); |
|
theRetToken=_returnToken; |
|
break; |
|
} |
|
case ')': |
|
{ |
|
mRPAREN(true); |
|
theRetToken=_returnToken; |
|
break; |
|
} |
|
case ':': |
|
{ |
|
mCOLON(true); |
|
theRetToken=_returnToken; |
|
break; |
|
} |
|
case '*': |
|
{ |
|
mSTAR(true); |
|
theRetToken=_returnToken; |
|
break; |
|
} |
|
case '+': |
|
{ |
|
mPLUS(true); |
|
theRetToken=_returnToken; |
|
break; |
|
} |
|
case ';': |
|
{ |
|
mSEMI(true); |
|
theRetToken=_returnToken; |
|
break; |
|
} |
|
case '^': |
|
{ |
|
mCARET(true); |
|
theRetToken=_returnToken; |
|
break; |
|
} |
|
case '!': |
|
{ |
|
mBANG(true); |
|
theRetToken=_returnToken; |
|
break; |
|
} |
|
case '|': |
|
{ |
|
mOR(true); |
|
theRetToken=_returnToken; |
|
break; |
|
} |
|
case '~': |
|
{ |
|
mNOT_OP(true); |
|
theRetToken=_returnToken; |
|
break; |
|
} |
|
case '}': |
|
{ |
|
mRCURLY(true); |
|
theRetToken=_returnToken; |
|
break; |
|
} |
|
case '\'': |
|
{ |
|
mCHAR_LITERAL(true); |
|
theRetToken=_returnToken; |
|
break; |
|
} |
|
case '"': |
|
{ |
|
mSTRING_LITERAL(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; |
|
} |
|
case '[': |
|
{ |
|
mARG_ACTION(true); |
|
theRetToken=_returnToken; |
|
break; |
|
} |
|
case '{': |
|
{ |
|
mACTION(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': |
|
{ |
|
mTOKEN_REF(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': |
|
{ |
|
mRULE_REF(true); |
|
theRetToken=_returnToken; |
|
break; |
|
} |
|
default: |
|
if ((LA(1)=='=') && (LA(2)=='>')) { |
|
mIMPLIES(true); |
|
theRetToken=_returnToken; |
|
} |
|
else if ((LA(1)=='.') && (LA(2)=='.')) { |
|
mRANGE(true); |
|
theRetToken=_returnToken; |
|
} |
|
else if ((LA(1)=='=') && (true)) { |
|
mASSIGN(true); |
|
theRetToken=_returnToken; |
|
} |
|
else if ((LA(1)=='.') && (true)) { |
|
mWILDCARD(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 '\n': |
|
{ |
|
match('\n'); |
|
newline(); |
|
break; |
|
} |
|
default: |
|
if ((LA(1)=='\r') && (LA(2)=='\n')) { |
|
match('\r'); |
|
match('\n'); |
|
newline(); |
|
} |
|
else if ((LA(1)=='\r') && (true)) { |
|
match('\r'); |
|
newline(); |
|
} |
|
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; |
|
} |
|
|
|
public final void mCOMMENT(boolean _createToken) throws RecognitionException, CharStreamException, TokenStreamException { |
|
int _ttype; Token _token=null; int _begin=text.length(); |
|
_ttype = COMMENT; |
|
int _saveIndex; |
|
Token t=null; |
|
|
|
{ |
|
if ((LA(1)=='/') && (LA(2)=='/')) { |
|
mSL_COMMENT(false); |
|
} |
|
else if ((LA(1)=='/') && (LA(2)=='*')) { |
|
mML_COMMENT(true); |
|
t=_returnToken; |
|
_ttype = t.getType(); |
|
} |
|
else { |
|
throw new NoViableAltForCharException((char)LA(1), getFilename(), getLine(), getColumn()); |
|
} |
|
|
|
} |
|
if ( _ttype != DOC_COMMENT ) _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; |
|
} |
|
|
|
protected 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("//"); |
|
{ |
|
_loop153: |
|
do { |
|
if ((_tokenSet_0.member(LA(1)))) { |
|
{ |
|
match(_tokenSet_0); |
|
} |
|
} |
|
else { |
|
break _loop153; |
|
} |
|
|
|
} while (true); |
|
} |
|
{ |
|
if ((LA(1)=='\r') && (LA(2)=='\n')) { |
|
match('\r'); |
|
match('\n'); |
|
} |
|
else if ((LA(1)=='\r') && (true)) { |
|
match('\r'); |
|
} |
|
else if ((LA(1)=='\n')) { |
|
match('\n'); |
|
} |
|
else { |
|
throw new NoViableAltForCharException((char)LA(1), getFilename(), getLine(), getColumn()); |
|
} |
|
|
|
} |
|
newline(); |
|
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 mML_COMMENT(boolean _createToken) throws RecognitionException, CharStreamException, TokenStreamException { |
|
int _ttype; Token _token=null; int _begin=text.length(); |
|
_ttype = ML_COMMENT; |
|
int _saveIndex; |
|
|
|
match("/*"); |
|
{ |
|
if (((LA(1)=='*') && ((LA(2) >= '\u0003' && LA(2) <= '\u00ff')))&&( LA(2)!='/' )) { |
|
match('*'); |
|
_ttype = DOC_COMMENT; |
|
} |
|
else if (((LA(1) >= '\u0003' && LA(1) <= '\u00ff')) && ((LA(2) >= '\u0003' && LA(2) <= '\u00ff'))) { |
|
} |
|
else { |
|
throw new NoViableAltForCharException((char)LA(1), getFilename(), getLine(), getColumn()); |
|
} |
|
|
|
} |
|
{ |
|
_loop159: |
|
do { |
|
// nongreedy exit test |
|
if ((LA(1)=='*') && (LA(2)=='/')) break _loop159; |
|
if ((LA(1)=='\r') && (LA(2)=='\n')) { |
|
match('\r'); |
|
match('\n'); |
|
newline(); |
|
} |
|
else if ((LA(1)=='\r') && ((LA(2) >= '\u0003' && LA(2) <= '\u00ff'))) { |
|
match('\r'); |
|
newline(); |
|
} |
|
else if ((_tokenSet_0.member(LA(1))) && ((LA(2) >= '\u0003' && LA(2) <= '\u00ff'))) { |
|
{ |
|
match(_tokenSet_0); |
|
} |
|
} |
|
else if ((LA(1)=='\n')) { |
|
match('\n'); |
|
newline(); |
|
} |
|
else { |
|
break _loop159; |
|
} |
|
|
|
} 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; |
|
} |
|
|
|
public final void mOPEN_ELEMENT_OPTION(boolean _createToken) throws RecognitionException, CharStreamException, TokenStreamException { |
|
int _ttype; Token _token=null; int _begin=text.length(); |
|
_ttype = OPEN_ELEMENT_OPTION; |
|
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 mCLOSE_ELEMENT_OPTION(boolean _createToken) throws RecognitionException, CharStreamException, TokenStreamException { |
|
int _ttype; Token _token=null; int _begin=text.length(); |
|
_ttype = CLOSE_ELEMENT_OPTION; |
|
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 mQUESTION(boolean _createToken) throws RecognitionException, CharStreamException, TokenStreamException { |
|
int _ttype; Token _token=null; int _begin=text.length(); |
|
_ttype = QUESTION; |
|
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 mTREE_BEGIN(boolean _createToken) throws RecognitionException, CharStreamException, TokenStreamException { |
|
int _ttype; Token _token=null; int _begin=text.length(); |
|
_ttype = TREE_BEGIN; |
|
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 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 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 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 mIMPLIES(boolean _createToken) throws RecognitionException, CharStreamException, TokenStreamException { |
|
int _ttype; Token _token=null; int _begin=text.length(); |
|
_ttype = IMPLIES; |
|
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 mCARET(boolean _createToken) throws RecognitionException, CharStreamException, TokenStreamException { |
|
int _ttype; Token _token=null; int _begin=text.length(); |
|
_ttype = CARET; |
|
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 mOR(boolean _createToken) throws RecognitionException, CharStreamException, TokenStreamException { |
|
int _ttype; Token _token=null; int _begin=text.length(); |
|
_ttype = OR; |
|
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 mWILDCARD(boolean _createToken) throws RecognitionException, CharStreamException, TokenStreamException { |
|
int _ttype; Token _token=null; int _begin=text.length(); |
|
_ttype = WILDCARD; |
|
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 mRANGE(boolean _createToken) throws RecognitionException, CharStreamException, TokenStreamException { |
|
int _ttype; Token _token=null; int _begin=text.length(); |
|
_ttype = RANGE; |
|
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 mNOT_OP(boolean _createToken) throws RecognitionException, CharStreamException, TokenStreamException { |
|
int _ttype; Token _token=null; int _begin=text.length(); |
|
_ttype = NOT_OP; |
|
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 mCHAR_LITERAL(boolean _createToken) throws RecognitionException, CharStreamException, TokenStreamException { |
|
int _ttype; Token _token=null; int _begin=text.length(); |
|
_ttype = CHAR_LITERAL; |
|
int _saveIndex; |
|
|
|
match('\''); |
|
{ |
|
if ((LA(1)=='\\')) { |
|
mESC(false); |
|
} |
|
else if ((_tokenSet_1.member(LA(1)))) { |
|
matchNot('\''); |
|
} |
|
else { |
|
throw new NoViableAltForCharException((char)LA(1), getFilename(), getLine(), getColumn()); |
|
} |
|
|
|
} |
|
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 'w': |
|
{ |
|
match('w'); |
|
break; |
|
} |
|
case 'a': |
|
{ |
|
match('a'); |
|
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) <= '7')) && ((LA(2) >= '\u0003' && LA(2) <= '\u00ff'))) { |
|
matchRange('0','7'); |
|
{ |
|
if (((LA(1) >= '0' && LA(1) <= '7')) && ((LA(2) >= '\u0003' && LA(2) <= '\u00ff'))) { |
|
matchRange('0','7'); |
|
} |
|
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) <= '7')) && ((LA(2) >= '\u0003' && LA(2) <= '\u00ff'))) { |
|
matchRange('0','7'); |
|
} |
|
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; |
|
} |
|
|
|
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('"'); |
|
{ |
|
_loop184: |
|
do { |
|
if ((LA(1)=='\\')) { |
|
mESC(false); |
|
} |
|
else if ((_tokenSet_2.member(LA(1)))) { |
|
matchNot('"'); |
|
} |
|
else { |
|
break _loop184; |
|
} |
|
|
|
} 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 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; |
|
} |
|
|
|
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 mINT(boolean _createToken) throws RecognitionException, CharStreamException, TokenStreamException { |
|
int _ttype; Token _token=null; int _begin=text.length(); |
|
_ttype = INT; |
|
int _saveIndex; |
|
|
|
{ |
|
int _cnt196=0; |
|
_loop196: |
|
do { |
|
if (((LA(1) >= '0' && LA(1) <= '9'))) { |
|
matchRange('0','9'); |
|
} |
|
else { |
|
if ( _cnt196>=1 ) { break _loop196; } else {throw new NoViableAltForCharException((char)LA(1), getFilename(), getLine(), getColumn());} |
|
} |
|
|
|
_cnt196++; |
|
} 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 mARG_ACTION(boolean _createToken) throws RecognitionException, CharStreamException, TokenStreamException { |
|
int _ttype; Token _token=null; int _begin=text.length(); |
|
_ttype = ARG_ACTION; |
|
int _saveIndex; |
|
|
|
mNESTED_ARG_ACTION(false); |
|
setText(StringUtils.stripFrontBack(getText(), "[", "]")); |
|
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 mNESTED_ARG_ACTION(boolean _createToken) throws RecognitionException, CharStreamException, TokenStreamException { |
|
int _ttype; Token _token=null; int _begin=text.length(); |
|
_ttype = NESTED_ARG_ACTION; |
|
int _saveIndex; |
|
|
|
match('['); |
|
{ |
|
_loop200: |
|
do { |
|
switch ( LA(1)) { |
|
case '[': |
|
{ |
|
mNESTED_ARG_ACTION(false); |
|
break; |
|
} |
|
case '\n': |
|
{ |
|
match('\n'); |
|
newline(); |
|
break; |
|
} |
|
case '\'': |
|
{ |
|
mCHAR_LITERAL(false); |
|
break; |
|
} |
|
case '"': |
|
{ |
|
mSTRING_LITERAL(false); |
|
break; |
|
} |
|
default: |
|
if ((LA(1)=='\r') && (LA(2)=='\n')) { |
|
match('\r'); |
|
match('\n'); |
|
newline(); |
|
} |
|
else if ((LA(1)=='\r') && ((LA(2) >= '\u0003' && LA(2) <= '\u00ff'))) { |
|
match('\r'); |
|
newline(); |
|
} |
|
else if ((_tokenSet_3.member(LA(1)))) { |
|
matchNot(']'); |
|
} |
|
else { |
|
break _loop200; |
|
} |
|
} |
|
} 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; |
|
} |
|
|
|
public final void mACTION(boolean _createToken) throws RecognitionException, CharStreamException, TokenStreamException { |
|
int _ttype; Token _token=null; int _begin=text.length(); |
|
_ttype = ACTION; |
|
int _saveIndex; |
|
int actionLine=getLine(); int actionColumn = getColumn(); |
|
|
|
mNESTED_ACTION(false); |
|
{ |
|
if ((LA(1)=='?')) { |
|
match('?'); |
|
_ttype = SEMPRED; |
|
} |
|
else { |
|
} |
|
|
|
} |
|
|
|
if ( _ttype==ACTION ) { |
|
setText(StringUtils.stripFrontBack(getText(), "{", "}")); |
|
} |
|
else { |
|
setText(StringUtils.stripFrontBack(getText(), "{", "}?")); |
|
} |
|
CommonToken t = new CommonToken(_ttype,new String(text.getBuffer(),_begin,text.length()-_begin)); |
|
t.setLine(actionLine); // set action line to start |
|
t.setColumn(actionColumn); |
|
_token = t; |
|
|
|
// 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 mNESTED_ACTION(boolean _createToken) throws RecognitionException, CharStreamException, TokenStreamException { |
|
int _ttype; Token _token=null; int _begin=text.length(); |
|
_ttype = NESTED_ACTION; |
|
int _saveIndex; |
|
|
|
match('{'); |
|
{ |
|
_loop206: |
|
do { |
|
// nongreedy exit test |
|
if ((LA(1)=='}') && (true)) break _loop206; |
|
if ((LA(1)=='\n'||LA(1)=='\r') && ((LA(2) >= '\u0003' && LA(2) <= '\u00ff'))) { |
|
{ |
|
if ((LA(1)=='\r') && (LA(2)=='\n')) { |
|
match('\r'); |
|
match('\n'); |
|
newline(); |
|
} |
|
else if ((LA(1)=='\r') && ((LA(2) >= '\u0003' && LA(2) <= '\u00ff'))) { |
|
match('\r'); |
|
newline(); |
|
} |
|
else if ((LA(1)=='\n')) { |
|
match('\n'); |
|
newline(); |
|
} |
|
else { |
|
throw new NoViableAltForCharException((char)LA(1), getFilename(), getLine(), getColumn()); |
|
} |
|
|
|
} |
|
} |
|
else if ((LA(1)=='{') && ((LA(2) >= '\u0003' && LA(2) <= '\u00ff'))) { |
|
mNESTED_ACTION(false); |
|
} |
|
else if ((LA(1)=='\'') && (_tokenSet_4.member(LA(2)))) { |
|
mCHAR_LITERAL(false); |
|
} |
|
else if ((LA(1)=='/') && (LA(2)=='*'||LA(2)=='/')) { |
|
mCOMMENT(false); |
|
} |
|
else if ((LA(1)=='"') && ((LA(2) >= '\u0003' && LA(2) <= '\u00ff'))) { |
|
mSTRING_LITERAL(false); |
|
} |
|
else if (((LA(1) >= '\u0003' && LA(1) <= '\u00ff')) && ((LA(2) >= '\u0003' && LA(2) <= '\u00ff'))) { |
|
matchNot(EOF_CHAR); |
|
} |
|
else { |
|
break _loop206; |
|
} |
|
|
|
} 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; |
|
} |
|
|
|
public final void mTOKEN_REF(boolean _createToken) throws RecognitionException, CharStreamException, TokenStreamException { |
|
int _ttype; Token _token=null; int _begin=text.length(); |
|
_ttype = TOKEN_REF; |
|
int _saveIndex; |
|
|
|
matchRange('A','Z'); |
|
{ |
|
_loop209: |
|
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 _loop209; |
|
} |
|
} |
|
} 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 mRULE_REF(boolean _createToken) throws RecognitionException, CharStreamException, TokenStreamException { |
|
int _ttype; Token _token=null; int _begin=text.length(); |
|
_ttype = RULE_REF; |
|
int _saveIndex; |
|
|
|
int t=0; |
|
|
|
|
|
t=mINTERNAL_RULE_REF(false); |
|
_ttype=t; |
|
{ |
|
if (( true )&&(t==LITERAL_options)) { |
|
mWS_LOOP(false); |
|
{ |
|
if ((LA(1)=='{')) { |
|
match('{'); |
|
_ttype = OPTIONS; |
|
} |
|
else { |
|
} |
|
|
|
} |
|
} |
|
else if (( true )&&(t==LITERAL_tokens)) { |
|
mWS_LOOP(false); |
|
{ |
|
if ((LA(1)=='{')) { |
|
match('{'); |
|
_ttype = TOKENS; |
|
} |
|
else { |
|
} |
|
|
|
} |
|
} |
|
else { |
|
} |
|
|
|
} |
|
if ( _createToken && _token==null && _ttype!=Token.SKIP ) { |
|
_token = makeToken(_ttype); |
|
_token.setText(new String(text.getBuffer(), _begin, text.length()-_begin)); |
|
} |
|
_returnToken = _token; |
|
} |
|
|
|
protected final int mINTERNAL_RULE_REF(boolean _createToken) throws RecognitionException, CharStreamException, TokenStreamException { |
|
int t; |
|
int _ttype; Token _token=null; int _begin=text.length(); |
|
_ttype = INTERNAL_RULE_REF; |
|
int _saveIndex; |
|
|
|
t = RULE_REF; |
|
|
|
|
|
matchRange('a','z'); |
|
{ |
|
_loop219: |
|
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 _loop219; |
|
} |
|
} |
|
} while (true); |
|
} |
|
t = testLiteralsTable(t); |
|
if ( _createToken && _token==null && _ttype!=Token.SKIP ) { |
|
_token = makeToken(_ttype); |
|
_token.setText(new String(text.getBuffer(), _begin, text.length()-_begin)); |
|
} |
|
_returnToken = _token; |
|
return t; |
|
} |
|
|
|
protected final void mWS_LOOP(boolean _createToken) throws RecognitionException, CharStreamException, TokenStreamException { |
|
int _ttype; Token _token=null; int _begin=text.length(); |
|
_ttype = WS_LOOP; |
|
int _saveIndex; |
|
|
|
{ |
|
_loop216: |
|
do { |
|
switch ( LA(1)) { |
|
case '\t': case '\n': case '\r': case ' ': |
|
{ |
|
mWS(false); |
|
break; |
|
} |
|
case '/': |
|
{ |
|
mCOMMENT(false); |
|
break; |
|
} |
|
default: |
|
{ |
|
break _loop216; |
|
} |
|
} |
|
} while (true); |
|
} |
|
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 mWS_OPT(boolean _createToken) throws RecognitionException, CharStreamException, TokenStreamException { |
|
int _ttype; Token _token=null; int _begin=text.length(); |
|
_ttype = WS_OPT; |
|
int _saveIndex; |
|
|
|
{ |
|
if ((_tokenSet_5.member(LA(1)))) { |
|
mWS(false); |
|
} |
|
else { |
|
} |
|
|
|
} |
|
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]=-549755813896L; |
|
data[1]=-268435457L; |
|
for (int i = 2; 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]=-17179869192L; |
|
data[1]=-268435457L; |
|
for (int i = 2; 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]=-566935692296L; |
|
data[1]=-671088641L; |
|
for (int i = 2; 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]=-549755813896L; |
|
for (int i = 1; i<=3; i++) { data[i]=-1L; } |
|
return data; |
|
} |
|
public static final BitSet _tokenSet_4 = new BitSet(mk_tokenSet_4()); |
|
private static final long[] mk_tokenSet_5() { |
|
long[] data = { 4294977024L, 0L, 0L, 0L, 0L}; |
|
return data; |
|
} |
|
public static final BitSet _tokenSet_5 = new BitSet(mk_tokenSet_5()); |
|
|
|
}
|
|
|