001    // $ANTLR 2.7.6 (2005-12-22): "groovy.g" -> "GroovyLexer.java"$
002    
003    package org.codehaus.groovy.antlr.parser;
004    import org.codehaus.groovy.antlr.*;
005    import java.util.*;
006    import java.io.InputStream;
007    import java.io.Reader;
008    import antlr.InputBuffer;
009    import antlr.LexerSharedInputState;
010    
011    import java.io.InputStream;
012    import antlr.TokenStreamException;
013    import antlr.TokenStreamIOException;
014    import antlr.TokenStreamRecognitionException;
015    import antlr.CharStreamException;
016    import antlr.CharStreamIOException;
017    import antlr.ANTLRException;
018    import java.io.Reader;
019    import java.util.Hashtable;
020    import antlr.CharScanner;
021    import antlr.InputBuffer;
022    import antlr.ByteBuffer;
023    import antlr.CharBuffer;
024    import antlr.Token;
025    import antlr.CommonToken;
026    import antlr.RecognitionException;
027    import antlr.NoViableAltForCharException;
028    import antlr.MismatchedCharException;
029    import antlr.TokenStream;
030    import antlr.ANTLRHashString;
031    import antlr.LexerSharedInputState;
032    import antlr.collections.impl.BitSet;
033    import antlr.SemanticException;
034    
035    public class GroovyLexer extends antlr.CharScanner implements GroovyTokenTypes, TokenStream
036     {
037    
038        /** flag for enabling the "assert" keyword */
039        private boolean assertEnabled = true;
040        /** flag for enabling the "enum" keyword */
041        private boolean enumEnabled = true;
042        /** flag for including whitespace tokens (for IDE preparsing) */
043        private boolean whitespaceIncluded = false;
044    
045        /** Enable the "assert" keyword */
046        public void enableAssert(boolean shouldEnable) { assertEnabled = shouldEnable; }
047        /** Query the "assert" keyword state */
048        public boolean isAssertEnabled() { return assertEnabled; }
049        /** Enable the "enum" keyword */
050        public void enableEnum(boolean shouldEnable) { enumEnabled = shouldEnable; }
051        /** Query the "enum" keyword state */
052        public boolean isEnumEnabled() { return enumEnabled; }
053    
054        /** Include whitespace tokens.  Note that this breaks the parser.   */
055        public void setWhitespaceIncluded(boolean z) { whitespaceIncluded = z; }
056        /** Are whitespace tokens included? */
057        public boolean isWhitespaceIncluded() { return whitespaceIncluded; }
058    
059        {
060            // Initialization actions performed on construction.
061            setTabSize(1);  // get rid of special tab interpretation, for IDEs and general clarity
062        }
063    
064        /** Bumped when inside '[x]' or '(x)', reset inside '{x}'.  See ONE_NL.  */
065        protected int parenLevel = 0;
066        protected int suppressNewline = 0;  // be really mean to newlines inside strings
067        protected static final int SCS_TYPE = 3, SCS_VAL = 4, SCS_LIT = 8, SCS_LIMIT = 16;
068        protected static final int SCS_SQ_TYPE = 0, SCS_TQ_TYPE = 1, SCS_RE_TYPE = 2;
069        protected int stringCtorState = 0;  // hack string and regexp constructor boundaries
070        /** Push parenLevel here and reset whenever inside '{x}'. */
071        protected ArrayList parenLevelStack = new ArrayList();
072        protected int lastSigTokenType = EOF;  // last returned non-whitespace token
073    
074        protected void pushParenLevel() {
075            parenLevelStack.add(new Integer(parenLevel*SCS_LIMIT + stringCtorState));
076            parenLevel = 0;
077            stringCtorState = 0;
078        }
079        protected void popParenLevel() {
080            int npl = parenLevelStack.size();
081            if (npl == 0)  return;
082            int i = ((Integer) parenLevelStack.remove(--npl)).intValue();
083            parenLevel      = i / SCS_LIMIT;
084            stringCtorState = i % SCS_LIMIT;
085        }
086    
087        protected void restartStringCtor(boolean expectLiteral) {
088            if (stringCtorState != 0) {
089                stringCtorState = (expectLiteral? SCS_LIT: SCS_VAL) + (stringCtorState & SCS_TYPE);
090            }
091        }
092        
093        protected boolean allowRegexpLiteral() {
094            return !isExpressionEndingToken(lastSigTokenType);
095        }
096    
097        /** Return true for an operator or punctuation which can end an expression.
098         *  Return true for keywords, identifiers, and literals.
099         *  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 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            }