View Javadoc

    1   // $ANTLR 2.7.2: "java.g" -> "JavaLexer.java"$
    2
    3   package org.codehaus.groovy.antlr.java;
    4   import org.codehaus.groovy.antlr.*;
    5   import org.codehaus.groovy.antlr.parser.*;
    6   import java.util.*;
    7   import java.io.InputStream;
    8   import java.io.Reader;
    9   import antlr.InputBuffer;
    10  import antlr.LexerSharedInputState;
    11
    12  import java.io.InputStream;
    13  import antlr.TokenStreamException;
    14  import antlr.TokenStreamIOException;
    15  import antlr.TokenStreamRecognitionException;
    16  import antlr.CharStreamException;
    17  import antlr.CharStreamIOException;
    18  import antlr.ANTLRException;
    19  import java.io.Reader;
    20  import java.util.Hashtable;
    21  import antlr.CharScanner;
    22  import antlr.InputBuffer;
    23  import antlr.ByteBuffer;
    24  import antlr.CharBuffer;
    25  import antlr.Token;
    26  import antlr.CommonToken;
    27  import antlr.RecognitionException;
    28  import antlr.NoViableAltForCharException;
    29  import antlr.MismatchedCharException;
    30  import antlr.TokenStream;
    31  import antlr.ANTLRHashString;
    32  import antlr.LexerSharedInputState;
    33  import antlr.collections.impl.BitSet;
    34  import antlr.SemanticException;
    35
    36  public class JavaLexer extends antlr.CharScanner implements JavaTokenTypes, TokenStream
    37   {
    38
    39      protected static final int SCS_TYPE = 3, SCS_VAL = 4, SCS_LIT = 8, SCS_LIMIT = 16;
    40      protected static final int SCS_SQ_TYPE = 0, SCS_TQ_TYPE = 1, SCS_RE_TYPE = 2;
    41      protected int stringCtorState = 0;  // hack string and regexp constructor boundaries
    42      protected int lastSigTokenType = EOF;  // last returned non-whitespace token
    43
    44      /*** flag for enabling the "assert" keyword */
    45  	private boolean assertEnabled = true;
    46  	/*** flag for enabling the "enum" keyword */
    47  	private boolean enumEnabled = true;
    48      /*** flag for including whitespace tokens (for IDE preparsing) */
    49      private boolean whitespaceIncluded = false;
    50
    51  	/*** Enable the "assert" keyword */
    52  	public void enableAssert(boolean shouldEnable) { assertEnabled = shouldEnable; }
    53  	/*** Query the "assert" keyword state */
    54  	public boolean isAssertEnabled() { return assertEnabled; }
    55  	/*** Enable the "enum" keyword */
    56  	public void enableEnum(boolean shouldEnable) { enumEnabled = shouldEnable; }
    57  	/*** Query the "enum" keyword state */
    58  	public boolean isEnumEnabled() { return enumEnabled; }
    59
    60      /*** This is a bit of plumbing which resumes collection of string constructor bodies,
    61       *  after an embedded expression has been parsed.
    62       *  Usage:  new JavaRecognizer(new JavaLexer(in).plumb()).
    63       */
    64      public TokenStream plumb() {
    65          return new TokenStream() {
    66              public Token nextToken() throws TokenStreamException {
    67                  if (stringCtorState >= SCS_LIT) {
    68                      // This goo is modeled upon the ANTLR code for nextToken:
    69                      int quoteType = (stringCtorState & SCS_TYPE);
    70                      stringCtorState = 0;  // get out of this mode, now
    71                      resetText();
    72  /*                    try {
    73                          switch (quoteType) {
    74                          case SCS_SQ_TYPE:
    75  //todo: suitable replacement???     mSTRING_CTOR_END(true, false, false);
    76                          	break;
    77                          case SCS_TQ_TYPE:
    78  //                            mSTRING_CTOR_END(true, false, true);
    79                          	break;
    80                          case SCS_RE_TYPE:
    81  //                            mREGEXP_CTOR_END(true, false);
    82                          	break;
    83                          default:  throw new AssertionError(false);
    84                          }
    85                          lastSigTokenType = _returnToken.getType();
    86                          return _returnToken;
    87                      }*//* catch (RecognitionException e) {
    88                          throw new TokenStreamRecognitionException(e);
    89                      }*/ /*catch (CharStreamException cse) {
    90                          if ( cse instanceof CharStreamIOException ) {
    91                              throw new TokenStreamIOException(((CharStreamIOException)cse).io);
    92                          }
    93                          else {
    94                              throw new TokenStreamException(cse.getMessage());
    95                          }
    96                      }*/
    97                  }
    98                  Token token = JavaLexer.this.nextToken();
    99                  int lasttype = token.getType();
    100                 if (whitespaceIncluded) {
    101                     switch (lasttype) {  // filter out insignificant types
    102                     case WS:
    103                     case SL_COMMENT:
    104                     case ML_COMMENT:
    105                         lasttype = lastSigTokenType;  // back up!
    106                     }
    107                 }
    108                 lastSigTokenType = lasttype;
    109                 return token;
    110             }
    111         };
    112     }
    113
    114     protected JavaRecognizer parser;  // little-used link; TODO: get rid of
    115 public JavaLexer(InputStream in) {
    116 	this(new ByteBuffer(in));
    117 }
    118 public JavaLexer(Reader in) {
    119 	this(new CharBuffer(in));
    120 }
    121 public JavaLexer(InputBuffer ib) {
    122 	this(new LexerSharedInputState(ib));
    123 }
    124 public JavaLexer(LexerSharedInputState state) {
    125 	super(state);
    126 	caseSensitiveLiterals = true;
    127 	setCaseSensitive(true);
    128 	literals = new Hashtable();
    129 	literals.put(new ANTLRHashString("byte", this), new Integer(79));
    130 	literals.put(new ANTLRHashString("public", this), new Integer(88));
    131 	literals.put(new ANTLRHashString("case", this), new Integer(121));
    132 	literals.put(new ANTLRHashString("short", this), new Integer(81));
    133 	literals.put(new ANTLRHashString("break", this), new Integer(114));
    134 	literals.put(new ANTLRHashString("while", this), new Integer(113));
    135 	literals.put(new ANTLRHashString("new", this), new Integer(157));
    136 	literals.put(new ANTLRHashString("instanceof", this), new Integer(144));
    137 	literals.put(new ANTLRHashString("implements", this), new Integer(106));
    138 	literals.put(new ANTLRHashString("synchronized", this), new Integer(93));
    139 	literals.put(new ANTLRHashString("float", this), new Integer(83));
    140 	literals.put(new ANTLRHashString("package", this), new Integer(61));
    141 	literals.put(new ANTLRHashString("return", this), new Integer(116));
    142 	literals.put(new ANTLRHashString("throw", this), new Integer(118));
    143 	literals.put(new ANTLRHashString("null", this), new Integer(156));
    144 	literals.put(new ANTLRHashString("threadsafe", this), new Integer(92));
    145 	literals.put(new ANTLRHashString("protected", this), new Integer(89));
    146 	literals.put(new ANTLRHashString("class", this), new Integer(101));
    147 	literals.put(new ANTLRHashString("throws", this), new Integer(108));
    148 	literals.put(new ANTLRHashString("strictfp", this), new Integer(40));
    149 	literals.put(new ANTLRHashString("super", this), new Integer(71));
    150 	literals.put(new ANTLRHashString("transient", this), new Integer(90));
    151 	literals.put(new ANTLRHashString("native", this), new Integer(91));
    152 	literals.put(new ANTLRHashString("interface", this), new Integer(102));
    153 	literals.put(new ANTLRHashString("final", this), new Integer(38));
    154 	literals.put(new ANTLRHashString("if", this), new Integer(111));
    155 	literals.put(new ANTLRHashString("double", this), new Integer(85));
    156 	literals.put(new ANTLRHashString("volatile", this), new Integer(94));
    157 	literals.put(new ANTLRHashString("assert", this), new Integer(119));
    158 	literals.put(new ANTLRHashString("catch", this), new Integer(124));
    159 	literals.put(new ANTLRHashString("try", this), new Integer(122));
    160 	literals.put(new ANTLRHashString("enum", this), new Integer(103));
    161 	literals.put(new ANTLRHashString("int", this), new Integer(82));
    162 	literals.put(new ANTLRHashString("for", this), new Integer(120));
    163 	literals.put(new ANTLRHashString("extends", this), new Integer(70));
    164 	literals.put(new ANTLRHashString("boolean", this), new Integer(78));
    165 	literals.put(new ANTLRHashString("char", this), new Integer(80));
    166 	literals.put(new ANTLRHashString("private", this), new Integer(87));
    167 	literals.put(new ANTLRHashString("default", this), new Integer(105));
    168 	literals.put(new ANTLRHashString("false", this), new Integer(155));
    169 	literals.put(new ANTLRHashString("this", this), new Integer(107));
    170 	literals.put(new ANTLRHashString("static", this), new Integer(64));
    171 	literals.put(new ANTLRHashString("abstract", this), new Integer(39));
    172 	literals.put(new ANTLRHashString("continue", this), new Integer(115));
    173 	literals.put(new ANTLRHashString("finally", this), new Integer(123));
    174 	literals.put(new ANTLRHashString("else", this), new Integer(112));
    175 	literals.put(new ANTLRHashString("import", this), new Integer(63));
    176 	literals.put(new ANTLRHashString("void", this), new Integer(77));
    177 	literals.put(new ANTLRHashString("switch", this), new Integer(117));
    178 	literals.put(new ANTLRHashString("true", this), new Integer(154));
    179 	literals.put(new ANTLRHashString("long", this), new Integer(84));
    180 }
    181
    182 public Token nextToken() throws TokenStreamException {
    183 	Token theRetToken=null;
    184 tryAgain:
    185 	for (;;) {
    186 		Token _token = null;
    187 		int _ttype = Token.INVALID_TYPE;
    188 		resetText();
    189 		try {   // for char stream error handling
    190 			try {   // for lexical error handling
    191 				switch ( LA(1)) {
    192 				case '?':
    193 				{
    194 					mQUESTION(true);
    195 					theRetToken=_returnToken;
    196 					break;
    197 				}
    198 				case '(':
    199 				{
    200 					mLPAREN(true);
    201 					theRetToken=_returnToken;
    202 					break;
    203 				}
    204 				case ')':
    205 				{
    206 					mRPAREN(true);
    207 					theRetToken=_returnToken;
    208 					break;
    209 				}
    210 				case '[':
    211 				{
    212 					mLBRACK(true);
    213 					theRetToken=_returnToken;
    214 					break;
    215 				}
    216 				case ']':
    217 				{
    218 					mRBRACK(true);
    219 					theRetToken=_returnToken;
    220 					break;
    221 				}
    222 				case '{':
    223 				{
    224 					mLCURLY(true);
    225 					theRetToken=_returnToken;
    226 					break;
    227 				}
    228 				case '}':
    229 				{
    230 					mRCURLY(true);
    231 					theRetToken=_returnToken;
    232 					break;
    233 				}
    234 				case ':':
    235 				{
    236 					mCOLON(true);
    237 					theRetToken=_returnToken;
    238 					break;
    239 				}
    240 				case ',':
    241 				{
    242 					mCOMMA(true);
    243 					theRetToken=_returnToken;
    244 					break;
    245 				}
    246 				case '~':
    247 				{
    248 					mBNOT(true);
    249 					theRetToken=_returnToken;
    250 					break;
    251 				}
    252 				case ';':
    253 				{
    254 					mSEMI(true);
    255 					theRetToken=_returnToken;
    256 					break;
    257 				}
    258 				case '\t':  case '\n':  case '\u000c':  case '\r':
    259 				case ' ':
    260 				{
    261 					mWS(true);
    262 					theRetToken=_returnToken;
    263 					break;
    264 				}
    265 				case '"':  case '\'':
    266 				{
    267 					mSTRING_LITERAL(true);
    268 					theRetToken=_returnToken;
    269 					break;
    270 				}
    271 				case '$':  case 'A':  case 'B':  case 'C':
    272 				case 'D':  case 'E':  case 'F':  case 'G':
    273 				case 'H':  case 'I':  case 'J':  case 'K':
    274 				case 'L':  case 'M':  case 'N':  case 'O':
    275 				case 'P':  case 'Q':  case 'R':  case 'S':
    276 				case 'T':  case 'U':  case 'V':  case 'W':
    277 				case 'X':  case 'Y':  case 'Z':  case '_':
    278 				case 'a':  case 'b':  case 'c':  case 'd':
    279 				case 'e':  case 'f':  case 'g':  case 'h':
    280 				case 'i':  case 'j':  case 'k':  case 'l':
    281 				case 'm':  case 'n':  case 'o':  case 'p':
    282 				case 'q':  case 'r':  case 's':  case 't':
    283 				case 'u':  case 'v':  case 'w':  case 'x':
    284 				case 'y':  case 'z':
    285 				{
    286 					mIDENT(true);
    287 					theRetToken=_returnToken;
    288 					break;
    289 				}
    290 				case '.':  case '0':  case '1':  case '2':
    291 				case '3':  case '4':  case '5':  case '6':
    292 				case '7':  case '8':  case '9':
    293 				{
    294 					mNUM_INT(true);
    295 					theRetToken=_returnToken;
    296 					break;
    297 				}
    298 				case '@':
    299 				{
    300 					mAT(true);
    301 					theRetToken=_returnToken;
    302 					break;
    303 				}
    304 				default:
    305 					if ((LA(1)=='>') && (LA(2)=='>') && (LA(3)=='>') && (LA(4)=='=')) {
    306 						mBSR_ASSIGN(true);
    307 						theRetToken=_returnToken;
    308 					}
    309 					else if ((LA(1)=='>') && (LA(2)=='>') && (LA(3)=='=')) {
    310 						mSR_ASSIGN(true);
    311 						theRetToken=_returnToken;
    312 					}
    313 					else if ((LA(1)=='>') && (LA(2)=='>') && (LA(3)=='>') && (true)) {
    314 						mBSR(true);
    315 						theRetToken=_returnToken;
    316 					}
    317 					else if ((LA(1)=='<') && (LA(2)=='<') && (LA(3)=='=')) {
    318 						mSL_ASSIGN(true);
    319 						theRetToken=_returnToken;
    320 					}
    321 					else if ((LA(1)=='=') && (LA(2)=='=')) {
    322 						mEQUAL(true);
    323 						theRetToken=_returnToken;
    324 					}
    325 					else if ((LA(1)=='!') && (LA(2)=='=')) {
    326 						mNOT_EQUAL(true);
    327 						theRetToken=_returnToken;
    328 					}
    329 					else if ((LA(1)=='/') && (LA(2)=='=')) {
    330 						mDIV_ASSIGN(true);
    331 						theRetToken=_returnToken;
    332 					}
    333 					else if ((LA(1)=='+') && (LA(2)=='=')) {
    334 						mPLUS_ASSIGN(true);
    335 						theRetToken=_returnToken;
    336 					}
    337 					else if ((LA(1)=='+') && (LA(2)=='+')) {
    338 						mINC(true);
    339 						theRetToken=_returnToken;
    340 					}
    341 					else if ((LA(1)=='-') && (LA(2)=='=')) {
    342 						mMINUS_ASSIGN(true);
    343 						theRetToken=_returnToken;
    344 					}
    345 					else if ((LA(1)=='-') && (LA(2)=='-')) {
    346 						mDEC(true);
    347 						theRetToken=_returnToken;
    348 					}
    349 					else if ((LA(1)=='*') && (LA(2)=='=')) {
    350 						mSTAR_ASSIGN(true);
    351 						theRetToken=_returnToken;
    352 					}
    353 					else if ((LA(1)=='%') && (LA(2)=='=')) {
    354 						mMOD_ASSIGN(true);
    355 						theRetToken=_returnToken;
    356 					}
    357 					else if ((LA(1)=='>') && (LA(2)=='>') && (true)) {
    358 						mSR(true);
    359 						theRetToken=_returnToken;
    360 					}
    361 					else if ((LA(1)=='>') && (LA(2)=='=')) {
    362 						mGE(true);
    363 						theRetToken=_returnToken;
    364 					}
    365 					else if ((LA(1)=='<') && (LA(2)=='<') && (true)) {
    366 						mSL(true);
    367 						theRetToken=_returnToken;
    368 					}
    369 					else if ((LA(1)=='<') && (LA(2)=='=')) {
    370 						mLE(true);
    371 						theRetToken=_returnToken;
    372 					}
    373 					else if ((LA(1)=='^') && (LA(2)=='=')) {
    374 						mBXOR_ASSIGN(true);
    375 						theRetToken=_returnToken;
    376 					}
    377 					else if ((LA(1)=='|') && (LA(2)=='=')) {
    378 						mBOR_ASSIGN(true);
    379 						theRetToken=_returnToken;
    380 					}
    381 					else if ((LA(1)=='|') && (LA(2)=='|')) {
    382 						mLOR(true);
    383 						theRetToken=_returnToken;
    384 					}
    385 					else if ((LA(1)=='&') && (LA(2)=='=')) {
    386 						mBAND_ASSIGN(true);
    387 						theRetToken=_returnToken;
    388 					}
    389 					else if ((LA(1)=='&') && (LA(2)=='&')) {
    390 						mLAND(true);
    391 						theRetToken=_returnToken;
    392 					}
    393 					else if ((LA(1)=='/') && (LA(2)=='/')) {
    394 						mSL_COMMENT(true);
    395 						theRetToken=_returnToken;
    396 					}
    397 					else if ((LA(1)=='/') && (LA(2)=='*')) {
    398 						mML_COMMENT(true);
    399 						theRetToken=_returnToken;
    400 					}
    401 					else if ((LA(1)=='=') && (true)) {
    402 						mASSIGN(true);
    403 						theRetToken=_returnToken;
    404 					}
    405 					else if ((LA(1)=='!') && (true)) {
    406 						mLNOT(true);
    407 						theRetToken=_returnToken;
    408 					}
    409 					else if ((LA(1)=='/') && (true)) {
    410 						mDIV(true);
    411 						theRetToken=_returnToken;
    412 					}
    413 					else if ((LA(1)=='+') && (true)) {
    414 						mPLUS(true);
    415 						theRetToken=_returnToken;
    416 					}
    417 					else if ((LA(1)=='-') && (true)) {
    418 						mMINUS(true);
    419 						theRetToken=_returnToken;
    420 					}
    421 					else if ((LA(1)=='*') && (true)) {
    422 						mSTAR(true);
    423 						theRetToken=_returnToken;
    424 					}
    425 					else if ((LA(1)=='%') && (true)) {
    426 						mMOD(true);
    427 						theRetToken=_returnToken;
    428 					}
    429 					else if ((LA(1)=='>') && (true)) {
    430 						mGT(true);
    431 						theRetToken=_returnToken;
    432 					}
    433 					else if ((LA(1)=='<') && (true)) {
    434 						mLT(true);
    435 						theRetToken=_returnToken;
    436 					}
    437 					else if ((LA(1)=='^') && (true)) {
    438 						mBXOR(true);
    439 						theRetToken=_returnToken;
    440 					}
    441 					else if ((LA(1)=='|') && (true)) {
    442 						mBOR(true);
    443 						theRetToken=_returnToken;
    444 					}
    445 					else if ((LA(1)=='&') && (true)) {
    446 						mBAND(true);
    447 						theRetToken=_returnToken;
    448 					}
    449 				else {
    450 					if (LA(1)==EOF_CHAR) {uponEOF(); _returnToken = makeToken(Token.EOF_TYPE);}
    451 				else {throw new NoViableAltForCharException((char)LA(1), getFilename(), getLine(), getColumn());}
    452 				}
    453 				}
    454 				if ( _returnToken==null ) continue tryAgain; // found SKIP token
    455 				_ttype = _returnToken.getType();
    456 				_returnToken.setType(_ttype);
    457 				return _returnToken;
    458 			}
    459 			catch (RecognitionException e) {
    460 				throw new TokenStreamRecognitionException(e);
    461 			}
    462 		}
    463 		catch (CharStreamException cse) {
    464 			if ( cse instanceof CharStreamIOException ) {
    465 				throw new TokenStreamIOException(((CharStreamIOException)cse).io);
    466 			}
    467 			else {
    468 				throw new TokenStreamException(cse.getMessage());
    469 			}
    470 		}
    471 	}
    472 }
    473
    474 	public final void mQUESTION(boolean _createToken) throws RecognitionException, CharStreamException, TokenStreamException {
    475 		int _ttype; Token _token=null; int _begin=text.length();
    476 		_ttype = QUESTION;
    477 		int _saveIndex;
    478
    479 		match('?');
    480 		if ( _createToken && _token==null && _ttype!=Token.SKIP ) {
    481 			_token = makeToken(_ttype);
    482 			_token.setText(new String(text.getBuffer(), _begin, text.length()-_begin));
    483 		}
    484 		_returnToken = _token;
    485 	}
    486
    487 	public final void mLPAREN(boolean _createToken) throws RecognitionException, CharStreamException, TokenStreamException {
    488 		int _ttype; Token _token=null; int _begin=text.length();
    489 		_ttype = LPAREN;
    490 		int _saveIndex;
    491
    492 		match('(');
    493 		if ( _createToken && _token==null && _ttype!=Token.SKIP ) {
    494 			_token = makeToken(_ttype);
    495 			_token.setText(new String(text.getBuffer(), _begin, text.length()-_begin));
    496 		}
    497 		_returnToken = _token;
    498 	}
    499
    500 	public final void mRPAREN(boolean _createToken) throws RecognitionException, CharStreamException, TokenStreamException {
    501 		int _ttype; Token _token=null; int _begin=text.length();
    502 		_ttype = RPAREN;
    503 		int _saveIndex;
    504
    505 		match(')');
    506 		if ( _createToken && _token==null && _ttype!=Token.SKIP ) {
    507 			_token = makeToken(_ttype);
    508 			_token.setText(new String(text.getBuffer(), _begin, text.length()-_begin));
    509 		}
    510 		_returnToken = _token;
    511 	}
    512
    513 	public final void mLBRACK(boolean _createToken) throws RecognitionException, CharStreamException, TokenStreamException {
    514 		int _ttype; Token _token=null; int _begin=text.length();
    515 		_ttype = LBRACK;
    516 		int _saveIndex;
    517
    518 		match('[');
    519 		if ( _createToken && _token==null && _ttype!=Token.SKIP ) {
    520 			_token = makeToken(_ttype);
    521 			_token.setText(new String(text.getBuffer(), _begin, text.length()-_begin));
    522 		}
    523 		_returnToken = _token;
    524 	}
    525
    526 	public final void mRBRACK(boolean _createToken) throws RecognitionException, CharStreamException, TokenStreamException {
    527 		int _ttype; Token _token=null; int _begin=text.length();
    528 		_ttype = RBRACK;
    529 		int _saveIndex;
    530
    531 		match(']');
    532 		if ( _createToken && _token==null && _ttype!=Token.SKIP ) {
    533 			_token = makeToken(_ttype);
    534 			_token.setText(new String(text.getBuffer(), _begin, text.length()-_begin));
    535 		}
    536 		_returnToken = _token;
    537 	}
    538
    539 	public final void mLCURLY(boolean _createToken) throws RecognitionException, CharStreamException, TokenStreamException {
    540 		int _ttype; Token _token=null; int _begin=text.length();
    541 		_ttype = LCURLY;
    542 		int _saveIndex;
    543
    544 		match('{');
    545 		if ( _createToken && _token==null && _ttype!=Token.SKIP ) {
    546 			_token = makeToken(_ttype);
    547 			_token.setText(new String(text.getBuffer(), _begin, text.length()-_begin));
    548 		}
    549 		_returnToken = _token;
    550 	}
    551
    552 	public final void mRCURLY(boolean _createToken) throws RecognitionException, CharStreamException, TokenStreamException {
    553 		int _ttype; Token _token=null; int _begin=text.length();
    554 		_ttype = RCURLY;
    555 		int _saveIndex;
    556
    557 		match('}');
    558 		if ( _createToken && _token==null && _ttype!=Token.SKIP ) {
    559 			_token = makeToken(_ttype);
    560 			_token.setText(new String(text.getBuffer(), _begin, text.length()-_begin));
    561 		}
    562 		_returnToken = _token;
    563 	}
    564
    565 	public final void mCOLON(boolean _createToken) throws RecognitionException, CharStreamException, TokenStreamException {
    566 		int _ttype; Token _token=null; int _begin=text.length();
    567 		_ttype = COLON;
    568 		int _saveIndex;
    569
    570 		match(':');
    571 		if ( _createToken && _token==null && _ttype!=Token.SKIP ) {
    572 			_token = makeToken(_ttype);
    573 			_token.setText(new String(text.getBuffer(), _begin, text.length()-_begin));
    574 		}
    575 		_returnToken = _token;
    576 	}
    577
    578 	public final void mCOMMA(boolean _createToken) throws RecognitionException, CharStreamException, TokenStreamException {
    579 		int _ttype; Token _token=null; int _begin=text.length();
    580 		_ttype = COMMA;
    581 		int _saveIndex;
    582
    583 		match(',');
    584 		if ( _createToken && _token==null && _ttype!=Token.SKIP ) {
    585 			_token = makeToken(_ttype);
    586 			_token.setText(new String(text.getBuffer(), _begin, text.length()-_begin));
    587 		}
    588 		_returnToken = _token;
    589 	}
    590
    591 	public final void mASSIGN(boolean _createToken) throws RecognitionException, CharStreamException, TokenStreamException {
    592 		int _ttype; Token _token=null; int _begin=text.length();
    593 		_ttype = ASSIGN;
    594 		int _saveIndex;
    595
    596 		match('=');
    597 		if ( _createToken && _token==null && _ttype!=Token.SKIP ) {
    598 			_token = makeToken(_ttype);
    599 			_token.setText(new String(text.getBuffer(), _begin, text.length()-_begin));
    600 		}
    601 		_returnToken = _token;
    602 	}
    603
    604 	public final void mEQUAL(boolean _createToken) throws RecognitionException, CharStreamException, TokenStreamException {
    605 		int _ttype; Token _token=null; int _begin=text.length();
    606 		_ttype = EQUAL;
    607 		int _saveIndex;
    608
    609 		match("==");
    610 		if ( _createToken && _token==null && _ttype!=Token.SKIP ) {
    611 			_token = makeToken(_ttype);
    612 			_token.setText(new String(text.getBuffer(), _begin, text.length()-_begin));
    613 		}
    614 		_returnToken = _token;
    615 	}
    616
    617 	public final void mLNOT(boolean _createToken) throws RecognitionException, CharStreamException, TokenStreamException {
    618 		int _ttype; Token _token=null; int _begin=text.length();
    619 		_ttype = LNOT;
    620 		int _saveIndex;
    621
    622 		match('!');
    623 		if ( _createToken && _token==null && _ttype!=Token.SKIP ) {
    624 			_token = makeToken(_ttype);
    625 			_token.setText(new String(text.getBuffer(), _begin, text.length()-_begin));
    626 		}
    627 		_returnToken = _token;
    628 	}
    629
    630 	public final void mBNOT(boolean _createToken) throws RecognitionException, CharStreamException, TokenStreamException {
    631 		int _ttype; Token _token=null; int _begin=text.length();
    632 		_ttype = BNOT;
    633 		int _saveIndex;
    634
    635 		match('~');
    636 		if ( _createToken && _token==null && _ttype!=Token.SKIP ) {
    637 			_token = makeToken(_ttype);
    638 			_token.setText(new String(text.getBuffer(), _begin, text.length()-_begin));
    639 		}
    640 		_returnToken = _token;
    641 	}
    642
    643 	public final void mNOT_EQUAL(boolean _createToken) throws RecognitionException, CharStreamException, TokenStreamException {
    644 		int _ttype; Token _token=null; int _begin=text.length();
    645 		_ttype = NOT_EQUAL;
    646 		int _saveIndex;
    647
    648 		match("!=");
    649 		if ( _createToken && _token==null && _ttype!=Token.SKIP ) {
    650 			_token = makeToken(_ttype);
    651 			_token.setText(new String(text.getBuffer(), _begin, text.length()-_begin));
    652 		}
    653 		_returnToken = _token;
    654 	}
    655
    656 	public final void mDIV(boolean _createToken) throws RecognitionException, CharStreamException, TokenStreamException {
    657 		int _ttype; Token _token=null; int _begin=text.length();
    658 		_ttype = DIV;
    659 		int _saveIndex;
    660
    661 		match('/');
    662 		if ( _createToken && _token==null && _ttype!=Token.SKIP ) {
    663 			_token = makeToken(_ttype);
    664 			_token.setText(new String(text.getBuffer(), _begin, text.length()-_begin));
    665 		}
    666 		_returnToken = _token;
    667 	}
    668
    669 	public final void mDIV_ASSIGN(boolean _createToken) throws RecognitionException, CharStreamException, TokenStreamException {
    670 		int _ttype; Token _token=null; int _begin=text.length();
    671 		_ttype = DIV_ASSIGN;
    672 		int _saveIndex;
    673
    674 		match("/=");
    675 		if ( _createToken && _token==null && _ttype!=Token.SKIP ) {
    676 			_token = makeToken(_ttype);
    677 			_token.setText(new String(text.getBuffer(), _begin, text.length()-_begin));
    678 		}
    679 		_returnToken = _token;
    680 	}
    681
    682 	public final void mPLUS(boolean _createToken) throws RecognitionException, CharStreamException, TokenStreamException {
    683 		int _ttype; Token _token=null; int _begin=text.length();
    684 		_ttype = PLUS;
    685 		int _saveIndex;
    686
    687 		match('+');
    688 		if ( _createToken && _token==null && _ttype!=Token.SKIP ) {
    689 			_token = makeToken(_ttype);
    690 			_token.setText(new String(text.getBuffer(), _begin, text.length()-_begin));
    691 		}
    692 		_returnToken = _token;
    693 	}
    694
    695 	public final void mPLUS_ASSIGN(boolean _createToken) throws RecognitionException, CharStreamException, TokenStreamException {
    696 		int _ttype; Token _token=null; int _begin=text.length();
    697 		_ttype = PLUS_ASSIGN;
    698 		int _saveIndex;
    699
    700 		match("+=");
    701 		if ( _createToken && _token==null && _ttype!=Token.SKIP ) {
    702 			_token = makeToken(_ttype);
    703 			_token.setText(new String(text.getBuffer(), _begin, text.length()-_begin));
    704 		}
    705 		_returnToken = _token;
    706 	}
    707
    708 	public final void mINC(boolean _createToken) throws RecognitionException, CharStreamException, TokenStreamException {
    709 		int _ttype; Token _token=null; int _begin=text.length();
    710 		_ttype = INC;
    711 		int _saveIndex;
    712
    713 		match("++");
    714 		if ( _createToken && _token==null && _ttype!=Token.SKIP ) {
    715 			_token = makeToken(_ttype);
    716 			_token.setText(new String(text.getBuffer(), _begin, text.length()-_begin));
    717 		}
    718 		_returnToken = _token;
    719 	}
    720
    721 	public final void mMINUS(boolean _createToken) throws RecognitionException, CharStreamException, TokenStreamException {
    722 		int _ttype; Token _token=null; int _begin=text.length();
    723 		_ttype = MINUS;
    724 		int _saveIndex;
    725
    726 		match('-');
    727 		if ( _createToken && _token==null && _ttype!=Token.SKIP ) {
    728 			_token = makeToken(_ttype);
    729 			_token.setText(new String(text.getBuffer(), _begin, text.length()-_begin));
    730 		}
    731 		_returnToken = _token;
    732 	}
    733
    734 	public final void mMINUS_ASSIGN(boolean _createToken) throws RecognitionException, CharStreamException, TokenStreamException {
    735 		int _ttype; Token _token=null; int _begin=text.length();
    736 		_ttype = MINUS_ASSIGN;
    737 		int _saveIndex;
    738
    739 		match("-=");
    740 		if ( _createToken && _token==null && _ttype!=Token.SKIP ) {
    741 			_token = makeToken(_ttype);
    742 			_token.setText(new String(text.getBuffer(), _begin, text.length()-_begin));
    743 		}
    744 		_returnToken = _token;
    745 	}
    746
    747 	public final void mDEC(boolean _createToken) throws RecognitionException, CharStreamException, TokenStreamException {
    748 		int _ttype; Token _token=null; int _begin=text.length();
    749 		_ttype = DEC;
    750 		int _saveIndex;
    751
    752 		match("--");
    753 		if ( _createToken && _token==null && _ttype!=Token.SKIP ) {
    754 			_token = makeToken(_ttype);
    755 			_token.setText(new String(text.getBuffer(), _begin, text.length()-_begin));
    756 		}
    757 		_returnToken = _token;
    758 	}
    759
    760 	public final void mSTAR(boolean _createToken) throws RecognitionException, CharStreamException, TokenStreamException {
    761 		int _ttype; Token _token=null; int _begin=text.length();
    762 		_ttype = STAR;
    763 		int _saveIndex;
    764
    765 		match('*');
    766 		if ( _createToken && _token==null && _ttype!=Token.SKIP ) {
    767 			_token = makeToken(_ttype);
    768 			_token.setText(new String(text.getBuffer(), _begin, text.length()-_begin));
    769 		}
    770 		_returnToken = _token;
    771 	}
    772
    773 	public final void mSTAR_ASSIGN(boolean _createToken) throws RecognitionException, CharStreamException, TokenStreamException {
    774 		int _ttype; Token _token=null; int _begin=text.length();
    775 		_ttype = STAR_ASSIGN;
    776 		int _saveIndex;
    777
    778 		match("*=");
    779 		if ( _createToken && _token==null && _ttype!=Token.SKIP ) {
    780 			_token = makeToken(_ttype);
    781 			_token.setText(new String(text.getBuffer(), _begin, text.length()-_begin));
    782 		}
    783 		_returnToken = _token;
    784 	}
    785
    786 	public final void mMOD(boolean _createToken) throws RecognitionException, CharStreamException, TokenStreamException {
    787 		int _ttype; Token _token=null; int _begin=text.length();
    788 		_ttype = MOD;
    789 		int _saveIndex;
    790
    791 		match('%');
    792 		if ( _createToken && _token==null && _ttype!=Token.SKIP ) {
    793 			_token = makeToken(_ttype);
    794 			_token.setText(new String(text.getBuffer(), _begin, text.length()-_begin));
    795 		}
    796 		_returnToken = _token;
    797 	}
    798
    799 	public final void mMOD_ASSIGN(boolean _createToken) throws RecognitionException, CharStreamException, TokenStreamException {
    800 		int _ttype; Token _token=null; int _begin=text.length();
    801 		_ttype = MOD_ASSIGN;
    802 		int _saveIndex;
    803
    804 		match("%=");
    805 		if ( _createToken && _token==null && _ttype!=Token.SKIP ) {
    806 			_token = makeToken(_ttype);
    807 			_token.setText(new String(text.getBuffer(), _begin, text.length()-_begin));
    808 		}
    809 		_returnToken = _token;
    810 	}
    811
    812 	public final void mSR(boolean _createToken) throws RecognitionException, CharStreamException, TokenStreamException {
    813 		int _ttype; Token _token=null; int _begin=text.length();
    814 		_ttype = SR;
    815 		int _saveIndex;
    816
    817 		match(">>");
    818 		if ( _createToken && _token==null && _ttype!=Token.SKIP ) {
    819 			_token = makeToken(_ttype);
    820 			_token.setText(new String(text.getBuffer(), _begin, text.length()-_begin));
    821 		}
    822 		_returnToken = _token;
    823 	}
    824
    825 	public final void mSR_ASSIGN(boolean _createToken) throws RecognitionException, CharStreamException, TokenStreamException {
    826 		int _ttype; Token _token=null; int _begin=text.length();
    827 		_ttype = SR_ASSIGN;
    828 		int _saveIndex;
    829
    830 		match(">>=");
    831 		if ( _createToken && _token==null && _ttype!=Token.SKIP ) {
    832 			_token = makeToken(_ttype);
    833 			_token.setText(new String(text.getBuffer(), _begin, text.length()-_begin));
    834 		}
    835 		_returnToken = _token;
    836 	}
    837
    838 	public final void mBSR(boolean _createToken) throws RecognitionException, CharStreamException, TokenStreamException {
    839 		int _ttype; Token _token=null; int _begin=text.length();
    840 		_ttype = BSR;
    841 		int _saveIndex;
    842
    843 		match(">>>");
    844 		if ( _createToken && _token==null && _ttype!=Token.SKIP ) {
    845 			_token = makeToken(_ttype);
    846 			_token.setText(new String(text.getBuffer(), _begin, text.length()-_begin));
    847 		}
    848 		_returnToken = _token;
    849 	}
    850
    851 	public final void mBSR_ASSIGN(boolean _createToken) throws RecognitionException, CharStreamException, TokenStreamException {
    852 		int _ttype; Token _token=null; int _begin=text.length();
    853 		_ttype = BSR_ASSIGN;
    854 		int _saveIndex;
    855
    856 		match(">>>=");
    857 		if ( _createToken && _token==null && _ttype!=Token.SKIP ) {
    858 			_token = makeToken(_ttype);
    859 			_token.setText(new String(text.getBuffer(), _begin, text.length()-_begin));
    860 		}
    861 		_returnToken = _token;
    862 	}
    863
    864 	public final void mGE(boolean _createToken) throws RecognitionException, CharStreamException, TokenStreamException {
    865 		int _ttype; Token _token=null; int _begin=text.length();
    866 		_ttype = GE;
    867 		int _saveIndex;
    868
    869 		match(">=");
    870 		if ( _createToken && _token==null && _ttype!=Token.SKIP ) {
    871 			_token = makeToken(_ttype);
    872 			_token.setText(new String(text.getBuffer(), _begin, text.length()-_begin));
    873 		}
    874 		_returnToken = _token;
    875 	}
    876
    877 	public final void mGT(boolean _createToken) throws RecognitionException, CharStreamException, TokenStreamException {
    878 		int _ttype; Token _token=null; int _begin=text.length();
    879 		_ttype = GT;
    880 		int _saveIndex;
    881
    882 		match(">");
    883 		if ( _createToken && _token==null && _ttype!=Token.SKIP ) {
    884 			_token = makeToken(_ttype);
    885 			_token.setText(new String(text.getBuffer(), _begin, text.length()-_begin));
    886 		}
    887 		_returnToken = _token;
    888 	}
    889
    890 	public final void mSL(boolean _createToken) throws RecognitionException, CharStreamException, TokenStreamException {
    891 		int _ttype; Token _token=null; int _begin=text.length();
    892 		_ttype = SL;
    893 		int _saveIndex;
    894
    895 		match("<<");
    896 		if ( _createToken && _token==null && _ttype!=Token.SKIP ) {
    897 			_token = makeToken(_ttype);
    898 			_token.setText(new String(text.getBuffer(), _begin, text.length()-_begin));
    899 		}
    900 		_returnToken = _token;
    901 	}
    902
    903 	public final void mSL_ASSIGN(boolean _createToken) throws RecognitionException, CharStreamException, TokenStreamException {
    904 		int _ttype; Token _token=null; int _begin=text.length();
    905 		_ttype = SL_ASSIGN;
    906 		int _saveIndex;
    907
    908 		match("<<=");
    909 		if ( _createToken && _token==null && _ttype!=Token.SKIP ) {
    910 			_token = makeToken(_ttype);
    911 			_token.setText(new String(text.getBuffer(), _begin, text.length()-_begin));
    912 		}
    913 		_returnToken = _token;
    914 	}
    915
    916 	public final void mLE(boolean _createToken) throws RecognitionException, CharStreamException, TokenStreamException {
    917 		int _ttype; Token _token=null; int _begin=text.length();
    918 		_ttype = LE;
    919 		int _saveIndex;
    920
    921 		match("<=");
    922 		if ( _createToken && _token==null && _ttype!=Token.SKIP ) {
    923 			_token = makeToken(_ttype);
    924 			_token.setText(new String(text.getBuffer(), _begin, text.length()-_begin));
    925 		}
    926 		_returnToken = _token;
    927 	}
    928
    929 	public final void mLT(boolean _createToken) throws RecognitionException, CharStreamException, TokenStreamException {
    930 		int _ttype; Token _token=null; int _begin=text.length();
    931 		_ttype = LT;
    932 		int _saveIndex;
    933
    934 		match('<');
    935 		if ( _createToken && _token==null && _ttype!=Token.SKIP ) {
    936 			_token = makeToken(_ttype);
    937 			_token.setText(new String(text.getBuffer(), _begin, text.length()-_begin));
    938 		}
    939 		_returnToken = _token;
    940 	}
    941
    942 	public final void mBXOR(boolean _createToken) throws RecognitionException, CharStreamException, TokenStreamException {
    943 		int _ttype; Token _token=null; int _begin=text.length();
    944 		_ttype = BXOR;
    945 		int _saveIndex;
    946
    947 		match('^');
    948 		if ( _createToken && _token==null && _ttype!=Token.SKIP ) {
    949 			_token = makeToken(_ttype);
    950 			_token.setText(new String(text.getBuffer(), _begin, text.length()-_begin));
    951 		}
    952 		_returnToken = _token;
    953 	}
    954
    955 	public final void mBXOR_ASSIGN(boolean _createToken) throws RecognitionException, CharStreamException, TokenStreamException {
    956 		int _ttype; Token _token=null; int _begin=text.length();
    957 		_ttype = BXOR_ASSIGN;
    958 		int _saveIndex;
    959
    960 		match("^=");
    961 		if ( _createToken && _token==null && _ttype!=Token.SKIP ) {
    962 			_token = makeToken(_ttype);
    963 			_token.setText(new String(text.getBuffer(), _begin, text.length()-_begin));
    964 		}
    965 		_returnToken = _token;
    966 	}
    967
    968 	public final void mBOR(boolean _createToken) throws RecognitionException, CharStreamException, TokenStreamException {
    969 		int _ttype; Token _token=null; int _begin=text.length();
    970 		_ttype = BOR;
    971 		int _saveIndex;
    972
    973 		match('|');
    974 		if ( _createToken && _token==null && _ttype!=Token.SKIP ) {
    975 			_token = makeToken(_ttype);
    976 			_token.setText(new String(text.getBuffer(), _begin, text.length()-_begin));
    977 		}
    978 		_returnToken = _token;
    979 	}
    980
    981 	public final void mBOR_ASSIGN(boolean _createToken) throws RecognitionException, CharStreamException, TokenStreamException {
    982 		int _ttype; Token _token=null; int _begin=text.length();
    983 		_ttype = BOR_ASSIGN;
    984 		int _saveIndex;
    985
    986 		match("|=");
    987 		if ( _createToken && _token==null && _ttype!=Token.SKIP ) {
    988 			_token = makeToken(_ttype);
    989 			_token.setText(new String(text.getBuffer(), _begin, text.length()-_begin));
    990 		}
    991 		_returnToken = _token;
    992 	}
    993
    994 	public final void mLOR(boolean _createToken) throws RecognitionException, CharStreamException, TokenStreamException {
    995 		int _ttype; Token _token=null; int _begin=text.length();
    996 		_ttype = LOR;
    997 		int _saveIndex;
    998
    999 		match("||");
    1000 		if ( _createToken && _token==null && _ttype!=Token.SKIP ) {
    1001 			_token = makeToken(_ttype);
    1002 			_token.setText(new String(text.getBuffer(), _begin, text.length()-_begin));
    1003 		}
    1004 		_returnToken = _token;
    1005 	}
    1006
    1007 	public final void mBAND(boolean _createToken) throws RecognitionException, CharStreamException, TokenStreamException {
    1008 		int _ttype; Token _token=null; int _begin=text.length();
    1009 		_ttype = BAND;
    1010 		int _saveIndex;
    1011
    1012 		match('&');
    1013 		if ( _createToken && _token==null && _ttype!=Token.SKIP ) {
    1014 			_token = makeToken(_ttype);
    1015 			_token.setText(new String(text.getBuffer(), _begin, text.length()-_begin));
    1016 		}
    1017 		_returnToken = _token;
    1018 	}
    1019
    1020 	public final void mBAND_ASSIGN(boolean _createToken) throws RecognitionException, CharStreamException, TokenStreamException {
    1021 		int _ttype; Token _token=null; int _begin=text.length();
    1022 		_ttype = BAND_ASSIGN;
    1023 		int _saveIndex;
    1024
    1025 		match("&=");
    1026 		if ( _createToken && _token==null && _ttype!=Token.SKIP ) {
    1027 			_token = makeToken(_ttype);
    1028 			_token.setText(new String(text.getBuffer(), _begin, text.length()-_begin));
    1029 		}
    1030 		_returnToken = _token;
    1031 	}
    1032
    1033 	public final void mLAND(boolean _createToken) throws RecognitionException, CharStreamException, TokenStreamException {
    1034 		int _ttype; Token _token=null; int _begin=text.length();
    1035 		_ttype = LAND;
    1036 		int _saveIndex;
    1037
    1038 		match("&&");
    1039 		if ( _createToken && _token==null && _ttype!=Token.SKIP ) {
    1040 			_token = makeToken(_ttype);
    1041 			_token.setText(new String(text.getBuffer(), _begin, text.length()-_begin));
    1042 		}
    1043 		_returnToken = _token;
    1044 	}
    1045
    1046 	public final void mSEMI(boolean _createToken) throws RecognitionException, CharStreamException, TokenStreamException {
    1047 		int _ttype; Token _token=null; int _begin=text.length();
    1048 		_ttype = SEMI;
    1049 		int _saveIndex;
    1050
    1051 		match(';');
    1052 		if ( _createToken && _token==null && _ttype!=Token.SKIP ) {
    1053 			_token = makeToken(_ttype);
    1054 			_token.setText(new String(text.getBuffer(), _begin, text.length()-_begin));
    1055 		}
    1056 		_returnToken = _token;
    1057 	}
    1058
    1059 	public final void mWS(boolean _createToken) throws RecognitionException, CharStreamException, TokenStreamException {
    1060 		int _ttype; Token _token=null; int _begin=text.length();
    1061 		_ttype = WS;
    1062 		int _saveIndex;
    1063
    1064 		{
    1065 		int _cnt363=0;
    1066 		_loop363:
    1067 		do {
    1068 			switch ( LA(1)) {
    1069 			case ' ':
    1070 			{
    1071 				match(' ');
    1072 				break;
    1073 			}
    1074 			case '\t':
    1075 			{
    1076 				match('\t');
    1077 				break;
    1078 			}
    1079 			case '\u000c':
    1080 			{
    1081 				match('\f');
    1082 				break;
    1083 			}
    1084 			case '\n':  case '\r':
    1085 			{
    1086 				{
    1087 				if ((LA(1)=='\r') && (LA(2)=='\n') && (true) && (true)) {
    1088 					match("\r\n");
    1089 				}
    1090 				else if ((LA(1)=='\r') && (true) && (true) && (true)) {
    1091 					match('\r');
    1092 				}
    1093 				else if ((LA(1)=='\n')) {
    1094 					match('\n');
    1095 				}
    1096 				else {
    1097 					throw new NoViableAltForCharException((char)LA(1), getFilename(), getLine(), getColumn());
    1098 				}
    1099
    1100 				}
    1101 				if ( inputState.guessing==0 ) {
    1102 					newline();
    1103 				}
    1104 				break;
    1105 			}
    1106 			default:
    1107 			{
    1108 				if ( _cnt363>=1 ) { break _loop363; } else {throw new NoViableAltForCharException((char)LA(1), getFilename(), getLine(), getColumn());}
    1109 			}
    1110 			}
    1111 			_cnt363++;
    1112 		} while (true);
    1113 		}
    1114 		if ( inputState.guessing==0 ) {
    1115 			_ttype = Token.SKIP;
    1116 		}
    1117 		if ( _createToken && _token==null && _ttype!=Token.SKIP ) {
    1118 			_token = makeToken(_ttype);
    1119 			_token.setText(new String(text.getBuffer(), _begin, text.length()-_begin));
    1120 		}
    1121 		_returnToken = _token;
    1122 	}
    1123
    1124 	public final void mSL_COMMENT(boolean _createToken) throws RecognitionException, CharStreamException, TokenStreamException {
    1125 		int _ttype; Token _token=null; int _begin=text.length();
    1126 		_ttype = SL_COMMENT;
    1127 		int _saveIndex;
    1128
    1129 		match("//");
    1130 		{
    1131 		_loop367:
    1132 		do {
    1133 			if ((_tokenSet_0.member(LA(1)))) {
    1134 				{
    1135 				match(_tokenSet_0);
    1136 				}
    1137 			}
    1138 			else {
    1139 				break _loop367;
    1140 			}
    1141
    1142 		} while (true);
    1143 		}
    1144 		{
    1145 		switch ( LA(1)) {
    1146 		case '\n':
    1147 		{
    1148 			match('\n');
    1149 			break;
    1150 		}
    1151 		case '\r':
    1152 		{
    1153 			match('\r');
    1154 			{
    1155 			if ((LA(1)=='\n')) {
    1156 				match('\n');
    1157 			}
    1158 			else {
    1159 			}
    1160
    1161 			}
    1162 			break;
    1163 		}
    1164 		default:
    1165 		{
    1166 			throw new NoViableAltForCharException((char)LA(1), getFilename(), getLine(), getColumn());
    1167 		}
    1168 		}
    1169 		}
    1170 		if ( inputState.guessing==0 ) {
    1171 			_ttype = Token.SKIP; newline();
    1172 		}
    1173 		if ( _createToken && _token==null && _ttype!=Token.SKIP ) {
    1174 			_token = makeToken(_ttype);
    1175 			_token.setText(new String(text.getBuffer(), _begin, text.length()-_begin));
    1176 		}
    1177 		_returnToken = _token;
    1178 	}
    1179
    1180 	public final void mML_COMMENT(boolean _createToken) throws RecognitionException, CharStreamException, TokenStreamException {
    1181 		int _ttype; Token _token=null; int _begin=text.length();
    1182 		_ttype = ML_COMMENT;
    1183 		int _saveIndex;
    1184
    1185 		match("/*");
    1186 		{
    1187 		_loop373:
    1188 		do {
    1189 			if ((LA(1)=='\r') && (LA(2)=='\n') && ((LA(3) >= '\u0003' && LA(3) <= '\uffff')) && ((LA(4) >= '\u0003' && LA(4) <= '\uffff'))) {
    1190 				match('\r');
    1191 				match('\n');
    1192 				if ( inputState.guessing==0 ) {
    1193 					newline();
    1194 				}
    1195 			}
    1196 			else if (((LA(1)=='*') && ((LA(2) >= '\u0003' && LA(2) <= '\uffff')) && ((LA(3) >= '\u0003' && LA(3) <= '\uffff')))&&( LA(2)!='/' )) {
    1197 				match('*');
    1198 			}
    1199 			else if ((LA(1)=='\r') && ((LA(2) >= '\u0003' && LA(2) <= '\uffff')) && ((LA(3) >= '\u0003' && LA(3) <= '\uffff')) && (true)) {
    1200 				match('\r');
    1201 				if ( inputState.guessing==0 ) {
    1202 					newline();
    1203 				}
    1204 			}
    1205 			else if ((LA(1)=='\n')) {
    1206 				match('\n');
    1207 				if ( inputState.guessing==0 ) {
    1208 					newline();
    1209 				}
    1210 			}
    1211 			else if ((_tokenSet_1.member(LA(1)))) {
    1212 				{
    1213 				match(_tokenSet_1);
    1214 				}
    1215 			}
    1216 			else {
    1217 				break _loop373;
    1218 			}
    1219
    1220 		} while (true);
    1221 		}
    1222 		match("*/");
    1223 		if ( inputState.guessing==0 ) {
    1224 			_ttype = Token.SKIP;
    1225 		}
    1226 		if ( _createToken && _token==null && _ttype!=Token.SKIP ) {
    1227 			_token = makeToken(_ttype);
    1228 			_token.setText(new String(text.getBuffer(), _begin, text.length()-_begin));
    1229 		}
    1230 		_returnToken = _token;
    1231 	}
    1232
    1233 	public final void mSTRING_LITERAL(boolean _createToken) throws RecognitionException, CharStreamException, TokenStreamException {
    1234 		int _ttype; Token _token=null; int _begin=text.length();
    1235 		_ttype = STRING_LITERAL;
    1236 		int _saveIndex;
    1237
    1238 		switch ( LA(1)) {
    1239 		case '"':
    1240 		{
    1241 			match('"');
    1242 			{
    1243 			_loop377:
    1244 			do {
    1245 				if ((LA(1)=='//')) {
    1246 					mESC(false);
    1247 				}
    1248 				else if ((_tokenSet_2.member(LA(1)))) {
    1249 					{
    1250 					match(_tokenSet_2);
    1251 					}
    1252 				}
    1253 				else {
    1254 					break _loop377;
    1255 				}
    1256
    1257 			} while (true);
    1258 			}
    1259 			match('"');
    1260 			break;
    1261 		}
    1262 		case '\'':
    1263 		{
    1264 			match('\'');
    1265 			{
    1266 			if ((LA(1)=='//')) {
    1267 				mESC(false);
    1268 			}
    1269 			else if ((_tokenSet_3.member(LA(1)))) {
    1270 				{
    1271 				match(_tokenSet_3);
    1272 				}
    1273 			}
    1274 			else {
    1275 				throw new NoViableAltForCharException((char)LA(1), getFilename(), getLine(), getColumn());
    1276 			}
    1277
    1278 			}
    1279 			match('\'');
    1280 			break;
    1281 		}
    1282 		default:
    1283 		{
    1284 			throw new NoViableAltForCharException((char)LA(1), getFilename(), getLine(), getColumn());
    1285 		}
    1286 		}
    1287 		if ( _createToken && _token==null && _ttype!=Token.SKIP ) {
    1288 			_token = makeToken(_ttype);
    1289 			_token.setText(new String(text.getBuffer(), _begin, text.length()-_begin));
    1290 		}
    1291 		_returnToken = _token;
    1292 	}
    1293
    1294 	protected final void mESC(boolean _createToken) throws RecognitionException, CharStreamException, TokenStreamException {
    1295 		int _ttype; Token _token=null; int _begin=text.length();
    1296 		_ttype = ESC;
    1297 		int _saveIndex;
    1298
    1299 		match('//');
    1300 		{
    1301 		switch ( LA(1)) {
    1302 		case 'n':
    1303 		{
    1304 			match('n');
    1305 			break;
    1306 		}
    1307 		case 'r':
    1308 		{
    1309 			match('r');
    1310 			break;
    1311 		}
    1312 		case 't':
    1313 		{
    1314 			match('t');
    1315 			break;
    1316 		}
    1317 		case 'b':
    1318 		{
    1319 			match('b');
    1320 			break;
    1321 		}
    1322 		case 'f':
    1323 		{
    1324 			match('f');
    1325 			break;
    1326 		}
    1327 		case '"':
    1328 		{
    1329 			match('"');
    1330 			break;
    1331 		}
    1332 		case '\'':
    1333 		{
    1334 			match('\'');
    1335 			break;
    1336 		}
    1337 		case '//':
    1338 		{
    1339 			match('//');
    1340 			break;
    1341 		}
    1342 		case 'u':
    1343 		{
    1344 			{
    1345 			int _cnt383=0;
    1346 			_loop383:
    1347 			do {
    1348 				if ((LA(1)=='u')) {
    1349 					match('u');
    1350 				}
    1351 				else {
    1352 					if ( _cnt383>=1 ) { break _loop383; } else {throw new NoViableAltForCharException((char)LA(1), getFilename(), getLine(), getColumn());}
    1353 				}
    1354
    1355 				_cnt383++;
    1356 			} while (true);
    1357 			}
    1358 			mHEX_DIGIT(false);
    1359 			mHEX_DIGIT(false);
    1360 			mHEX_DIGIT(false);
    1361 			mHEX_DIGIT(false);
    1362 			break;
    1363 		}
    1364 		case '0':  case '1':  case '2':  case '3':
    1365 		{
    1366 			matchRange('0','3');
    1367 			{
    1368 			if (((LA(1) >= '0' && LA(1) <= '7')) && (_tokenSet_0.member(LA(2))) && (true) && (true)) {
    1369 				matchRange('0','7');
    1370 				{
    1371 				if (((LA(1) >= '0' && LA(1) <= '7')) && (_tokenSet_0.member(LA(2))) && (true) && (true)) {
    1372 					matchRange('0','7');
    1373 				}
    1374 				else if ((_tokenSet_0.member(LA(1))) && (true) && (true) && (true)) {
    1375 				}
    1376 				else {
    1377 					throw new NoViableAltForCharException((char)LA(1), getFilename(), getLine(), getColumn());
    1378 				}
    1379
    1380 				}
    1381 			}
    1382 			else if ((_tokenSet_0.member(LA(1))) && (true) && (true) && (true)) {
    1383 			}
    1384 			else {
    1385 				throw new NoViableAltForCharException((char)LA(1), getFilename(), getLine(), getColumn());
    1386 			}
    1387
    1388 			}
    1389 			break;
    1390 		}
    1391 		case '4':  case '5':  case '6':  case '7':
    1392 		{
    1393 			matchRange('4','7');
    1394 			{
    1395 			if (((LA(1) >= '0' && LA(1) <= '7')) && (_tokenSet_0.member(LA(2))) && (true) && (true)) {
    1396 				matchRange('0','7');
    1397 			}
    1398 			else if ((_tokenSet_0.member(LA(1))) && (true) && (true) && (true)) {
    1399 			}
    1400 			else {
    1401 				throw new NoViableAltForCharException((char)LA(1), getFilename(), getLine(), getColumn());
    1402 			}
    1403
    1404 			}
    1405 			break;
    1406 		}
    1407 		default:
    1408 		{
    1409 			throw new NoViableAltForCharException((char)LA(1), getFilename(), getLine(), getColumn());
    1410 		}
    1411 		}
    1412 		}
    1413 		if ( _createToken && _token==null && _ttype!=Token.SKIP ) {
    1414 			_token = makeToken(_ttype);
    1415 			_token.setText(new String(text.getBuffer(), _begin, text.length()-_begin));
    1416 		}
    1417 		_returnToken = _token;
    1418 	}
    1419
    1420 	protected final void mHEX_DIGIT(boolean _createToken) throws RecognitionException, CharStreamException, TokenStreamException {
    1421 		int _ttype; Token _token=null; int _begin=text.length();
    1422 		_ttype = HEX_DIGIT;
    1423 		int _saveIndex;
    1424
    1425 		{
    1426 		switch ( LA(1)) {
    1427 		case '0':  case '1':  case '2':  case '3':
    1428 		case '4':  case '5':  case '6':  case '7':
    1429 		case '8':  case '9':
    1430 		{
    1431 			matchRange('0','9');
    1432 			break;
    1433 		}
    1434 		case 'A':  case 'B':  case 'C':  case 'D':
    1435 		case 'E':  case 'F':
    1436 		{
    1437 			matchRange('A','F');
    1438 			break;
    1439 		}
    1440 		case 'a':  case 'b':  case 'c':  case 'd':
    1441 		case 'e':  case 'f':
    1442 		{
    1443 			matchRange('a','f');
    1444 			break;
    1445 		}
    1446 		default:
    1447 		{
    1448 			throw new NoViableAltForCharException((char)LA(1), getFilename(), getLine(), getColumn());
    1449 		}
    1450 		}
    1451 		}
    1452 		if ( _createToken && _token==null && _ttype!=Token.SKIP ) {
    1453 			_token = makeToken(_ttype);
    1454 			_token.setText(new String(text.getBuffer(), _begin, text.length()-_begin));
    1455 		}
    1456 		_returnToken = _token;
    1457 	}
    1458
    1459 	protected final void mVOCAB(boolean _createToken) throws RecognitionException, CharStreamException, TokenStreamException {
    1460 		int _ttype; Token _token=null; int _begin=text.length();
    1461 		_ttype = VOCAB;
    1462 		int _saveIndex;
    1463
    1464 		matchRange('\3','\377');
    1465 		if ( _createToken && _token==null && _ttype!=Token.SKIP ) {
    1466 			_token = makeToken(_ttype);
    1467 			_token.setText(new String(text.getBuffer(), _begin, text.length()-_begin));
    1468 		}
    1469 		_returnToken = _token;
    1470 	}
    1471
    1472 	public final void mIDENT(boolean _createToken) throws RecognitionException, CharStreamException, TokenStreamException {
    1473 		int _ttype; Token _token=null; int _begin=text.length();
    1474 		_ttype = IDENT;
    1475 		int _saveIndex;
    1476
    1477 		{
    1478 		switch ( LA(1)) {
    1479 		case 'a':  case 'b':  case 'c':  case 'd':
    1480 		case 'e':  case 'f':  case 'g':  case 'h':
    1481 		case 'i':  case 'j':  case 'k':  case 'l':
    1482 		case 'm':  case 'n':  case 'o':  case 'p':
    1483 		case 'q':  case 'r':  case 's':  case 't':
    1484 		case 'u':  case 'v':  case 'w':  case 'x':
    1485 		case 'y':  case 'z':
    1486 		{
    1487 			matchRange('a','z');
    1488 			break;
    1489 		}
    1490 		case 'A':  case 'B':  case 'C':  case 'D':
    1491 		case 'E':  case 'F':  case 'G':  case 'H':
    1492 		case 'I':  case 'J':  case 'K':  case 'L':
    1493 		case 'M':  case 'N':  case 'O':  case 'P':
    1494 		case 'Q':  case 'R':  case 'S':  case 'T':
    1495 		case 'U':  case 'V':  case 'W':  case 'X':
    1496 		case 'Y':  case 'Z':
    1497 		{
    1498 			matchRange('A','Z');
    1499 			break;
    1500 		}
    1501 		case '_':
    1502 		{
    1503 			match('_');
    1504 			break;
    1505 		}
    1506 		case '$':
    1507 		{
    1508 			match('$');
    1509 			break;
    1510 		}
    1511 		default:
    1512 		{
    1513 			throw new NoViableAltForCharException((char)LA(1), getFilename(), getLine(), getColumn());
    1514 		}
    1515 		}
    1516 		}
    1517 		{
    1518 		_loop393:
    1519 		do {
    1520 			switch ( LA(1)) {
    1521 			case 'a':  case 'b':  case 'c':  case 'd':
    1522 			case 'e':  case 'f':  case 'g':  case 'h':
    1523 			case 'i':  case 'j':  case 'k':  case 'l':
    1524 			case 'm':  case 'n':  case 'o':  case 'p':
    1525 			case 'q':  case 'r':  case 's':  case 't':
    1526 			case 'u':  case 'v':  case 'w':  case 'x':
    1527 			case 'y':  case 'z':
    1528 			{
    1529 				matchRange('a','z');
    1530 				break;
    1531 			}
    1532 			case 'A':  case 'B':  case 'C':  case 'D':
    1533 			case 'E':  case 'F':  case 'G':  case 'H':
    1534 			case 'I':  case 'J':  case 'K':  case 'L':
    1535 			case 'M':  case 'N':  case 'O':  case 'P':
    1536 			case 'Q':  case 'R':  case 'S':  case 'T':
    1537 			case 'U':  case 'V':  case 'W':  case 'X':
    1538 			case 'Y':  case 'Z':
    1539 			{
    1540 				matchRange('A','Z');
    1541 				break;
    1542 			}
    1543 			case '_':
    1544 			{
    1545 				match('_');
    1546 				break;
    1547 			}
    1548 			case '0':  case '1':  case '2':  case '3':
    1549 			case '4':  case '5':  case '6':  case '7':
    1550 			case '8':  case '9':
    1551 			{
    1552 				matchRange('0','9');
    1553 				break;
    1554 			}
    1555 			case '$':
    1556 			{
    1557 				match('$');
    1558 				break;
    1559 			}
    1560 			default:
    1561 			{
    1562 				break _loop393;
    1563 			}
    1564 			}
    1565 		} while (true);
    1566 		}
    1567 		if ( inputState.guessing==0 ) {
    1568
    1569 						// check if "assert" keyword is enabled
    1570 						if (assertEnabled && "assert".equals(new String(text.getBuffer(),_begin,text.length()-_begin))) {
    1571 							_ttype = LITERAL_assert; // set token type for the rule in the parser
    1572 						}
    1573 						// check if "enum" keyword is enabled
    1574 						if (enumEnabled && "enum".equals(new String(text.getBuffer(),_begin,text.length()-_begin))) {
    1575 							_ttype = LITERAL_enum; // set token type for the rule in the parser
    1576 						}
    1577
    1578 		}
    1579 		_ttype = testLiteralsTable(_ttype);
    1580 		if ( _createToken && _token==null && _ttype!=Token.SKIP ) {
    1581 			_token = makeToken(_ttype);
    1582 			_token.setText(new String(text.getBuffer(), _begin, text.length()-_begin));
    1583 		}
    1584 		_returnToken = _token;
    1585 	}
    1586
    1587 	public final void mNUM_INT(boolean _createToken) throws RecognitionException, CharStreamException, TokenStreamException {
    1588 		int _ttype; Token _token=null; int _begin=text.length();
    1589 		_ttype = NUM_INT;
    1590 		int _saveIndex;
    1591 		Token f1=null;
    1592 		Token f2=null;
    1593 		Token f3=null;
    1594 		Token f4=null;
    1595 		boolean isDecimal=false; Token t=null;
    1596
    1597 		switch ( LA(1)) {
    1598 		case '.':
    1599 		{
    1600 			match('.');
    1601 			if ( inputState.guessing==0 ) {
    1602 				_ttype = DOT;
    1603 			}
    1604 			{
    1605 			switch ( LA(1)) {
    1606 			case '0':  case '1':  case '2':  case '3':
    1607 			case '4':  case '5':  case '6':  case '7':
    1608 			case '8':  case '9':
    1609 			{
    1610 				{
    1611 				{
    1612 				int _cnt398=0;
    1613 				_loop398:
    1614 				do {
    1615 					if (((LA(1) >= '0' && LA(1) <= '9'))) {
    1616 						matchRange('0','9');
    1617 					}
    1618 					else {
    1619 						if ( _cnt398>=1 ) { break _loop398; } else {throw new NoViableAltForCharException((char)LA(1), getFilename(), getLine(), getColumn());}
    1620 					}
    1621
    1622 					_cnt398++;
    1623 				} while (true);
    1624 				}
    1625 				{
    1626 				if ((LA(1)=='E'||LA(1)=='e')) {
    1627 					mEXPONENT(false);
    1628 				}
    1629 				else {
    1630 				}
    1631
    1632 				}
    1633 				{
    1634 				if ((LA(1)=='D'||LA(1)=='F'||LA(1)=='d'||LA(1)=='f')) {
    1635 					mFLOAT_SUFFIX(true);
    1636 					f1=_returnToken;
    1637 					if ( inputState.guessing==0 ) {
    1638 						t=f1;
    1639 					}
    1640 				}
    1641 				else {
    1642 				}
    1643
    1644 				}
    1645 				if ( inputState.guessing==0 ) {
    1646
    1647 									if (t != null && t.getText().toUpperCase().indexOf('F')>=0) {
    1648 										_ttype = NUM_FLOAT;
    1649 									}
    1650 									else {
    1651 										_ttype = NUM_DOUBLE; // assume double
    1652 									}
    1653
    1654 				}
    1655 				}
    1656 				break;
    1657 			}
    1658 			case '.':
    1659 			{
    1660 				{
    1661 				match("..");
    1662 				if ( inputState.guessing==0 ) {
    1663 					_ttype = TRIPLE_DOT;
    1664 				}
    1665 				}
    1666 				break;
    1667 			}
    1668 			default:
    1669 				{
    1670 				}
    1671 			}
    1672 			}
    1673 			break;
    1674 		}
    1675 		case '0':  case '1':  case '2':  case '3':
    1676 		case '4':  case '5':  case '6':  case '7':
    1677 		case '8':  case '9':
    1678 		{
    1679 			{
    1680 			switch ( LA(1)) {
    1681 			case '0':
    1682 			{
    1683 				match('0');
    1684 				if ( inputState.guessing==0 ) {
    1685 					isDecimal = true;
    1686 				}
    1687 				{
    1688 				if ((LA(1)=='X'||LA(1)=='x')) {
    1689 					{
    1690 					switch ( LA(1)) {
    1691 					case 'x':
    1692 					{
    1693 						match('x');
    1694 						break;
    1695 					}
    1696 					case 'X':
    1697 					{
    1698 						match('X');
    1699 						break;
    1700 					}
    1701 					default:
    1702 					{
    1703 						throw new NoViableAltForCharException((char)LA(1), getFilename(), getLine(), getColumn());
    1704 					}
    1705 					}
    1706 					}
    1707 					{
    1708 					int _cnt406=0;
    1709 					_loop406:
    1710 					do {
    1711 						if ((_tokenSet_4.member(LA(1))) && (true) && (true) && (true)) {
    1712 							mHEX_DIGIT(false);
    1713 						}
    1714 						else {
    1715 							if ( _cnt406>=1 ) { break _loop406; } else {throw new NoViableAltForCharException((char)LA(1), getFilename(), getLine(), getColumn());}
    1716 						}
    1717
    1718 						_cnt406++;
    1719 					} while (true);
    1720 					}
    1721 				}
    1722 				else {
    1723 					boolean synPredMatched411 = false;
    1724 					if ((((LA(1) >= '0' && LA(1) <= '9')) && (true) && (true) && (true))) {
    1725 						int _m411 = mark();
    1726 						synPredMatched411 = true;
    1727 						inputState.guessing++;
    1728 						try {
    1729 							{
    1730 							{
    1731 							int _cnt409=0;
    1732 							_loop409:
    1733 							do {
    1734 								if (((LA(1) >= '0' && LA(1) <= '9'))) {
    1735 									matchRange('0','9');
    1736 								}
    1737 								else {
    1738 									if ( _cnt409>=1 ) { break _loop409; } else {throw new NoViableAltForCharException((char)LA(1), getFilename(), getLine(), getColumn());}
    1739 								}
    1740
    1741 								_cnt409++;
    1742 							} while (true);
    1743 							}
    1744 							{
    1745 							switch ( LA(1)) {
    1746 							case '.':
    1747 							{
    1748 								match('.');
    1749 								break;
    1750 							}
    1751 							case 'E':  case 'e':
    1752 							{
    1753 								mEXPONENT(false);
    1754 								break;
    1755 							}
    1756 							case 'D':  case 'F':  case 'd':  case 'f':
    1757 							{
    1758 								mFLOAT_SUFFIX(false);
    1759 								break;
    1760 							}
    1761 							default:
    1762 							{
    1763 								throw new NoViableAltForCharException((char)LA(1), getFilename(), getLine(), getColumn());
    1764 							}
    1765 							}
    1766 							}
    1767 							}
    1768 						}
    1769 						catch (RecognitionException pe) {
    1770 							synPredMatched411 = false;
    1771 						}
    1772 						rewind(_m411);
    1773 						inputState.guessing--;
    1774 					}
    1775 					if ( synPredMatched411 ) {
    1776 						{
    1777 						int _cnt413=0;
    1778 						_loop413:
    1779 						do {
    1780 							if (((LA(1) >= '0' && LA(1) <= '9'))) {
    1781 								matchRange('0','9');
    1782 							}
    1783 							else {
    1784 								if ( _cnt413>=1 ) { break _loop413; } else {throw new NoViableAltForCharException((char)LA(1), getFilename(), getLine(), getColumn());}
    1785 							}
    1786
    1787 							_cnt413++;
    1788 						} while (true);
    1789 						}
    1790 					}
    1791 					else if (((LA(1) >= '0' && LA(1) <= '7')) && (true) && (true) && (true)) {
    1792 						{
    1793 						int _cnt415=0;
    1794 						_loop415:
    1795 						do {
    1796 							if (((LA(1) >= '0' && LA(1) <= '7'))) {
    1797 								matchRange('0','7');
    1798 							}
    1799 							else {
    1800 								if ( _cnt415>=1 ) { break _loop415; } else {throw new NoViableAltForCharException((char)LA(1), getFilename(), getLine(), getColumn());}
    1801 							}
    1802
    1803 							_cnt415++;
    1804 						} while (true);
    1805 						}
    1806 					}
    1807 					else {
    1808 					}
    1809 					}
    1810 					}
    1811 					break;
    1812 				}
    1813 				case '1':  case '2':  case '3':  case '4':
    1814 				case '5':  case '6':  case '7':  case '8':
    1815 				case '9':
    1816 				{
    1817 					{
    1818 					matchRange('1','9');
    1819 					}
    1820 					{
    1821 					_loop418:
    1822 					do {
    1823 						if (((LA(1) >= '0' && LA(1) <= '9'))) {
    1824 							matchRange('0','9');
    1825 						}
    1826 						else {
    1827 							break _loop418;
    1828 						}
    1829
    1830 					} while (true);
    1831 					}
    1832 					if ( inputState.guessing==0 ) {
    1833 						isDecimal=true;
    1834 					}
    1835 					break;
    1836 				}
    1837 				default:
    1838 				{
    1839 					throw new NoViableAltForCharException((char)LA(1), getFilename(), getLine(), getColumn());
    1840 				}
    1841 				}
    1842 				}
    1843 				{
    1844 				if ((LA(1)=='L'||LA(1)=='l')) {
    1845 					{
    1846 					switch ( LA(1)) {
    1847 					case 'l':
    1848 					{
    1849 						match('l');
    1850 						break;
    1851 					}
    1852 					case 'L':
    1853 					{
    1854 						match('L');
    1855 						break;
    1856 					}
    1857 					default:
    1858 					{
    1859 						throw new NoViableAltForCharException((char)LA(1), getFilename(), getLine(), getColumn());
    1860 					}
    1861 					}
    1862 					}
    1863 					if ( inputState.guessing==0 ) {
    1864 						_ttype = NUM_LONG;
    1865 					}
    1866 				}
    1867 				else if (((LA(1)=='.'||LA(1)=='D'||LA(1)=='E'||LA(1)=='F'||LA(1)=='d'||LA(1)=='e'||LA(1)=='f'))&&(isDecimal)) {
    1868 					{
    1869 					switch ( LA(1)) {
    1870 					case '.':
    1871 					{
    1872 						match('.');
    1873 						{
    1874 						_loop423:
    1875 						do {
    1876 							if (((LA(1) >= '0' && LA(1) <= '9'))) {
    1877 								matchRange('0','9');
    1878 							}
    1879 							else {
    1880 								break _loop423;
    1881 							}
    1882
    1883 						} while (true);
    1884 						}
    1885 						{
    1886 						if ((LA(1)=='E'||LA(1)=='e')) {
    1887 							mEXPONENT(false);
    1888 						}
    1889 						else {
    1890 						}
    1891
    1892 						}
    1893 						{
    1894 						if ((LA(1)=='D'||LA(1)=='F'||LA(1)=='d'||LA(1)=='f')) {
    1895 							mFLOAT_SUFFIX(true);
    1896 							f2=_returnToken;
    1897 							if ( inputState.guessing==0 ) {
    1898 								t=f2;
    1899 							}
    1900 						}
    1901 						else {
    1902 						}
    1903
    1904 						}
    1905 						break;
    1906 					}
    1907 					case 'E':  case 'e':
    1908 					{
    1909 						mEXPONENT(false);
    1910 						{
    1911 						if ((LA(1)=='D'||LA(1)=='F'||LA(1)=='d'||LA(1)=='f')) {
    1912 							mFLOAT_SUFFIX(true);
    1913 							f3=_returnToken;
    1914 							if ( inputState.guessing==0 ) {
    1915 								t=f3;
    1916 							}
    1917 						}
    1918 						else {
    1919 						}
    1920
    1921 						}
    1922 						break;
    1923 					}
    1924 					case 'D':  case 'F':  case 'd':  case 'f':
    1925 					{
    1926 						mFLOAT_SUFFIX(true);
    1927 						f4=_returnToken;
    1928 						if ( inputState.guessing==0 ) {
    1929 							t=f4;
    1930 						}
    1931 						break;
    1932 					}
    1933 					default:
    1934 					{
    1935 						throw new NoViableAltForCharException((char)LA(1), getFilename(), getLine(), getColumn());
    1936 					}
    1937 					}
    1938 					}
    1939 					if ( inputState.guessing==0 ) {
    1940
    1941 									if (t != null && t.getText().toUpperCase() .indexOf('F') >= 0) {
    1942 										_ttype = NUM_FLOAT;
    1943 									}
    1944 									else {
    1945 										_ttype = NUM_DOUBLE; // assume double
    1946 									}
    1947
    1948 					}
    1949 				}
    1950 				else {
    1951 				}
    1952
    1953 				}
    1954 				break;
    1955 			}
    1956 			default:
    1957 			{
    1958 				throw new NoViableAltForCharException((char)LA(1), getFilename(), getLine(), getColumn());
    1959 			}
    1960 			}
    1961 			if ( _createToken && _token==null && _ttype!=Token.SKIP ) {
    1962 				_token = makeToken(_ttype);
    1963 				_token.setText(new String(text.getBuffer(), _begin, text.length()-_begin));
    1964 			}
    1965 			_returnToken = _token;
    1966 		}
    1967
    1968 	protected final void mEXPONENT(boolean _createToken) throws RecognitionException, CharStreamException, TokenStreamException {
    1969 		int _ttype; Token _token=null; int _begin=text.length();
    1970 		_ttype = EXPONENT;
    1971 		int _saveIndex;
    1972
    1973 		{
    1974 		switch ( LA(1)) {
    1975 		case 'e':
    1976 		{
    1977 			match('e');
    1978 			break;
    1979 		}
    1980 		case 'E':
    1981 		{
    1982 			match('E');
    1983 			break;
    1984 		}
    1985 		default:
    1986 		{
    1987 			throw new NoViableAltForCharException((char)LA(1), getFilename(), getLine(), getColumn());
    1988 		}
    1989 		}
    1990 		}
    1991 		{
    1992 		switch ( LA(1)) {
    1993 		case '+':
    1994 		{
    1995 			match('+');
    1996 			break;
    1997 		}
    1998 		case '-':
    1999 		{
    2000 			match('-');
    2001 			break;
    2002 		}
    2003 		case '0':  case '1':  case '2':  case '3':
    2004 		case '4':  case '5':  case '6':  case '7':
    2005 		case '8':  case '9':
    2006 		{
    2007 			break;
    2008 		}
    2009 		default:
    2010 		{
    2011 			throw new NoViableAltForCharException((char)LA(1), getFilename(), getLine(), getColumn());
    2012 		}
    2013 		}
    2014 		}
    2015 		{
    2016 		int _cnt432=0;
    2017 		_loop432:
    2018 		do {
    2019 			if (((LA(1) >= '0' && LA(1) <= '9'))) {
    2020 				matchRange('0','9');
    2021 			}
    2022 			else {
    2023 				if ( _cnt432>=1 ) { break _loop432; } else {throw new NoViableAltForCharException((char)LA(1), getFilename(), getLine(), getColumn());}
    2024 			}
    2025
    2026 			_cnt432++;
    2027 		} while (true);
    2028 		}
    2029 		if ( _createToken && _token==null && _ttype!=Token.SKIP ) {
    2030 			_token = makeToken(_ttype);
    2031 			_token.setText(new String(text.getBuffer(), _begin, text.length()-_begin));
    2032 		}
    2033 		_returnToken = _token;
    2034 	}
    2035
    2036 	protected final void mFLOAT_SUFFIX(boolean _createToken) throws RecognitionException, CharStreamException, TokenStreamException {
    2037 		int _ttype; Token _token=null; int _begin=text.length();
    2038 		_ttype = FLOAT_SUFFIX;
    2039 		int _saveIndex;
    2040
    2041 		switch ( LA(1)) {
    2042 		case 'f':
    2043 		{
    2044 			match('f');
    2045 			break;
    2046 		}
    2047 		case 'F':
    2048 		{
    2049 			match('F');
    2050 			break;
    2051 		}
    2052 		case 'd':
    2053 		{
    2054 			match('d');
    2055 			break;
    2056 		}
    2057 		case 'D':
    2058 		{
    2059 			match('D');
    2060 			break;
    2061 		}
    2062 		default:
    2063 		{
    2064 			throw new NoViableAltForCharException((char)LA(1), getFilename(), getLine(), getColumn());
    2065 		}
    2066 		}
    2067 		if ( _createToken && _token==null && _ttype!=Token.SKIP ) {
    2068 			_token = makeToken(_ttype);
    2069 			_token.setText(new String(text.getBuffer(), _begin, text.length()-_begin));
    2070 		}
    2071 		_returnToken = _token;
    2072 	}
    2073
    2074 	public final void mAT(boolean _createToken) throws RecognitionException, CharStreamException, TokenStreamException {
    2075 		int _ttype; Token _token=null; int _begin=text.length();
    2076 		_ttype = AT;
    2077 		int _saveIndex;
    2078
    2079 		match('@');
    2080 		if ( _createToken && _token==null && _ttype!=Token.SKIP ) {
    2081 			_token = makeToken(_ttype);
    2082 			_token.setText(new String(text.getBuffer(), _begin, text.length()-_begin));
    2083 		}
    2084 		_returnToken = _token;
    2085 	}
    2086
    2087
    2088 	private static final long[] mk_tokenSet_0() {
    2089 		long[] data = new long[2048];
    2090 		data[0]=-9224L;
    2091 		for (int i = 1; i<=1023; i++) { data[i]=-1L; }
    2092 		return data;
    2093 	}
    2094 	public static final BitSet _tokenSet_0 = new BitSet(mk_tokenSet_0());
    2095 	private static final long[] mk_tokenSet_1() {
    2096 		long[] data = new long[2048];
    2097 		data[0]=-4398046520328L;
    2098 		for (int i = 1; i<=1023; i++) { data[i]=-1L; }
    2099 		return data;
    2100 	}
    2101 	public static final BitSet _tokenSet_1 = new BitSet(mk_tokenSet_1());
    2102 	private static final long[] mk_tokenSet_2() {
    2103 		long[] data = new long[2048];
    2104 		data[0]=-17179878408L;
    2105 		data[1]=-268435457L;
    2106 		for (int i = 2; i<=1023; i++) { data[i]=-1L; }
    2107 		return data;
    2108 	}
    2109 	public static final BitSet _tokenSet_2 = new BitSet(mk_tokenSet_2());
    2110 	private static final long[] mk_tokenSet_3() {
    2111 		long[] data = new long[2048];
    2112 		data[0]=-549755823112L;
    2113 		data[1]=-268435457L;
    2114 		for (int i = 2; i<=1023; i++) { data[i]=-1L; }
    2115 		return data;
    2116 	}
    2117 	public static final BitSet _tokenSet_3 = new BitSet(mk_tokenSet_3());
    2118 	private static final long[] mk_tokenSet_4() {
    2119 		long[] data = new long[1025];
    2120 		data[0]=287948901175001088L;
    2121 		data[1]=541165879422L;
    2122 		return data;
    2123 	}
    2124 	public static final BitSet _tokenSet_4 = new BitSet(mk_tokenSet_4());
    2125
    2126 	}