View Javadoc

    1   // $ANTLR 2.7.2: "groovy.g" -> "GroovyLexer.java"$
    2
    3   package org.codehaus.groovy.antlr.parser;
    4   import org.codehaus.groovy.antlr.*;
    5   import java.util.*;
    6   import java.io.InputStream;
    7   import java.io.Reader;
    8   import antlr.InputBuffer;
    9   import antlr.LexerSharedInputState;
    10
    11  import java.io.InputStream;
    12  import antlr.TokenStreamException;
    13  import antlr.TokenStreamIOException;
    14  import antlr.TokenStreamRecognitionException;
    15  import antlr.CharStreamException;
    16  import antlr.CharStreamIOException;
    17  import antlr.ANTLRException;
    18  import java.io.Reader;
    19  import java.util.Hashtable;
    20  import antlr.CharScanner;
    21  import antlr.InputBuffer;
    22  import antlr.ByteBuffer;
    23  import antlr.CharBuffer;
    24  import antlr.Token;
    25  import antlr.CommonToken;
    26  import antlr.RecognitionException;
    27  import antlr.NoViableAltForCharException;
    28  import antlr.MismatchedCharException;
    29  import antlr.TokenStream;
    30  import antlr.ANTLRHashString;
    31  import antlr.LexerSharedInputState;
    32  import antlr.collections.impl.BitSet;
    33  import antlr.SemanticException;
    34
    35  public class GroovyLexer extends antlr.CharScanner implements GroovyTokenTypes, TokenStream
    36   {
    37
    38      /*** flag for enabling the "assert" keyword */
    39      private boolean assertEnabled = true;
    40      /*** flag for enabling the "enum" keyword */
    41      private boolean enumEnabled = true;
    42      /*** flag for including whitespace tokens (for IDE preparsing) */
    43      private boolean whitespaceIncluded = false;
    44
    45      /*** Enable the "assert" keyword */
    46      public void enableAssert(boolean shouldEnable) { assertEnabled = shouldEnable; }
    47      /*** Query the "assert" keyword state */
    48      public boolean isAssertEnabled() { return assertEnabled; }
    49      /*** Enable the "enum" keyword */
    50      public void enableEnum(boolean shouldEnable) { enumEnabled = shouldEnable; }
    51      /*** Query the "enum" keyword state */
    52      public boolean isEnumEnabled() { return enumEnabled; }
    53
    54      /*** Include whitespace tokens.  Note that this breaks the parser.   */
    55      public void setWhitespaceIncluded(boolean z) { whitespaceIncluded = z; }
    56      /*** Are whitespace tokens included? */
    57      public boolean isWhitespaceIncluded() { return whitespaceIncluded; }
    58
    59      {
    60          // Initialization actions performed on construction.
    61          setTabSize(1);  // get rid of special tab interpretation, for IDEs and general clarity
    62      }
    63
    64      /*** Bumped when inside '[x]' or '(x)', reset inside '{x}'.  See ONE_NL.  */
    65      protected int parenLevel = 0;
    66      protected int suppressNewline = 0;  // be really mean to newlines inside strings
    67      protected static final int SCS_TYPE = 3, SCS_VAL = 4, SCS_LIT = 8, SCS_LIMIT = 16;
    68      protected static final int SCS_SQ_TYPE = 0, SCS_TQ_TYPE = 1, SCS_RE_TYPE = 2;
    69      protected int stringCtorState = 0;  // hack string and regexp constructor boundaries
    70      /*** Push parenLevel here and reset whenever inside '{x}'. */
    71      protected ArrayList parenLevelStack = new ArrayList();
    72      protected int lastSigTokenType = EOF;  // last returned non-whitespace token
    73
    74      protected void pushParenLevel() {
    75          parenLevelStack.add(new Integer(parenLevel*SCS_LIMIT + stringCtorState));
    76          parenLevel = 0;
    77          stringCtorState = 0;
    78      }
    79      protected void popParenLevel() {
    80          int npl = parenLevelStack.size();
    81          if (npl == 0)  return;
    82          int i = ((Integer) parenLevelStack.remove(--npl)).intValue();
    83          parenLevel      = i / SCS_LIMIT;
    84          stringCtorState = i % SCS_LIMIT;
    85      }
    86
    87      protected void restartStringCtor(boolean expectLiteral) {
    88          if (stringCtorState != 0) {
    89              stringCtorState = (expectLiteral? SCS_LIT: SCS_VAL) + (stringCtorState & SCS_TYPE);
    90          }
    91      }
    92
    93      protected boolean allowRegexpLiteral() {
    94          return !isExpressionEndingToken(lastSigTokenType);
    95      }
    96
    97      /*** Return true for an operator or punctuation which can end an expression.
    98       *  Return true for keywords, identifiers, and literals.
    99       *  Return true for tokens which can end expressions (right brackets, ++, --).
    100      *  Return false for EOF and all other operator and punctuation tokens.
    101      *  Used to suppress the recognition of /foo/ as opposed to the simple division operator '/'.
    102      */
    103     // Cf. 'constant' and 'balancedBrackets' rules in the grammar.)
    104     protected static boolean isExpressionEndingToken(int ttype) {
    105         switch (ttype) {
    106         case INC:               // x++ / y
    107         case DEC:               // x-- / y
    108         case RPAREN:            // (x) / y
    109         case RBRACK:            // f[x] / y
    110         case RCURLY:            // f{x} / y
    111         case STRING_LITERAL:    // "x" / y
    112         case STRING_CTOR_END:   // "$x" / y
    113         case NUM_INT:           // 0 / y
    114         case NUM_FLOAT:         // 0f / y
    115         case NUM_LONG:          // 0l / y
    116         case NUM_DOUBLE:        // 0.0 / y
    117         case NUM_BIG_INT:       // 0g / y
    118         case NUM_BIG_DECIMAL:   // 0.0g / y
    119         case IDENT:             // x / y
    120         // and a bunch of keywords (all of them; no sense picking and choosing):
    121         case LITERAL_any:
    122         case LITERAL_as:
    123         case LITERAL_assert:
    124         case LITERAL_boolean:
    125         case LITERAL_break:
    126         case LITERAL_byte:
    127         case LITERAL_case:
    128         case LITERAL_catch:
    129         case LITERAL_char:
    130         case LITERAL_class:
    131         case LITERAL_continue:
    132         case LITERAL_def:
    133         case LITERAL_default:
    134         case LITERAL_double:
    135         case LITERAL_else:
    136         case LITERAL_enum:
    137         case LITERAL_extends:
    138         case LITERAL_false:
    139         case LITERAL_finally:
    140         case LITERAL_float:
    141         case LITERAL_for:
    142         case LITERAL_if:
    143         case LITERAL_implements:
    144         case LITERAL_import:
    145         case LITERAL_in:
    146         case LITERAL_instanceof:
    147         case LITERAL_int:
    148         case LITERAL_interface:
    149         case LITERAL_long:
    150         case LITERAL_native:
    151         case LITERAL_new:
    152         case LITERAL_null:
    153         case</strong> LITERAL_package:
    154         case LITERAL_private:
    155         case LITERAL_protected:
    156         case LITERAL_public:
    157         case LITERAL_return:
    158         case LITERAL_short:
    159         case LITERAL_static:
    160         case LITERAL_super:
    161         case LITERAL_switch:
    162         case LITERAL_synchronized:
    163         case LITERAL_this:
    164         case LITERAL_threadsafe:
    165         case LITERAL_throw:
    166         case LITERAL_throws:
    167         case LITERAL_transient:
    168         case LITERAL_true:
    169         case LITERAL_try:
    170         case LITERAL_void:
    171         case LITERAL_volatile:
    172         case LITERAL_while:
    173         case LITERAL_with:
    174             return true;
    175         default:
    176             return false;
    177         }
    178     }
    179
    180     protected void newlineCheck(boolean check) throws RecognitionException {
    181         if (check && suppressNewline > 0) {
    182             require(suppressNewline == 0,
    183                 "end of line reached within a simple string 'x' or \"x\" or /x/",
    184                 "for multi-line literals, use triple quotes '''x''' or \"\"\"x\"\"\"");
    185             suppressNewline = 0;  // shut down any flood of errors
    186         }
    187         newline();
    188     }
    189
    190     protected boolean atValidDollarEscape() throws CharStreamException {
    191         // '$' (('*')? ('{' | LETTER)) =>
    192         int k = 1;
    193         char lc = LA(k++);
    194         if (lc != '$')  return false;
    195         lc = LA(k++);
    196         if (lc == '*')  lc = LA(k++);
    197         return (lc == '{' || (lc != '$' && Character.isJavaIdentifierStart(lc)));
    198     }
    199
    200     /*** This is a bit of plumbing which resumes collection of string constructor bodies,
    201      *  after an embedded expression has been parsed.
    202      *  Usage:  new GroovyRecognizer(new GroovyLexer(in).plumb()).
    203      */
    204     public TokenStream plumb() {
    205         return new TokenStream() {
    206             public Token nextToken() throws TokenStreamException {
    207                 if (stringCtorState >= SCS_LIT) {
    208                     // This goo is modeled upon the ANTLR code for nextToken:
    209                     int quoteType = (stringCtorState & SCS_TYPE);
    210                     stringCtorState = 0;  // get out of this mode, now
    211                     resetText();
    212                     try {
    213                         switch (quoteType) {
    214                         case SCS_SQ_TYPE:
    215                             mSTRING_CTOR_END(true, /*fromStart:*/false, false); break;
    216                         case SCS_TQ_TYPE:
    217                             mSTRING_CTOR_END(true, /*fromStart:*/false, true); break;
    218                         case SCS_RE_TYPE:
    219                             mREGEXP_CTOR_END(true, /*fromStart:*/false); break;
    220                         default:  throw new AssertionError(false);
    221                         }
    222                         lastSigTokenType = _returnToken.getType();
    223                         return _returnToken;
    224                     } catch (RecognitionException e) {
    225                         throw new TokenStreamRecognitionException(e);
    226                     } catch (CharStreamException cse) {
    227                         if ( cse instanceof CharStreamIOException ) {
    228                             throw new TokenStreamIOException(((CharStreamIOException)cse).io);
    229                         }
    230                         else {
    231                             throw new TokenStreamException(cse.getMessage());
    232                         }
    233                     }
    234                 }
    235                 Token token = GroovyLexer.this.nextToken();
    236                 int lasttype = token.getType();
    237                 if (whitespaceIncluded) {
    238                     switch (lasttype) {  // filter out insignificant types
    239                     case WS:
    240                     case ONE_NL:
    241                     case SL_COMMENT:
    242                     case ML_COMMENT:
    243                         lasttype = lastSigTokenType;  // back up!
    244                     }
    245                 }
    246                 lastSigTokenType = lasttype;
    247                 return token;
    248             }
    249         };
    250     }
    251
    252         // stuff to adjust ANTLR's tracing machinery
    253     public static boolean tracing = false;  // only effective if antlr.Tool is run with -traceLexer
    254     public void traceIn(String rname) throws CharStreamException {
    255         if (!GroovyLexer.tracing)  return;
    256         super.traceIn(rname);
    257     }
    258     public void traceOut(String rname) throws CharStreamException {
    259         if (!GroovyLexer.tracing)  return;
    260         if (_returnToken != null)  rname += tokenStringOf(_returnToken);
    261         super.traceOut(rname);
    262     }
    263     private static java.util.HashMap ttypes;
    264     private static String tokenStringOf(Token t) {
    265         if (ttypes == null) {
    266             java.util.HashMap map = new java.util.HashMap();
    267             java.lang.reflect.Field[] fields = GroovyTokenTypes.class.getDeclaredFields();
    268             for (int i = 0; i < fields.length; i++) {
    269                 if (fields[i].getType() != int.class)  continue;
    270                 try {
    271                     map.put(fields[i].get(null), fields[i].getName());
    272                 } catch (IllegalAccessException ee) {
    273                 }
    274             }
    275             ttypes = map;
    276         }
    277         Integer tt = new Integer(t.getType());
    278         Object ttn = ttypes.get(tt);
    279         if (ttn == null)  ttn = "<"+tt+">";
    280         return "["+ttn+",\""+t.getText()+"\"]";
    281     }
    282
    283     protected GroovyRecognizer parser;  // little-used link; TODO: get rid of
    284     private void require(boolean z, String problem, String solution) throws SemanticException {
    285         // TODO: Direct to a common error handler, rather than through the parser.
    286         if (!z)  parser.requireFailed(problem, solution);
    287     }
    288 public GroovyLexer(InputStream in) {
    289 	this(new ByteBuffer(in));
    290 }
    291 public GroovyLexer(Reader in) {
    292 	this(new CharBuffer(in));
    293 }
    294 public GroovyLexer(InputBuffer ib) {
    295 	this(new LexerSharedInputState(ib));
    296 }
    297 public GroovyLexer(LexerSharedInputState state) {
    298 	super(state);
    299 	caseSensitiveLiterals = true;
    300 	setCaseSensitive(true);
    301 	literals = new Hashtable();
    302 	literals.put(new ANTLRHashString("byte", this), new Integer(101));
    303 	literals.put(new ANTLRHashString("public", this), new Integer(112));
    304 	literals.put(new ANTLRHashString("case", this), new Integer(148));
    305 	literals.put(new ANTLRHashString("short", this), new Integer(103));
    306 	literals.put(new ANTLRHashString("break", this), new Integer(142));
    307 	literals.put(new ANTLRHashString("while", this), new Integer(136));
    308 	literals.put(new ANTLRHashString("new", this), new Integer(192));
    309 	literals.put(new ANTLRHashString("instanceof", this), new Integer(178));
    310 	literals.put(new ANTLRHashString("implements", this), new Integer(128));
    311 	literals.put(new ANTLRHashString("synchronized", this), new Integer(117));
    312 	literals.put(new ANTLRHashString("const", this), new Integer(40));
    313 	literals.put(new ANTLRHashString("float", this), new Integer(105));
    314 	literals.put(new ANTLRHashString("package", this), new Integer(78));
    315 	literals.put(new ANTLRHashString("return", this), new Integer(141));
    316 	literals.put(new ANTLRHashString("throw", this), new Integer(144));
    317 	literals.put(new ANTLRHashString("null", this), new Integer(195));
    318 	literals.put(new ANTLRHashString("def", this), new Integer(81));
    319 	literals.put(new ANTLRHashString("threadsafe", this), new Integer(116));
    320 	literals.put(new ANTLRHashString("protected", this), new Integer(113));
    321 	literals.put(new ANTLRHashString("class", this), new Integer(88));
    322 	literals.put(new ANTLRHashString("throws", this), new Integer(127));
    323 	literals.put(new ANTLRHashString("do", this), new Integer(41));
    324 	literals.put(new ANTLRHashString("strictfp", this), new Integer(42));
    325 	literals.put(new ANTLRHashString("super", this), new Integer(93));
    326 	literals.put(new ANTLRHashString("with", this), new Integer(137));
    327 	literals.put(new ANTLRHashString("transient", this), new Integer(114));
    328 	literals.put(new ANTLRHashString("native", this), new Integer(115));
    329 	literals.put(new ANTLRHashString("interface", this), new Integer(89));
    330 	literals.put(new ANTLRHashString("final", this), new Integer(37));
    331 	literals.put(new ANTLRHashString("any", this), new Integer(108));
    332 	literals.put(new ANTLRHashString("if", this), new Integer(134));
    333 	literals.put(new ANTLRHashString("double", this), new Integer(107));
    334 	literals.put(new ANTLRHashString("volatile", this), new Integer(118));
    335 	literals.put(new ANTLRHashString("as", this), new Integer(110));
    336 	literals.put(new ANTLRHashString("assert", this), new Integer(145));
    337 	literals.put(new ANTLRHashString("catch", this), new Integer(151));
    338 	literals.put(new ANTLRHashString("try", this), new Integer(149));
    339 	literals.put(new ANTLRHashString("goto", this), new Integer(39));
    340 	literals.put(new ANTLRHashString("enum", this), new Integer(90));
    341 	literals.put(new ANTLRHashString("int", this), new Integer(104));
    342 	literals.put(new ANTLRHashString("for", this), new Integer(139));
    343 	literals.put(new ANTLRHashString("extends", this), new Integer(92));
    344 	literals.put(new ANTLRHashString("boolean", this), new Integer(100));
    345 	literals.put(new ANTLRHashString("char", this), new Integer(102));
    346 	literals.put(new ANTLRHashString("private", this), new Integer(111));
    347 	literals.put(new ANTLRHashString("default", this), new Integer(126));
    348 	literals.put(new ANTLRHashString("false", this), new Integer(194));
    349 	literals.put(new ANTLRHashString("this", this), new Integer(129));
    350 	literals.put(new ANTLRHashString("static", this), new Integer(80));
    351 	literals.put(new ANTLRHashString("abstract", this), new Integer(38));
    352 	literals.put(new ANTLRHashString("continue", this), new Integer(143));
    353 	literals.put(new ANTLRHashString("finally", this), new Integer(150));
    354 	literals.put(new ANTLRHashString("else", this), new Integer(135));
    355 	literals.put(new ANTLRHashString("import", this), new Integer(79));
    356 	literals.put(new ANTLRHashString("in", this), new Integer(140));
    357 	literals.put(new ANTLRHashString("void", this), new Integer(99));
    358 	literals.put(new ANTLRHashString("switch", this), new Integer(138));
    359 	literals.put(new ANTLRHashString("true", this), new Integer(193));
    360 	literals.put(new ANTLRHashString("long", this), new Integer(106));
    361 }
    362
    363 public Token nextToken() throws TokenStreamException {
    364 	Token theRetToken=null;
    365 tryAgain:
    366 	for (;;) {
    367 		Token _token = null;
    368 		int _ttype = Token.INVALID_TYPE;
    369 		resetText();
    370 		try {   // for char stream error handling
    371 			try {   // for lexical error handling
    372 				switch ( LA(1)) {
    373 				case '(':
    374 				{
    375 					mLPAREN(true);
    376 					theRetToken=_returnToken;
    377 					break;
    378 				}
    379 				case ')':
    380 				{
    381 					mRPAREN(true);
    382 					theRetToken=_returnToken;
    383 					break;
    384 				}
    385 				case '[':
    386 				{
    387 					mLBRACK(true);
    388 					theRetToken=_returnToken;
    389 					break;
    390 				}
    391 				case ']':
    392 				{
    393 					mRBRACK(true);
    394 					theRetToken=_returnToken;
    395 					break;
    396 				}
    397 				case '{':
    398 				{
    399 					mLCURLY(true);
    400 					theRetToken=_returnToken;
    401 					break;
    402 				}
    403 				case '}':
    404 				{
    405 					mRCURLY(true);
    406 					theRetToken=_returnToken;
    407 					break;
    408 				}
    409 				case ':':
    410 				{
    411 					mCOLON(true);
    412 					theRetToken=_returnToken;
    413 					break;
    414 				}
    415 				case ',':
    416 				{
    417 					mCOMMA(true);
    418 					theRetToken=_returnToken;
    419 					break;
    420 				}
    421 				case '~':
    422 				{
    423 					mBNOT(true);
    424 					theRetToken=_returnToken;
    425 					break;
    426 				}
    427 				case ';':
    428 				{
    429 					mSEMI(true);
    430 					theRetToken=_returnToken;
    431 					break;
    432 				}
    433 				case '$':
    434 				{
    435 					mDOLLAR(true);
    436 					theRetToken=_returnToken;
    437 					break;
    438 				}
    439 				case '\t':  case '\u000c':  case ' ':  case '//':
    440 				{
    441 					mWS(true);
    442 					theRetToken=_returnToken;
    443 					break;
    444 				}
    445 				case '\n':  case '\r':
    446 				{
    447 					mNLS(true);
    448 					theRetToken=_returnToken;
    449 					break;
    450 				}
    451 				case '"':  case '\'':
    452 				{
    453 					mSTRING_LITERAL(true);
    454 					theRetToken=_returnToken;
    455 					break;
    456 				}
    457 				case '0':  case '1':  case '2':  case '3':
    458 				case '4':  case '5':  case '6':  case '7':
    459 				case '8':  case '9':
    460 				{
    461 					mNUM_INT(true);
    462 					theRetToken=_returnToken;
    463 					break;
    464 				}
    465 				case '@':
    466 				{
    467 					mAT(true);
    468 					theRetToken=_returnToken;
    469 					break;
    470 				}
    471 				default:
    472 					if ((LA(1)=='>') && (LA(2)=='>') && (LA(3)=='>') && (LA(4)=='=')) {
    473 						mBSR_ASSIGN(true);
    474 						theRetToken=_returnToken;
    475 					}
    476 					else if ((LA(1)=='<') && (LA(2)=='=') && (LA(3)=='>')) {
    477 						mCOMPARE_TO(true);
    478 						theRetToken=_returnToken;
    479 					}
    480 					else if ((LA(1)=='>') && (LA(2)=='>') && (LA(3)=='=')) {
    481 						mSR_ASSIGN(true);
    482 						theRetToken=_returnToken;
    483 					}
    484 					else if ((LA(1)=='>') && (LA(2)=='>') && (LA(3)=='>') && (true)) {
    485 						mBSR(true);
    486 						theRetToken=_returnToken;
    487 					}
    488 					else if ((LA(1)=='<') && (LA(2)=='<') && (LA(3)=='=')) {
    489 						mSL_ASSIGN(true);
    490 						theRetToken=_returnToken;
    491 					}
    492 					else if ((LA(1)=='.') && (LA(2)=='.') && (LA(3)=='<')) {
    493 						mRANGE_EXCLUSIVE(true);
    494 						theRetToken=_returnToken;
    495 					}
    496 					else if ((LA(1)=='.') && (LA(2)=='.') && (LA(3)=='.')) {
    497 						mTRIPLE_DOT(true);
    498 						theRetToken=_returnToken;
    499 					}
    500 					else if ((LA(1)=='=') && (LA(2)=='=') && (LA(3)=='~')) {
    501 						mREGEX_MATCH(true);
    502 						theRetToken=_returnToken;
    503 					}
    504 					else if ((LA(1)=='*') && (LA(2)=='*') && (LA(3)=='=')) {
    505 						mSTAR_STAR_ASSIGN(true);
    506 						theRetToken=_returnToken;
    507 					}
    508 					else if ((LA(1)=='=') && (LA(2)=='=') && (true)) {
    509 						mEQUAL(true);
    510 						theRetToken=_returnToken;
    511 					}
    512 					else if ((LA(1)=='!') && (LA(2)=='=')) {
    513 						mNOT_EQUAL(true);
    514 						theRetToken=_returnToken;
    515 					}
    516 					else if ((LA(1)=='+') && (LA(2)=='=')) {
    517 						mPLUS_ASSIGN(true);
    518 						theRetToken=_returnToken;
    519 					}
    520 					else if ((LA(1)=='+') && (LA(2)=='+')) {
    521 						mINC(true);
    522 						theRetToken=_returnToken;
    523 					}
    524 					else if ((LA(1)=='-') && (LA(2)=='=')) {
    525 						mMINUS_ASSIGN(true);
    526 						theRetToken=_returnToken;
    527 					}
    528 					else if ((LA(1)=='-') && (LA(2)=='-')) {
    529 						mDEC(true);
    530 						theRetToken=_returnToken;
    531 					}
    532 					else if ((LA(1)=='*') && (LA(2)=='=')) {
    533 						mSTAR_ASSIGN(true);
    534 						theRetToken=_returnToken;
    535 					}
    536 					else if ((LA(1)=='%') && (LA(2)=='=')) {
    537 						mMOD_ASSIGN(true);
    538 						theRetToken=_returnToken;
    539 					}
    540 					else if ((LA(1)=='>') && (LA(2)=='>') && (true)) {
    541 						mSR(true);
    542 						theRetToken=_returnToken;
    543 					}
    544 					else if ((LA(1)=='>') && (LA(2)=='=')) {
    545 						mGE(true);
    546 						theRetToken=_returnToken;
    547 					}
    548 					else if ((LA(1)=='<') && (LA(2)=='<') && (true)) {
    549 						mSL(true);
    550 						theRetToken=_returnToken;
    551 					}
    552 					else if ((LA(1)=='<') && (LA(2)=='=') && (true)) {
    553 						mLE(true);
    554 						theRetToken=_returnToken;
    555 					}
    556 					else if ((LA(1)=='^') && (LA(2)=='=')) {
    557 						mBXOR_ASSIGN(true);
    558 						theRetToken=_returnToken;
    559 					}
    560 					else if ((LA(1)=='|') && (LA(2)=='=')) {
    561 						mBOR_ASSIGN(true);
    562 						theRetToken=_returnToken;
    563 					}
    564 					else if ((LA(1)=='|') && (LA(2)=='|')) {
    565 						mLOR(true);
    566 						theRetToken=_returnToken;
    567 					}
    568 					else if ((LA(1)=='&') && (LA(2)=='=')) {
    569 						mBAND_ASSIGN(true);
    570 						theRetToken=_returnToken;
    571 					}
    572 					else if ((LA(1)=='&') && (LA(2)=='&')) {
    573 						mLAND(true);
    574 						theRetToken=_returnToken;
    575 					}
    576 					else if ((LA(1)=='.') && (LA(2)=='.') && (true)) {
    577 						mRANGE_INCLUSIVE(true);
    578 						theRetToken=_returnToken;
    579 					}
    580 					else if ((LA(1)=='*') && (LA(2)=='.')) {
    581 						mSPREAD_DOT(true);
    582 						theRetToken=_returnToken;
    583 					}
    584 					else if ((LA(1)=='?') && (LA(2)=='.')) {
    585 						mOPTIONAL_DOT(true);
    586 						theRetToken=_returnToken;
    587 					}
    588 					else if ((LA(1)=='.') && (LA(2)=='&')) {
    589 						mMEMBER_POINTER(true);
    590 						theRetToken=_returnToken;
    591 					}
    592 					else if ((LA(1)=='=') && (LA(2)=='~')) {
    593 						mREGEX_FIND(true);
    594 						theRetToken=_returnToken;
    595 					}
    596 					else if ((LA(1)=='*') && (LA(2)=='*') && (true)) {
    597 						mSTAR_STAR(true);
    598 						theRetToken=_returnToken;
    599 					}
    600 					else if ((LA(1)=='-') && (LA(2)=='>')) {
    601 						mCLOSABLE_BLOCK_OP(true);
    602 						theRetToken=_returnToken;
    603 					}
    604 					else if ((LA(1)=='/') && (LA(2)=='/')) {
    605 						mSL_COMMENT(true);
    606 						theRetToken=_returnToken;
    607 					}
    608 					else if ((LA(1)=='/') && (LA(2)=='*')) {
    609 						mML_COMMENT(true);
    610 						theRetToken=_returnToken;
    611 					}
    612 					else if ((LA(1)=='?') && (true)) {
    613 						mQUESTION(true);
    614 						theRetToken=_returnToken;
    615 					}
    616 					else if ((LA(1)=='.') && (true)) {
    617 						mDOT(true);
    618 						theRetToken=_returnToken;
    619 					}
    620 					else if ((LA(1)=='=') && (true)) {
    621 						mASSIGN(true);
    622 						theRetToken=_returnToken;
    623 					}
    624 					else if ((LA(1)=='!') && (true)) {
    625 						mLNOT(true);
    626 						theRetToken=_returnToken;
    627 					}
    628 					else if ((LA(1)=='+') && (true)) {
    629 						mPLUS(true);
    630 						theRetToken=_returnToken;
    631 					}
    632 					else if ((LA(1)=='-') && (true)) {
    633 						mMINUS(true);
    634 						theRetToken=_returnToken;
    635 					}
    636 					else if ((LA(1)=='*') && (true)) {
    637 						mSTAR(true);
    638 						theRetToken=_returnToken;
    639 					}
    640 					else if ((LA(1)=='%') && (true)) {
    641 						mMOD(true);
    642 						theRetToken=_returnToken;
    643 					}
    644 					else if ((LA(1)=='>') && (true)) {
    645 						mGT(true);
    646 						theRetToken=_returnToken;
    647 					}
    648 					else if ((LA(1)=='<') && (true)) {
    649 						mLT(true);
    650 						theRetToken=_returnToken;
    651 					}
    652 					else if ((LA(1)=='^') && (true)) {
    653 						mBXOR(true);
    654 						theRetToken=_returnToken;
    655 					}
    656 					else if ((LA(1)=='|') && (true)) {
    657 						mBOR(true);
    658 						theRetToken=_returnToken;
    659 					}
    660 					else if ((LA(1)=='&') && (true)) {
    661 						mBAND(true);
    662 						theRetToken=_returnToken;
    663 					}
    664 					else if (((LA(1)=='#'))&&(getLine() == 1 && getColumn() == 1)) {
    665 						mSH_COMMENT(true);
    666 						theRetToken=_returnToken;
    667 					}
    668 					else if ((LA(1)=='/') && (true)) {
    669 						mREGEXP_LITERAL(true);
    670 						theRetToken=_returnToken;
    671 					}
    672 					else if ((_tokenSet_0.member(LA(1)))) {
    673 						mIDENT(true);
    674 						theRetToken=_returnToken;
    675 					}
    676 				else {
    677 					if (LA(1)==EOF_CHAR) {uponEOF(); _returnToken = makeToken(Token.EOF_TYPE);}
    678 				else {throw new NoViableAltForCharException((char)LA(1), getFilename(), getLine(), getColumn());}
    679 				}
    680 				}
    681 				if ( _returnToken==null ) continue tryAgain; // found SKIP token
    682 				_ttype = _returnToken.getType();
    683 				_returnToken.setType(_ttype);
    684 				return _returnToken;
    685 			}
    686 			catch (RecognitionException e) {
    687 				throw new TokenStreamRecognitionException(e);
    688 			}
    689 		}
    690 		catch (CharStreamException cse) {
    691 			if ( cse instanceof CharStreamIOException ) {
    692 				throw new TokenStreamIOException(((CharStreamIOException)cse).io);
    693 			}
    694 			else {
    695 				throw new TokenStreamException(cse.getMessage());
    696 			}
    697 		}
    698 	}
    699 }
    700
    701 	public final void mQUESTION(boolean _createToken) throws RecognitionException, CharStreamException, TokenStreamException {
    702 		int _ttype; Token _token=null; int _begin=text.length();
    703 		_ttype = QUESTION;
    704 		int _saveIndex;
    705
    706 		match('?');
    707 		if ( _createToken && _token==null && _ttype!=Token.SKIP ) {
    708 			_token = makeToken(_ttype);
    709 			_token.setText(new String(text.getBuffer(), _begin, text.length()-_begin));
    710 		}
    711 		_returnToken = _token;
    712 	}
    713
    714 	public final void mLPAREN(boolean _createToken) throws RecognitionException, CharStreamException, TokenStreamException {
    715 		int _ttype; Token _token=null; int _begin=text.length();
    716 		_ttype = LPAREN;
    717 		int _saveIndex;
    718
    719 		match('(');
    720 		if ( inputState.guessing==0 ) {
    721 			++parenLevel;
    722 		}
    723 		if ( _createToken && _token==null && _ttype!=Token.SKIP ) {
    724 			_token = makeToken(_ttype);
    725 			_token.setText(new String(text.getBuffer(), _begin, text.length()-_begin));
    726 		}
    727 		_returnToken = _token;
    728 	}
    729
    730 	public final void mRPAREN(boolean _createToken) throws RecognitionException, CharStreamException, TokenStreamException {
    731 		int _ttype; Token _token=null; int _begin=text.length();
    732 		_ttype = RPAREN;
    733 		int _saveIndex;
    734
    735 		match(')');
    736 		if ( inputState.guessing==0 ) {
    737 			--parenLevel;
    738 		}
    739 		if ( _createToken && _token==null && _ttype!=Token.SKIP ) {
    740 			_token = makeToken(_ttype);
    741 			_token.setText(new String(text.getBuffer(), _begin, text.length()-_begin));
    742 		}
    743 		_returnToken = _token;
    744 	}
    745
    746 	public final void mLBRACK(boolean _createToken) throws RecognitionException, CharStreamException, TokenStreamException {
    747 		int _ttype; Token _token=null; int _begin=text.length();
    748 		_ttype = LBRACK;
    749 		int _saveIndex;
    750
    751 		match('[');
    752 		if ( inputState.guessing==0 ) {
    753 			++parenLevel;
    754 		}
    755 		if ( _createToken && _token==null && _ttype!=Token.SKIP ) {
    756 			_token = makeToken(_ttype);
    757 			_token.setText(new String(text.getBuffer(), _begin, text.length()-_begin));
    758 		}
    759 		_returnToken = _token;
    760 	}
    761
    762 	public final void mRBRACK(boolean _createToken) throws RecognitionException, CharStreamException, TokenStreamException {
    763 		int _ttype; Token _token=null; int _begin=text.length();
    764 		_ttype = RBRACK;
    765 		int _saveIndex;
    766
    767 		match(']');
    768 		if ( inputState.guessing==0 ) {
    769 			--parenLevel;
    770 		}
    771 		if ( _createToken && _token==null && _ttype!=Token.SKIP ) {
    772 			_token = makeToken(_ttype);
    773 			_token.setText(new String(text.getBuffer(), _begin, text.length()-_begin));
    774 		}
    775 		_returnToken = _token;
    776 	}
    777
    778 	public final void mLCURLY(boolean _createToken) throws RecognitionException, CharStreamException, TokenStreamException {
    779 		int _ttype; Token _token=null; int _begin=text.length();
    780 		_ttype = LCURLY;
    781 		int _saveIndex;
    782
    783 		match('{');
    784 		if ( inputState.guessing==0 ) {
    785 			pushParenLevel();
    786 		}
    787 		if ( _createToken && _token==null && _ttype!=Token.SKIP ) {
    788 			_token = makeToken(_ttype);
    789 			_token.setText(new String(text.getBuffer(), _begin, text.length()-_begin));
    790 		}
    791 		_returnToken = _token;
    792 	}
    793
    794 	public final void mRCURLY(boolean _createToken) throws RecognitionException, CharStreamException, TokenStreamException {
    795 		int _ttype; Token _token=null; int _begin=text.length();
    796 		_ttype = RCURLY;
    797 		int _saveIndex;
    798
    799 		match('}');
    800 		if ( inputState.guessing==0 ) {
    801 			popParenLevel(); if(stringCtorState!=0) restartStringCtor(true);
    802 		}
    803 		if ( _createToken && _token==null && _ttype!=Token.SKIP ) {
    804 			_token = makeToken(_ttype);
    805 			_token.setText(new String(text.getBuffer(), _begin, text.length()-_begin));
    806 		}
    807 		_returnToken = _token;
    808 	}
    809
    810 	public final void mCOLON(boolean _createToken) throws RecognitionException, CharStreamException, TokenStreamException {
    811 		int _ttype; Token _token=null; int _begin=text.length();
    812 		_ttype = COLON;
    813 		int _saveIndex;
    814
    815 		match(':');
    816 		if ( _createToken && _token==null && _ttype!=Token.SKIP ) {
    817 			_token = makeToken(_ttype);
    818 			_token.setText(new String(text.getBuffer(), _begin, text.length()-_begin));
    819 		}
    820 		_returnToken = _token;
    821 	}
    822
    823 	public final void mCOMMA(boolean _createToken) throws RecognitionException, CharStreamException, TokenStreamException {
    824 		int _ttype; Token _token=null; int _begin=text.length();
    825 		_ttype = COMMA;
    826 		int _saveIndex;
    827
    828 		match(',');
    829 		if ( _createToken && _token==null && _ttype!=Token.SKIP ) {
    830 			_token = makeToken(_ttype);
    831 			_token.setText(new String(text.getBuffer(), _begin, text.length()-_begin));
    832 		}
    833 		_returnToken = _token;
    834 	}
    835
    836 	public final void mDOT(boolean _createToken) throws RecognitionException, CharStreamException, TokenStreamException {
    837 		int _ttype; Token _token=null; int _begin=text.length();
    838 		_ttype = DOT;
    839 		int _saveIndex;
    840
    841 		match('.');
    842 		if ( _createToken && _token==null && _ttype!=Token.SKIP ) {
    843 			_token = makeToken(_ttype);
    844 			_token.setText(new String(text.getBuffer(), _begin, text.length()-_begin));
    845 		}
    846 		_returnToken = _token;
    847 	}
    848
    849 	public final void mASSIGN(boolean _createToken) throws RecognitionException, CharStreamException, TokenStreamException {
    850 		int _ttype; Token _token=null; int _begin=text.length();
    851 		_ttype = ASSIGN;
    852 		int _saveIndex;
    853
    854 		match('=');
    855 		if ( _createToken && _token==null && _ttype!=Token.SKIP ) {
    856 			_token = makeToken(_ttype);
    857 			_token.setText(new String(text.getBuffer(), _begin, text.length()-_begin));
    858 		}
    859 		_returnToken = _token;
    860 	}
    861
    862 	public final void mCOMPARE_TO(boolean _createToken) throws RecognitionException, CharStreamException, TokenStreamException {
    863 		int _ttype; Token _token=null; int _begin=text.length();
    864 		_ttype = COMPARE_TO;
    865 		int _saveIndex;
    866
    867 		match("<=>");
    868 		if ( _createToken && _token==null && _ttype!=Token.SKIP ) {
    869 			_token = makeToken(_ttype);
    870 			_token.setText(new String(text.getBuffer(), _begin, text.length()-_begin));
    871 		}
    872 		_returnToken = _token;
    873 	}
    874
    875 	public final void mEQUAL(boolean _createToken) throws RecognitionException, CharStreamException, TokenStreamException {
    876 		int _ttype; Token _token=null; int _begin=text.length();
    877 		_ttype = EQUAL;
    878 		int _saveIndex;
    879
    880 		match("==");
    881 		if ( _createToken && _token==null && _ttype!=Token.SKIP ) {
    882 			_token = makeToken(_ttype);
    883 			_token.setText(new String(text.getBuffer(), _begin, text.length()-_begin));
    884 		}
    885 		_returnToken = _token;
    886 	}
    887
    888 	public final void mLNOT(boolean _createToken) throws RecognitionException, CharStreamException, TokenStreamException {
    889 		int _ttype; Token _token=null; int _begin=text.length();
    890 		_ttype = LNOT;
    891 		int _saveIndex;
    892
    893 		match('!');
    894 		if ( _createToken && _token==null && _ttype!=Token.SKIP ) {
    895 			_token = makeToken(_ttype);
    896 			_token.setText(new String(text.getBuffer(), _begin, text.length()-_begin));
    897 		}
    898 		_returnToken = _token;
    899 	}
    900
    901 	public final void mBNOT(boolean _createToken) throws RecognitionException, CharStreamException, TokenStreamException {
    902 		int _ttype; Token _token=null; int _begin=text.length();
    903 		_ttype = BNOT;
    904 		int _saveIndex;
    905
    906 		match('~');
    907 		if ( _createToken && _token==null && _ttype!=Token.SKIP ) {
    908 			_token = makeToken(_ttype);
    909 			_token.setText(new String(text.getBuffer(), _begin, text.length()-_begin));
    910 		}
    911 		_returnToken = _token;
    912 	}
    913
    914 	public final void mNOT_EQUAL(boolean _createToken) throws RecognitionException, CharStreamException, TokenStreamException {
    915 		int _ttype; Token _token=null; int _begin=text.length();
    916 		_ttype = NOT_EQUAL;
    917 		int _saveIndex;
    918
    919 		match("!=");
    920 		if ( _createToken && _token==null && _ttype!=Token.SKIP ) {
    921 			_token = makeToken(_ttype);
    922 			_token.setText(new String(text.getBuffer(), _begin, text.length()-_begin));
    923 		}
    924 		_returnToken = _token;
    925 	}
    926
    927 	protected final void mDIV(boolean _createToken) throws RecognitionException, CharStreamException, TokenStreamException {
    928 		int _ttype; Token _token=null; int _begin=text.length();
    929 		_ttype = DIV;
    930 		int _saveIndex;
    931
    932 		match('/');
    933 		if ( _createToken && _token==null && _ttype!=Token.SKIP ) {
    934 			_token = makeToken(_ttype);
    935 			_token.setText(new String(text.getBuffer(), _begin, text.length()-_begin));
    936 		}
    937 		_returnToken = _token;
    938 	}
    939
    940 	protected final void mDIV_ASSIGN(boolean _createToken) throws RecognitionException, CharStreamException, TokenStreamException {
    941 		int _ttype; Token _token=null; int _begin=text.length();
    942 		_ttype = DIV_ASSIGN;
    943 		int _saveIndex;
    944
    945 		match("/=");
    946 		if ( _createToken && _token==null && _ttype!=Token.SKIP ) {
    947 			_token = makeToken(_ttype);
    948 			_token.setText(new String(text.getBuffer(), _begin, text.length()-_begin));
    949 		}
    950 		_returnToken = _token;
    951 	}
    952
    953 	public final void mPLUS(boolean _createToken) throws RecognitionException, CharStreamException, TokenStreamException {
    954 		int _ttype; Token _token=null; int _begin=text.length();
    955 		_ttype = PLUS;
    956 		int _saveIndex;
    957
    958 		match('+');
    959 		if ( _createToken && _token==null && _ttype!=Token.SKIP ) {
    960 			_token = makeToken(_ttype);
    961 			_token.setText(new String(text.getBuffer(), _begin, text.length()-_begin));
    962 		}
    963 		_returnToken = _token;
    964 	}
    965
    966 	public final void mPLUS_ASSIGN(boolean _createToken) throws RecognitionException, CharStreamException, TokenStreamException {
    967 		int _ttype; Token _token=null; int _begin=text.length();
    968 		_ttype = PLUS_ASSIGN;
    969 		int _saveIndex;
    970
    971 		match("+=");
    972 		if ( _createToken && _token==null && _ttype!=Token.SKIP ) {
    973 			_token = makeToken(_ttype);
    974 			_token.setText(new String(text.getBuffer(), _begin, text.length()-_begin));
    975 		}
    976 		_returnToken = _token;
    977 	}
    978
    979 	public final void mINC(boolean _createToken) throws RecognitionException, CharStreamException, TokenStreamException {
    980 		int _ttype; Token _token=null; int _begin=text.length();
    981 		_ttype = INC;
    982 		int _saveIndex;
    983
    984 		match("++");
    985 		if ( _createToken && _token==null && _ttype!=Token.SKIP ) {
    986 			_token = makeToken(_ttype);
    987 			_token.setText(new String(text.getBuffer(), _begin, text.length()-_begin));
    988 		}
    989 		_returnToken = _token;
    990 	}
    991
    992 	public final void mMINUS(boolean _createToken) throws RecognitionException, CharStreamException, TokenStreamException {
    993 		int _ttype; Token _token=null; int _begin=text.length();
    994 		_ttype = MINUS;
    995 		int _saveIndex;
    996
    997 		match('-');
    998 		if ( _createToken && _token==null && _ttype!=Token.SKIP ) {
    999 			_token = makeToken(_ttype);
    1000 			_token.setText(new String(text.getBuffer(), _begin, text.length()-_begin));
    1001 		}
    1002 		_returnToken = _token;
    1003 	}
    1004
    1005 	public final void mMINUS_ASSIGN(boolean _createToken) throws RecognitionException, CharStreamException, TokenStreamException {
    1006 		int _ttype; Token _token=null; int _begin=text.length();
    1007 		_ttype = MINUS_ASSIGN;
    1008 		int _saveIndex;
    1009
    1010 		match("-=");
    1011 		if ( _createToken && _token==null && _ttype!=Token.SKIP ) {
    1012 			_token = makeToken(_ttype);
    1013 			_token.setText(new String(text.getBuffer(), _begin, text.length()-_begin));
    1014 		}
    1015 		_returnToken = _token;
    1016 	}
    1017
    1018 	public final void mDEC(boolean _createToken) throws RecognitionException, CharStreamException, TokenStreamException {
    1019 		int _ttype; Token _token=null; int _begin=text.length();
    1020 		_ttype = DEC;
    1021 		int _saveIndex;
    1022
    1023 		match("--");
    1024 		if ( _createToken && _token==null && _ttype!=Token.SKIP ) {
    1025 			_token = makeToken(_ttype);
    1026 			_token.setText(new String(text.getBuffer(), _begin, text.length()-_begin));
    1027 		}
    1028 		_returnToken = _token;
    1029 	}
    1030
    1031 	public final void mSTAR(boolean _createToken) throws RecognitionException, CharStreamException, TokenStreamException {
    1032 		int _ttype; Token _token=null; int _begin=text.length();
    1033 		_ttype = STAR;
    1034 		int _saveIndex;
    1035
    1036 		match('*');
    1037 		if ( _createToken && _token==null && _ttype!=Token.SKIP ) {
    1038 			_token = makeToken(_ttype);
    1039 			_token.setText(new String(text.getBuffer(), _begin, text.length()-_begin));
    1040 		}
    1041 		_returnToken = _token;
    1042 	}
    1043
    1044 	public final void mSTAR_ASSIGN(boolean _createToken) throws RecognitionException, CharStreamException, TokenStreamException {
    1045 		int _ttype; Token _token=null; int _begin=text.length();
    1046 		_ttype = STAR_ASSIGN;
    1047 		int _saveIndex;
    1048
    1049 		match("*=");
    1050 		if ( _createToken && _token==null && _ttype!=Token.SKIP ) {
    1051 			_token = makeToken(_ttype);
    1052 			_token.setText(new String(text.getBuffer(), _begin, text.length()-_begin));
    1053 		}
    1054 		_returnToken = _token;
    1055 	}
    1056
    1057 	public final void mMOD(boolean _createToken) throws RecognitionException, CharStreamException, TokenStreamException {
    1058 		int _ttype; Token _token=null; int _begin=text.length();
    1059 		_ttype = MOD;
    1060 		int _saveIndex;
    1061
    1062 		match('%');
    1063 		if ( _createToken && _token==null && _ttype!=Token.SKIP ) {
    1064 			_token = makeToken(_ttype);
    1065 			_token.setText(new String(text.getBuffer(), _begin, text.length()-_begin));
    1066 		}
    1067 		_returnToken = _token;
    1068 	}
    1069
    1070 	public final void mMOD_ASSIGN(boolean _createToken) throws RecognitionException, CharStreamException, TokenStreamException {
    1071 		int _ttype; Token _token=null; int _begin=text.length();
    1072 		_ttype = MOD_ASSIGN;
    1073 		int _saveIndex;
    1074
    1075 		match("%=");
    1076 		if ( _createToken && _token==null && _ttype!=Token.SKIP ) {
    1077 			_token = makeToken(_ttype);
    1078 			_token.setText(new String(text.getBuffer(), _begin, text.length()-_begin));
    1079 		}
    1080 		_returnToken = _token;
    1081 	}
    1082
    1083 	public final void mSR(boolean _createToken) throws RecognitionException, CharStreamException, TokenStreamException {
    1084 		int _ttype; Token _token=null; int _begin=text.length();
    1085 		_ttype = SR;
    1086 		int _saveIndex;
    1087
    1088 		match(">>");
    1089 		if ( _createToken && _token==null && _ttype!=Token.SKIP ) {
    1090 			_token = makeToken(_ttype);
    1091 			_token.setText(new String(text.getBuffer(), _begin, text.length()-_begin));
    1092 		}
    1093 		_returnToken = _token;
    1094 	}
    1095
    1096 	public final void mSR_ASSIGN(boolean _createToken) throws RecognitionException, CharStreamException, TokenStreamException {
    1097 		int _ttype; Token _token=null; int _begin=text.length();
    1098 		_ttype = SR_ASSIGN;
    1099 		int _saveIndex;
    1100
    1101 		match(">>=");
    1102 		if ( _createToken && _token==null && _ttype!=Token.SKIP ) {
    1103 			_token = makeToken(_ttype);
    1104 			_token.setText(new String(text.getBuffer(), _begin, text.length()-_begin));
    1105 		}
    1106 		_returnToken = _token;
    1107 	}
    1108
    1109 	public final void mBSR(boolean _createToken) throws RecognitionException, CharStreamException, TokenStreamException {
    1110 		int _ttype; Token _token=null; int _begin=text.length();
    1111 		_ttype = BSR;
    1112 		int _saveIndex;
    1113
    1114 		match(">>>");
    1115 		if ( _createToken && _token==null && _ttype!=Token.SKIP ) {
    1116 			_token = makeToken(_ttype);
    1117 			_token.setText(new String(text.getBuffer(), _begin, text.length()-_begin));
    1118 		}
    1119 		_returnToken = _token;
    1120 	}
    1121
    1122 	public final void mBSR_ASSIGN(boolean _createToken) throws RecognitionException, CharStreamException, TokenStreamException {
    1123 		int _ttype; Token _token=null; int _begin=text.length();
    1124 		_ttype = BSR_ASSIGN;
    1125 		int _saveIndex;
    1126
    1127 		match(">>>=");
    1128 		if ( _createToken && _token==null && _ttype!=Token.SKIP ) {
    1129 			_token = makeToken(_ttype);
    1130 			_token.setText(new String(text.getBuffer(), _begin, text.length()-_begin));
    1131 		}
    1132 		_returnToken = _token;
    1133 	}
    1134
    1135 	public final void mGE(boolean _createToken) throws RecognitionException, CharStreamException, TokenStreamException {
    1136 		int _ttype; Token _token=null; int _begin=text.length();
    1137 		_ttype = GE;
    1138 		int _saveIndex;
    1139
    1140 		match(">=");
    1141 		if ( _createToken && _token==null && _ttype!=Token.SKIP ) {
    1142 			_token = makeToken(_ttype);
    1143 			_token.setText(new String(text.getBuffer(), _begin, text.length()-_begin));
    1144 		}
    1145 		_returnToken = _token;
    1146 	}
    1147
    1148 	public final void mGT(boolean _createToken) throws RecognitionException, CharStreamException, TokenStreamException {
    1149 		int _ttype; Token _token=null; int _begin=text.length();
    1150 		_ttype = GT;
    1151 		int _saveIndex;
    1152
    1153 		match(">");
    1154 		if ( _createToken && _token==null && _ttype!=Token.SKIP ) {
    1155 			_token = makeToken(_ttype);
    1156 			_token.setText(new String(text.getBuffer(), _begin, text.length()-_begin));
    1157 		}
    1158 		_returnToken = _token;
    1159 	}
    1160
    1161 	public final void mSL(boolean _createToken) throws RecognitionException, CharStreamException, TokenStreamException {
    1162 		int _ttype; Token _token=null; int _begin=text.length();
    1163 		_ttype = SL;
    1164 		int _saveIndex;
    1165
    1166 		match("<<");
    1167 		if ( _createToken && _token==null && _ttype!=Token.SKIP ) {
    1168 			_token = makeToken(_ttype);
    1169 			_token.setText(new String(text.getBuffer(), _begin, text.length()-_begin));
    1170 		}
    1171 		_returnToken = _token;
    1172 	}
    1173
    1174 	public final void mSL_ASSIGN(boolean _createToken) throws RecognitionException, CharStreamException, TokenStreamException {
    1175 		int _ttype; Token _token=null; int _begin=text.length();
    1176 		_ttype = SL_ASSIGN;
    1177 		int _saveIndex;
    1178
    1179 		match("<<=");
    1180 		if ( _createToken && _token==null && _ttype!=Token.SKIP ) {
    1181 			_token = makeToken(_ttype);
    1182 			_token.setText(new String(text.getBuffer(), _begin, text.length()-_begin));
    1183 		}
    1184 		_returnToken = _token;
    1185 	}
    1186
    1187 	public final void mLE(boolean _createToken) throws RecognitionException, CharStreamException, TokenStreamException {
    1188 		int _ttype; Token _token=null; int _begin=text.length();
    1189 		_ttype = LE;
    1190 		int _saveIndex;
    1191
    1192 		match("<=");
    1193 		if ( _createToken && _token==null && _ttype!=Token.SKIP ) {
    1194 			_token = makeToken(_ttype);
    1195 			_token.setText(new String(text.getBuffer(), _begin, text.length()-_begin));
    1196 		}
    1197 		_returnToken = _token;
    1198 	}
    1199
    1200 	public final void mLT(boolean _createToken) throws RecognitionException, CharStreamException, TokenStreamException {
    1201 		int _ttype; Token _token=null; int _begin=text.length();
    1202 		_ttype = LT;
    1203 		int _saveIndex;
    1204
    1205 		match('<');
    1206 		if ( _createToken && _token==null && _ttype!=Token.SKIP ) {
    1207 			_token = makeToken(_ttype);
    1208 			_token.setText(new String(text.getBuffer(), _begin, text.length()-_begin));
    1209 		}
    1210 		_returnToken = _token;
    1211 	}
    1212
    1213 	public final void mBXOR(boolean _createToken) throws RecognitionException, CharStreamException, TokenStreamException {
    1214 		int _ttype; Token _token=null; int _begin=text.length();
    1215 		_ttype = BXOR;
    1216 		int _saveIndex;
    1217
    1218 		match('^');
    1219 		if ( _createToken && _token==null && _ttype!=Token.SKIP ) {
    1220 			_token = makeToken(_ttype);
    1221 			_token.setText(new String(text.getBuffer(), _begin, text.length()-_begin));
    1222 		}
    1223 		_returnToken = _token;
    1224 	}
    1225
    1226 	public final void mBXOR_ASSIGN(boolean _createToken) throws RecognitionException, CharStreamException, TokenStreamException {
    1227 		int _ttype; Token _token=null; int _begin=text.length();
    1228 		_ttype = BXOR_ASSIGN;
    1229 		int _saveIndex;
    1230
    1231 		match("^=");
    1232 		if ( _createToken && _token==null && _ttype!=Token.SKIP ) {
    1233 			_token = makeToken(_ttype);
    1234 			_token.setText(new String(text.getBuffer(), _begin, text.length()-_begin));
    1235 		}
    1236 		_returnToken = _token;
    1237 	}
    1238
    1239 	public final void mBOR(boolean _createToken) throws RecognitionException, CharStreamException, TokenStreamException {
    1240 		int _ttype; Token _token=null; int _begin=text.length();
    1241 		_ttype = BOR;
    1242 		int _saveIndex;
    1243
    1244 		match('|');
    1245 		if ( _createToken && _token==null && _ttype!=Token.SKIP ) {
    1246 			_token = makeToken(_ttype);
    1247 			_token.setText(new String(text.getBuffer(), _begin, text.length()-_begin));
    1248 		}
    1249 		_returnToken = _token;
    1250 	}
    1251
    1252 	public final void mBOR_ASSIGN(boolean _createToken) throws RecognitionException, CharStreamException, TokenStreamException {
    1253 		int _ttype; Token _token=null; int _begin=text.length();
    1254 		_ttype = BOR_ASSIGN;
    1255 		int _saveIndex;
    1256
    1257 		match("|=");
    1258 		if ( _createToken && _token==null && _ttype!=Token.SKIP ) {
    1259 			_token = makeToken(_ttype);
    1260 			_token.setText(new String(text.getBuffer(), _begin, text.length()-_begin));
    1261 		}
    1262 		_returnToken = _token;
    1263 	}
    1264
    1265 	public final void mLOR(boolean _createToken) throws RecognitionException, CharStreamException, TokenStreamException {
    1266 		int _ttype; Token _token=null; int _begin=text.length();
    1267 		_ttype = LOR;
    1268 		int _saveIndex;
    1269
    1270 		match("||");
    1271 		if ( _createToken && _token==null && _ttype!=Token.SKIP ) {
    1272 			_token = makeToken(_ttype);
    1273 			_token.setText(new String(text.getBuffer(), _begin, text.length()-_begin));
    1274 		}
    1275 		_returnToken = _token;
    1276 	}
    1277
    1278 	public final void mBAND(boolean _createToken) throws RecognitionException, CharStreamException, TokenStreamException {
    1279 		int _ttype; Token _token=null; int _begin=text.length();
    1280 		_ttype = BAND;
    1281 		int _saveIndex;
    1282
    1283 		match('&');
    1284 		if ( _createToken && _token==null && _ttype!=Token.SKIP ) {
    1285 			_token = makeToken(_ttype);
    1286 			_token.setText(new String(text.getBuffer(), _begin, text.length()-_begin));
    1287 		}
    1288 		_returnToken = _token;
    1289 	}
    1290
    1291 	public final void mBAND_ASSIGN(boolean _createToken) throws RecognitionException, CharStreamException, TokenStreamException {
    1292 		int _ttype; Token _token=null; int _begin=text.length();
    1293 		_ttype = BAND_ASSIGN;
    1294 		int _saveIndex;
    1295
    1296 		match("&=");
    1297 		if ( _createToken && _token==null && _ttype!=Token.SKIP ) {
    1298 			_token = makeToken(_ttype);
    1299 			_token.setText(new String(text.getBuffer(), _begin, text.length()-_begin));
    1300 		}
    1301 		_returnToken = _token;
    1302 	}
    1303
    1304 	public final void mLAND(boolean _createToken) throws RecognitionException, CharStreamException, TokenStreamException {
    1305 		int _ttype; Token _token=null; int _begin=text.length();
    1306 		_ttype = LAND;
    1307 		int _saveIndex;
    1308
    1309 		match("&&");
    1310 		if ( _createToken && _token==null && _ttype!=Token.SKIP ) {
    1311 			_token = makeToken(_ttype);
    1312 			_token.setText(new String(text.getBuffer(), _begin, text.length()-_begin));
    1313 		}
    1314 		_returnToken = _token;
    1315 	}
    1316
    1317 	public final void mSEMI(boolean _createToken) throws RecognitionException, CharStreamException, TokenStreamException {
    1318 		int _ttype; Token _token=null; int _begin=text.length();
    1319 		_ttype = SEMI;
    1320 		int _saveIndex;
    1321
    1322 		match(';');
    1323 		if ( _createToken && _token==null && _ttype!=Token.SKIP ) {
    1324 			_token = makeToken(_ttype);
    1325 			_token.setText(new String(text.getBuffer(), _begin, text.length()-_begin));
    1326 		}
    1327 		_returnToken = _token;
    1328 	}
    1329
    1330 	public final void mDOLLAR(boolean _createToken) throws RecognitionException, CharStreamException, TokenStreamException {
    1331 		int _ttype; Token _token=null; int _begin=text.length();
    1332 		_ttype = DOLLAR;
    1333 		int _saveIndex;
    1334
    1335 		match('$');
    1336 		if ( _createToken && _token==null && _ttype!=Token.SKIP ) {
    1337 			_token = makeToken(_ttype);
    1338 			_token.setText(new String(text.getBuffer(), _begin, text.length()-_begin));
    1339 		}
    1340 		_returnToken = _token;
    1341 	}
    1342
    1343 	public final void mRANGE_INCLUSIVE(boolean _createToken) throws RecognitionException, CharStreamException, TokenStreamException {
    1344 		int _ttype; Token _token=null; int _begin=text.length();
    1345 		_ttype = RANGE_INCLUSIVE;
    1346 		int _saveIndex;
    1347
    1348 		match("..");
    1349 		if ( _createToken && _token==null && _ttype!=Token.SKIP ) {
    1350 			_token = makeToken(_ttype);
    1351 			_token.setText(new String(text.getBuffer(), _begin, text.length()-_begin));
    1352 		}
    1353 		_returnToken = _token;
    1354 	}
    1355
    1356 	public final void mRANGE_EXCLUSIVE(boolean _createToken) throws RecognitionException, CharStreamException, TokenStreamException {
    1357 		int _ttype; Token _token=null; int _begin=text.length();
    1358 		_ttype = RANGE_EXCLUSIVE;
    1359 		int _saveIndex;
    1360
    1361 		match("..<");
    1362 		if ( _createToken && _token==null && _ttype!=Token.SKIP ) {
    1363 			_token = makeToken(_ttype);
    1364 			_token.setText(new String(text.getBuffer(), _begin, text.length()-_begin));
    1365 		}
    1366 		_returnToken = _token;
    1367 	}
    1368
    1369 	public final void mTRIPLE_DOT(boolean _createToken) throws RecognitionException, CharStreamException, TokenStreamException {
    1370 		int _ttype; Token _token=null; int _begin=text.length();
    1371 		_ttype = TRIPLE_DOT;
    1372 		int _saveIndex;
    1373
    1374 		match("...");
    1375 		if ( _createToken && _token==null && _ttype!=Token.SKIP ) {
    1376 			_token = makeToken(_ttype);
    1377 			_token.setText(new String(text.getBuffer(), _begin, text.length()-_begin));
    1378 		}
    1379 		_returnToken = _token;
    1380 	}
    1381
    1382 	public final void mSPREAD_DOT(boolean _createToken) throws RecognitionException, CharStreamException, TokenStreamException {
    1383 		int _ttype; Token _token=null; int _begin=text.length();
    1384 		_ttype = SPREAD_DOT;
    1385 		int _saveIndex;
    1386
    1387 		match("*.");
    1388 		if ( _createToken && _token==null && _ttype!=Token.SKIP ) {
    1389 			_token = makeToken(_ttype);
    1390 			_token.setText(new String(text.getBuffer(), _begin, text.length()-_begin));
    1391 		}
    1392 		_returnToken = _token;
    1393 	}
    1394
    1395 	public final void mOPTIONAL_DOT(boolean _createToken) throws RecognitionException, CharStreamException, TokenStreamException {
    1396 		int _ttype; Token _token=null; int _begin=text.length();
    1397 		_ttype = OPTIONAL_DOT;
    1398 		int _saveIndex;
    1399
    1400 		match("?.");
    1401 		if ( _createToken && _token==null && _ttype!=Token.SKIP ) {
    1402 			_token = makeToken(_ttype);
    1403 			_token.setText(new String(text.getBuffer(), _begin, text.length()-_begin));
    1404 		}
    1405 		_returnToken = _token;
    1406 	}
    1407
    1408 	public final void mMEMBER_POINTER(boolean _createToken) throws RecognitionException, CharStreamException, TokenStreamException {
    1409 		int _ttype; Token _token=null; int _begin=text.length();
    1410 		_ttype = MEMBER_POINTER;
    1411 		int _saveIndex;
    1412
    1413 		match(".&");
    1414 		if ( _createToken && _token==null && _ttype!=Token.SKIP ) {
    1415 			_token = makeToken(_ttype);
    1416 			_token.setText(new String(text.getBuffer(), _begin, text.length()-_begin));
    1417 		}
    1418 		_returnToken = _token;
    1419 	}
    1420
    1421 	public final void mREGEX_FIND(boolean _createToken) throws RecognitionException, CharStreamException, TokenStreamException {
    1422 		int _ttype; Token _token=null; int _begin=text.length();
    1423 		_ttype = REGEX_FIND;
    1424 		int _saveIndex;
    1425
    1426 		match("=~");
    1427 		if ( _createToken && _token==null && _ttype!=Token.SKIP ) {
    1428 			_token = makeToken(_ttype);
    1429 			_token.setText(new String(text.getBuffer(), _begin, text.length()-_begin));
    1430 		}
    1431 		_returnToken = _token;
    1432 	}
    1433
    1434 	public final void mREGEX_MATCH(boolean _createToken) throws RecognitionException, CharStreamException, TokenStreamException {
    1435 		int _ttype; Token _token=null; int _begin=text.length();
    1436 		_ttype = REGEX_MATCH;
    1437 		int _saveIndex;
    1438
    1439 		match("==~");
    1440 		if ( _createToken && _token==null && _ttype!=Token.SKIP ) {
    1441 			_token = makeToken(_ttype);
    1442 			_token.setText(new String(text.getBuffer(), _begin, text.length()-_begin));
    1443 		}
    1444 		_returnToken = _token;
    1445 	}
    1446
    1447 	public final void mSTAR_STAR(boolean _createToken) throws RecognitionException, CharStreamException, TokenStreamException {
    1448 		int _ttype; Token _token=null; int _begin=text.length();
    1449 		_ttype = STAR_STAR;
    1450 		int _saveIndex;
    1451
    1452 		match("**");
    1453 		if ( _createToken && _token==null && _ttype!=Token.SKIP ) {
    1454 			_token = makeToken(_ttype);
    1455 			_token.setText(new String(text.getBuffer(), _begin, text.length()-_begin));
    1456 		}
    1457 		_returnToken = _token;
    1458 	}
    1459
    1460 	public final void mSTAR_STAR_ASSIGN(boolean _createToken) throws RecognitionException, CharStreamException, TokenStreamException {
    1461 		int _ttype; Token _token=null; int _begin=text.length();
    1462 		_ttype = STAR_STAR_ASSIGN;
    1463 		int _saveIndex;
    1464
    1465 		match("**=");
    1466 		if ( _createToken && _token==null && _ttype!=Token.SKIP ) {
    1467 			_token = makeToken(_ttype);
    1468 			_token.setText(new String(text.getBuffer(), _begin, text.length()-_begin));
    1469 		}
    1470 		_returnToken = _token;
    1471 	}
    1472
    1473 	public final void mCLOSABLE_BLOCK_OP(boolean _createToken) throws RecognitionException, CharStreamException, TokenStreamException {
    1474 		int _ttype; Token _token=null; int _begin=text.length();
    1475 		_ttype = CLOSABLE_BLOCK_OP;
    1476 		int _saveIndex;
    1477
    1478 		match("->");
    1479 		if ( _createToken && _token==null && _ttype!=Token.SKIP ) {
    1480 			_token = makeToken(_ttype);
    1481 			_token.setText(new String(text.getBuffer(), _begin, text.length()-_begin));
    1482 		}
    1483 		_returnToken = _token;
    1484 	}
    1485
    1486 	public final void mWS(boolean _createToken) throws RecognitionException, CharStreamException, TokenStreamException {
    1487 		int _ttype; Token _token=null; int _begin=text.length();
    1488 		_ttype = WS;
    1489 		int _saveIndex;
    1490
    1491 		{
    1492 		int _cnt547=0;
    1493 		_loop547:
    1494 		do {
    1495 			if ((LA(1)=='//') && (LA(2)=='\n'||LA(2)=='\r') && (true) && (true)) {
    1496 				match('//');
    1497 				mONE_NL(false,false);
    1498 			}
    1499 			else if ((LA(1)==' ') && (true) && (true) && (true)) {
    1500 				match(' ');
    1501 			}
    1502 			else if ((LA(1)=='\t') && (true) && (true) && (true)) {
    1503 				match('\t');
    1504 			}
    1505 			else if ((LA(1)=='\u000c') && (true) && (true) && (true)) {
    1506 				match('\f');
    1507 			}
    1508 			else {
    1509 				if ( _cnt547>=1 ) { break _loop547; } else {throw new NoViableAltForCharException((char)LA(1), getFilename(), getLine(), getColumn());}
    1510 			}
    1511
    1512 			_cnt547++;
    1513 		} while (true);
    1514 		}
    1515 		if ( inputState.guessing==0 ) {
    1516 			if (!whitespaceIncluded)  _ttype = Token.SKIP;
    1517 		}
    1518 		if ( _createToken && _token==null && _ttype!=Token.SKIP ) {
    1519 			_token = makeToken(_ttype);
    1520 			_token.setText(new String(text.getBuffer(), _begin, text.length()-_begin));
    1521 		}
    1522 		_returnToken = _token;
    1523 	}
    1524
    1525 	protected final void mONE_NL(boolean _createToken,
    1526 		boolean check
    1527 	) throws RecognitionException, CharStreamException, TokenStreamException {
    1528 		int _ttype; Token _token=null; int _begin=text.length();
    1529 		_ttype = ONE_NL;
    1530 		int _saveIndex;
    1531
    1532 		{
    1533 		if ((LA(1)=='\r') && (LA(2)=='\n') && (true) && (true)) {
    1534 			_saveIndex=text.length();
    1535 			match("\r\n");
    1536 			text.setLength(_saveIndex);
    1537 		}
    1538 		else if ((LA(1)=='\r') && (true) && (true) && (true)) {
    1539 			_saveIndex=text.length();
    1540 			match('\r');
    1541 			text.setLength(_saveIndex);
    1542 		}
    1543 		else if ((LA(1)=='\n')) {
    1544 			_saveIndex=text.length();
    1545 			match('\n');
    1546 			text.setLength(_saveIndex);
    1547 		}
    1548 		else {
    1549 			throw new NoViableAltForCharException((char)LA(1), getFilename(), getLine(), getColumn());
    1550 		}
    1551
    1552 		}
    1553 		if ( inputState.guessing==0 ) {
    1554
    1555 			// update current line number for error reporting
    1556 			newlineCheck(check);
    1557
    1558 		}
    1559 		if ( _createToken && _token==null && _ttype!=Token.SKIP ) {
    1560 			_token = makeToken(_ttype);
    1561 			_token.setText(new String(text.getBuffer(), _begin, text.length()-_begin));
    1562 		}
    1563 		_returnToken = _token;
    1564 	}
    1565
    1566 	public final void mNLS(boolean _createToken) throws RecognitionException, CharStreamException, TokenStreamException {
    1567 		int _ttype; Token _token=null; int _begin=text.length();
    1568 		_ttype = NLS;
    1569 		int _saveIndex;
    1570
    1571 		mONE_NL(false,true);
    1572 		{
    1573 		if (((LA(1)=='\t'||LA(1)=='\n'||LA(1)=='\u000c'||LA(1)=='\r'||LA(1)==' '||LA(1)=='/'||LA(1)=='//'))&&(!whitespaceIncluded)) {
    1574 			{
    1575 			int _cnt553=0;
    1576 			_loop553:
    1577 			do {
    1578 				switch ( LA(1)) {
    1579 				case '\n':  case '\r':
    1580 				{
    1581 					mONE_NL(false,true);
    1582 					break;
    1583 				}
    1584 				case '\t':  case '\u000c':  case ' ':  case '//':
    1585 				{
    1586 					mWS(false);
    1587 					break;
    1588 				}
    1589 				default:
    1590 					if ((LA(1)=='/') && (LA(2)=='/')) {
    1591 						mSL_COMMENT(false);
    1592 					}
    1593 					else if ((LA(1)=='/') && (LA(2)=='*')) {
    1594 						mML_COMMENT(false);
    1595 					}
    1596 				else {
    1597 					if ( _cnt553>=1 ) { break _loop553; } else {throw new NoViableAltForCharException((char)LA(1), getFilename(), getLine(), getColumn());}
    1598 				}
    1599 				}
    1600 				_cnt553++;
    1601 			} while (true);
    1602 			}
    1603 		}
    1604 		else {
    1605 		}
    1606
    1607 		}
    1608 		if ( inputState.guessing==0 ) {
    1609 			if (whitespaceIncluded) {
    1610 			// keep the token as-is
    1611 			} else if (parenLevel != 0) {
    1612 			// when directly inside parens, all newlines are ignored here
    1613 			_ttype = Token.SKIP;
    1614 			} else {
    1615 			// inside {...}, newlines must be explicitly matched as 'nls!'
    1616 			text.setLength(_begin); text.append("<newline>");
    1617 			}
    1618
    1619 		}
    1620 		if ( _createToken && _token==null && _ttype!=Token.SKIP ) {
    1621 			_token = makeToken(_ttype);
    1622 			_token.setText(new String(text.getBuffer(), _begin, text.length()-_begin));
    1623 		}
    1624 		_returnToken = _token;
    1625 	}
    1626
    1627 	public final void mSL_COMMENT(boolean _createToken) throws RecognitionException, CharStreamException, TokenStreamException {
    1628 		int _ttype; Token _token=null; int _begin=text.length();
    1629 		_ttype = SL_COMMENT;
    1630 		int _saveIndex;
    1631
    1632 		match("//");
    1633 		{
    1634 		_loop557:
    1635 		do {
    1636 			if ((_tokenSet_1.member(LA(1))) && (true) && (true) && (true)) {
    1637 				{
    1638 				match(_tokenSet_1);
    1639 				}
    1640 			}
    1641 			else {
    1642 				break _loop557;
    1643 			}
    1644
    1645 		} while (true);
    1646 		}
    1647 		if ( inputState.guessing==0 ) {
    1648 			if (!whitespaceIncluded)  _ttype = Token.SKIP;
    1649 		}
    1650 		if ( _createToken && _token==null && _ttype!=Token.SKIP ) {
    1651 			_token = makeToken(_ttype);
    1652 			_token.setText(new String(text.getBuffer(), _begin, text.length()-_begin));
    1653 		}
    1654 		_returnToken = _token;
    1655 	}
    1656
    1657 	public final void mML_COMMENT(boolean _createToken) throws RecognitionException, CharStreamException, TokenStreamException {
    1658 		int _ttype; Token _token=null; int _begin=text.length();
    1659 		_ttype = ML_COMMENT;
    1660 		int _saveIndex;
    1661
    1662 		match("/*");
    1663 		{
    1664 		_loop567:
    1665 		do {
    1666 			boolean synPredMatched565 = false;
    1667 			if (((LA(1)=='*') && ((LA(2) >= '\u0003' && LA(2) <= '\ufffe')) && ((LA(3) >= '\u0003' && LA(3) <= '\ufffe')) && (true))) {
    1668 				int _m565 = mark();
    1669 				synPredMatched565 = true;
    1670 				inputState.guessing++;
    1671 				try {
    1672 					{
    1673 					match('*');
    1674 					matchNot('/');
    1675 					}
    1676 				}
    1677 				catch (RecognitionException pe) {
    1678 					synPredMatched565 = false;
    1679 				}
    1680 				rewind(_m565);
    1681 				inputState.guessing--;
    1682 			}
    1683 			if ( synPredMatched565 ) {
    1684 				match('*');
    1685 			}
    1686 			else if ((LA(1)=='\n'||LA(1)=='\r')) {
    1687 				mONE_NL(false,true);
    1688 			}
    1689 			else if ((_tokenSet_2.member(LA(1)))) {
    1690 				{
    1691 				match(_tokenSet_2);
    1692 				}
    1693 			}
    1694 			else {
    1695 				break _loop567;
    1696 			}
    1697
    1698 		} while (true);
    1699 		}
    1700 		match("*/");
    1701 		if ( inputState.guessing==0 ) {
    1702 			if (!whitespaceIncluded)  _ttype = Token.SKIP;
    1703 		}
    1704 		if ( _createToken && _token==null && _ttype!=Token.SKIP ) {
    1705 			_token = makeToken(_ttype);
    1706 			_token.setText(new String(text.getBuffer(), _begin, text.length()-_begin));
    1707 		}
    1708 		_returnToken = _token;
    1709 	}
    1710
    1711 	public final void mSH_COMMENT(boolean _createToken) throws RecognitionException, CharStreamException, TokenStreamException {
    1712 		int _ttype; Token _token=null; int _begin=text.length();
    1713 		_ttype = SH_COMMENT;
    1714 		int _saveIndex;
    1715
    1716 		if (!(getLine() == 1 && getColumn() == 1))
    1717 		  throw new SemanticException("getLine() == 1 && getColumn() == 1");
    1718 		match("#!");
    1719 		{
    1720 		_loop561:
    1721 		do {
    1722 			if ((_tokenSet_1.member(LA(1)))) {
    1723 				{
    1724 				match(_tokenSet_1);
    1725 				}
    1726 			}
    1727 			else {
    1728 				break _loop561;
    1729 			}
    1730
    1731 		} while (true);
    1732 		}
    1733 		if ( inputState.guessing==0 ) {
    1734 			if (!whitespaceIncluded)  _ttype = Token.SKIP;
    1735 		}
    1736 		if ( _createToken && _token==null && _ttype!=Token.SKIP ) {
    1737 			_token = makeToken(_ttype);
    1738 			_token.setText(new String(text.getBuffer(), _begin, text.length()-_begin));
    1739 		}
    1740 		_returnToken = _token;
    1741 	}
    1742
    1743 	public final void mSTRING_LITERAL(boolean _createToken) throws RecognitionException, CharStreamException, TokenStreamException {
    1744 		int _ttype; Token _token=null; int _begin=text.length();
    1745 		_ttype = STRING_LITERAL;
    1746 		int _saveIndex;
    1747 		int tt=0;
    1748
    1749 		boolean synPredMatched570 = false;
    1750 		if (((LA(1)=='\'') && (LA(2)=='\'') && (LA(3)=='\'') && ((LA(4) >= '\u0003' && LA(4) <= '\ufffe')))) {
    1751 			int _m570 = mark();
    1752 			synPredMatched570 = true;
    1753 			inputState.guessing++;
    1754 			try {
    1755 				{
    1756 				match("'''");
    1757 				}
    1758 			}
    1759 			catch (RecognitionException pe) {
    1760 				synPredMatched570 = false;
    1761 			}
    1762 			rewind(_m570);
    1763 			inputState.guessing--;
    1764 		}
    1765 		if ( synPredMatched570 ) {
    1766 			_saveIndex=text.length();
    1767 			match("'''");
    1768 			text.setLength(_saveIndex);
    1769 			{
    1770 			_loop575:
    1771 			do {
    1772 				switch ( LA(1)) {
    1773 				case '//':
    1774 				{
    1775 					mESC(false);
    1776 					break;
    1777 				}
    1778 				case '"':
    1779 				{
    1780 					match('"');
    1781 					break;
    1782 				}
    1783 				case '$':
    1784 				{
    1785 					match('$');
    1786 					break;
    1787 				}
    1788 				case '\n':  case '\r':
    1789 				{
    1790 					mSTRING_NL(false,true);
    1791 					break;
    1792 				}
    1793 				default:
    1794 					boolean synPredMatched574 = false;
    1795 					if (((LA(1)=='\'') && ((LA(2) >= '\u0003' && LA(2) <= '\ufffe')) && ((LA(3) >= '\u0003' && LA(3) <= '\ufffe')) && ((LA(4) >= '\u0003' && LA(4) <= '\ufffe')))) {
    1796 						int _m574 = mark();
    1797 						synPredMatched574 = true;
    1798 						inputState.guessing++;
    1799 						try {
    1800 							{
    1801 							match('\'');
    1802 							{
    1803 							if ((_tokenSet_3.member(LA(1)))) {
    1804 								matchNot('\'');
    1805 							}
    1806 							else if ((LA(1)=='\'')) {
    1807 								match('\'');
    1808 								matchNot('\'');
    1809 							}
    1810 							else {
    1811 								throw new NoViableAltForCharException((char)LA(1), getFilename(), getLine(), getColumn());
    1812 							}
    1813
    1814 							}
    1815 							}
    1816 						}
    1817 						catch (RecognitionException pe) {
    1818 							synPredMatched574 = false;
    1819 						}
    1820 						rewind(_m574);
    1821 						inputState.guessing--;
    1822 					}
    1823 					if ( synPredMatched574 ) {
    1824 						match('\'');
    1825 					}
    1826 					else if ((_tokenSet_4.member(LA(1)))) {
    1827 						mSTRING_CH(false);
    1828 					}
    1829 				else {
    1830 					break _loop575;
    1831 				}
    1832 				}
    1833 			} while (true);
    1834 			}
    1835 			_saveIndex=text.length();
    1836 			match("'''");
    1837 			text.setLength(_saveIndex);
    1838 		}
    1839 		else {
    1840 			boolean synPredMatched579 = false;
    1841 			if (((LA(1)=='"') && (LA(2)=='"') && (LA(3)=='"') && ((LA(4) >= '\u0003' && LA(4) <= '\ufffe')))) {
    1842 				int _m579 = mark();
    1843 				synPredMatched579 = true;
    1844 				inputState.guessing++;
    1845 				try {
    1846 					{
    1847 					match("\"\"\"");
    1848 					}
    1849 				}
    1850 				catch (RecognitionException pe) {
    1851 					synPredMatched579 = false;
    1852 				}
    1853 				rewind(_m579);
    1854 				inputState.guessing--;
    1855 			}
    1856 			if ( synPredMatched579 ) {
    1857 				_saveIndex=text.length();
    1858 				match("\"\"\"");
    1859 				text.setLength(_saveIndex);
    1860 				tt=mSTRING_CTOR_END(false,true, /*tripleQuote:*/ true);
    1861 				if ( inputState.guessing==0 ) {
    1862 					_ttype = tt;
    1863 				}
    1864 			}
    1865 			else if ((LA(1)=='\'') && (_tokenSet_1.member(LA(2))) && (true) && (true)) {
    1866 				_saveIndex=text.length();
    1867 				match('\'');
    1868 				text.setLength(_saveIndex);
    1869 				if ( inputState.guessing==0 ) {
    1870 					++suppressNewline;
    1871 				}
    1872 				{
    1873 				_loop577:
    1874 				do {
    1875 					switch ( LA(1)) {
    1876 					case '//':
    1877 					{
    1878 						mESC(false);
    1879 						break;
    1880 					}
    1881 					case '"':
    1882 					{
    1883 						match('"');
    1884 						break;
    1885 					}
    1886 					case '$':
    1887 					{
    1888 						match('$');
    1889 						break;
    1890 					}
    1891 					default:
    1892 						if ((_tokenSet_4.member(LA(1)))) {
    1893 							mSTRING_CH(false);
    1894 						}
    1895 					else {
    1896 						break _loop577;
    1897 					}
    1898 					}
    1899 				} while (true);
    1900 				}
    1901 				if ( inputState.guessing==0 ) {
    1902 					--suppressNewline;
    1903 				}
    1904 				_saveIndex=text.length();
    1905 				match('\'');
    1906 				text.setLength(_saveIndex);
    1907 			}
    1908 			else if ((LA(1)=='"') && ((LA(2) >= '\u0003' && LA(2) <= '\ufffe')) && (true) && (true)) {
    1909 				_saveIndex=text.length();
    1910 				match('"');
    1911 				text.setLength(_saveIndex);
    1912 				if ( inputState.guessing==0 ) {
    1913 					++suppressNewline;
    1914 				}
    1915 				tt=mSTRING_CTOR_END(false,true, /*tripleQuote:*/ false);
    1916 				if ( inputState.guessing==0 ) {
    1917 					_ttype = tt;
    1918 				}
    1919 			}
    1920 			else {
    1921 				throw new NoViableAltForCharException((char)LA(1), getFilename(), getLine(), getColumn());
    1922 			}
    1923 			}
    1924 			if ( _createToken && _token==null && _ttype!=Token.SKIP ) {
    1925 				_token = makeToken(_ttype);
    1926 				_token.setText(new String(text.getBuffer(), _begin, text.length()-_begin));
    1927 			}
    1928 			_returnToken = _token;
    1929 		}
    1930
    1931 	protected final void mSTRING_CH(boolean _createToken) throws RecognitionException, CharStreamException, TokenStreamException {
    1932 		int _ttype; Token _token=null; int _begin=text.length();
    1933 		_ttype = STRING_CH;
    1934 		int _saveIndex;
    1935
    1936 		{
    1937 		match(_tokenSet_4);
    1938 		}
    1939 		if ( _createToken && _token==null && _ttype!=Token.SKIP ) {
    1940 			_token = makeToken(_ttype);
    1941 			_token.setText(new String(text.getBuffer(), _begin, text.length()-_begin));
    1942 		}
    1943 		_returnToken = _token;
    1944 	}
    1945
    1946 	protected final void mESC(boolean _createToken) throws RecognitionException, CharStreamException, TokenStreamException {
    1947 		int _ttype; Token _token=null; int _begin=text.length();
    1948 		_ttype = ESC;
    1949 		int _saveIndex;
    1950
    1951 		if ((LA(1)=='//') && (LA(2)=='"'||LA(2)=='$'||LA(2)=='\''||LA(2)=='0'||LA(2)=='1'||LA(2)=='2'||LA(2)=='3'||LA(2)=='4'||LA(2)=='5'||LA(2)=='6'||LA(2)=='7'||LA(2)=='//'||LA(2)=='b'||LA(2)=='f'||LA(2)=='n'||LA(2)=='r'||LA(2)=='t'||LA(2)=='u')) {
    1952 			_saveIndex=text.length();
    1953 			match('//');
    1954 			text.setLength(_saveIndex);
    1955 			{
    1956 			switch ( LA(1)) {
    1957 			case 'n':
    1958 			{
    1959 				match('n');
    1960 				if ( inputState.guessing==0 ) {
    1961 					text.setLength(_begin); text.append("\n");
    1962 				}
    1963 				break;
    1964 			}
    1965 			case 'r':
    1966 			{
    1967 				match('r');
    1968 				if ( inputState.guessing==0 ) {
    1969 					text.setLength(_begin); text.append("\r");
    1970 				}
    1971 				break;
    1972 			}
    1973 			case 't':
    1974 			{
    1975 				match('t');
    1976 				if ( inputState.guessing==0 ) {
    1977 					text.setLength(_begin); text.append("\t");
    1978 				}
    1979 				break;
    1980 			}
    1981 			case 'b':
    1982 			{
    1983 				match('b');
    1984 				if ( inputState.guessing==0 ) {
    1985 					text.setLength(_begin); text.append("\b");
    1986 				}
    1987 				break;
    1988 			}
    1989 			case 'f':
    1990 			{
    1991 				match('f');
    1992 				if ( inputState.guessing==0 ) {
    1993 					text.setLength(_begin); text.append("\f");
    1994 				}
    1995 				break;
    1996 			}
    1997 			case '"':
    1998 			{
    1999 				match('"');
    2000 				break;
    2001 			}
    2002 			case '\'':
    2003 			{
    2004 				match('\'');
    2005 				break;
    2006 			}
    2007 			case '//':
    2008 			{
    2009 				match('//');
    2010 				break;
    2011 			}
    2012 			case '$':
    2013 			{
    2014 				match('$');
    2015 				break;
    2016 			}
    2017 			case 'u':
    2018 			{
    2019 				{
    2020 				int _cnt605=0;
    2021 				_loop605:
    2022 				do {
    2023 					if ((LA(1)=='u')) {
    2024 						match('u');
    2025 					}
    2026 					else {
    2027 						if ( _cnt605>=1 ) { break _loop605; } else {throw new NoViableAltForCharException((char)LA(1), getFilename(), getLine(), getColumn());}
    2028 					}
    2029
    2030 					_cnt605++;
    2031 				} while (true);
    2032 				}
    2033 				if ( inputState.guessing==0 ) {
    2034 					text.setLength(_begin); text.append("");
    2035 				}
    2036 				mHEX_DIGIT(false);
    2037 				mHEX_DIGIT(false);
    2038 				mHEX_DIGIT(false);
    2039 				mHEX_DIGIT(false);
    2040 				if ( inputState.guessing==0 ) {
    2041 					char ch = (char)Integer.parseInt(new String(text.getBuffer(),_begin,text.length()-_begin),16); text.setLength(_begin); text.append(ch);
    2042 				}
    2043 				break;
    2044 			}
    2045 			case '0':  case '1':  case '2':  case '3':
    2046 			{
    2047 				matchRange('0','3');
    2048 				{
    2049 				if (((LA(1) >= '0' && LA(1) <= '7')) && ((LA(2) >= '\u0003' && LA(2) <= '\ufffe')) && (true) && (true)) {
    2050 					matchRange('0','7');
    2051 					{
    2052 					if (((LA(1) >= '0' && LA(1) <= '7')) && ((LA(2) >= '\u0003' && LA(2) <= '\ufffe')) && (true) && (true)) {
    2053 						matchRange('0','7');
    2054 					}
    2055 					else if (((LA(1) >= '\u0003' && LA(1) <= '\ufffe')) && (true) && (true) && (true)) {
    2056 					}
    2057 					else {
    2058 						throw new NoViableAltForCharException((char)LA(1), getFilename(), getLine(), getColumn());
    2059 					}
    2060
    2061 					}
    2062 				}
    2063 				else if (((LA(1) >= '\u0003' && LA(1) <= '\ufffe')) && (true) && (true) && (true)) {
    2064 				}
    2065 				else {
    2066 					throw new NoViableAltForCharException((char)LA(1), getFilename(), getLine(), getColumn());
    2067 				}
    2068
    2069 				}
    2070 				if ( inputState.guessing==0 ) {
    2071 					char ch = (char)Integer.parseInt(new String(text.getBuffer(),_begin,text.length()-_begin),8); text.setLength(_begin); text.append(ch);
    2072 				}
    2073 				break;
    2074 			}
    2075 			case '4':  case '5':  case '6':  case '7':
    2076 			{
    2077 				matchRange('4','7');
    2078 				{
    2079 				if (((LA(1) >= '0' && LA(1) <= '7')) && ((LA(2) >= '\u0003' && LA(2) <= '\ufffe')) && (true) && (true)) {
    2080 					matchRange('0','7');
    2081 				}
    2082 				else if (((LA(1) >= '\u0003' && LA(1) <= '\ufffe')) && (true) && (true) && (true)) {
    2083 				}
    2084 				else {
    2085 					throw new NoViableAltForCharException((char)LA(1), getFilename(), getLine(), getColumn());
    2086 				}
    2087
    2088 				}
    2089 				if ( inputState.guessing==0 ) {
    2090 					char ch = (char)Integer.parseInt(new String(text.getBuffer(),_begin,text.length()-_begin),8); text.setLength(_begin); text.append(ch);
    2091 				}
    2092 				break;
    2093 			}
    2094 			default:
    2095 			{
    2096 				throw new NoViableAltForCharException((char)LA(1), getFilename(), getLine(), getColumn());
    2097 			}
    2098 			}
    2099 			}
    2100 		}
    2101 		else if ((LA(1)=='//') && (LA(2)=='\n'||LA(2)=='\r')) {
    2102 			_saveIndex=text.length();
    2103 			match('//');
    2104 			text.setLength(_saveIndex);
    2105 			_saveIndex=text.length();
    2106 			mONE_NL(false,false);
    2107 			text.setLength(_saveIndex);
    2108 		}
    2109 		else {
    2110 			throw new NoViableAltForCharException((char)LA(1), getFilename(), getLine(), getColumn());
    2111 		}
    2112
    2113 		if ( _createToken && _token==null && _ttype!=Token.SKIP ) {
    2114 			_token = makeToken(_ttype);
    2115 			_token.setText(new String(text.getBuffer(), _begin, text.length()-_begin));
    2116 		}
    2117 		_returnToken = _token;
    2118 	}
    2119
    2120 	protected final void mSTRING_NL(boolean _createToken,
    2121 		boolean allowNewline
    2122 	) throws RecognitionException, CharStreamException, TokenStreamException {
    2123 		int _ttype; Token _token=null; int _begin=text.length();
    2124 		_ttype = STRING_NL;
    2125 		int _saveIndex;
    2126
    2127 		if ( inputState.guessing==0 ) {
    2128 			if (!allowNewline) throw new MismatchedCharException('\n', '\n', true, this);
    2129 		}
    2130 		mONE_NL(false,false);
    2131 		if ( inputState.guessing==0 ) {
    2132 			text.setLength(_begin); text.append('\n');
    2133 		}
    2134 		if ( _createToken && _token==null && _ttype!=Token.SKIP ) {
    2135 			_token = makeToken(_ttype);
    2136 			_token.setText(new String(text.getBuffer(), _begin, text.length()-_begin));
    2137 		}
    2138 		_returnToken = _token;
    2139 	}
    2140
    2141 	protected final int  mSTRING_CTOR_END(boolean _createToken,
    2142 		boolean fromStart, boolean tripleQuote
    2143 	) throws RecognitionException, CharStreamException, TokenStreamException {
    2144 		int tt=STRING_CTOR_END;
    2145 		int _ttype; Token _token=null; int _begin=text.length();
    2146 		_ttype = STRING_CTOR_END;
    2147 		int _saveIndex;
    2148 		boolean dollarOK = false;
    2149
    2150 		{
    2151 		_loop585:
    2152 		do {
    2153 			switch ( LA(1)) {
    2154 			case '//':
    2155 			{
    2156 				mESC(false);
    2157 				break;
    2158 			}
    2159 			case '\'':
    2160 			{
    2161 				match('\'');
    2162 				break;
    2163 			}
    2164 			case '\n':  case '\r':
    2165 			{
    2166 				mSTRING_NL(false,tripleQuote);
    2167 				break;
    2168 			}
    2169 			default:
    2170 				boolean synPredMatched584 = false;
    2171 				if ((((LA(1)=='"') && ((LA(2) >= '\u0003' && LA(2) <= '\ufffe')) && (true) && (true))&&(tripleQuote))) {
    2172 					int _m584 = mark();
    2173 					synPredMatched584 = true;
    2174 					inputState.guessing++;
    2175 					try {
    2176 						{
    2177 						match('"');
    2178 						{
    2179 						if ((_tokenSet_5.member(LA(1)))) {
    2180 							matchNot('"');
    2181 						}
    2182 						else if ((LA(1)=='"')) {
    2183 							match('"');
    2184 							matchNot('"');
    2185 						}
    2186 						else {
    2187 							throw new NoViableAltForCharException((char)LA(1), getFilename(), getLine(), getColumn());
    2188 						}
    2189
    2190 						}
    2191 						}
    2192 					}
    2193 					catch (RecognitionException pe) {
    2194 						synPredMatched584 = false;
    2195 					}
    2196 					rewind(_m584);
    2197 					inputState.guessing--;
    2198 				}
    2199 				if ( synPredMatched584 ) {
    2200 					match('"');
    2201 				}
    2202 				else if ((_tokenSet_4.member(LA(1)))) {
    2203 					mSTRING_CH(false);
    2204 				}
    2205 			else {
    2206 				break _loop585;
    2207 			}
    2208 			}
    2209 		} while (true);
    2210 		}
    2211 		{
    2212 		switch ( LA(1)) {
    2213 		case '"':
    2214 		{
    2215 			{
    2216 			if (((LA(1)=='"') && (LA(2)=='"'))&&(  tripleQuote )) {
    2217 				_saveIndex=text.length();
    2218 				match("\"\"\"");
    2219 				text.setLength(_saveIndex);
    2220 			}
    2221 			else if (((LA(1)=='"') && (true))&&( !tripleQuote )) {
    2222 				_saveIndex=text.length();
    2223 				match("\"");
    2224 				text.setLength(_saveIndex);
    2225 			}
    2226 			else {
    2227 				throw new NoViableAltForCharException((char)LA(1), getFilename(), getLine(), getColumn());
    2228 			}
    2229
    2230 			}
    2231 			if ( inputState.guessing==0 ) {
    2232
    2233 				if (fromStart)      tt = STRING_LITERAL;  // plain string literal!
    2234 				if (!tripleQuote)   {--suppressNewline;}
    2235 				// done with string constructor!
    2236 				//assert(stringCtorState == 0);
    2237
    2238 			}
    2239 			break;
    2240 		}
    2241 		case '$':
    2242 		{
    2243 			if ( inputState.guessing==0 ) {
    2244 				dollarOK = atValidDollarEscape();
    2245 			}
    2246 			_saveIndex=text.length();
    2247 			match('$');
    2248 			text.setLength(_saveIndex);
    2249 			if ( inputState.guessing==0 ) {
    2250
    2251 				require(dollarOK,
    2252 				"illegal string body character after dollar sign",
    2253 				"either escape a literal dollar sign \"//$5\" or bracket the value expression \"${5}\"");
    2254 				// Yes, it's a string constructor, and we've got a value part.
    2255 				tt = (fromStart ? STRING_CTOR_START : STRING_CTOR_MIDDLE);
    2256 				stringCtorState = SCS_VAL + (tripleQuote? SCS_TQ_TYPE: SCS_SQ_TYPE);
    2257
    2258 			}
    2259 			break;
    2260 		}
    2261 		default:
    2262 		{
    2263 			throw new NoViableAltForCharException((char)LA(1), getFilename(), getLine(), getColumn());
    2264 		}
    2265 		}
    2266 		}
    2267 		if ( inputState.guessing==0 ) {
    2268 			_ttype = tt;
    2269 		}
    2270 		if ( _createToken && _token==null && _ttype!=Token.SKIP ) {
    2271 			_token = makeToken(_ttype);
    2272 			_token.setText(new String(text.getBuffer(), _begin, text.length()-_begin));
    2273 		}
    2274 		_returnToken = _token;
    2275 		return tt;
    2276 	}
    2277
    2278 	public final void mREGEXP_LITERAL(boolean _createToken) throws RecognitionException, CharStreamException, TokenStreamException {
    2279 		int _ttype; Token _token=null; int _begin=text.length();
    2280 		_ttype = REGEXP_LITERAL;
    2281 		int _saveIndex;
    2282 		int tt=0;
    2283
    2284 		if (((LA(1)=='/') && (_tokenSet_6.member(LA(2))) && (true) && (true))&&(allowRegexpLiteral())) {
    2285 			_saveIndex=text.length();
    2286 			match('/');
    2287 			text.setLength(_saveIndex);
    2288 			if ( inputState.guessing==0 ) {
    2289 				++suppressNewline;
    2290 			}
    2291 			{
    2292 			if (((LA(1)=='$') && (_tokenSet_2.member(LA(2))))&&(!atValidDollarEscape())) {
    2293 				match('$');
    2294 				tt=mREGEXP_CTOR_END(false,true);
    2295 			}
    2296 			else if ((_tokenSet_7.member(LA(1)))) {
    2297 				mREGEXP_SYMBOL(false);
    2298 				tt=mREGEXP_CTOR_END(false,true);
    2299 			}
    2300 			else if ((LA(1)=='$') && (true)) {
    2301 				_saveIndex=text.length();
    2302 				match('$');
    2303 				text.setLength(_saveIndex);
    2304 				if ( inputState.guessing==0 ) {
    2305
    2306 					// Yes, it's a regexp constructor, and we've got a value part.
    2307 					tt = STRING_CTOR_START;
    2308 					stringCtorState = SCS_VAL + SCS_RE_TYPE;
    2309
    2310 				}
    2311 			}
    2312 			else {
    2313 				throw new NoViableAltForCharException((char)LA(1), getFilename(), getLine(), getColumn());
    2314 			}
    2315
    2316 			}
    2317 			if ( inputState.guessing==0 ) {
    2318 				_ttype = tt;
    2319 			}
    2320 		}
    2321 		else if ((LA(1)=='/') && (LA(2)=='=') && (true) && (true)) {
    2322 			mDIV_ASSIGN(false);
    2323 			if ( inputState.guessing==0 ) {
    2324 				_ttype = DIV_ASSIGN;
    2325 			}
    2326 		}
    2327 		else if ((LA(1)=='/') && (true)) {
    2328 			mDIV(false);
    2329 			if ( inputState.guessing==0 ) {
    2330 				_ttype = DIV;
    2331 			}
    2332 		}
    2333 		else {
    2334 			throw new NoViableAltForCharException((char)LA(1), getFilename(), getLine(), getColumn());
    2335 		}
    2336
    2337 		if ( _createToken && _token==null && _ttype!=Token.SKIP ) {
    2338 			_token = makeToken(_ttype);
    2339 			_token.setText(new String(text.getBuffer(), _begin, text.length()-_begin));
    2340 		}
    2341 		_returnToken = _token;
    2342 	}
    2343
    2344 	protected final void mREGEXP_SYMBOL(boolean _createToken) throws RecognitionException, CharStreamException, TokenStreamException {
    2345 		int _ttype; Token _token=null; int _begin=text.length();
    2346 		_ttype = REGEXP_SYMBOL;
    2347 		int _saveIndex;
    2348
    2349 		{
    2350 		if ((LA(1)=='//') && (_tokenSet_8.member(LA(2)))) {
    2351 			match('//');
    2352 			{
    2353 			match(_tokenSet_8);
    2354 			}
    2355 		}
    2356 		else if ((LA(1)=='//') && (LA(2)=='\n'||LA(2)=='\r')) {
    2357 			_saveIndex=text.length();
    2358 			match('//');
    2359 			text.setLength(_saveIndex);
    2360 			_saveIndex=text.length();
    2361 			mONE_NL(false,false);
    2362 			text.setLength(_saveIndex);
    2363 			if ( inputState.guessing==0 ) {
    2364 				text.setLength(_begin); text.append('\n');
    2365 			}
    2366 		}
    2367 		else if ((_tokenSet_9.member(LA(1)))) {
    2368 			{
    2369 			match(_tokenSet_9);
    2370 			}
    2371 		}
    2372 		else {
    2373 			throw new NoViableAltForCharException((char)LA(1), getFilename(), getLine(), getColumn());
    2374 		}
    2375
    2376 		}
    2377 		{
    2378 		_loop601:
    2379 		do {
    2380 			if ((LA(1)=='*')) {
    2381 				match('*');
    2382 			}
    2383 			else {
    2384 				break _loop601;
    2385 			}
    2386
    2387 		} while (true);
    2388 		}
    2389 		if ( _createToken && _token==null && _ttype!=Token.SKIP ) {
    2390 			_token = makeToken(_ttype);
    2391 			_token.setText(new String(text.getBuffer(), _begin, text.length()-_begin));
    2392 		}
    2393 		_returnToken = _token;
    2394 	}
    2395
    2396 	protected final int  mREGEXP_CTOR_END(boolean _createToken,
    2397 		boolean fromStart
    2398 	) throws RecognitionException, CharStreamException, TokenStreamException {
    2399 		int tt=STRING_CTOR_END;
    2400 		int _ttype; Token _token=null; int _begin=text.length();
    2401 		_ttype = REGEXP_CTOR_END;
    2402 		int _saveIndex;
    2403
    2404 		{
    2405 		_loop594:
    2406 		do {
    2407 			if (((LA(1)=='$') && (_tokenSet_2.member(LA(2))))&&(!atValidDollarEscape())) {
    2408 				match('$');
    2409 			}
    2410 			else if ((_tokenSet_7.member(LA(1)))) {
    2411 				mREGEXP_SYMBOL(false);
    2412 			}
    2413 			else {
    2414 				break _loop594;
    2415 			}
    2416
    2417 		} while (true);
    2418 		}
    2419 		{
    2420 		switch ( LA(1)) {
    2421 		case '/':
    2422 		{
    2423 			_saveIndex=text.length();
    2424 			match('/');
    2425 			text.setLength(_saveIndex);
    2426 			if ( inputState.guessing==0 ) {
    2427
    2428 				if (fromStart)      tt = STRING_LITERAL;  // plain regexp literal!
    2429 				{--suppressNewline;}
    2430 				// done with regexp constructor!
    2431 				//assert(stringCtorState == 0);
    2432
    2433 			}
    2434 			break;
    2435 		}
    2436 		case '$':
    2437 		{
    2438 			_saveIndex=text.length();
    2439 			match('$');
    2440 			text.setLength(_saveIndex);
    2441 			if ( inputState.guessing==0 ) {
    2442
    2443 				// Yes, it's a regexp constructor, and we've got a value part.
    2444 				tt = (fromStart ? STRING_CTOR_START : STRING_CTOR_MIDDLE);
    2445 				stringCtorState = SCS_VAL + SCS_RE_TYPE;
    2446
    2447 			}
    2448 			break;
    2449 		}
    2450 		default:
    2451 		{
    2452 			throw new NoViableAltForCharException((char)LA(1), getFilename(), getLine(), getColumn());
    2453 		}
    2454 		}
    2455 		}
    2456 		if ( inputState.guessing==0 ) {
    2457 			_ttype = tt;
    2458 		}
    2459 		if ( _createToken && _token==null && _ttype!=Token.SKIP ) {
    2460 			_token = makeToken(_ttype);
    2461 			_token.setText(new String(text.getBuffer(), _begin, text.length()-_begin));
    2462 		}
    2463 		_returnToken = _token;
    2464 		return tt;
    2465 	}
    2466
    2467 	protected final void mHEX_DIGIT(boolean _createToken) throws RecognitionException, CharStreamException, TokenStreamException {
    2468 		int _ttype; Token _token=null; int _begin=text.length();
    2469 		_ttype = HEX_DIGIT;
    2470 		int _saveIndex;
    2471
    2472 		{
    2473 		switch ( LA(1)) {
    2474 		case '0':  case '1':  case '2':  case '3':
    2475 		case '4':  case '5':  case '6':  case '7':
    2476 		case '8':  case '9':
    2477 		{
    2478 			matchRange('0','9');
    2479 			break;
    2480 		}
    2481 		case 'A':  case 'B':  case 'C':  case 'D':
    2482 		case 'E':  case 'F':
    2483 		{
    2484 			matchRange('A','F');
    2485 			break;
    2486 		}
    2487 		case 'a':  case 'b':  case 'c':  case 'd':
    2488 		case 'e':  case 'f':
    2489 		{
    2490 			matchRange('a','f');
    2491 			break;
    2492 		}
    2493 		default:
    2494 		{
    2495 			throw new NoViableAltForCharException((char)LA(1), getFilename(), getLine(), getColumn());
    2496 		}
    2497 		}
    2498 		}
    2499 		if ( _createToken && _token==null && _ttype!=Token.SKIP ) {
    2500 			_token = makeToken(_ttype);
    2501 			_token.setText(new String(text.getBuffer(), _begin, text.length()-_begin));
    2502 		}
    2503 		_returnToken = _token;
    2504 	}
    2505
    2506 	protected final void mVOCAB(boolean _createToken) throws RecognitionException, CharStreamException, TokenStreamException {
    2507 		int _ttype; Token _token=null; int _begin=text.length();
    2508 		_ttype = VOCAB;
    2509 		int _saveIndex;
    2510
    2511 		matchRange('\3','\377');
    2512 		if ( _createToken && _token==null && _ttype!=Token.SKIP ) {
    2513 			_token = makeToken(_ttype);
    2514 			_token.setText(new String(text.getBuffer(), _begin, text.length()-_begin));
    2515 		}
    2516 		_returnToken = _token;
    2517 	}
    2518
    2519 	public final void mIDENT(boolean _createToken) throws RecognitionException, CharStreamException, TokenStreamException {
    2520 		int _ttype; Token _token=null; int _begin=text.length();
    2521 		_ttype = IDENT;
    2522 		int _saveIndex;
    2523
    2524 		mLETTER(false);
    2525 		{
    2526 		_loop615:
    2527 		do {
    2528 			if ((_tokenSet_0.member(LA(1)))) {
    2529 				mLETTER(false);
    2530 			}
    2531 			else if (((LA(1) >= '0' && LA(1) <= '9'))) {
    2532 				mDIGIT(false);
    2533 			}
    2534 			else {
    2535 				break _loop615;
    2536 			}
    2537
    2538 		} while (true);
    2539 		}
    2540 		if ( inputState.guessing==0 ) {
    2541
    2542 			if (stringCtorState != 0) {
    2543 			if (LA(1) == '.' && LA(2) != '$' &&
    2544 			Character.isJavaIdentifierStart(LA(2))) {
    2545 			// pick up another name component before going literal again:
    2546 			restartStringCtor(false);
    2547 			} else {
    2548 			// go back to the string
    2549 			restartStringCtor(true);
    2550 			}
    2551 			}
    2552 			int ttype = testLiteralsTable(IDENT);
    2553 			/* The grammar allows a few keywords to follow dot.
    2554 			* TODO: Reinstate this logic if we change or remove keywordPropertyNames.
    2555 			if (ttype != IDENT && lastSigTokenType == DOT) {
    2556 			// A few keywords can follow a dot:
    2557 			switch (ttype) {
    2558 			case LITERAL_this: case LITERAL_super: case LITERAL_class:
    2559 			break;
    2560 			default:
    2561 			ttype = LITERAL_in;  // the poster child for bad dotted names
    2562 			}
    2563 			}
    2564 			*/
    2565 			_ttype = ttype;
    2566
    2567 			// check if "assert" keyword is enabled
    2568 			if (assertEnabled && "assert".equals(new String(text.getBuffer(),_begin,text.length()-_begin))) {
    2569 			_ttype = LITERAL_assert; // set token type for the rule in the parser
    2570 			}
    2571 			// check if "enum" keyword is enabled
    2572 			if (enumEnabled && "enum".equals(new String(text.getBuffer(),_begin,text.length()-_begin))) {
    2573 			_ttype = LITERAL_enum; // set token type for the rule in the parser
    2574 			}
    2575
    2576 		}
    2577 		if ( _createToken && _token==null && _ttype!=Token.SKIP ) {
    2578 			_token = makeToken(_ttype);
    2579 			_token.setText(new String(text.getBuffer(), _begin, text.length()-_begin));
    2580 		}
    2581 		_returnToken = _token;
    2582 	}
    2583
    2584 	protected final void mLETTER(boolean _createToken) throws RecognitionException, CharStreamException, TokenStreamException {
    2585 		int _ttype; Token _token=null; int _begin=text.length();
    2586 		_ttype = LETTER;
    2587 		int _saveIndex;
    2588
    2589 		switch ( LA(1)) {
    2590 		case 'a':  case 'b':  case 'c':  case 'd':
    2591 		case 'e':  case 'f':  case 'g':  case 'h':
    2592 		case 'i':  case 'j':  case 'k':  case 'l':
    2593 		case 'm':  case 'n':  case 'o':  case 'p':
    2594 		case 'q':  case 'r':  case 's':  case 't':
    2595 		case 'u':  case 'v':  case 'w':  case 'x':
    2596 		case 'y':  case 'z':
    2597 		{
    2598 			matchRange('a','z');
    2599 			break;
    2600 		}
    2601 		case 'A':  case 'B':  case 'C':  case 'D':
    2602 		case 'E':  case 'F':  case 'G':  case 'H':
    2603 		case 'I':  case 'J':  case 'K':  case 'L':
    2604 		case 'M':  case 'N':  case 'O':  case 'P':
    2605 		case 'Q':  case 'R':  case 'S':  case 'T':
    2606 		case 'U':  case 'V':  case 'W':  case 'X':
    2607 		case 'Y':  case 'Z':
    2608 		{
    2609 			matchRange('A','Z');
    2610 			break;
    2611 		}
    2612 		case '\u00c0':  case '\u00c1':  case '\u00c2':  case '\u00c3':
    2613 		case '\u00c4':  case '\u00c5':  case '\u00c6':  case '\u00c7':
    2614 		case '\u00c8':  case '\u00c9':  case '\u00ca':  case '\u00cb':
    2615 		case '\u00cc':  case '\u00cd':  case '\u00ce':  case '\u00cf':
    2616 		case '\u00d0':  case '\u00d1':  case '\u00d2':  case '\u00d3':
    2617 		case '\u00d4':  case '\u00d5':  case '\u00d6':
    2618 		{
    2619 			matchRange('\u00C0','\u00D6');
    2620 			break;
    2621 		}
    2622 		case '\u00d8':  case '\u00d9':  case '\u00da':  case '\u00db':
    2623 		case '\u00dc':  case '\u00dd':  case '\u00de':  case '\u00df':
    2624 		case '\u00e0':  case '\u00e1':  case '\u00e2':  case '\u00e3':
    2625 		case '\u00e4':  case '\u00e5':  case '\u00e6':  case '\u00e7':
    2626 		case '\u00e8':  case '\u00e9':  case '\u00ea':  case '\u00eb':
    2627 		case '\u00ec':  case '\u00ed':  case '\u00ee':  case '\u00ef':
    2628 		case '\u00f0':  case '\u00f1':  case '\u00f2':  case '\u00f3':
    2629 		case '\u00f4':  case '\u00f5':  case '\u00f6':
    2630 		{
    2631 			matchRange('\u00D8','\u00F6');
    2632 			break;
    2633 		}
    2634 		case '\u00f8':  case '\u00f9':  case '\u00fa':  case '\u00fb':
    2635 		case '\u00fc':  case '\u00fd':  case '\u00fe':  case '\u00ff':
    2636 		{
    2637 			matchRange('\u00F8','\u00FF');
    2638 			break;
    2639 		}
    2640 		case '_':
    2641 		{
    2642 			match('_');
    2643 			break;
    2644 		}
    2645 		default:
    2646 			if (((LA(1) >= '\u0100' && LA(1) <= '\ufffe'))) {
    2647 				matchRange('\u0100','\uFFFE');
    2648 			}
    2649 		else {
    2650 			throw new NoViableAltForCharException((char)LA(1), getFilename(), getLine(), getColumn());
    2651 		}
    2652 		}
    2653 		if ( _createToken && _token==null && _ttype!=Token.SKIP ) {
    2654 			_token = makeToken(_ttype);
    2655 			_token.setText(new String(text.getBuffer(), _begin, text.length()-_begin));
    2656 		}
    2657 		_returnToken = _token;
    2658 	}
    2659
    2660 	protected final void mDIGIT(boolean _createToken) throws RecognitionException, CharStreamException, TokenStreamException {
    2661 		int _ttype; Token _token=null; int _begin=text.length();
    2662 		_ttype = DIGIT;
    2663 		int _saveIndex;
    2664
    2665 		matchRange('0','9');
    2666 		if ( _createToken && _token==null && _ttype!=Token.SKIP ) {
    2667 			_token = makeToken(_ttype);
    2668 			_token.setText(new String(text.getBuffer(), _begin, text.length()-_begin));
    2669 		}
    2670 		_returnToken = _token;
    2671 	}
    2672
    2673 	public final void mNUM_INT(boolean _createToken) throws RecognitionException, CharStreamException, TokenStreamException {
    2674 		int _ttype; Token _token=null; int _begin=text.length();
    2675 		_ttype = NUM_INT;
    2676 		int _saveIndex;
    2677 		Token f2=null;
    2678 		Token g2=null;
    2679 		Token f3=null;
    2680 		Token g3=null;
    2681 		Token f4=null;
    2682 		boolean isDecimal=false; Token t=null;
    2683
    2684 		{
    2685 		switch ( LA(1)) {
    2686 		case '0':
    2687 		{
    2688 			match('0');
    2689 			if ( inputState.guessing==0 ) {
    2690 				isDecimal = true;
    2691 			}
    2692 			{
    2693 			if ((LA(1)=='X'||LA(1)=='x')) {
    2694 				{
    2695 				switch ( LA(1)) {
    2696 				case 'x':
    2697 				{
    2698 					match('x');
    2699 					break;
    2700 				}
    2701 				case 'X':
    2702 				{
    2703 					match('X');
    2704 					break;
    2705 				}
    2706 				default:
    2707 				{
    2708 					throw new NoViableAltForCharException((char)LA(1), getFilename(), getLine(), getColumn());
    2709 				}
    2710 				}
    2711 				}
    2712 				if ( inputState.guessing==0 ) {
    2713 					isDecimal = false;
    2714 				}
    2715 				{
    2716 				int _cnt623=0;
    2717 				_loop623:
    2718 				do {
    2719 					if ((_tokenSet_10.member(LA(1))) && (true) && (true) && (true)) {
    2720 						mHEX_DIGIT(false);
    2721 					}
    2722 					else {
    2723 						if ( _cnt623>=1 ) { break _loop623; } else {throw new NoViableAltForCharException((char)LA(1), getFilename(), getLine(), getColumn());}
    2724 					}
    2725
    2726 					_cnt623++;
    2727 				} while (true);
    2728 				}
    2729 			}
    2730 			else {
    2731 				boolean synPredMatched629 = false;
    2732 				if ((((LA(1) >= '0' && LA(1) <= '9')) && (true) && (true) && (true))) {
    2733 					int _m629 = mark();
    2734 					synPredMatched629 = true;
    2735 					inputState.guessing++;
    2736 					try {
    2737 						{
    2738 						{
    2739 						int _cnt626=0;
    2740 						_loop626:
    2741 						do {
    2742 							if (((LA(1) >= '0' && LA(1) <= '9'))) {
    2743 								matchRange('0','9');
    2744 							}
    2745 							else {
    2746 								if ( _cnt626>=1 ) { break _loop626; } else {throw new NoViableAltForCharException((char)LA(1), getFilename(), getLine(), getColumn());}
    2747 							}
    2748
    2749 							_cnt626++;
    2750 						} while (true);
    2751 						}
    2752 						{
    2753 						switch ( LA(1)) {
    2754 						case '.':
    2755 						{
    2756 							match('.');
    2757 							{
    2758 							matchRange('0','9');
    2759 							}
    2760 							break;
    2761 						}
    2762 						case 'E':  case 'e':
    2763 						{
    2764 							mEXPONENT(false);
    2765 							break;
    2766 						}
    2767 						case 'D':  case 'F':  case 'd':  case 'f':
    2768 						{
    2769 							mFLOAT_SUFFIX(false);
    2770 							break;
    2771 						}
    2772 						default:
    2773 						{
    2774 							throw new NoViableAltForCharException((char)LA(1), getFilename(), getLine(), getColumn());
    2775 						}
    2776 						}
    2777 						}
    2778 						}
    2779 					}
    2780 					catch (RecognitionException pe) {
    2781 						synPredMatched629 = false;
    2782 					}
    2783 					rewind(_m629);
    2784 					inputState.guessing--;
    2785 				}
    2786 				if ( synPredMatched629 ) {
    2787 					{
    2788 					int _cnt631=0;
    2789 					_loop631:
    2790 					do {
    2791 						if (((LA(1) >= '0' && LA(1) <= '9'))) {
    2792 							matchRange('0','9');
    2793 						}
    2794 						else {
    2795 							if ( _cnt631>=1 ) { break _loop631; } else {throw new NoViableAltForCharException((char)LA(1), getFilename(), getLine(), getColumn());}
    2796 						}
    2797
    2798 						_cnt631++;
    2799 					} while (true);
    2800 					}
    2801 				}
    2802 				else if (((LA(1) >= '0' && LA(1) <= '7')) && (true) && (true) && (true)) {
    2803 					{
    2804 					int _cnt633=0;
    2805 					_loop633:
    2806 					do {
    2807 						if (((LA(1) >= '0' && LA(1) <= '7'))) {
    2808 							matchRange('0','7');
    2809 						}
    2810 						else {
    2811 							if ( _cnt633>=1 ) { break _loop633; } else {throw new NoViableAltForCharException((char)LA(1), getFilename(), getLine(), getColumn());}
    2812 						}
    2813
    2814 						_cnt633++;
    2815 					} while (true);
    2816 					}
    2817 					if ( inputState.guessing==0 ) {
    2818 						isDecimal = false;
    2819 					}
    2820 				}
    2821 				else {
    2822 				}
    2823 				}
    2824 				}
    2825 				break;
    2826 			}
    2827 			case '1':  case '2':  case '3':  case '4':
    2828 			case '5':  case '6':  case '7':  case '8':
    2829 			case '9':
    2830 			{
    2831 				{
    2832 				matchRange('1','9');
    2833 				}
    2834 				{
    2835 				_loop636:
    2836 				do {
    2837 					if (((LA(1) >= '0' && LA(1) <= '9'))) {
    2838 						matchRange('0','9');
    2839 					}
    2840 					else {
    2841 						break _loop636;
    2842 					}
    2843
    2844 				} while (true);
    2845 				}
    2846 				if ( inputState.guessing==0 ) {
    2847 					isDecimal=true;
    2848 				}
    2849 				break;
    2850 			}
    2851 			default:
    2852 			{
    2853 				throw new NoViableAltForCharException((char)LA(1), getFilename(), getLine(), getColumn());
    2854 			}
    2855 			}
    2856 			}
    2857 			{
    2858 			switch ( LA(1)) {
    2859 			case 'L':  case 'l':
    2860 			{
    2861 				{
    2862 				switch ( LA(1)) {
    2863 				case 'l':
    2864 				{
    2865 					match('l');
    2866 					break;
    2867 				}
    2868 				case 'L':
    2869 				{
    2870 					match('L');
    2871 					break;
    2872 				}
    2873 				default:
    2874 				{
    2875 					throw new NoViableAltForCharException((char)LA(1), getFilename(), getLine(), getColumn());
    2876 				}
    2877 				}
    2878 				}
    2879 				if ( inputState.guessing==0 ) {
    2880 					_ttype = NUM_LONG;
    2881 				}
    2882 				break;
    2883 			}
    2884 			case 'I':  case 'i':
    2885 			{
    2886 				{
    2887 				switch ( LA(1)) {
    2888 				case 'i':
    2889 				{
    2890 					match('i');
    2891 					break;
    2892 				}
    2893 				case 'I':
    2894 				{
    2895 					match('I');
    2896 					break;
    2897 				}
    2898 				default:
    2899 				{
    2900 					throw new NoViableAltForCharException((char)LA(1), getFilename(), getLine(), getColumn());
    2901 				}
    2902 				}
    2903 				}
    2904 				if ( inputState.guessing==0 ) {
    2905 					_ttype = NUM_INT;
    2906 				}
    2907 				break;
    2908 			}
    2909 			case 'G':  case 'g':
    2910 			{
    2911 				mBIG_SUFFIX(false);
    2912 				if ( inputState.guessing==0 ) {
    2913 					_ttype = NUM_BIG_INT;
    2914 				}
    2915 				break;
    2916 			}
    2917 			default:
    2918 				boolean synPredMatched642 = false;
    2919 				if ((((LA(1)=='.'||LA(1)=='D'||LA(1)=='E'||LA(1)=='F'||LA(1)=='d'||LA(1)=='e'||LA(1)=='f'))&&(isDecimal))) {
    2920 					int _m642 = mark();
    2921 					synPredMatched642 = true;
    2922 					inputState.guessing++;
    2923 					try {
    2924 						{
    2925 						if ((_tokenSet_11.member(LA(1)))) {
    2926 							matchNot('.');
    2927 						}
    2928 						else if ((LA(1)=='.')) {
    2929 							match('.');
    2930 							{
    2931 							matchRange('0','9');
    2932 							}
    2933 						}
    2934 						else {
    2935 							throw new NoViableAltForCharException((char)LA(1), getFilename(), getLine(), getColumn());
    2936 						}
    2937
    2938 						}
    2939 					}
    2940 					catch (RecognitionException pe) {
    2941 						synPredMatched642 = false;
    2942 					}
    2943 					rewind(_m642);
    2944 					inputState.guessing--;
    2945 				}
    2946 				if ( synPredMatched642 ) {
    2947 					{
    2948 					switch ( LA(1)) {
    2949 					case '.':
    2950 					{
    2951 						match('.');
    2952 						{
    2953 						int _cnt645=0;
    2954 						_loop645:
    2955 						do {
    2956 							if (((LA(1) >= '0' && LA(1) <= '9'))) {
    2957 								matchRange('0','9');
    2958 							}
    2959 							else {
    2960 								if ( _cnt645>=1 ) { break _loop645; } else {throw new NoViableAltForCharException((char)LA(1), getFilename(), getLine(), getColumn());}
    2961 							}
    2962
    2963 							_cnt645++;
    2964 						} while (true);
    2965 						}
    2966 						{
    2967 						if ((LA(1)=='E'||LA(1)=='e')) {
    2968 							mEXPONENT(false);
    2969 						}
    2970 						else {
    2971 						}
    2972
    2973 						}
    2974 						{
    2975 						switch ( LA(1)) {
    2976 						case 'D':  case 'F':  case 'd':  case 'f':
    2977 						{
    2978 							mFLOAT_SUFFIX(true);
    2979 							f2=_returnToken;
    2980 							if ( inputState.guessing==0 ) {
    2981 								t=f2;
    2982 							}
    2983 							break;
    2984 						}
    2985 						case 'G':  case 'g':
    2986 						{
    2987 							mBIG_SUFFIX(true);
    2988 							g2=_returnToken;
    2989 							if ( inputState.guessing==0 ) {
    2990 								t=g2;
    2991 							}
    2992 							break;
    2993 						}
    2994 						default:
    2995 							{
    2996 							}
    2997 						}
    2998 						}
    2999 						break;
    3000 					}
    3001 					case 'E':  case 'e':
    3002 					{
    3003 						mEXPONENT(false);
    3004 						{
    3005 						switch ( LA(1)) {
    3006 						case 'D':  case 'F':  case 'd':  case 'f':
    3007 						{
    3008 							mFLOAT_SUFFIX(true);
    3009 							f3=_returnToken;
    3010 							if ( inputState.guessing==0 ) {
    3011 								t=f3;
    3012 							}
    3013 							break;
    3014 						}
    3015 						case 'G':  case 'g':
    3016 						{
    3017 							mBIG_SUFFIX(true);
    3018 							g3=_returnToken;
    3019 							if ( inputState.guessing==0 ) {
    3020 								t=g3;
    3021 							}
    3022 							break;
    3023 						}
    3024 						default:
    3025 							{
    3026 							}
    3027 						}
    3028 						}
    3029 						break;
    3030 					}
    3031 					case 'D':  case 'F':  case 'd':  case 'f':
    3032 					{
    3033 						mFLOAT_SUFFIX(true);
    3034 						f4=_returnToken;
    3035 						if ( inputState.guessing==0 ) {
    3036 							t=f4;
    3037 						}
    3038 						break;
    3039 					}
    3040 					default:
    3041 					{
    3042 						throw new NoViableAltForCharException((char)LA(1), getFilename(), getLine(), getColumn());
    3043 					}
    3044 					}
    3045 					}
    3046 					if ( inputState.guessing==0 ) {
    3047
    3048 						String txt = (t == null ? "" : t.getText().toUpperCase());
    3049 						if (txt.indexOf('F') >= 0) {
    3050 						_ttype = NUM_FLOAT;
    3051 						} else if (txt.indexOf('G') >= 0) {
    3052 						_ttype = NUM_BIG_DECIMAL;
    3053 						} else {
    3054 						_ttype = NUM_DOUBLE; // assume double
    3055 						}
    3056
    3057 					}
    3058 				}
    3059 				else {
    3060 				}
    3061 			}
    3062 			}
    3063 			if ( _createToken && _token==null && _ttype!=Token.SKIP ) {
    3064 				_token = makeToken(_ttype);
    3065 				_token.setText(new String(text.getBuffer(), _begin, text.length()-_begin));
    3066 			}
    3067 			_returnToken = _token;
    3068 		}
    3069
    3070 	protected final void mEXPONENT(boolean _createToken) throws RecognitionException, CharStreamException, TokenStreamException {
    3071 		int _ttype; Token _token=null; int _begin=text.length();
    3072 		_ttype = EXPONENT;
    3073 		int _saveIndex;
    3074
    3075 		{
    3076 		switch ( LA(1)) {
    3077 		case 'e':
    3078 		{
    3079 			match('e');
    3080 			break;
    3081 		}
    3082 		case 'E':
    3083 		{
    3084 			match('E');
    3085 			break;
    3086 		}
    3087 		default:
    3088 		{
    3089 			throw new NoViableAltForCharException((char)LA(1), getFilename(), getLine(), getColumn());
    3090 		}
    3091 		}
    3092 		}
    3093 		{
    3094 		switch ( LA(1)) {
    3095 		case '+':
    3096 		{
    3097 			match('+');
    3098 			break;
    3099 		}
    3100 		case '-':
    3101 		{
    3102 			match('-');
    3103 			break;
    3104 		}
    3105 		case '0':  case '1':  case '2':  case '3':
    3106 		case '4':  case '5':  case '6':  case '7':
    3107 		case '8':  case '9':
    3108 		{
    3109 			break;
    3110 		}
    3111 		default:
    3112 		{
    3113 			throw new NoViableAltForCharException((char)LA(1), getFilename(), getLine(), getColumn());
    3114 		}
    3115 		}
    3116 		}
    3117 		{
    3118 		int _cnt654=0;
    3119 		_loop654:
    3120 		do {
    3121 			if (((LA(1) >= '0' && LA(1) <= '9'))) {
    3122 				matchRange('0','9');
    3123 			}
    3124 			else {
    3125 				if ( _cnt654>=1 ) { break _loop654; } else {throw new NoViableAltForCharException((char)LA(1), getFilename(), getLine(), getColumn());}
    3126 			}
    3127
    3128 			_cnt654++;
    3129 		} while (true);
    3130 		}
    3131 		if ( _createToken && _token==null && _ttype!=Token.SKIP ) {
    3132 			_token = makeToken(_ttype);
    3133 			_token.setText(new String(text.getBuffer(), _begin, text.length()-_begin));
    3134 		}
    3135 		_returnToken = _token;
    3136 	}
    3137
    3138 	protected final void mFLOAT_SUFFIX(boolean _createToken) throws RecognitionException, CharStreamException, TokenStreamException {
    3139 		int _ttype; Token _token=null; int _begin=text.length();
    3140 		_ttype = FLOAT_SUFFIX;
    3141 		int _saveIndex;
    3142
    3143 		switch ( LA(1)) {
    3144 		case 'f':
    3145 		{
    3146 			match('f');
    3147 			break;
    3148 		}
    3149 		case 'F':
    3150 		{
    3151 			match('F');
    3152 			break;
    3153 		}
    3154 		case 'd':
    3155 		{
    3156 			match('d');
    3157 			break;
    3158 		}
    3159 		case 'D':
    3160 		{
    3161 			match('D');
    3162 			break;
    3163 		}
    3164 		default:
    3165 		{
    3166 			throw new NoViableAltForCharException((char)LA(1), getFilename(), getLine(), getColumn());
    3167 		}
    3168 		}
    3169 		if ( _createToken && _token==null && _ttype!=Token.SKIP ) {
    3170 			_token = makeToken(_ttype);
    3171 			_token.setText(new String(text.getBuffer(), _begin, text.length()-_begin));
    3172 		}
    3173 		_returnToken = _token;
    3174 	}
    3175
    3176 	protected final void mBIG_SUFFIX(boolean _createToken) throws RecognitionException, CharStreamException, TokenStreamException {
    3177 		int _ttype; Token _token=null; int _begin=text.length();
    3178 		_ttype = BIG_SUFFIX;
    3179 		int _saveIndex;
    3180
    3181 		switch ( LA(1)) {
    3182 		case 'g':
    3183 		{
    3184 			match('g');
    3185 			break;
    3186 		}
    3187 		case 'G':
    3188 		{
    3189 			match('G');
    3190 			break;
    3191 		}
    3192 		default:
    3193 		{
    3194 			throw new NoViableAltForCharException((char)LA(1), getFilename(), getLine(), getColumn());
    3195 		}
    3196 		}
    3197 		if ( _createToken && _token==null && _ttype!=Token.SKIP ) {
    3198 			_token = makeToken(_ttype);
    3199 			_token.setText(new String(text.getBuffer(), _begin, text.length()-_begin));
    3200 		}
    3201 		_returnToken = _token;
    3202 	}
    3203
    3204 	public final void mAT(boolean _createToken) throws RecognitionException, CharStreamException, TokenStreamException {
    3205 		int _ttype; Token _token=null; int _begin=text.length();
    3206 		_ttype = AT;
    3207 		int _saveIndex;
    3208
    3209 		match('@');
    3210 		if ( _createToken && _token==null && _ttype!=Token.SKIP ) {
    3211 			_token = makeToken(_ttype);
    3212 			_token.setText(new String(text.getBuffer(), _begin, text.length()-_begin));
    3213 		}
    3214 		_returnToken = _token;
    3215 	}
    3216
    3217
    3218 	private static final long[] mk_tokenSet_0() {
    3219 		long[] data = new long[2560];
    3220 		data[1]=576460745995190270L;
    3221 		data[3]=-36028797027352577L;
    3222 		for (int i = 4; i<=1022; i++) { data[i]=-1L; }
    3223 		data[1023]=9223372036854775807L;
    3224 		return data;
    3225 	}
    3226 	public static final BitSet _tokenSet_0 = new BitSet(mk_tokenSet_0());
    3227 	private static final long[] mk_tokenSet_1() {
    3228 		long[] data = new long[2048];
    3229 		data[0]=-9224L;
    3230 		for (int i = 1; i<=1022; i++) { data[i]=-1L; }
    3231 		data[1023]=9223372036854775807L;
    3232 		return data;
    3233 	}
    3234 	public static final BitSet _tokenSet_1 = new BitSet(mk_tokenSet_1());
    3235 	private static final long[] mk_tokenSet_2() {
    3236 		long[] data = new long[2048];
    3237 		data[0]=-4398046520328L;
    3238 		for (int i = 1; i<=1022; i++) { data[i]=-1L; }
    3239 		data[1023]=9223372036854775807L;
    3240 		return data;
    3241 	}
    3242 	public static final BitSet _tokenSet_2 = new BitSet(mk_tokenSet_2());
    3243 	private static final long[] mk_tokenSet_3() {
    3244 		long[] data = new long[2048];
    3245 		data[0]=-549755813896L;
    3246 		for (int i = 1; i<=1023; i++) { data[i]=-1L; }
    3247 		return data;
    3248 	}
    3249 	public static final BitSet _tokenSet_3 = new BitSet(mk_tokenSet_3());
    3250 	private static final long[] mk_tokenSet_4() {
    3251 		long[] data = new long[2048];
    3252 		data[0]=-635655169032L;
    3253 		data[1]=-268435457L;
    3254 		for (int i = 2; i<=1022; i++) { data[i]=-1L; }
    3255 		data[1023]=9223372036854775807L;
    3256 		return data;
    3257 	}
    3258 	public static final BitSet _tokenSet_4 = new BitSet(mk_tokenSet_4());
    3259 	private static final long[] mk_tokenSet_5() {
    3260 		long[] data = new long[2048];
    3261 		data[0]=-17179869192L;
    3262 		for (int i = 1; i<=1023; i++) { data[i]=-1L; }
    3263 		return data;
    3264 	}
    3265 	public static final BitSet _tokenSet_5 = new BitSet(mk_tokenSet_5());
    3266 	private static final long[] mk_tokenSet_6() {
    3267 		long[] data = new long[2048];
    3268 		data[0]=-145135534875656L;
    3269 		for (int i = 1; i<=1022; i++) { data[i]=-1L; }
    3270 		data[1023]=9223372036854775807L;
    3271 		return data;
    3272 	}
    3273 	public static final BitSet _tokenSet_6 = new BitSet(mk_tokenSet_6());
    3274 	private static final long[] mk_tokenSet_7() {
    3275 		long[] data = new long[2048];
    3276 		data[0]=-145204254352392L;
    3277 		for (int i = 1; i<=1022; i++) { data[i]=-1L; }
    3278 		data[1023]=9223372036854775807L;
    3279 		return data;
    3280 	}
    3281 	public static final BitSet _tokenSet_7 = new BitSet(mk_tokenSet_7());
    3282 	private static final long[] mk_tokenSet_8() {
    3283 		long[] data = new long[2048];
    3284 		data[0]=-9224L;
    3285 		for (int i = 1; i<=1023; i++) { data[i]=-1L; }
    3286 		return data;
    3287 	}
    3288 	public static final BitSet _tokenSet_8 = new BitSet(mk_tokenSet_8());
    3289 	private static final long[] mk_tokenSet_9() {
    3290 		long[] data = new long[2048];
    3291 		data[0]=-145204254352392L;
    3292 		data[1]=-268435457L;
    3293 		for (int i = 2; i<=1022; i++) { data[i]=-1L; }
    3294 		data[1023]=9223372036854775807L;
    3295 		return data;
    3296 	}
    3297 	public static final BitSet _tokenSet_9 = new BitSet(mk_tokenSet_9());
    3298 	private static final long[] mk_tokenSet_10() {
    3299 		long[] data = new long[1025];
    3300 		data[0]=287948901175001088L;
    3301 		data[1]=541165879422L;
    3302 		return data;
    3303 	}
    3304 	public static final BitSet _tokenSet_10 = new BitSet(mk_tokenSet_10());
    3305 	private static final long[] mk_tokenSet_11() {
    3306 		long[] data = new long[2048];
    3307 		data[0]=-70368744177672L;
    3308 		for (int i = 1; i<=1023; i++) { data[i]=-1L; }
    3309 		return data;
    3310 	}
    3311 	public static final BitSet _tokenSet_11 = new BitSet(mk_tokenSet_11());
    3312
    3313 	}