001// $ANTLR 2.7.7 (20141024): "java.g" -> "GeneratedJavaLexer.java"$
002
003package com.puppycrawl.tools.checkstyle.grammars;
004
005import com.puppycrawl.tools.checkstyle.api.DetailAST;
006import java.text.MessageFormat;
007import antlr.CommonToken;
008
009import java.io.InputStream;
010import antlr.TokenStreamException;
011import antlr.TokenStreamIOException;
012import antlr.TokenStreamRecognitionException;
013import antlr.CharStreamException;
014import antlr.CharStreamIOException;
015import antlr.ANTLRException;
016import java.io.Reader;
017import java.util.Hashtable;
018import antlr.CharScanner;
019import antlr.InputBuffer;
020import antlr.ByteBuffer;
021import antlr.CharBuffer;
022import antlr.Token;
023import antlr.CommonToken;
024import antlr.RecognitionException;
025import antlr.NoViableAltForCharException;
026import antlr.MismatchedCharException;
027import antlr.TokenStream;
028import antlr.ANTLRHashString;
029import antlr.LexerSharedInputState;
030import antlr.collections.impl.BitSet;
031import antlr.SemanticException;
032
033public class GeneratedJavaLexer extends antlr.CharScanner implements GeneratedJavaTokenTypes, TokenStream
034 {
035
036
037    // explicitly set tab width to 1 (default in ANTLR 2.7.1)
038    // in ANTLR 2.7.2a2 the default has changed from 1 to 8
039    public void tab()
040    {
041        setColumn( getColumn() + 1 );
042    }
043
044    private CommentListener mCommentListener = null;
045
046    // TODO: Check visibility of this method one parsing is done in central
047    // utility method
048    public void setCommentListener(CommentListener aCommentListener)
049    {
050        mCommentListener = aCommentListener;
051    }
052
053    private boolean mTreatAssertAsKeyword = true;
054
055    public void setTreatAssertAsKeyword(boolean aTreatAsKeyword)
056    {
057        mTreatAssertAsKeyword = aTreatAsKeyword;
058    }
059
060    private boolean mTreatEnumAsKeyword = true;
061
062    public void setTreatEnumAsKeyword(boolean aTreatAsKeyword)
063    {
064        mTreatEnumAsKeyword = aTreatAsKeyword;
065    }
066
067public GeneratedJavaLexer(InputStream in) {
068        this(new ByteBuffer(in));
069}
070public GeneratedJavaLexer(Reader in) {
071        this(new CharBuffer(in));
072}
073public GeneratedJavaLexer(InputBuffer ib) {
074        this(new LexerSharedInputState(ib));
075}
076public GeneratedJavaLexer(LexerSharedInputState state) {
077        super(state);
078        caseSensitiveLiterals = true;
079        setCaseSensitive(true);
080        literals = new Hashtable();
081        literals.put(new ANTLRHashString("byte", this), new Integer(52));
082        literals.put(new ANTLRHashString("public", this), new Integer(63));
083        literals.put(new ANTLRHashString("case", this), new Integer(95));
084        literals.put(new ANTLRHashString("short", this), new Integer(54));
085        literals.put(new ANTLRHashString("break", this), new Integer(88));
086        literals.put(new ANTLRHashString("while", this), new Integer(86));
087        literals.put(new ANTLRHashString("new", this), new Integer(138));
088        literals.put(new ANTLRHashString("instanceof", this), new Integer(123));
089        literals.put(new ANTLRHashString("implements", this), new Integer(76));
090        literals.put(new ANTLRHashString("synchronized", this), new Integer(68));
091        literals.put(new ANTLRHashString("float", this), new Integer(56));
092        literals.put(new ANTLRHashString("package", this), new Integer(45));
093        literals.put(new ANTLRHashString("return", this), new Integer(90));
094        literals.put(new ANTLRHashString("throw", this), new Integer(92));
095        literals.put(new ANTLRHashString("null", this), new Integer(137));
096        literals.put(new ANTLRHashString("protected", this), new Integer(64));
097        literals.put(new ANTLRHashString("class", this), new Integer(70));
098        literals.put(new ANTLRHashString("throws", this), new Integer(82));
099        literals.put(new ANTLRHashString("do", this), new Integer(87));
100        literals.put(new ANTLRHashString("strictfp", this), new Integer(42));
101        literals.put(new ANTLRHashString("super", this), new Integer(80));
102        literals.put(new ANTLRHashString("transient", this), new Integer(66));
103        literals.put(new ANTLRHashString("native", this), new Integer(67));
104        literals.put(new ANTLRHashString("interface", this), new Integer(72));
105        literals.put(new ANTLRHashString("final", this), new Integer(40));
106        literals.put(new ANTLRHashString("if", this), new Integer(85));
107        literals.put(new ANTLRHashString("double", this), new Integer(58));
108        literals.put(new ANTLRHashString("volatile", this), new Integer(69));
109        literals.put(new ANTLRHashString("catch", this), new Integer(98));
110        literals.put(new ANTLRHashString("try", this), new Integer(97));
111        literals.put(new ANTLRHashString("int", this), new Integer(55));
112        literals.put(new ANTLRHashString("for", this), new Integer(93));
113        literals.put(new ANTLRHashString("extends", this), new Integer(71));
114        literals.put(new ANTLRHashString("boolean", this), new Integer(51));
115        literals.put(new ANTLRHashString("char", this), new Integer(53));
116        literals.put(new ANTLRHashString("private", this), new Integer(62));
117        literals.put(new ANTLRHashString("default", this), new Integer(96));
118        literals.put(new ANTLRHashString("false", this), new Integer(136));
119        literals.put(new ANTLRHashString("this", this), new Integer(79));
120        literals.put(new ANTLRHashString("static", this), new Integer(65));
121        literals.put(new ANTLRHashString("abstract", this), new Integer(41));
122        literals.put(new ANTLRHashString("continue", this), new Integer(89));
123        literals.put(new ANTLRHashString("finally", this), new Integer(99));
124        literals.put(new ANTLRHashString("else", this), new Integer(94));
125        literals.put(new ANTLRHashString("import", this), new Integer(47));
126        literals.put(new ANTLRHashString("void", this), new Integer(50));
127        literals.put(new ANTLRHashString("switch", this), new Integer(91));
128        literals.put(new ANTLRHashString("true", this), new Integer(135));
129        literals.put(new ANTLRHashString("long", this), new Integer(57));
130}
131
132public Token nextToken() throws TokenStreamException {
133        Token theRetToken=null;
134tryAgain:
135        for (;;) {
136                Token _token = null;
137                int _ttype = Token.INVALID_TYPE;
138                resetText();
139                try {   // for char stream error handling
140                        try {   // for lexical error handling
141                                switch ( LA(1)) {
142                                case '?':
143                                {
144                                        mQUESTION(true);
145                                        theRetToken=_returnToken;
146                                        break;
147                                }
148                                case '(':
149                                {
150                                        mLPAREN(true);
151                                        theRetToken=_returnToken;
152                                        break;
153                                }
154                                case ')':
155                                {
156                                        mRPAREN(true);
157                                        theRetToken=_returnToken;
158                                        break;
159                                }
160                                case '[':
161                                {
162                                        mLBRACK(true);
163                                        theRetToken=_returnToken;
164                                        break;
165                                }
166                                case ']':
167                                {
168                                        mRBRACK(true);
169                                        theRetToken=_returnToken;
170                                        break;
171                                }
172                                case '{':
173                                {
174                                        mLCURLY(true);
175                                        theRetToken=_returnToken;
176                                        break;
177                                }
178                                case '}':
179                                {
180                                        mRCURLY(true);
181                                        theRetToken=_returnToken;
182                                        break;
183                                }
184                                case ',':
185                                {
186                                        mCOMMA(true);
187                                        theRetToken=_returnToken;
188                                        break;
189                                }
190                                case '~':
191                                {
192                                        mBNOT(true);
193                                        theRetToken=_returnToken;
194                                        break;
195                                }
196                                case ';':
197                                {
198                                        mSEMI(true);
199                                        theRetToken=_returnToken;
200                                        break;
201                                }
202                                case '@':
203                                {
204                                        mAT(true);
205                                        theRetToken=_returnToken;
206                                        break;
207                                }
208                                case '\t':  case '\n':  case '\u000c':  case '\r':
209                                case ' ':
210                                {
211                                        mWS(true);
212                                        theRetToken=_returnToken;
213                                        break;
214                                }
215                                case '\'':
216                                {
217                                        mCHAR_LITERAL(true);
218                                        theRetToken=_returnToken;
219                                        break;
220                                }
221                                case '"':
222                                {
223                                        mSTRING_LITERAL(true);
224                                        theRetToken=_returnToken;
225                                        break;
226                                }
227                                case '.':  case '0':  case '1':  case '2':
228                                case '3':  case '4':  case '5':  case '6':
229                                case '7':  case '8':  case '9':
230                                {
231                                        mNUM_INT(true);
232                                        theRetToken=_returnToken;
233                                        break;
234                                }
235                                default:
236                                        if ((LA(1)=='>') && (LA(2)=='>') && (LA(3)=='>') && (LA(4)=='=')) {
237                                                mBSR_ASSIGN(true);
238                                                theRetToken=_returnToken;
239                                        }
240                                        else if ((LA(1)=='>') && (LA(2)=='>') && (LA(3)=='=')) {
241                                                mSR_ASSIGN(true);
242                                                theRetToken=_returnToken;
243                                        }
244                                        else if ((LA(1)=='>') && (LA(2)=='>') && (LA(3)=='>') && (true)) {
245                                                mBSR(true);
246                                                theRetToken=_returnToken;
247                                        }
248                                        else if ((LA(1)=='<') && (LA(2)=='<') && (LA(3)=='=')) {
249                                                mSL_ASSIGN(true);
250                                                theRetToken=_returnToken;
251                                        }
252                                        else if ((LA(1)==':') && (LA(2)==':')) {
253                                                mDOUBLE_COLON(true);
254                                                theRetToken=_returnToken;
255                                        }
256                                        else if ((LA(1)=='=') && (LA(2)=='=')) {
257                                                mEQUAL(true);
258                                                theRetToken=_returnToken;
259                                        }
260                                        else if ((LA(1)=='!') && (LA(2)=='=')) {
261                                                mNOT_EQUAL(true);
262                                                theRetToken=_returnToken;
263                                        }
264                                        else if ((LA(1)=='/') && (LA(2)=='=')) {
265                                                mDIV_ASSIGN(true);
266                                                theRetToken=_returnToken;
267                                        }
268                                        else if ((LA(1)=='+') && (LA(2)=='=')) {
269                                                mPLUS_ASSIGN(true);
270                                                theRetToken=_returnToken;
271                                        }
272                                        else if ((LA(1)=='+') && (LA(2)=='+')) {
273                                                mINC(true);
274                                                theRetToken=_returnToken;
275                                        }
276                                        else if ((LA(1)=='-') && (LA(2)=='=')) {
277                                                mMINUS_ASSIGN(true);
278                                                theRetToken=_returnToken;
279                                        }
280                                        else if ((LA(1)=='-') && (LA(2)=='-')) {
281                                                mDEC(true);
282                                                theRetToken=_returnToken;
283                                        }
284                                        else if ((LA(1)=='*') && (LA(2)=='=')) {
285                                                mSTAR_ASSIGN(true);
286                                                theRetToken=_returnToken;
287                                        }
288                                        else if ((LA(1)=='%') && (LA(2)=='=')) {
289                                                mMOD_ASSIGN(true);
290                                                theRetToken=_returnToken;
291                                        }
292                                        else if ((LA(1)=='>') && (LA(2)=='>') && (true)) {
293                                                mSR(true);
294                                                theRetToken=_returnToken;
295                                        }
296                                        else if ((LA(1)=='>') && (LA(2)=='=')) {
297                                                mGE(true);
298                                                theRetToken=_returnToken;
299                                        }
300                                        else if ((LA(1)=='<') && (LA(2)=='<') && (true)) {
301                                                mSL(true);
302                                                theRetToken=_returnToken;
303                                        }
304                                        else if ((LA(1)=='<') && (LA(2)=='=')) {
305                                                mLE(true);
306                                                theRetToken=_returnToken;
307                                        }
308                                        else if ((LA(1)=='-') && (LA(2)=='>')) {
309                                                mLAMBDA(true);
310                                                theRetToken=_returnToken;
311                                        }
312                                        else if ((LA(1)=='^') && (LA(2)=='=')) {
313                                                mBXOR_ASSIGN(true);
314                                                theRetToken=_returnToken;
315                                        }
316                                        else if ((LA(1)=='|') && (LA(2)=='=')) {
317                                                mBOR_ASSIGN(true);
318                                                theRetToken=_returnToken;
319                                        }
320                                        else if ((LA(1)=='|') && (LA(2)=='|')) {
321                                                mLOR(true);
322                                                theRetToken=_returnToken;
323                                        }
324                                        else if ((LA(1)=='&') && (LA(2)=='=')) {
325                                                mBAND_ASSIGN(true);
326                                                theRetToken=_returnToken;
327                                        }
328                                        else if ((LA(1)=='&') && (LA(2)=='&')) {
329                                                mLAND(true);
330                                                theRetToken=_returnToken;
331                                        }
332                                        else if ((LA(1)=='/') && (LA(2)=='/')) {
333                                                mSL_COMMENT(true);
334                                                theRetToken=_returnToken;
335                                        }
336                                        else if ((LA(1)=='/') && (LA(2)=='*')) {
337                                                mML_COMMENT(true);
338                                                theRetToken=_returnToken;
339                                        }
340                                        else if ((LA(1)==':') && (true)) {
341                                                mCOLON(true);
342                                                theRetToken=_returnToken;
343                                        }
344                                        else if ((LA(1)=='=') && (true)) {
345                                                mASSIGN(true);
346                                                theRetToken=_returnToken;
347                                        }
348                                        else if ((LA(1)=='!') && (true)) {
349                                                mLNOT(true);
350                                                theRetToken=_returnToken;
351                                        }
352                                        else if ((LA(1)=='/') && (true)) {
353                                                mDIV(true);
354                                                theRetToken=_returnToken;
355                                        }
356                                        else if ((LA(1)=='+') && (true)) {
357                                                mPLUS(true);
358                                                theRetToken=_returnToken;
359                                        }
360                                        else if ((LA(1)=='-') && (true)) {
361                                                mMINUS(true);
362                                                theRetToken=_returnToken;
363                                        }
364                                        else if ((LA(1)=='*') && (true)) {
365                                                mSTAR(true);
366                                                theRetToken=_returnToken;
367                                        }
368                                        else if ((LA(1)=='%') && (true)) {
369                                                mMOD(true);
370                                                theRetToken=_returnToken;
371                                        }
372                                        else if ((LA(1)=='>') && (true)) {
373                                                mGT(true);
374                                                theRetToken=_returnToken;
375                                        }
376                                        else if ((LA(1)=='<') && (true)) {
377                                                mLT(true);
378                                                theRetToken=_returnToken;
379                                        }
380                                        else if ((LA(1)=='^') && (true)) {
381                                                mBXOR(true);
382                                                theRetToken=_returnToken;
383                                        }
384                                        else if ((LA(1)=='|') && (true)) {
385                                                mBOR(true);
386                                                theRetToken=_returnToken;
387                                        }
388                                        else if ((LA(1)=='&') && (true)) {
389                                                mBAND(true);
390                                                theRetToken=_returnToken;
391                                        }
392                                        else if ((_tokenSet_0.member(LA(1)))) {
393                                                mIDENT(true);
394                                                theRetToken=_returnToken;
395                                        }
396                                else {
397                                        if (LA(1)==EOF_CHAR) {uponEOF(); _returnToken = makeToken(Token.EOF_TYPE);}
398                                else {throw new NoViableAltForCharException((char)LA(1), getFilename(), getLine(), getColumn());}
399                                }
400                                }
401                                if ( _returnToken==null ) continue tryAgain; // found SKIP token
402                                _ttype = _returnToken.getType();
403                                _returnToken.setType(_ttype);
404                                return _returnToken;
405                        }
406                        catch (RecognitionException e) {
407                                throw new TokenStreamRecognitionException(e);
408                        }
409                }
410                catch (CharStreamException cse) {
411                        if ( cse instanceof CharStreamIOException ) {
412                                throw new TokenStreamIOException(((CharStreamIOException)cse).io);
413                        }
414                        else {
415                                throw new TokenStreamException(cse.getMessage());
416                        }
417                }
418        }
419}
420
421        public final void mQUESTION(boolean _createToken) throws RecognitionException, CharStreamException, TokenStreamException {
422                int _ttype; Token _token=null; int _begin=text.length();
423                _ttype = QUESTION;
424                int _saveIndex;
425                
426                match('?');
427                if ( _createToken && _token==null && _ttype!=Token.SKIP ) {
428                        _token = makeToken(_ttype);
429                        _token.setText(new String(text.getBuffer(), _begin, text.length()-_begin));
430                }
431                _returnToken = _token;
432        }
433        
434        public final void mLPAREN(boolean _createToken) throws RecognitionException, CharStreamException, TokenStreamException {
435                int _ttype; Token _token=null; int _begin=text.length();
436                _ttype = LPAREN;
437                int _saveIndex;
438                
439                match('(');
440                if ( _createToken && _token==null && _ttype!=Token.SKIP ) {
441                        _token = makeToken(_ttype);
442                        _token.setText(new String(text.getBuffer(), _begin, text.length()-_begin));
443                }
444                _returnToken = _token;
445        }
446        
447        public final void mRPAREN(boolean _createToken) throws RecognitionException, CharStreamException, TokenStreamException {
448                int _ttype; Token _token=null; int _begin=text.length();
449                _ttype = RPAREN;
450                int _saveIndex;
451                
452                match(')');
453                if ( _createToken && _token==null && _ttype!=Token.SKIP ) {
454                        _token = makeToken(_ttype);
455                        _token.setText(new String(text.getBuffer(), _begin, text.length()-_begin));
456                }
457                _returnToken = _token;
458        }
459        
460        public final void mLBRACK(boolean _createToken) throws RecognitionException, CharStreamException, TokenStreamException {
461                int _ttype; Token _token=null; int _begin=text.length();
462                _ttype = LBRACK;
463                int _saveIndex;
464                
465                match('[');
466                if ( _createToken && _token==null && _ttype!=Token.SKIP ) {
467                        _token = makeToken(_ttype);
468                        _token.setText(new String(text.getBuffer(), _begin, text.length()-_begin));
469                }
470                _returnToken = _token;
471        }
472        
473        public final void mRBRACK(boolean _createToken) throws RecognitionException, CharStreamException, TokenStreamException {
474                int _ttype; Token _token=null; int _begin=text.length();
475                _ttype = RBRACK;
476                int _saveIndex;
477                
478                match(']');
479                if ( _createToken && _token==null && _ttype!=Token.SKIP ) {
480                        _token = makeToken(_ttype);
481                        _token.setText(new String(text.getBuffer(), _begin, text.length()-_begin));
482                }
483                _returnToken = _token;
484        }
485        
486        public final void mLCURLY(boolean _createToken) throws RecognitionException, CharStreamException, TokenStreamException {
487                int _ttype; Token _token=null; int _begin=text.length();
488                _ttype = LCURLY;
489                int _saveIndex;
490                
491                match('{');
492                if ( _createToken && _token==null && _ttype!=Token.SKIP ) {
493                        _token = makeToken(_ttype);
494                        _token.setText(new String(text.getBuffer(), _begin, text.length()-_begin));
495                }
496                _returnToken = _token;
497        }
498        
499        public final void mRCURLY(boolean _createToken) throws RecognitionException, CharStreamException, TokenStreamException {
500                int _ttype; Token _token=null; int _begin=text.length();
501                _ttype = RCURLY;
502                int _saveIndex;
503                
504                match('}');
505                if ( _createToken && _token==null && _ttype!=Token.SKIP ) {
506                        _token = makeToken(_ttype);
507                        _token.setText(new String(text.getBuffer(), _begin, text.length()-_begin));
508                }
509                _returnToken = _token;
510        }
511        
512        public final void mCOLON(boolean _createToken) throws RecognitionException, CharStreamException, TokenStreamException {
513                int _ttype; Token _token=null; int _begin=text.length();
514                _ttype = COLON;
515                int _saveIndex;
516                
517                match(':');
518                if ( _createToken && _token==null && _ttype!=Token.SKIP ) {
519                        _token = makeToken(_ttype);
520                        _token.setText(new String(text.getBuffer(), _begin, text.length()-_begin));
521                }
522                _returnToken = _token;
523        }
524        
525        public final void mDOUBLE_COLON(boolean _createToken) throws RecognitionException, CharStreamException, TokenStreamException {
526                int _ttype; Token _token=null; int _begin=text.length();
527                _ttype = DOUBLE_COLON;
528                int _saveIndex;
529                
530                match("::");
531                if ( _createToken && _token==null && _ttype!=Token.SKIP ) {
532                        _token = makeToken(_ttype);
533                        _token.setText(new String(text.getBuffer(), _begin, text.length()-_begin));
534                }
535                _returnToken = _token;
536        }
537        
538        public final void mCOMMA(boolean _createToken) throws RecognitionException, CharStreamException, TokenStreamException {
539                int _ttype; Token _token=null; int _begin=text.length();
540                _ttype = COMMA;
541                int _saveIndex;
542                
543                match(',');
544                if ( _createToken && _token==null && _ttype!=Token.SKIP ) {
545                        _token = makeToken(_ttype);
546                        _token.setText(new String(text.getBuffer(), _begin, text.length()-_begin));
547                }
548                _returnToken = _token;
549        }
550        
551        public final void mASSIGN(boolean _createToken) throws RecognitionException, CharStreamException, TokenStreamException {
552                int _ttype; Token _token=null; int _begin=text.length();
553                _ttype = ASSIGN;
554                int _saveIndex;
555                
556                match('=');
557                if ( _createToken && _token==null && _ttype!=Token.SKIP ) {
558                        _token = makeToken(_ttype);
559                        _token.setText(new String(text.getBuffer(), _begin, text.length()-_begin));
560                }
561                _returnToken = _token;
562        }
563        
564        public final void mEQUAL(boolean _createToken) throws RecognitionException, CharStreamException, TokenStreamException {
565                int _ttype; Token _token=null; int _begin=text.length();
566                _ttype = EQUAL;
567                int _saveIndex;
568                
569                match("==");
570                if ( _createToken && _token==null && _ttype!=Token.SKIP ) {
571                        _token = makeToken(_ttype);
572                        _token.setText(new String(text.getBuffer(), _begin, text.length()-_begin));
573                }
574                _returnToken = _token;
575        }
576        
577        public final void mLNOT(boolean _createToken) throws RecognitionException, CharStreamException, TokenStreamException {
578                int _ttype; Token _token=null; int _begin=text.length();
579                _ttype = LNOT;
580                int _saveIndex;
581                
582                match('!');
583                if ( _createToken && _token==null && _ttype!=Token.SKIP ) {
584                        _token = makeToken(_ttype);
585                        _token.setText(new String(text.getBuffer(), _begin, text.length()-_begin));
586                }
587                _returnToken = _token;
588        }
589        
590        public final void mBNOT(boolean _createToken) throws RecognitionException, CharStreamException, TokenStreamException {
591                int _ttype; Token _token=null; int _begin=text.length();
592                _ttype = BNOT;
593                int _saveIndex;
594                
595                match('~');
596                if ( _createToken && _token==null && _ttype!=Token.SKIP ) {
597                        _token = makeToken(_ttype);
598                        _token.setText(new String(text.getBuffer(), _begin, text.length()-_begin));
599                }
600                _returnToken = _token;
601        }
602        
603        public final void mNOT_EQUAL(boolean _createToken) throws RecognitionException, CharStreamException, TokenStreamException {
604                int _ttype; Token _token=null; int _begin=text.length();
605                _ttype = NOT_EQUAL;
606                int _saveIndex;
607                
608                match("!=");
609                if ( _createToken && _token==null && _ttype!=Token.SKIP ) {
610                        _token = makeToken(_ttype);
611                        _token.setText(new String(text.getBuffer(), _begin, text.length()-_begin));
612                }
613                _returnToken = _token;
614        }
615        
616        public final void mDIV(boolean _createToken) throws RecognitionException, CharStreamException, TokenStreamException {
617                int _ttype; Token _token=null; int _begin=text.length();
618                _ttype = DIV;
619                int _saveIndex;
620                
621                match('/');
622                if ( _createToken && _token==null && _ttype!=Token.SKIP ) {
623                        _token = makeToken(_ttype);
624                        _token.setText(new String(text.getBuffer(), _begin, text.length()-_begin));
625                }
626                _returnToken = _token;
627        }
628        
629        public final void mDIV_ASSIGN(boolean _createToken) throws RecognitionException, CharStreamException, TokenStreamException {
630                int _ttype; Token _token=null; int _begin=text.length();
631                _ttype = DIV_ASSIGN;
632                int _saveIndex;
633                
634                match("/=");
635                if ( _createToken && _token==null && _ttype!=Token.SKIP ) {
636                        _token = makeToken(_ttype);
637                        _token.setText(new String(text.getBuffer(), _begin, text.length()-_begin));
638                }
639                _returnToken = _token;
640        }
641        
642        public final void mPLUS(boolean _createToken) throws RecognitionException, CharStreamException, TokenStreamException {
643                int _ttype; Token _token=null; int _begin=text.length();
644                _ttype = PLUS;
645                int _saveIndex;
646                
647                match('+');
648                if ( _createToken && _token==null && _ttype!=Token.SKIP ) {
649                        _token = makeToken(_ttype);
650                        _token.setText(new String(text.getBuffer(), _begin, text.length()-_begin));
651                }
652                _returnToken = _token;
653        }
654        
655        public final void mPLUS_ASSIGN(boolean _createToken) throws RecognitionException, CharStreamException, TokenStreamException {
656                int _ttype; Token _token=null; int _begin=text.length();
657                _ttype = PLUS_ASSIGN;
658                int _saveIndex;
659                
660                match("+=");
661                if ( _createToken && _token==null && _ttype!=Token.SKIP ) {
662                        _token = makeToken(_ttype);
663                        _token.setText(new String(text.getBuffer(), _begin, text.length()-_begin));
664                }
665                _returnToken = _token;
666        }
667        
668        public final void mINC(boolean _createToken) throws RecognitionException, CharStreamException, TokenStreamException {
669                int _ttype; Token _token=null; int _begin=text.length();
670                _ttype = INC;
671                int _saveIndex;
672                
673                match("++");
674                if ( _createToken && _token==null && _ttype!=Token.SKIP ) {
675                        _token = makeToken(_ttype);
676                        _token.setText(new String(text.getBuffer(), _begin, text.length()-_begin));
677                }
678                _returnToken = _token;
679        }
680        
681        public final void mMINUS(boolean _createToken) throws RecognitionException, CharStreamException, TokenStreamException {
682                int _ttype; Token _token=null; int _begin=text.length();
683                _ttype = MINUS;
684                int _saveIndex;
685                
686                match('-');
687                if ( _createToken && _token==null && _ttype!=Token.SKIP ) {
688                        _token = makeToken(_ttype);
689                        _token.setText(new String(text.getBuffer(), _begin, text.length()-_begin));
690                }
691                _returnToken = _token;
692        }
693        
694        public final void mMINUS_ASSIGN(boolean _createToken) throws RecognitionException, CharStreamException, TokenStreamException {
695                int _ttype; Token _token=null; int _begin=text.length();
696                _ttype = MINUS_ASSIGN;
697                int _saveIndex;
698                
699                match("-=");
700                if ( _createToken && _token==null && _ttype!=Token.SKIP ) {
701                        _token = makeToken(_ttype);
702                        _token.setText(new String(text.getBuffer(), _begin, text.length()-_begin));
703                }
704                _returnToken = _token;
705        }
706        
707        public final void mDEC(boolean _createToken) throws RecognitionException, CharStreamException, TokenStreamException {
708                int _ttype; Token _token=null; int _begin=text.length();
709                _ttype = DEC;
710                int _saveIndex;
711                
712                match("--");
713                if ( _createToken && _token==null && _ttype!=Token.SKIP ) {
714                        _token = makeToken(_ttype);
715                        _token.setText(new String(text.getBuffer(), _begin, text.length()-_begin));
716                }
717                _returnToken = _token;
718        }
719        
720        public final void mSTAR(boolean _createToken) throws RecognitionException, CharStreamException, TokenStreamException {
721                int _ttype; Token _token=null; int _begin=text.length();
722                _ttype = STAR;
723                int _saveIndex;
724                
725                match('*');
726                if ( _createToken && _token==null && _ttype!=Token.SKIP ) {
727                        _token = makeToken(_ttype);
728                        _token.setText(new String(text.getBuffer(), _begin, text.length()-_begin));
729                }
730                _returnToken = _token;
731        }
732        
733        public final void mSTAR_ASSIGN(boolean _createToken) throws RecognitionException, CharStreamException, TokenStreamException {
734                int _ttype; Token _token=null; int _begin=text.length();
735                _ttype = STAR_ASSIGN;
736                int _saveIndex;
737                
738                match("*=");
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 mMOD(boolean _createToken) throws RecognitionException, CharStreamException, TokenStreamException {
747                int _ttype; Token _token=null; int _begin=text.length();
748                _ttype = MOD;
749                int _saveIndex;
750                
751                match('%');
752                if ( _createToken && _token==null && _ttype!=Token.SKIP ) {
753                        _token = makeToken(_ttype);
754                        _token.setText(new String(text.getBuffer(), _begin, text.length()-_begin));
755                }
756                _returnToken = _token;
757        }
758        
759        public final void mMOD_ASSIGN(boolean _createToken) throws RecognitionException, CharStreamException, TokenStreamException {
760                int _ttype; Token _token=null; int _begin=text.length();
761                _ttype = MOD_ASSIGN;
762                int _saveIndex;
763                
764                match("%=");
765                if ( _createToken && _token==null && _ttype!=Token.SKIP ) {
766                        _token = makeToken(_ttype);
767                        _token.setText(new String(text.getBuffer(), _begin, text.length()-_begin));
768                }
769                _returnToken = _token;
770        }
771        
772        public final void mSR(boolean _createToken) throws RecognitionException, CharStreamException, TokenStreamException {
773                int _ttype; Token _token=null; int _begin=text.length();
774                _ttype = SR;
775                int _saveIndex;
776                
777                match(">>");
778                if ( _createToken && _token==null && _ttype!=Token.SKIP ) {
779                        _token = makeToken(_ttype);
780                        _token.setText(new String(text.getBuffer(), _begin, text.length()-_begin));
781                }
782                _returnToken = _token;
783        }
784        
785        public final void mSR_ASSIGN(boolean _createToken) throws RecognitionException, CharStreamException, TokenStreamException {
786                int _ttype; Token _token=null; int _begin=text.length();
787                _ttype = SR_ASSIGN;
788                int _saveIndex;
789                
790                match(">>=");
791                if ( _createToken && _token==null && _ttype!=Token.SKIP ) {
792                        _token = makeToken(_ttype);
793                        _token.setText(new String(text.getBuffer(), _begin, text.length()-_begin));
794                }
795                _returnToken = _token;
796        }
797        
798        public final void mBSR(boolean _createToken) throws RecognitionException, CharStreamException, TokenStreamException {
799                int _ttype; Token _token=null; int _begin=text.length();
800                _ttype = BSR;
801                int _saveIndex;
802                
803                match(">>>");
804                if ( _createToken && _token==null && _ttype!=Token.SKIP ) {
805                        _token = makeToken(_ttype);
806                        _token.setText(new String(text.getBuffer(), _begin, text.length()-_begin));
807                }
808                _returnToken = _token;
809        }
810        
811        public final void mBSR_ASSIGN(boolean _createToken) throws RecognitionException, CharStreamException, TokenStreamException {
812                int _ttype; Token _token=null; int _begin=text.length();
813                _ttype = BSR_ASSIGN;
814                int _saveIndex;
815                
816                match(">>>=");
817                if ( _createToken && _token==null && _ttype!=Token.SKIP ) {
818                        _token = makeToken(_ttype);
819                        _token.setText(new String(text.getBuffer(), _begin, text.length()-_begin));
820                }
821                _returnToken = _token;
822        }
823        
824        public final void mGE(boolean _createToken) throws RecognitionException, CharStreamException, TokenStreamException {
825                int _ttype; Token _token=null; int _begin=text.length();
826                _ttype = GE;
827                int _saveIndex;
828                
829                match(">=");
830                if ( _createToken && _token==null && _ttype!=Token.SKIP ) {
831                        _token = makeToken(_ttype);
832                        _token.setText(new String(text.getBuffer(), _begin, text.length()-_begin));
833                }
834                _returnToken = _token;
835        }
836        
837        public final void mGT(boolean _createToken) throws RecognitionException, CharStreamException, TokenStreamException {
838                int _ttype; Token _token=null; int _begin=text.length();
839                _ttype = GT;
840                int _saveIndex;
841                
842                match(">");
843                if ( _createToken && _token==null && _ttype!=Token.SKIP ) {
844                        _token = makeToken(_ttype);
845                        _token.setText(new String(text.getBuffer(), _begin, text.length()-_begin));
846                }
847                _returnToken = _token;
848        }
849        
850        public final void mSL(boolean _createToken) throws RecognitionException, CharStreamException, TokenStreamException {
851                int _ttype; Token _token=null; int _begin=text.length();
852                _ttype = SL;
853                int _saveIndex;
854                
855                match("<<");
856                if ( _createToken && _token==null && _ttype!=Token.SKIP ) {
857                        _token = makeToken(_ttype);
858                        _token.setText(new String(text.getBuffer(), _begin, text.length()-_begin));
859                }
860                _returnToken = _token;
861        }
862        
863        public final void mSL_ASSIGN(boolean _createToken) throws RecognitionException, CharStreamException, TokenStreamException {
864                int _ttype; Token _token=null; int _begin=text.length();
865                _ttype = SL_ASSIGN;
866                int _saveIndex;
867                
868                match("<<=");
869                if ( _createToken && _token==null && _ttype!=Token.SKIP ) {
870                        _token = makeToken(_ttype);
871                        _token.setText(new String(text.getBuffer(), _begin, text.length()-_begin));
872                }
873                _returnToken = _token;
874        }
875        
876        public final void mLE(boolean _createToken) throws RecognitionException, CharStreamException, TokenStreamException {
877                int _ttype; Token _token=null; int _begin=text.length();
878                _ttype = LE;
879                int _saveIndex;
880                
881                match("<=");
882                if ( _createToken && _token==null && _ttype!=Token.SKIP ) {
883                        _token = makeToken(_ttype);
884                        _token.setText(new String(text.getBuffer(), _begin, text.length()-_begin));
885                }
886                _returnToken = _token;
887        }
888        
889        public final void mLT(boolean _createToken) throws RecognitionException, CharStreamException, TokenStreamException {
890                int _ttype; Token _token=null; int _begin=text.length();
891                _ttype = LT;
892                int _saveIndex;
893                
894                match('<');
895                if ( _createToken && _token==null && _ttype!=Token.SKIP ) {
896                        _token = makeToken(_ttype);
897                        _token.setText(new String(text.getBuffer(), _begin, text.length()-_begin));
898                }
899                _returnToken = _token;
900        }
901        
902        public final void mLAMBDA(boolean _createToken) throws RecognitionException, CharStreamException, TokenStreamException {
903                int _ttype; Token _token=null; int _begin=text.length();
904                _ttype = LAMBDA;
905                int _saveIndex;
906                
907                match("->");
908                if ( _createToken && _token==null && _ttype!=Token.SKIP ) {
909                        _token = makeToken(_ttype);
910                        _token.setText(new String(text.getBuffer(), _begin, text.length()-_begin));
911                }
912                _returnToken = _token;
913        }
914        
915        public final void mBXOR(boolean _createToken) throws RecognitionException, CharStreamException, TokenStreamException {
916                int _ttype; Token _token=null; int _begin=text.length();
917                _ttype = BXOR;
918                int _saveIndex;
919                
920                match('^');
921                if ( _createToken && _token==null && _ttype!=Token.SKIP ) {
922                        _token = makeToken(_ttype);
923                        _token.setText(new String(text.getBuffer(), _begin, text.length()-_begin));
924                }
925                _returnToken = _token;
926        }
927        
928        public final void mBXOR_ASSIGN(boolean _createToken) throws RecognitionException, CharStreamException, TokenStreamException {
929                int _ttype; Token _token=null; int _begin=text.length();
930                _ttype = BXOR_ASSIGN;
931                int _saveIndex;
932                
933                match("^=");
934                if ( _createToken && _token==null && _ttype!=Token.SKIP ) {
935                        _token = makeToken(_ttype);
936                        _token.setText(new String(text.getBuffer(), _begin, text.length()-_begin));
937                }
938                _returnToken = _token;
939        }
940        
941        public final void mBOR(boolean _createToken) throws RecognitionException, CharStreamException, TokenStreamException {
942                int _ttype; Token _token=null; int _begin=text.length();
943                _ttype = BOR;
944                int _saveIndex;
945                
946                match('|');
947                if ( _createToken && _token==null && _ttype!=Token.SKIP ) {
948                        _token = makeToken(_ttype);
949                        _token.setText(new String(text.getBuffer(), _begin, text.length()-_begin));
950                }
951                _returnToken = _token;
952        }
953        
954        public final void mBOR_ASSIGN(boolean _createToken) throws RecognitionException, CharStreamException, TokenStreamException {
955                int _ttype; Token _token=null; int _begin=text.length();
956                _ttype = BOR_ASSIGN;
957                int _saveIndex;
958                
959                match("|=");
960                if ( _createToken && _token==null && _ttype!=Token.SKIP ) {
961                        _token = makeToken(_ttype);
962                        _token.setText(new String(text.getBuffer(), _begin, text.length()-_begin));
963                }
964                _returnToken = _token;
965        }
966        
967        public final void mLOR(boolean _createToken) throws RecognitionException, CharStreamException, TokenStreamException {
968                int _ttype; Token _token=null; int _begin=text.length();
969                _ttype = LOR;
970                int _saveIndex;
971                
972                match("||");
973                if ( _createToken && _token==null && _ttype!=Token.SKIP ) {
974                        _token = makeToken(_ttype);
975                        _token.setText(new String(text.getBuffer(), _begin, text.length()-_begin));
976                }
977                _returnToken = _token;
978        }
979        
980        public final void mBAND(boolean _createToken) throws RecognitionException, CharStreamException, TokenStreamException {
981                int _ttype; Token _token=null; int _begin=text.length();
982                _ttype = BAND;
983                int _saveIndex;
984                
985                match('&');
986                if ( _createToken && _token==null && _ttype!=Token.SKIP ) {
987                        _token = makeToken(_ttype);
988                        _token.setText(new String(text.getBuffer(), _begin, text.length()-_begin));
989                }
990                _returnToken = _token;
991        }
992        
993        public final void mBAND_ASSIGN(boolean _createToken) throws RecognitionException, CharStreamException, TokenStreamException {
994                int _ttype; Token _token=null; int _begin=text.length();
995                _ttype = BAND_ASSIGN;
996                int _saveIndex;
997                
998                match("&=");
999                if ( _createToken && _token==null && _ttype!=Token.SKIP ) {
1000                        _token = makeToken(_ttype);
1001                        _token.setText(new String(text.getBuffer(), _begin, text.length()-_begin));
1002                }
1003                _returnToken = _token;
1004        }
1005        
1006        public final void mLAND(boolean _createToken) throws RecognitionException, CharStreamException, TokenStreamException {
1007                int _ttype; Token _token=null; int _begin=text.length();
1008                _ttype = LAND;
1009                int _saveIndex;
1010                
1011                match("&&");
1012                if ( _createToken && _token==null && _ttype!=Token.SKIP ) {
1013                        _token = makeToken(_ttype);
1014                        _token.setText(new String(text.getBuffer(), _begin, text.length()-_begin));
1015                }
1016                _returnToken = _token;
1017        }
1018        
1019        public final void mSEMI(boolean _createToken) throws RecognitionException, CharStreamException, TokenStreamException {
1020                int _ttype; Token _token=null; int _begin=text.length();
1021                _ttype = SEMI;
1022                int _saveIndex;
1023                
1024                match(';');
1025                if ( _createToken && _token==null && _ttype!=Token.SKIP ) {
1026                        _token = makeToken(_ttype);
1027                        _token.setText(new String(text.getBuffer(), _begin, text.length()-_begin));
1028                }
1029                _returnToken = _token;
1030        }
1031        
1032        public final void mAT(boolean _createToken) throws RecognitionException, CharStreamException, TokenStreamException {
1033                int _ttype; Token _token=null; int _begin=text.length();
1034                _ttype = AT;
1035                int _saveIndex;
1036                
1037                match('@');
1038                if ( _createToken && _token==null && _ttype!=Token.SKIP ) {
1039                        _token = makeToken(_ttype);
1040                        _token.setText(new String(text.getBuffer(), _begin, text.length()-_begin));
1041                }
1042                _returnToken = _token;
1043        }
1044        
1045        public final void mWS(boolean _createToken) throws RecognitionException, CharStreamException, TokenStreamException {
1046                int _ttype; Token _token=null; int _begin=text.length();
1047                _ttype = WS;
1048                int _saveIndex;
1049                
1050                {
1051                int _cnt417=0;
1052                _loop417:
1053                do {
1054                        switch ( LA(1)) {
1055                        case ' ':
1056                        {
1057                                match(' ');
1058                                break;
1059                        }
1060                        case '\t':
1061                        {
1062                                match('\t');
1063                                break;
1064                        }
1065                        case '\u000c':
1066                        {
1067                                match('\f');
1068                                break;
1069                        }
1070                        case '\n':  case '\r':
1071                        {
1072                                {
1073                                if ((LA(1)=='\r') && (LA(2)=='\n') && (true) && (true)) {
1074                                        match("\r\n");
1075                                }
1076                                else if ((LA(1)=='\r') && (true) && (true) && (true)) {
1077                                        match('\r');
1078                                }
1079                                else if ((LA(1)=='\n')) {
1080                                        match('\n');
1081                                }
1082                                else {
1083                                        throw new NoViableAltForCharException((char)LA(1), getFilename(), getLine(), getColumn());
1084                                }
1085                                
1086                                }
1087                                if ( inputState.guessing==0 ) {
1088                                        newline();
1089                                }
1090                                break;
1091                        }
1092                        default:
1093                        {
1094                                if ( _cnt417>=1 ) { break _loop417; } else {throw new NoViableAltForCharException((char)LA(1), getFilename(), getLine(), getColumn());}
1095                        }
1096                        }
1097                        _cnt417++;
1098                } while (true);
1099                }
1100                if ( inputState.guessing==0 ) {
1101                        _ttype = Token.SKIP;
1102                }
1103                if ( _createToken && _token==null && _ttype!=Token.SKIP ) {
1104                        _token = makeToken(_ttype);
1105                        _token.setText(new String(text.getBuffer(), _begin, text.length()-_begin));
1106                }
1107                _returnToken = _token;
1108        }
1109        
1110        public final void mSL_COMMENT(boolean _createToken) throws RecognitionException, CharStreamException, TokenStreamException {
1111                int _ttype; Token _token=null; int _begin=text.length();
1112                _ttype = SL_COMMENT;
1113                int _saveIndex;
1114                
1115                match("//");
1116                if ( inputState.guessing==0 ) {
1117                        mCommentListener.reportSingleLineComment("//", getLine(),
1118                        getColumn() - 3);
1119                }
1120                {
1121                _loop421:
1122                do {
1123                        if ((_tokenSet_1.member(LA(1)))) {
1124                                {
1125                                match(_tokenSet_1);
1126                                }
1127                        }
1128                        else {
1129                                break _loop421;
1130                        }
1131                        
1132                } while (true);
1133                }
1134                {
1135                switch ( LA(1)) {
1136                case '\n':
1137                {
1138                        match('\n');
1139                        break;
1140                }
1141                case '\r':
1142                {
1143                        match('\r');
1144                        {
1145                        if ((LA(1)=='\n')) {
1146                                match('\n');
1147                        }
1148                        else {
1149                        }
1150                        
1151                        }
1152                        break;
1153                }
1154                default:
1155                        {
1156                        }
1157                }
1158                }
1159                if ( inputState.guessing==0 ) {
1160                        _ttype = Token.SKIP; newline();
1161                }
1162                if ( _createToken && _token==null && _ttype!=Token.SKIP ) {
1163                        _token = makeToken(_ttype);
1164                        _token.setText(new String(text.getBuffer(), _begin, text.length()-_begin));
1165                }
1166                _returnToken = _token;
1167        }
1168        
1169        public final void mML_COMMENT(boolean _createToken) throws RecognitionException, CharStreamException, TokenStreamException {
1170                int _ttype; Token _token=null; int _begin=text.length();
1171                _ttype = ML_COMMENT;
1172                int _saveIndex;
1173                
1174                int startLine = -1;
1175                int startCol = -1;
1176                
1177                
1178                match("/*");
1179                if ( inputState.guessing==0 ) {
1180                        startLine = getLine(); startCol = getColumn() - 3;
1181                }
1182                {
1183                _loop427:
1184                do {
1185                        if ((LA(1)=='\r') && (LA(2)=='\n') && ((LA(3) >= '\u0000' && LA(3) <= '\ufffe')) && ((LA(4) >= '\u0000' && LA(4) <= '\ufffe'))) {
1186                                match('\r');
1187                                match('\n');
1188                                if ( inputState.guessing==0 ) {
1189                                        newline();
1190                                }
1191                        }
1192                        else if (((LA(1)=='*') && ((LA(2) >= '\u0000' && LA(2) <= '\ufffe')) && ((LA(3) >= '\u0000' && LA(3) <= '\ufffe')))&&( LA(2)!='/' )) {
1193                                match('*');
1194                        }
1195                        else if ((LA(1)=='\r') && ((LA(2) >= '\u0000' && LA(2) <= '\ufffe')) && ((LA(3) >= '\u0000' && LA(3) <= '\ufffe')) && (true)) {
1196                                match('\r');
1197                                if ( inputState.guessing==0 ) {
1198                                        newline();
1199                                }
1200                        }
1201                        else if ((LA(1)=='\n')) {
1202                                match('\n');
1203                                if ( inputState.guessing==0 ) {
1204                                        newline();
1205                                }
1206                        }
1207                        else if ((_tokenSet_2.member(LA(1)))) {
1208                                {
1209                                match(_tokenSet_2);
1210                                }
1211                        }
1212                        else {
1213                                break _loop427;
1214                        }
1215                        
1216                } while (true);
1217                }
1218                match("*/");
1219                if ( inputState.guessing==0 ) {
1220                        
1221                        mCommentListener.reportBlockComment("/*", startLine, startCol,
1222                        getLine(), getColumn() - 2);
1223                        _ttype = Token.SKIP;
1224                        
1225                }
1226                if ( _createToken && _token==null && _ttype!=Token.SKIP ) {
1227                        _token = makeToken(_ttype);
1228                        _token.setText(new String(text.getBuffer(), _begin, text.length()-_begin));
1229                }
1230                _returnToken = _token;
1231        }
1232        
1233        public final void mCHAR_LITERAL(boolean _createToken) throws RecognitionException, CharStreamException, TokenStreamException {
1234                int _ttype; Token _token=null; int _begin=text.length();
1235                _ttype = CHAR_LITERAL;
1236                int _saveIndex;
1237                
1238                match('\'');
1239                {
1240                if ((LA(1)=='\\')) {
1241                        mESC(false);
1242                }
1243                else if ((_tokenSet_3.member(LA(1)))) {
1244                        matchNot('\'');
1245                }
1246                else {
1247                        throw new NoViableAltForCharException((char)LA(1), getFilename(), getLine(), getColumn());
1248                }
1249                
1250                }
1251                match('\'');
1252                if ( _createToken && _token==null && _ttype!=Token.SKIP ) {
1253                        _token = makeToken(_ttype);
1254                        _token.setText(new String(text.getBuffer(), _begin, text.length()-_begin));
1255                }
1256                _returnToken = _token;
1257        }
1258        
1259        protected final void mESC(boolean _createToken) throws RecognitionException, CharStreamException, TokenStreamException {
1260                int _ttype; Token _token=null; int _begin=text.length();
1261                _ttype = ESC;
1262                int _saveIndex;
1263                
1264                match('\\');
1265                {
1266                switch ( LA(1)) {
1267                case 'u':
1268                {
1269                        {
1270                        int _cnt436=0;
1271                        _loop436:
1272                        do {
1273                                if ((LA(1)=='u')) {
1274                                        match('u');
1275                                }
1276                                else {
1277                                        if ( _cnt436>=1 ) { break _loop436; } else {throw new NoViableAltForCharException((char)LA(1), getFilename(), getLine(), getColumn());}
1278                                }
1279                                
1280                                _cnt436++;
1281                        } while (true);
1282                        }
1283                        {
1284                        if ((LA(1)=='0') && (LA(2)=='0') && (LA(3)=='5') && (LA(4)=='C'||LA(4)=='c')) {
1285                                match('0');
1286                                match('0');
1287                                match('5');
1288                                {
1289                                switch ( LA(1)) {
1290                                case 'c':
1291                                {
1292                                        match('c');
1293                                        break;
1294                                }
1295                                case 'C':
1296                                {
1297                                        match('C');
1298                                        break;
1299                                }
1300                                default:
1301                                {
1302                                        throw new NoViableAltForCharException((char)LA(1), getFilename(), getLine(), getColumn());
1303                                }
1304                                }
1305                                }
1306                                {
1307                                if ((LA(1)=='\\') && (LA(2)=='u') && (LA(3)=='0'||LA(3)=='u') && (LA(4)=='0'||LA(4)=='u')) {
1308                                        match('\\');
1309                                        {
1310                                        int _cnt441=0;
1311                                        _loop441:
1312                                        do {
1313                                                if ((LA(1)=='u')) {
1314                                                        match('u');
1315                                                }
1316                                                else {
1317                                                        if ( _cnt441>=1 ) { break _loop441; } else {throw new NoViableAltForCharException((char)LA(1), getFilename(), getLine(), getColumn());}
1318                                                }
1319                                                
1320                                                _cnt441++;
1321                                        } while (true);
1322                                        }
1323                                        match('0');
1324                                        match('0');
1325                                        match('5');
1326                                        {
1327                                        switch ( LA(1)) {
1328                                        case 'c':
1329                                        {
1330                                                match('c');
1331                                                break;
1332                                        }
1333                                        case 'C':
1334                                        {
1335                                                match('C');
1336                                                break;
1337                                        }
1338                                        default:
1339                                        {
1340                                                throw new NoViableAltForCharException((char)LA(1), getFilename(), getLine(), getColumn());
1341                                        }
1342                                        }
1343                                        }
1344                                }
1345                                else if ((LA(1)=='"'||LA(1)=='\''||LA(1)=='0'||LA(1)=='1'||LA(1)=='2'||LA(1)=='3'||LA(1)=='4'||LA(1)=='5'||LA(1)=='6'||LA(1)=='7'||LA(1)=='\\'||LA(1)=='b'||LA(1)=='f'||LA(1)=='n'||LA(1)=='r'||LA(1)=='t') && ((LA(2) >= '\u0000' && LA(2) <= '\ufffe')) && (true) && (true)) {
1346                                        mSTD_ESC(false);
1347                                }
1348                                else {
1349                                        throw new NoViableAltForCharException((char)LA(1), getFilename(), getLine(), getColumn());
1350                                }
1351                                
1352                                }
1353                        }
1354                        else if ((_tokenSet_4.member(LA(1))) && (_tokenSet_4.member(LA(2))) && (_tokenSet_4.member(LA(3))) && (_tokenSet_4.member(LA(4)))) {
1355                                mHEX_DIGIT(false);
1356                                mHEX_DIGIT(false);
1357                                mHEX_DIGIT(false);
1358                                mHEX_DIGIT(false);
1359                        }
1360                        else {
1361                                throw new NoViableAltForCharException((char)LA(1), getFilename(), getLine(), getColumn());
1362                        }
1363                        
1364                        }
1365                        break;
1366                }
1367                case '"':  case '\'':  case '0':  case '1':
1368                case '2':  case '3':  case '4':  case '5':
1369                case '6':  case '7':  case '\\':  case 'b':
1370                case 'f':  case 'n':  case 'r':  case 't':
1371                {
1372                        mSTD_ESC(false);
1373                        break;
1374                }
1375                default:
1376                {
1377                        throw new NoViableAltForCharException((char)LA(1), getFilename(), getLine(), getColumn());
1378                }
1379                }
1380                }
1381                if ( _createToken && _token==null && _ttype!=Token.SKIP ) {
1382                        _token = makeToken(_ttype);
1383                        _token.setText(new String(text.getBuffer(), _begin, text.length()-_begin));
1384                }
1385                _returnToken = _token;
1386        }
1387        
1388        public final void mSTRING_LITERAL(boolean _createToken) throws RecognitionException, CharStreamException, TokenStreamException {
1389                int _ttype; Token _token=null; int _begin=text.length();
1390                _ttype = STRING_LITERAL;
1391                int _saveIndex;
1392                
1393                match('"');
1394                {
1395                _loop432:
1396                do {
1397                        if ((LA(1)=='\\')) {
1398                                mESC(false);
1399                        }
1400                        else if ((_tokenSet_5.member(LA(1)))) {
1401                                matchNot('"');
1402                        }
1403                        else {
1404                                break _loop432;
1405                        }
1406                        
1407                } while (true);
1408                }
1409                match('"');
1410                if ( _createToken && _token==null && _ttype!=Token.SKIP ) {
1411                        _token = makeToken(_ttype);
1412                        _token.setText(new String(text.getBuffer(), _begin, text.length()-_begin));
1413                }
1414                _returnToken = _token;
1415        }
1416        
1417        protected final void mSTD_ESC(boolean _createToken) throws RecognitionException, CharStreamException, TokenStreamException {
1418                int _ttype; Token _token=null; int _begin=text.length();
1419                _ttype = STD_ESC;
1420                int _saveIndex;
1421                
1422                switch ( LA(1)) {
1423                case 'n':
1424                {
1425                        match('n');
1426                        break;
1427                }
1428                case 'r':
1429                {
1430                        match('r');
1431                        break;
1432                }
1433                case 't':
1434                {
1435                        match('t');
1436                        break;
1437                }
1438                case 'b':
1439                {
1440                        match('b');
1441                        break;
1442                }
1443                case 'f':
1444                {
1445                        match('f');
1446                        break;
1447                }
1448                case '"':
1449                {
1450                        match('"');
1451                        break;
1452                }
1453                case '\'':
1454                {
1455                        match('\'');
1456                        break;
1457                }
1458                case '\\':
1459                {
1460                        match('\\');
1461                        break;
1462                }
1463                case '0':  case '1':  case '2':  case '3':
1464                {
1465                        {
1466                        matchRange('0','3');
1467                        }
1468                        {
1469                        if (((LA(1) >= '0' && LA(1) <= '7')) && ((LA(2) >= '\u0000' && LA(2) <= '\ufffe')) && (true) && (true)) {
1470                                {
1471                                matchRange('0','7');
1472                                }
1473                                {
1474                                if (((LA(1) >= '0' && LA(1) <= '7')) && ((LA(2) >= '\u0000' && LA(2) <= '\ufffe')) && (true) && (true)) {
1475                                        matchRange('0','7');
1476                                }
1477                                else if (((LA(1) >= '\u0000' && LA(1) <= '\ufffe')) && (true) && (true) && (true)) {
1478                                }
1479                                else {
1480                                        throw new NoViableAltForCharException((char)LA(1), getFilename(), getLine(), getColumn());
1481                                }
1482                                
1483                                }
1484                        }
1485                        else if (((LA(1) >= '\u0000' && LA(1) <= '\ufffe')) && (true) && (true) && (true)) {
1486                        }
1487                        else {
1488                                throw new NoViableAltForCharException((char)LA(1), getFilename(), getLine(), getColumn());
1489                        }
1490                        
1491                        }
1492                        break;
1493                }
1494                case '4':  case '5':  case '6':  case '7':
1495                {
1496                        {
1497                        matchRange('4','7');
1498                        }
1499                        {
1500                        if (((LA(1) >= '0' && LA(1) <= '9')) && ((LA(2) >= '\u0000' && LA(2) <= '\ufffe')) && (true) && (true)) {
1501                                {
1502                                matchRange('0','9');
1503                                }
1504                        }
1505                        else if (((LA(1) >= '\u0000' && LA(1) <= '\ufffe')) && (true) && (true) && (true)) {
1506                        }
1507                        else {
1508                                throw new NoViableAltForCharException((char)LA(1), getFilename(), getLine(), getColumn());
1509                        }
1510                        
1511                        }
1512                        break;
1513                }
1514                default:
1515                {
1516                        throw new NoViableAltForCharException((char)LA(1), getFilename(), getLine(), getColumn());
1517                }
1518                }
1519                if ( _createToken && _token==null && _ttype!=Token.SKIP ) {
1520                        _token = makeToken(_ttype);
1521                        _token.setText(new String(text.getBuffer(), _begin, text.length()-_begin));
1522                }
1523                _returnToken = _token;
1524        }
1525        
1526        protected final void mHEX_DIGIT(boolean _createToken) throws RecognitionException, CharStreamException, TokenStreamException {
1527                int _ttype; Token _token=null; int _begin=text.length();
1528                _ttype = HEX_DIGIT;
1529                int _saveIndex;
1530                
1531                {
1532                switch ( LA(1)) {
1533                case '0':  case '1':  case '2':  case '3':
1534                case '4':  case '5':  case '6':  case '7':
1535                case '8':  case '9':
1536                {
1537                        matchRange('0','9');
1538                        break;
1539                }
1540                case 'A':  case 'B':  case 'C':  case 'D':
1541                case 'E':  case 'F':
1542                {
1543                        matchRange('A','F');
1544                        break;
1545                }
1546                case 'a':  case 'b':  case 'c':  case 'd':
1547                case 'e':  case 'f':
1548                {
1549                        matchRange('a','f');
1550                        break;
1551                }
1552                default:
1553                {
1554                        throw new NoViableAltForCharException((char)LA(1), getFilename(), getLine(), getColumn());
1555                }
1556                }
1557                }
1558                if ( _createToken && _token==null && _ttype!=Token.SKIP ) {
1559                        _token = makeToken(_ttype);
1560                        _token.setText(new String(text.getBuffer(), _begin, text.length()-_begin));
1561                }
1562                _returnToken = _token;
1563        }
1564        
1565        protected final void mBINARY_DIGIT(boolean _createToken) throws RecognitionException, CharStreamException, TokenStreamException {
1566                int _ttype; Token _token=null; int _begin=text.length();
1567                _ttype = BINARY_DIGIT;
1568                int _saveIndex;
1569                
1570                {
1571                switch ( LA(1)) {
1572                case '0':
1573                {
1574                        match('0');
1575                        break;
1576                }
1577                case '1':
1578                {
1579                        match('1');
1580                        break;
1581                }
1582                default:
1583                {
1584                        throw new NoViableAltForCharException((char)LA(1), getFilename(), getLine(), getColumn());
1585                }
1586                }
1587                }
1588                if ( _createToken && _token==null && _ttype!=Token.SKIP ) {
1589                        _token = makeToken(_ttype);
1590                        _token.setText(new String(text.getBuffer(), _begin, text.length()-_begin));
1591                }
1592                _returnToken = _token;
1593        }
1594        
1595        protected final void mVOCAB(boolean _createToken) throws RecognitionException, CharStreamException, TokenStreamException {
1596                int _ttype; Token _token=null; int _begin=text.length();
1597                _ttype = VOCAB;
1598                int _saveIndex;
1599                
1600                matchRange('\3','\377');
1601                if ( _createToken && _token==null && _ttype!=Token.SKIP ) {
1602                        _token = makeToken(_ttype);
1603                        _token.setText(new String(text.getBuffer(), _begin, text.length()-_begin));
1604                }
1605                _returnToken = _token;
1606        }
1607        
1608        protected final void mID_START(boolean _createToken) throws RecognitionException, CharStreamException, TokenStreamException {
1609                int _ttype; Token _token=null; int _begin=text.length();
1610                _ttype = ID_START;
1611                int _saveIndex;
1612                
1613                try {      // for error handling
1614                        switch ( LA(1)) {
1615                        case '_':
1616                        {
1617                                match('_');
1618                                break;
1619                        }
1620                        case '$':
1621                        {
1622                                match('$');
1623                                break;
1624                        }
1625                        default:
1626                                if ((_tokenSet_6.member(LA(1)))) {
1627                                        {
1628                                        if (!(Character.isJavaIdentifierStart(LA(1))))
1629                                          throw new SemanticException("Character.isJavaIdentifierStart(LA(1))");
1630                                        {
1631                                        match(_tokenSet_6);
1632                                        }
1633                                        }
1634                                }
1635                        else {
1636                                throw new NoViableAltForCharException((char)LA(1), getFilename(), getLine(), getColumn());
1637                        }
1638                        }
1639                }
1640                catch (SemanticException ex) {
1641                        if (inputState.guessing==0) {
1642                                
1643                                throw new SemanticException(
1644                                MessageFormat.format(
1645                                "Unexpected character {0} in identifier",
1646                                new Object[] {"0x" + Integer.toHexString(LA(1))}),
1647                                getFilename(), getLine(), getColumn());
1648                                
1649                        } else {
1650                                throw ex;
1651                        }
1652                }
1653                if ( _createToken && _token==null && _ttype!=Token.SKIP ) {
1654                        _token = makeToken(_ttype);
1655                        _token.setText(new String(text.getBuffer(), _begin, text.length()-_begin));
1656                }
1657                _returnToken = _token;
1658        }
1659        
1660        protected final void mID_PART(boolean _createToken) throws RecognitionException, CharStreamException, TokenStreamException {
1661                int _ttype; Token _token=null; int _begin=text.length();
1662                _ttype = ID_PART;
1663                int _saveIndex;
1664                
1665                try {      // for error handling
1666                        switch ( LA(1)) {
1667                        case '_':
1668                        {
1669                                match('_');
1670                                break;
1671                        }
1672                        case '$':
1673                        {
1674                                match('$');
1675                                break;
1676                        }
1677                        default:
1678                                if ((_tokenSet_7.member(LA(1)))) {
1679                                        {
1680                                        if (!(Character.isJavaIdentifierPart(LA(1))))
1681                                          throw new SemanticException("Character.isJavaIdentifierPart(LA(1))");
1682                                        {
1683                                        match(_tokenSet_7);
1684                                        }
1685                                        }
1686                                }
1687                        else {
1688                                throw new NoViableAltForCharException((char)LA(1), getFilename(), getLine(), getColumn());
1689                        }
1690                        }
1691                }
1692                catch (SemanticException ex) {
1693                        if (inputState.guessing==0) {
1694                                
1695                                throw new SemanticException(
1696                                MessageFormat.format(
1697                                "Unexpected character {0} in identifier",
1698                                new Object[] {"0x" + Integer.toHexString(LA(1))}),
1699                                getFilename(), getLine(), getColumn());
1700                                
1701                        } else {
1702                                throw ex;
1703                        }
1704                }
1705                if ( _createToken && _token==null && _ttype!=Token.SKIP ) {
1706                        _token = makeToken(_ttype);
1707                        _token.setText(new String(text.getBuffer(), _begin, text.length()-_begin));
1708                }
1709                _returnToken = _token;
1710        }
1711        
1712        public final void mIDENT(boolean _createToken) throws RecognitionException, CharStreamException, TokenStreamException {
1713                int _ttype; Token _token=null; int _begin=text.length();
1714                _ttype = IDENT;
1715                int _saveIndex;
1716                
1717                mID_START(false);
1718                {
1719                _loop464:
1720                do {
1721                        if ((_tokenSet_8.member(LA(1)))) {
1722                                mID_PART(false);
1723                        }
1724                        else {
1725                                break _loop464;
1726                        }
1727                        
1728                } while (true);
1729                }
1730                if ( inputState.guessing==0 ) {
1731                        
1732                                                if (mTreatAssertAsKeyword && "assert".equals(new String(text.getBuffer(),_begin,text.length()-_begin))) {
1733                                                        _ttype = ASSERT;
1734                                                }
1735                                                if (mTreatEnumAsKeyword && "enum".equals(new String(text.getBuffer(),_begin,text.length()-_begin))) {
1736                                                        _ttype = ENUM;
1737                                                }
1738                        
1739                }
1740                _ttype = testLiteralsTable(_ttype);
1741                if ( _createToken && _token==null && _ttype!=Token.SKIP ) {
1742                        _token = makeToken(_ttype);
1743                        _token.setText(new String(text.getBuffer(), _begin, text.length()-_begin));
1744                }
1745                _returnToken = _token;
1746        }
1747        
1748        public final void mNUM_INT(boolean _createToken) throws RecognitionException, CharStreamException, TokenStreamException {
1749                int _ttype; Token _token=null; int _begin=text.length();
1750                _ttype = NUM_INT;
1751                int _saveIndex;
1752                
1753                boolean synPredMatched475 = false;
1754                if (((LA(1)=='0') && (LA(2)=='X'||LA(2)=='x') && (_tokenSet_9.member(LA(3))) && (_tokenSet_10.member(LA(4))))) {
1755                        int _m475 = mark();
1756                        synPredMatched475 = true;
1757                        inputState.guessing++;
1758                        try {
1759                                {
1760                                mHEX_DOUBLE_LITERAL(false);
1761                                }
1762                        }
1763                        catch (RecognitionException pe) {
1764                                synPredMatched475 = false;
1765                        }
1766                        rewind(_m475);
1767inputState.guessing--;
1768                }
1769                if ( synPredMatched475 ) {
1770                        mHEX_DOUBLE_LITERAL(false);
1771                        if ( inputState.guessing==0 ) {
1772                                _ttype = NUM_DOUBLE;
1773                        }
1774                }
1775                else {
1776                        boolean synPredMatched477 = false;
1777                        if (((LA(1)=='0') && (LA(2)=='X'||LA(2)=='x') && (_tokenSet_9.member(LA(3))) && (_tokenSet_10.member(LA(4))))) {
1778                                int _m477 = mark();
1779                                synPredMatched477 = true;
1780                                inputState.guessing++;
1781                                try {
1782                                        {
1783                                        mHEX_FLOAT_LITERAL(false);
1784                                        }
1785                                }
1786                                catch (RecognitionException pe) {
1787                                        synPredMatched477 = false;
1788                                }
1789                                rewind(_m477);
1790inputState.guessing--;
1791                        }
1792                        if ( synPredMatched477 ) {
1793                                mHEX_FLOAT_LITERAL(false);
1794                                if ( inputState.guessing==0 ) {
1795                                        _ttype = NUM_FLOAT;
1796                                }
1797                        }
1798                        else {
1799                                boolean synPredMatched467 = false;
1800                                if (((LA(1)=='.') && (LA(2)=='.') && (LA(3)=='.') && (true))) {
1801                                        int _m467 = mark();
1802                                        synPredMatched467 = true;
1803                                        inputState.guessing++;
1804                                        try {
1805                                                {
1806                                                mELLIPSIS(false);
1807                                                }
1808                                        }
1809                                        catch (RecognitionException pe) {
1810                                                synPredMatched467 = false;
1811                                        }
1812                                        rewind(_m467);
1813inputState.guessing--;
1814                                }
1815                                if ( synPredMatched467 ) {
1816                                        mELLIPSIS(false);
1817                                        if ( inputState.guessing==0 ) {
1818                                                _ttype = ELLIPSIS;
1819                                        }
1820                                }
1821                                else {
1822                                        boolean synPredMatched471 = false;
1823                                        if (((LA(1)=='.'||LA(1)=='0'||LA(1)=='1'||LA(1)=='2'||LA(1)=='3'||LA(1)=='4'||LA(1)=='5'||LA(1)=='6'||LA(1)=='7'||LA(1)=='8'||LA(1)=='9') && (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)=='8'||LA(2)=='9'||LA(2)=='D'||LA(2)=='E'||LA(2)=='_'||LA(2)=='d'||LA(2)=='e') && (true) && (true))) {
1824                                                int _m471 = mark();
1825                                                synPredMatched471 = true;
1826                                                inputState.guessing++;
1827                                                try {
1828                                                        {
1829                                                        mDOUBLE_LITERAL(false);
1830                                                        }
1831                                                }
1832                                                catch (RecognitionException pe) {
1833                                                        synPredMatched471 = false;
1834                                                }
1835                                                rewind(_m471);
1836inputState.guessing--;
1837                                        }
1838                                        if ( synPredMatched471 ) {
1839                                                mDOUBLE_LITERAL(false);
1840                                                if ( inputState.guessing==0 ) {
1841                                                        _ttype = NUM_DOUBLE;
1842                                                }
1843                                        }
1844                                        else {
1845                                                boolean synPredMatched473 = false;
1846                                                if (((LA(1)=='.'||LA(1)=='0'||LA(1)=='1'||LA(1)=='2'||LA(1)=='3'||LA(1)=='4'||LA(1)=='5'||LA(1)=='6'||LA(1)=='7'||LA(1)=='8'||LA(1)=='9') && (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)=='8'||LA(2)=='9'||LA(2)=='E'||LA(2)=='F'||LA(2)=='_'||LA(2)=='e'||LA(2)=='f') && (true) && (true))) {
1847                                                        int _m473 = mark();
1848                                                        synPredMatched473 = true;
1849                                                        inputState.guessing++;
1850                                                        try {
1851                                                                {
1852                                                                mFLOAT_LITERAL(false);
1853                                                                }
1854                                                        }
1855                                                        catch (RecognitionException pe) {
1856                                                                synPredMatched473 = false;
1857                                                        }
1858                                                        rewind(_m473);
1859inputState.guessing--;
1860                                                }
1861                                                if ( synPredMatched473 ) {
1862                                                        mFLOAT_LITERAL(false);
1863                                                        if ( inputState.guessing==0 ) {
1864                                                                _ttype = NUM_FLOAT;
1865                                                        }
1866                                                }
1867                                                else {
1868                                                        boolean synPredMatched479 = false;
1869                                                        if ((((LA(1) >= '0' && LA(1) <= '9')) && (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)=='8'||LA(2)=='9'||LA(2)=='B'||LA(2)=='L'||LA(2)=='X'||LA(2)=='_'||LA(2)=='b'||LA(2)=='l'||LA(2)=='x') && (true) && (true))) {
1870                                                                int _m479 = mark();
1871                                                                synPredMatched479 = true;
1872                                                                inputState.guessing++;
1873                                                                try {
1874                                                                        {
1875                                                                        mLONG_LITERAL(false);
1876                                                                        }
1877                                                                }
1878                                                                catch (RecognitionException pe) {
1879                                                                        synPredMatched479 = false;
1880                                                                }
1881                                                                rewind(_m479);
1882inputState.guessing--;
1883                                                        }
1884                                                        if ( synPredMatched479 ) {
1885                                                                mLONG_LITERAL(false);
1886                                                                if ( inputState.guessing==0 ) {
1887                                                                        _ttype = NUM_LONG;
1888                                                                }
1889                                                        }
1890                                                        else {
1891                                                                boolean synPredMatched469 = false;
1892                                                                if (((LA(1)=='.') && (true))) {
1893                                                                        int _m469 = mark();
1894                                                                        synPredMatched469 = true;
1895                                                                        inputState.guessing++;
1896                                                                        try {
1897                                                                                {
1898                                                                                mDOT(false);
1899                                                                                }
1900                                                                        }
1901                                                                        catch (RecognitionException pe) {
1902                                                                                synPredMatched469 = false;
1903                                                                        }
1904                                                                        rewind(_m469);
1905inputState.guessing--;
1906                                                                }
1907                                                                if ( synPredMatched469 ) {
1908                                                                        mDOT(false);
1909                                                                        if ( inputState.guessing==0 ) {
1910                                                                                _ttype = DOT;
1911                                                                        }
1912                                                                }
1913                                                                else {
1914                                                                        boolean synPredMatched481 = false;
1915                                                                        if ((((LA(1) >= '0' && LA(1) <= '9')) && (true) && (true) && (true))) {
1916                                                                                int _m481 = mark();
1917                                                                                synPredMatched481 = true;
1918                                                                                inputState.guessing++;
1919                                                                                try {
1920                                                                                        {
1921                                                                                        mINT_LITERAL(false);
1922                                                                                        }
1923                                                                                }
1924                                                                                catch (RecognitionException pe) {
1925                                                                                        synPredMatched481 = false;
1926                                                                                }
1927                                                                                rewind(_m481);
1928inputState.guessing--;
1929                                                                        }
1930                                                                        if ( synPredMatched481 ) {
1931                                                                                mINT_LITERAL(false);
1932                                                                                if ( inputState.guessing==0 ) {
1933                                                                                        _ttype = NUM_INT;
1934                                                                                }
1935                                                                        }
1936                                                                        else {
1937                                                                                throw new NoViableAltForCharException((char)LA(1), getFilename(), getLine(), getColumn());
1938                                                                        }
1939                                                                        }}}}}}}
1940                                                                        if ( _createToken && _token==null && _ttype!=Token.SKIP ) {
1941                                                                                _token = makeToken(_ttype);
1942                                                                                _token.setText(new String(text.getBuffer(), _begin, text.length()-_begin));
1943                                                                        }
1944                                                                        _returnToken = _token;
1945                                                                }
1946                                                                
1947        protected final void mELLIPSIS(boolean _createToken) throws RecognitionException, CharStreamException, TokenStreamException {
1948                int _ttype; Token _token=null; int _begin=text.length();
1949                _ttype = ELLIPSIS;
1950                int _saveIndex;
1951                
1952                match("...");
1953                if ( _createToken && _token==null && _ttype!=Token.SKIP ) {
1954                        _token = makeToken(_ttype);
1955                        _token.setText(new String(text.getBuffer(), _begin, text.length()-_begin));
1956                }
1957                _returnToken = _token;
1958        }
1959        
1960        protected final void mDOT(boolean _createToken) throws RecognitionException, CharStreamException, TokenStreamException {
1961                int _ttype; Token _token=null; int _begin=text.length();
1962                _ttype = DOT;
1963                int _saveIndex;
1964                
1965                match('.');
1966                if ( _createToken && _token==null && _ttype!=Token.SKIP ) {
1967                        _token = makeToken(_ttype);
1968                        _token.setText(new String(text.getBuffer(), _begin, text.length()-_begin));
1969                }
1970                _returnToken = _token;
1971        }
1972        
1973        protected final void mDOUBLE_LITERAL(boolean _createToken) throws RecognitionException, CharStreamException, TokenStreamException {
1974                int _ttype; Token _token=null; int _begin=text.length();
1975                _ttype = DOUBLE_LITERAL;
1976                int _saveIndex;
1977                
1978                {
1979                boolean synPredMatched583 = false;
1980                if (((LA(1)=='.'||LA(1)=='0'||LA(1)=='1'||LA(1)=='2'||LA(1)=='3'||LA(1)=='4'||LA(1)=='5'||LA(1)=='6'||LA(1)=='7'||LA(1)=='8'||LA(1)=='9') && (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)=='8'||LA(2)=='9'||LA(2)=='_') && (LA(3)=='.'||LA(3)=='0'||LA(3)=='1'||LA(3)=='2'||LA(3)=='3'||LA(3)=='4'||LA(3)=='5'||LA(3)=='6'||LA(3)=='7'||LA(3)=='8'||LA(3)=='9'||LA(3)=='D'||LA(3)=='E'||LA(3)=='_'||LA(3)=='d'||LA(3)=='e') && (true))) {
1981                        int _m583 = mark();
1982                        synPredMatched583 = true;
1983                        inputState.guessing++;
1984                        try {
1985                                {
1986                                {
1987                                switch ( LA(1)) {
1988                                case '0':  case '1':  case '2':  case '3':
1989                                case '4':  case '5':  case '6':  case '7':
1990                                case '8':  case '9':
1991                                {
1992                                        {
1993                                        matchRange('0','9');
1994                                        }
1995                                        {
1996                                        switch ( LA(1)) {
1997                                        case '0':  case '1':  case '2':  case '3':
1998                                        case '4':  case '5':  case '6':  case '7':
1999                                        case '8':  case '9':  case '_':
2000                                        {
2001                                                {
2002                                                _loop581:
2003                                                do {
2004                                                        if (((LA(1) >= '0' && LA(1) <= '9')) && (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)=='8'||LA(2)=='9'||LA(2)=='_')) {
2005                                                                matchRange('0','9');
2006                                                        }
2007                                                        else if ((LA(1)=='_')) {
2008                                                                match('_');
2009                                                        }
2010                                                        else {
2011                                                                break _loop581;
2012                                                        }
2013                                                        
2014                                                } while (true);
2015                                                }
2016                                                {
2017                                                matchRange('0','9');
2018                                                }
2019                                                break;
2020                                        }
2021                                        case '.':
2022                                        {
2023                                                break;
2024                                        }
2025                                        default:
2026                                        {
2027                                                throw new NoViableAltForCharException((char)LA(1), getFilename(), getLine(), getColumn());
2028                                        }
2029                                        }
2030                                        }
2031                                        break;
2032                                }
2033                                case '.':
2034                                {
2035                                        break;
2036                                }
2037                                default:
2038                                {
2039                                        throw new NoViableAltForCharException((char)LA(1), getFilename(), getLine(), getColumn());
2040                                }
2041                                }
2042                                }
2043                                match('.');
2044                                }
2045                        }
2046                        catch (RecognitionException pe) {
2047                                synPredMatched583 = false;
2048                        }
2049                        rewind(_m583);
2050inputState.guessing--;
2051                }
2052                if ( synPredMatched583 ) {
2053                        {
2054                        switch ( LA(1)) {
2055                        case '0':  case '1':  case '2':  case '3':
2056                        case '4':  case '5':  case '6':  case '7':
2057                        case '8':  case '9':
2058                        {
2059                                {
2060                                {
2061                                matchRange('0','9');
2062                                }
2063                                {
2064                                switch ( LA(1)) {
2065                                case '0':  case '1':  case '2':  case '3':
2066                                case '4':  case '5':  case '6':  case '7':
2067                                case '8':  case '9':  case '_':
2068                                {
2069                                        {
2070                                        _loop589:
2071                                        do {
2072                                                if (((LA(1) >= '0' && LA(1) <= '9')) && (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)=='8'||LA(2)=='9'||LA(2)=='_')) {
2073                                                        matchRange('0','9');
2074                                                }
2075                                                else if ((LA(1)=='_')) {
2076                                                        match('_');
2077                                                }
2078                                                else {
2079                                                        break _loop589;
2080                                                }
2081                                                
2082                                        } while (true);
2083                                        }
2084                                        {
2085                                        matchRange('0','9');
2086                                        }
2087                                        break;
2088                                }
2089                                case '.':
2090                                {
2091                                        break;
2092                                }
2093                                default:
2094                                {
2095                                        throw new NoViableAltForCharException((char)LA(1), getFilename(), getLine(), getColumn());
2096                                }
2097                                }
2098                                }
2099                                }
2100                                match('.');
2101                                {
2102                                switch ( LA(1)) {
2103                                case '0':  case '1':  case '2':  case '3':
2104                                case '4':  case '5':  case '6':  case '7':
2105                                case '8':  case '9':
2106                                {
2107                                        {
2108                                        matchRange('0','9');
2109                                        }
2110                                        {
2111                                        switch ( LA(1)) {
2112                                        case '0':  case '1':  case '2':  case '3':
2113                                        case '4':  case '5':  case '6':  case '7':
2114                                        case '8':  case '9':  case '_':
2115                                        {
2116                                                {
2117                                                _loop595:
2118                                                do {
2119                                                        if (((LA(1) >= '0' && LA(1) <= '9')) && (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)=='8'||LA(2)=='9'||LA(2)=='_')) {
2120                                                                matchRange('0','9');
2121                                                        }
2122                                                        else if ((LA(1)=='_')) {
2123                                                                match('_');
2124                                                        }
2125                                                        else {
2126                                                                break _loop595;
2127                                                        }
2128                                                        
2129                                                } while (true);
2130                                                }
2131                                                {
2132                                                matchRange('0','9');
2133                                                }
2134                                                break;
2135                                        }
2136                                        case 'D':  case 'E':  case 'd':  case 'e':
2137                                        {
2138                                                break;
2139                                        }
2140                                        default:
2141                                        {
2142                                                throw new NoViableAltForCharException((char)LA(1), getFilename(), getLine(), getColumn());
2143                                        }
2144                                        }
2145                                        }
2146                                        break;
2147                                }
2148                                case 'D':  case 'E':  case 'd':  case 'e':
2149                                {
2150                                        break;
2151                                }
2152                                default:
2153                                {
2154                                        throw new NoViableAltForCharException((char)LA(1), getFilename(), getLine(), getColumn());
2155                                }
2156                                }
2157                                }
2158                                break;
2159                        }
2160                        case '.':
2161                        {
2162                                match('.');
2163                                {
2164                                {
2165                                matchRange('0','9');
2166                                }
2167                                {
2168                                switch ( LA(1)) {
2169                                case '0':  case '1':  case '2':  case '3':
2170                                case '4':  case '5':  case '6':  case '7':
2171                                case '8':  case '9':  case '_':
2172                                {
2173                                        {
2174                                        _loop601:
2175                                        do {
2176                                                if (((LA(1) >= '0' && LA(1) <= '9')) && (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)=='8'||LA(2)=='9'||LA(2)=='_')) {
2177                                                        matchRange('0','9');
2178                                                }
2179                                                else if ((LA(1)=='_')) {
2180                                                        match('_');
2181                                                }
2182                                                else {
2183                                                        break _loop601;
2184                                                }
2185                                                
2186                                        } while (true);
2187                                        }
2188                                        {
2189                                        matchRange('0','9');
2190                                        }
2191                                        break;
2192                                }
2193                                case 'D':  case 'E':  case 'd':  case 'e':
2194                                {
2195                                        break;
2196                                }
2197                                default:
2198                                {
2199                                        throw new NoViableAltForCharException((char)LA(1), getFilename(), getLine(), getColumn());
2200                                }
2201                                }
2202                                }
2203                                }
2204                                break;
2205                        }
2206                        default:
2207                        {
2208                                throw new NoViableAltForCharException((char)LA(1), getFilename(), getLine(), getColumn());
2209                        }
2210                        }
2211                        }
2212                }
2213                else if (((LA(1) >= '0' && LA(1) <= '9')) && (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)=='8'||LA(2)=='9'||LA(2)=='D'||LA(2)=='E'||LA(2)=='_'||LA(2)=='d'||LA(2)=='e') && (true) && (true)) {
2214                        {
2215                        {
2216                        matchRange('0','9');
2217                        }
2218                        {
2219                        switch ( LA(1)) {
2220                        case '0':  case '1':  case '2':  case '3':
2221                        case '4':  case '5':  case '6':  case '7':
2222                        case '8':  case '9':  case '_':
2223                        {
2224                                {
2225                                _loop607:
2226                                do {
2227                                        if (((LA(1) >= '0' && LA(1) <= '9')) && (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)=='8'||LA(2)=='9'||LA(2)=='_')) {
2228                                                matchRange('0','9');
2229                                        }
2230                                        else if ((LA(1)=='_')) {
2231                                                match('_');
2232                                        }
2233                                        else {
2234                                                break _loop607;
2235                                        }
2236                                        
2237                                } while (true);
2238                                }
2239                                {
2240                                matchRange('0','9');
2241                                }
2242                                break;
2243                        }
2244                        case 'D':  case 'E':  case 'd':  case 'e':
2245                        {
2246                                break;
2247                        }
2248                        default:
2249                        {
2250                                throw new NoViableAltForCharException((char)LA(1), getFilename(), getLine(), getColumn());
2251                        }
2252                        }
2253                        }
2254                        }
2255                }
2256                else {
2257                        throw new NoViableAltForCharException((char)LA(1), getFilename(), getLine(), getColumn());
2258                }
2259                
2260                }
2261                {
2262                switch ( LA(1)) {
2263                case 'E':  case 'e':
2264                {
2265                        mEXPONENT(false);
2266                        break;
2267                }
2268                case 'D':  case 'd':
2269                {
2270                        break;
2271                }
2272                default:
2273                {
2274                        throw new NoViableAltForCharException((char)LA(1), getFilename(), getLine(), getColumn());
2275                }
2276                }
2277                }
2278                {
2279                switch ( LA(1)) {
2280                case 'd':
2281                {
2282                        match('d');
2283                        break;
2284                }
2285                case 'D':
2286                {
2287                        match('D');
2288                        break;
2289                }
2290                default:
2291                {
2292                        throw new NoViableAltForCharException((char)LA(1), getFilename(), getLine(), getColumn());
2293                }
2294                }
2295                }
2296                if ( _createToken && _token==null && _ttype!=Token.SKIP ) {
2297                        _token = makeToken(_ttype);
2298                        _token.setText(new String(text.getBuffer(), _begin, text.length()-_begin));
2299                }
2300                _returnToken = _token;
2301        }
2302        
2303        protected final void mFLOAT_LITERAL(boolean _createToken) throws RecognitionException, CharStreamException, TokenStreamException {
2304                int _ttype; Token _token=null; int _begin=text.length();
2305                _ttype = FLOAT_LITERAL;
2306                int _saveIndex;
2307                
2308                {
2309                boolean synPredMatched542 = false;
2310                if (((LA(1)=='.'||LA(1)=='0'||LA(1)=='1'||LA(1)=='2'||LA(1)=='3'||LA(1)=='4'||LA(1)=='5'||LA(1)=='6'||LA(1)=='7'||LA(1)=='8'||LA(1)=='9') && (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)=='8'||LA(2)=='9'||LA(2)=='_') && (true) && (true))) {
2311                        int _m542 = mark();
2312                        synPredMatched542 = true;
2313                        inputState.guessing++;
2314                        try {
2315                                {
2316                                {
2317                                switch ( LA(1)) {
2318                                case '0':  case '1':  case '2':  case '3':
2319                                case '4':  case '5':  case '6':  case '7':
2320                                case '8':  case '9':
2321                                {
2322                                        {
2323                                        matchRange('0','9');
2324                                        }
2325                                        {
2326                                        switch ( LA(1)) {
2327                                        case '0':  case '1':  case '2':  case '3':
2328                                        case '4':  case '5':  case '6':  case '7':
2329                                        case '8':  case '9':  case '_':
2330                                        {
2331                                                {
2332                                                _loop540:
2333                                                do {
2334                                                        if (((LA(1) >= '0' && LA(1) <= '9')) && (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)=='8'||LA(2)=='9'||LA(2)=='_')) {
2335                                                                matchRange('0','9');
2336                                                        }
2337                                                        else if ((LA(1)=='_')) {
2338                                                                match('_');
2339                                                        }
2340                                                        else {
2341                                                                break _loop540;
2342                                                        }
2343                                                        
2344                                                } while (true);
2345                                                }
2346                                                {
2347                                                matchRange('0','9');
2348                                                }
2349                                                break;
2350                                        }
2351                                        case '.':
2352                                        {
2353                                                break;
2354                                        }
2355                                        default:
2356                                        {
2357                                                throw new NoViableAltForCharException((char)LA(1), getFilename(), getLine(), getColumn());
2358                                        }
2359                                        }
2360                                        }
2361                                        break;
2362                                }
2363                                case '.':
2364                                {
2365                                        break;
2366                                }
2367                                default:
2368                                {
2369                                        throw new NoViableAltForCharException((char)LA(1), getFilename(), getLine(), getColumn());
2370                                }
2371                                }
2372                                }
2373                                match('.');
2374                                }
2375                        }
2376                        catch (RecognitionException pe) {
2377                                synPredMatched542 = false;
2378                        }
2379                        rewind(_m542);
2380inputState.guessing--;
2381                }
2382                if ( synPredMatched542 ) {
2383                        {
2384                        switch ( LA(1)) {
2385                        case '0':  case '1':  case '2':  case '3':
2386                        case '4':  case '5':  case '6':  case '7':
2387                        case '8':  case '9':
2388                        {
2389                                {
2390                                {
2391                                matchRange('0','9');
2392                                }
2393                                {
2394                                switch ( LA(1)) {
2395                                case '0':  case '1':  case '2':  case '3':
2396                                case '4':  case '5':  case '6':  case '7':
2397                                case '8':  case '9':  case '_':
2398                                {
2399                                        {
2400                                        _loop548:
2401                                        do {
2402                                                if (((LA(1) >= '0' && LA(1) <= '9')) && (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)=='8'||LA(2)=='9'||LA(2)=='_')) {
2403                                                        matchRange('0','9');
2404                                                }
2405                                                else if ((LA(1)=='_')) {
2406                                                        match('_');
2407                                                }
2408                                                else {
2409                                                        break _loop548;
2410                                                }
2411                                                
2412                                        } while (true);
2413                                        }
2414                                        {
2415                                        matchRange('0','9');
2416                                        }
2417                                        break;
2418                                }
2419                                case '.':
2420                                {
2421                                        break;
2422                                }
2423                                default:
2424                                {
2425                                        throw new NoViableAltForCharException((char)LA(1), getFilename(), getLine(), getColumn());
2426                                }
2427                                }
2428                                }
2429                                }
2430                                match('.');
2431                                {
2432                                if (((LA(1) >= '0' && LA(1) <= '9'))) {
2433                                        {
2434                                        matchRange('0','9');
2435                                        }
2436                                        {
2437                                        if ((LA(1)=='0'||LA(1)=='1'||LA(1)=='2'||LA(1)=='3'||LA(1)=='4'||LA(1)=='5'||LA(1)=='6'||LA(1)=='7'||LA(1)=='8'||LA(1)=='9'||LA(1)=='_')) {
2438                                                {
2439                                                _loop554:
2440                                                do {
2441                                                        if (((LA(1) >= '0' && LA(1) <= '9')) && (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)=='8'||LA(2)=='9'||LA(2)=='_')) {
2442                                                                matchRange('0','9');
2443                                                        }
2444                                                        else if ((LA(1)=='_')) {
2445                                                                match('_');
2446                                                        }
2447                                                        else {
2448                                                                break _loop554;
2449                                                        }
2450                                                        
2451                                                } while (true);
2452                                                }
2453                                                {
2454                                                matchRange('0','9');
2455                                                }
2456                                        }
2457                                        else {
2458                                        }
2459                                        
2460                                        }
2461                                }
2462                                else {
2463                                }
2464                                
2465                                }
2466                                break;
2467                        }
2468                        case '.':
2469                        {
2470                                match('.');
2471                                {
2472                                {
2473                                matchRange('0','9');
2474                                }
2475                                {
2476                                if ((LA(1)=='0'||LA(1)=='1'||LA(1)=='2'||LA(1)=='3'||LA(1)=='4'||LA(1)=='5'||LA(1)=='6'||LA(1)=='7'||LA(1)=='8'||LA(1)=='9'||LA(1)=='_')) {
2477                                        {
2478                                        _loop560:
2479                                        do {
2480                                                if (((LA(1) >= '0' && LA(1) <= '9')) && (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)=='8'||LA(2)=='9'||LA(2)=='_')) {
2481                                                        matchRange('0','9');
2482                                                }
2483                                                else if ((LA(1)=='_')) {
2484                                                        match('_');
2485                                                }
2486                                                else {
2487                                                        break _loop560;
2488                                                }
2489                                                
2490                                        } while (true);
2491                                        }
2492                                        {
2493                                        matchRange('0','9');
2494                                        }
2495                                }
2496                                else {
2497                                }
2498                                
2499                                }
2500                                }
2501                                break;
2502                        }
2503                        default:
2504                        {
2505                                throw new NoViableAltForCharException((char)LA(1), getFilename(), getLine(), getColumn());
2506                        }
2507                        }
2508                        }
2509                        {
2510                        if ((LA(1)=='E'||LA(1)=='e')) {
2511                                mEXPONENT(false);
2512                        }
2513                        else {
2514                        }
2515                        
2516                        }
2517                        {
2518                        switch ( LA(1)) {
2519                        case 'f':
2520                        {
2521                                match('f');
2522                                break;
2523                        }
2524                        case 'F':
2525                        {
2526                                match('F');
2527                                break;
2528                        }
2529                        default:
2530                                {
2531                                }
2532                        }
2533                        }
2534                }
2535                else if (((LA(1) >= '0' && LA(1) <= '9')) && (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)=='8'||LA(2)=='9'||LA(2)=='E'||LA(2)=='F'||LA(2)=='_'||LA(2)=='e'||LA(2)=='f') && (true) && (true)) {
2536                        {
2537                        {
2538                        matchRange('0','9');
2539                        }
2540                        {
2541                        switch ( LA(1)) {
2542                        case '0':  case '1':  case '2':  case '3':
2543                        case '4':  case '5':  case '6':  case '7':
2544                        case '8':  case '9':  case '_':
2545                        {
2546                                {
2547                                _loop568:
2548                                do {
2549                                        if (((LA(1) >= '0' && LA(1) <= '9')) && (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)=='8'||LA(2)=='9'||LA(2)=='_')) {
2550                                                matchRange('0','9');
2551                                        }
2552                                        else if ((LA(1)=='_')) {
2553                                                match('_');
2554                                        }
2555                                        else {
2556                                                break _loop568;
2557                                        }
2558                                        
2559                                } while (true);
2560                                }
2561                                {
2562                                matchRange('0','9');
2563                                }
2564                                break;
2565                        }
2566                        case 'E':  case 'F':  case 'e':  case 'f':
2567                        {
2568                                break;
2569                        }
2570                        default:
2571                        {
2572                                throw new NoViableAltForCharException((char)LA(1), getFilename(), getLine(), getColumn());
2573                        }
2574                        }
2575                        }
2576                        }
2577                        {
2578                        switch ( LA(1)) {
2579                        case 'E':  case 'e':
2580                        {
2581                                {
2582                                mEXPONENT(false);
2583                                {
2584                                switch ( LA(1)) {
2585                                case 'f':
2586                                {
2587                                        match('f');
2588                                        break;
2589                                }
2590                                case 'F':
2591                                {
2592                                        match('F');
2593                                        break;
2594                                }
2595                                default:
2596                                        {
2597                                        }
2598                                }
2599                                }
2600                                }
2601                                break;
2602                        }
2603                        case 'F':  case 'f':
2604                        {
2605                                {
2606                                switch ( LA(1)) {
2607                                case 'f':
2608                                {
2609                                        match('f');
2610                                        break;
2611                                }
2612                                case 'F':
2613                                {
2614                                        match('F');
2615                                        break;
2616                                }
2617                                default:
2618                                {
2619                                        throw new NoViableAltForCharException((char)LA(1), getFilename(), getLine(), getColumn());
2620                                }
2621                                }
2622                                }
2623                                break;
2624                        }
2625                        default:
2626                        {
2627                                throw new NoViableAltForCharException((char)LA(1), getFilename(), getLine(), getColumn());
2628                        }
2629                        }
2630                        }
2631                }
2632                else {
2633                        throw new NoViableAltForCharException((char)LA(1), getFilename(), getLine(), getColumn());
2634                }
2635                
2636                }
2637                if ( _createToken && _token==null && _ttype!=Token.SKIP ) {
2638                        _token = makeToken(_ttype);
2639                        _token.setText(new String(text.getBuffer(), _begin, text.length()-_begin));
2640                }
2641                _returnToken = _token;
2642        }
2643        
2644        protected final void mHEX_DOUBLE_LITERAL(boolean _createToken) throws RecognitionException, CharStreamException, TokenStreamException {
2645                int _ttype; Token _token=null; int _begin=text.length();
2646                _ttype = HEX_DOUBLE_LITERAL;
2647                int _saveIndex;
2648                
2649                match('0');
2650                {
2651                switch ( LA(1)) {
2652                case 'x':
2653                {
2654                        match('x');
2655                        break;
2656                }
2657                case 'X':
2658                {
2659                        match('X');
2660                        break;
2661                }
2662                default:
2663                {
2664                        throw new NoViableAltForCharException((char)LA(1), getFilename(), getLine(), getColumn());
2665                }
2666                }
2667                }
2668                {
2669                boolean synPredMatched658 = false;
2670                if (((_tokenSet_9.member(LA(1))) && (_tokenSet_11.member(LA(2))) && (_tokenSet_10.member(LA(3))) && (_tokenSet_12.member(LA(4))))) {
2671                        int _m658 = mark();
2672                        synPredMatched658 = true;
2673                        inputState.guessing++;
2674                        try {
2675                                {
2676                                {
2677                                switch ( LA(1)) {
2678                                case '0':  case '1':  case '2':  case '3':
2679                                case '4':  case '5':  case '6':  case '7':
2680                                case '8':  case '9':  case 'A':  case 'B':
2681                                case 'C':  case 'D':  case 'E':  case 'F':
2682                                case 'a':  case 'b':  case 'c':  case 'd':
2683                                case 'e':  case 'f':
2684                                {
2685                                        {
2686                                        mHEX_DIGIT(false);
2687                                        }
2688                                        {
2689                                        switch ( LA(1)) {
2690                                        case '0':  case '1':  case '2':  case '3':
2691                                        case '4':  case '5':  case '6':  case '7':
2692                                        case '8':  case '9':  case 'A':  case 'B':
2693                                        case 'C':  case 'D':  case 'E':  case 'F':
2694                                        case '_':  case 'a':  case 'b':  case 'c':
2695                                        case 'd':  case 'e':  case 'f':
2696                                        {
2697                                                {
2698                                                _loop656:
2699                                                do {
2700                                                        if ((_tokenSet_4.member(LA(1))) && (_tokenSet_13.member(LA(2)))) {
2701                                                                mHEX_DIGIT(false);
2702                                                        }
2703                                                        else if ((LA(1)=='_')) {
2704                                                                match('_');
2705                                                        }
2706                                                        else {
2707                                                                break _loop656;
2708                                                        }
2709                                                        
2710                                                } while (true);
2711                                                }
2712                                                {
2713                                                mHEX_DIGIT(false);
2714                                                }
2715                                                break;
2716                                        }
2717                                        case '.':
2718                                        {
2719                                                break;
2720                                        }
2721                                        default:
2722                                        {
2723                                                throw new NoViableAltForCharException((char)LA(1), getFilename(), getLine(), getColumn());
2724                                        }
2725                                        }
2726                                        }
2727                                        break;
2728                                }
2729                                case '.':
2730                                {
2731                                        break;
2732                                }
2733                                default:
2734                                {
2735                                        throw new NoViableAltForCharException((char)LA(1), getFilename(), getLine(), getColumn());
2736                                }
2737                                }
2738                                }
2739                                match('.');
2740                                }
2741                        }
2742                        catch (RecognitionException pe) {
2743                                synPredMatched658 = false;
2744                        }
2745                        rewind(_m658);
2746inputState.guessing--;
2747                }
2748                if ( synPredMatched658 ) {
2749                        {
2750                        switch ( LA(1)) {
2751                        case '0':  case '1':  case '2':  case '3':
2752                        case '4':  case '5':  case '6':  case '7':
2753                        case '8':  case '9':  case 'A':  case 'B':
2754                        case 'C':  case 'D':  case 'E':  case 'F':
2755                        case 'a':  case 'b':  case 'c':  case 'd':
2756                        case 'e':  case 'f':
2757                        {
2758                                {
2759                                {
2760                                mHEX_DIGIT(false);
2761                                }
2762                                {
2763                                switch ( LA(1)) {
2764                                case '0':  case '1':  case '2':  case '3':
2765                                case '4':  case '5':  case '6':  case '7':
2766                                case '8':  case '9':  case 'A':  case 'B':
2767                                case 'C':  case 'D':  case 'E':  case 'F':
2768                                case '_':  case 'a':  case 'b':  case 'c':
2769                                case 'd':  case 'e':  case 'f':
2770                                {
2771                                        {
2772                                        _loop664:
2773                                        do {
2774                                                if ((_tokenSet_4.member(LA(1))) && (_tokenSet_13.member(LA(2)))) {
2775                                                        mHEX_DIGIT(false);
2776                                                }
2777                                                else if ((LA(1)=='_')) {
2778                                                        match('_');
2779                                                }
2780                                                else {
2781                                                        break _loop664;
2782                                                }
2783                                                
2784                                        } while (true);
2785                                        }
2786                                        {
2787                                        mHEX_DIGIT(false);
2788                                        }
2789                                        break;
2790                                }
2791                                case '.':
2792                                {
2793                                        break;
2794                                }
2795                                default:
2796                                {
2797                                        throw new NoViableAltForCharException((char)LA(1), getFilename(), getLine(), getColumn());
2798                                }
2799                                }
2800                                }
2801                                }
2802                                match('.');
2803                                {
2804                                switch ( LA(1)) {
2805                                case '0':  case '1':  case '2':  case '3':
2806                                case '4':  case '5':  case '6':  case '7':
2807                                case '8':  case '9':  case 'A':  case 'B':
2808                                case 'C':  case 'D':  case 'E':  case 'F':
2809                                case 'a':  case 'b':  case 'c':  case 'd':
2810                                case 'e':  case 'f':
2811                                {
2812                                        {
2813                                        mHEX_DIGIT(false);
2814                                        }
2815                                        {
2816                                        switch ( LA(1)) {
2817                                        case '0':  case '1':  case '2':  case '3':
2818                                        case '4':  case '5':  case '6':  case '7':
2819                                        case '8':  case '9':  case 'A':  case 'B':
2820                                        case 'C':  case 'D':  case 'E':  case 'F':
2821                                        case '_':  case 'a':  case 'b':  case 'c':
2822                                        case 'd':  case 'e':  case 'f':
2823                                        {
2824                                                {
2825                                                _loop670:
2826                                                do {
2827                                                        if ((_tokenSet_4.member(LA(1))) && (_tokenSet_13.member(LA(2)))) {
2828                                                                mHEX_DIGIT(false);
2829                                                        }
2830                                                        else if ((LA(1)=='_')) {
2831                                                                match('_');
2832                                                        }
2833                                                        else {
2834                                                                break _loop670;
2835                                                        }
2836                                                        
2837                                                } while (true);
2838                                                }
2839                                                {
2840                                                mHEX_DIGIT(false);
2841                                                }
2842                                                break;
2843                                        }
2844                                        case 'P':  case 'p':
2845                                        {
2846                                                break;
2847                                        }
2848                                        default:
2849                                        {
2850                                                throw new NoViableAltForCharException((char)LA(1), getFilename(), getLine(), getColumn());
2851                                        }
2852                                        }
2853                                        }
2854                                        break;
2855                                }
2856                                case 'P':  case 'p':
2857                                {
2858                                        break;
2859                                }
2860                                default:
2861                                {
2862                                        throw new NoViableAltForCharException((char)LA(1), getFilename(), getLine(), getColumn());
2863                                }
2864                                }
2865                                }
2866                                break;
2867                        }
2868                        case '.':
2869                        {
2870                                match('.');
2871                                {
2872                                {
2873                                mHEX_DIGIT(false);
2874                                }
2875                                {
2876                                switch ( LA(1)) {
2877                                case '0':  case '1':  case '2':  case '3':
2878                                case '4':  case '5':  case '6':  case '7':
2879                                case '8':  case '9':  case 'A':  case 'B':
2880                                case 'C':  case 'D':  case 'E':  case 'F':
2881                                case '_':  case 'a':  case 'b':  case 'c':
2882                                case 'd':  case 'e':  case 'f':
2883                                {
2884                                        {
2885                                        _loop676:
2886                                        do {
2887                                                if ((_tokenSet_4.member(LA(1))) && (_tokenSet_13.member(LA(2)))) {
2888                                                        mHEX_DIGIT(false);
2889                                                }
2890                                                else if ((LA(1)=='_')) {
2891                                                        match('_');
2892                                                }
2893                                                else {
2894                                                        break _loop676;
2895                                                }
2896                                                
2897                                        } while (true);
2898                                        }
2899                                        {
2900                                        mHEX_DIGIT(false);
2901                                        }
2902                                        break;
2903                                }
2904                                case 'P':  case 'p':
2905                                {
2906                                        break;
2907                                }
2908                                default:
2909                                {
2910                                        throw new NoViableAltForCharException((char)LA(1), getFilename(), getLine(), getColumn());
2911                                }
2912                                }
2913                                }
2914                                }
2915                                break;
2916                        }
2917                        default:
2918                        {
2919                                throw new NoViableAltForCharException((char)LA(1), getFilename(), getLine(), getColumn());
2920                        }
2921                        }
2922                        }
2923                }
2924                else if ((_tokenSet_4.member(LA(1))) && (_tokenSet_14.member(LA(2))) && (_tokenSet_15.member(LA(3))) && (_tokenSet_15.member(LA(4)))) {
2925                        {
2926                        {
2927                        mHEX_DIGIT(false);
2928                        }
2929                        {
2930                        switch ( LA(1)) {
2931                        case '0':  case '1':  case '2':  case '3':
2932                        case '4':  case '5':  case '6':  case '7':
2933                        case '8':  case '9':  case 'A':  case 'B':
2934                        case 'C':  case 'D':  case 'E':  case 'F':
2935                        case '_':  case 'a':  case 'b':  case 'c':
2936                        case 'd':  case 'e':  case 'f':
2937                        {
2938                                {
2939                                _loop682:
2940                                do {
2941                                        if ((_tokenSet_4.member(LA(1))) && (_tokenSet_13.member(LA(2)))) {
2942                                                mHEX_DIGIT(false);
2943                                        }
2944                                        else if ((LA(1)=='_')) {
2945                                                match('_');
2946                                        }
2947                                        else {
2948                                                break _loop682;
2949                                        }
2950                                        
2951                                } while (true);
2952                                }
2953                                {
2954                                mHEX_DIGIT(false);
2955                                }
2956                                break;
2957                        }
2958                        case 'P':  case 'p':
2959                        {
2960                                break;
2961                        }
2962                        default:
2963                        {
2964                                throw new NoViableAltForCharException((char)LA(1), getFilename(), getLine(), getColumn());
2965                        }
2966                        }
2967                        }
2968                        }
2969                }
2970                else {
2971                        throw new NoViableAltForCharException((char)LA(1), getFilename(), getLine(), getColumn());
2972                }
2973                
2974                }
2975                mBINARY_EXPONENT(false);
2976                {
2977                switch ( LA(1)) {
2978                case 'd':
2979                {
2980                        match('d');
2981                        break;
2982                }
2983                case 'D':
2984                {
2985                        match('D');
2986                        break;
2987                }
2988                default:
2989                {
2990                        throw new NoViableAltForCharException((char)LA(1), getFilename(), getLine(), getColumn());
2991                }
2992                }
2993                }
2994                if ( _createToken && _token==null && _ttype!=Token.SKIP ) {
2995                        _token = makeToken(_ttype);
2996                        _token.setText(new String(text.getBuffer(), _begin, text.length()-_begin));
2997                }
2998                _returnToken = _token;
2999        }
3000        
3001        protected final void mHEX_FLOAT_LITERAL(boolean _createToken) throws RecognitionException, CharStreamException, TokenStreamException {
3002                int _ttype; Token _token=null; int _begin=text.length();
3003                _ttype = HEX_FLOAT_LITERAL;
3004                int _saveIndex;
3005                
3006                match('0');
3007                {
3008                switch ( LA(1)) {
3009                case 'x':
3010                {
3011                        match('x');
3012                        break;
3013                }
3014                case 'X':
3015                {
3016                        match('X');
3017                        break;
3018                }
3019                default:
3020                {
3021                        throw new NoViableAltForCharException((char)LA(1), getFilename(), getLine(), getColumn());
3022                }
3023                }
3024                }
3025                {
3026                boolean synPredMatched621 = false;
3027                if (((_tokenSet_9.member(LA(1))) && (_tokenSet_11.member(LA(2))) && (_tokenSet_10.member(LA(3))) && (_tokenSet_12.member(LA(4))))) {
3028                        int _m621 = mark();
3029                        synPredMatched621 = true;
3030                        inputState.guessing++;
3031                        try {
3032                                {
3033                                {
3034                                switch ( LA(1)) {
3035                                case '0':  case '1':  case '2':  case '3':
3036                                case '4':  case '5':  case '6':  case '7':
3037                                case '8':  case '9':  case 'A':  case 'B':
3038                                case 'C':  case 'D':  case 'E':  case 'F':
3039                                case 'a':  case 'b':  case 'c':  case 'd':
3040                                case 'e':  case 'f':
3041                                {
3042                                        {
3043                                        mHEX_DIGIT(false);
3044                                        }
3045                                        {
3046                                        switch ( LA(1)) {
3047                                        case '0':  case '1':  case '2':  case '3':
3048                                        case '4':  case '5':  case '6':  case '7':
3049                                        case '8':  case '9':  case 'A':  case 'B':
3050                                        case 'C':  case 'D':  case 'E':  case 'F':
3051                                        case '_':  case 'a':  case 'b':  case 'c':
3052                                        case 'd':  case 'e':  case 'f':
3053                                        {
3054                                                {
3055                                                _loop619:
3056                                                do {
3057                                                        if ((_tokenSet_4.member(LA(1))) && (_tokenSet_13.member(LA(2)))) {
3058                                                                mHEX_DIGIT(false);
3059                                                        }
3060                                                        else if ((LA(1)=='_')) {
3061                                                                match('_');
3062                                                        }
3063                                                        else {
3064                                                                break _loop619;
3065                                                        }
3066                                                        
3067                                                } while (true);
3068                                                }
3069                                                {
3070                                                mHEX_DIGIT(false);
3071                                                }
3072                                                break;
3073                                        }
3074                                        case '.':
3075                                        {
3076                                                break;
3077                                        }
3078                                        default:
3079                                        {
3080                                                throw new NoViableAltForCharException((char)LA(1), getFilename(), getLine(), getColumn());
3081                                        }
3082                                        }
3083                                        }
3084                                        break;
3085                                }
3086                                case '.':
3087                                {
3088                                        break;
3089                                }
3090                                default:
3091                                {
3092                                        throw new NoViableAltForCharException((char)LA(1), getFilename(), getLine(), getColumn());
3093                                }
3094                                }
3095                                }
3096                                match('.');
3097                                }
3098                        }
3099                        catch (RecognitionException pe) {
3100                                synPredMatched621 = false;
3101                        }
3102                        rewind(_m621);
3103inputState.guessing--;
3104                }
3105                if ( synPredMatched621 ) {
3106                        {
3107                        switch ( LA(1)) {
3108                        case '0':  case '1':  case '2':  case '3':
3109                        case '4':  case '5':  case '6':  case '7':
3110                        case '8':  case '9':  case 'A':  case 'B':
3111                        case 'C':  case 'D':  case 'E':  case 'F':
3112                        case 'a':  case 'b':  case 'c':  case 'd':
3113                        case 'e':  case 'f':
3114                        {
3115                                {
3116                                {
3117                                mHEX_DIGIT(false);
3118                                }
3119                                {
3120                                switch ( LA(1)) {
3121                                case '0':  case '1':  case '2':  case '3':
3122                                case '4':  case '5':  case '6':  case '7':
3123                                case '8':  case '9':  case 'A':  case 'B':
3124                                case 'C':  case 'D':  case 'E':  case 'F':
3125                                case '_':  case 'a':  case 'b':  case 'c':
3126                                case 'd':  case 'e':  case 'f':
3127                                {
3128                                        {
3129                                        _loop627:
3130                                        do {
3131                                                if ((_tokenSet_4.member(LA(1))) && (_tokenSet_13.member(LA(2)))) {
3132                                                        mHEX_DIGIT(false);
3133                                                }
3134                                                else if ((LA(1)=='_')) {
3135                                                        match('_');
3136                                                }
3137                                                else {
3138                                                        break _loop627;
3139                                                }
3140                                                
3141                                        } while (true);
3142                                        }
3143                                        {
3144                                        mHEX_DIGIT(false);
3145                                        }
3146                                        break;
3147                                }
3148                                case '.':
3149                                {
3150                                        break;
3151                                }
3152                                default:
3153                                {
3154                                        throw new NoViableAltForCharException((char)LA(1), getFilename(), getLine(), getColumn());
3155                                }
3156                                }
3157                                }
3158                                }
3159                                match('.');
3160                                {
3161                                switch ( LA(1)) {
3162                                case '0':  case '1':  case '2':  case '3':
3163                                case '4':  case '5':  case '6':  case '7':
3164                                case '8':  case '9':  case 'A':  case 'B':
3165                                case 'C':  case 'D':  case 'E':  case 'F':
3166                                case 'a':  case 'b':  case 'c':  case 'd':
3167                                case 'e':  case 'f':
3168                                {
3169                                        {
3170                                        mHEX_DIGIT(false);
3171                                        }
3172                                        {
3173                                        switch ( LA(1)) {
3174                                        case '0':  case '1':  case '2':  case '3':
3175                                        case '4':  case '5':  case '6':  case '7':
3176                                        case '8':  case '9':  case 'A':  case 'B':
3177                                        case 'C':  case 'D':  case 'E':  case 'F':
3178                                        case '_':  case 'a':  case 'b':  case 'c':
3179                                        case 'd':  case 'e':  case 'f':
3180                                        {
3181                                                {
3182                                                _loop633:
3183                                                do {
3184                                                        if ((_tokenSet_4.member(LA(1))) && (_tokenSet_13.member(LA(2)))) {
3185                                                                mHEX_DIGIT(false);
3186                                                        }
3187                                                        else if ((LA(1)=='_')) {
3188                                                                match('_');
3189                                                        }
3190                                                        else {
3191                                                                break _loop633;
3192                                                        }
3193                                                        
3194                                                } while (true);
3195                                                }
3196                                                {
3197                                                mHEX_DIGIT(false);
3198                                                }
3199                                                break;
3200                                        }
3201                                        case 'P':  case 'p':
3202                                        {
3203                                                break;
3204                                        }
3205                                        default:
3206                                        {
3207                                                throw new NoViableAltForCharException((char)LA(1), getFilename(), getLine(), getColumn());
3208                                        }
3209                                        }
3210                                        }
3211                                        break;
3212                                }
3213                                case 'P':  case 'p':
3214                                {
3215                                        break;
3216                                }
3217                                default:
3218                                {
3219                                        throw new NoViableAltForCharException((char)LA(1), getFilename(), getLine(), getColumn());
3220                                }
3221                                }
3222                                }
3223                                break;
3224                        }
3225                        case '.':
3226                        {
3227                                match('.');
3228                                {
3229                                {
3230                                mHEX_DIGIT(false);
3231                                }
3232                                {
3233                                switch ( LA(1)) {
3234                                case '0':  case '1':  case '2':  case '3':
3235                                case '4':  case '5':  case '6':  case '7':
3236                                case '8':  case '9':  case 'A':  case 'B':
3237                                case 'C':  case 'D':  case 'E':  case 'F':
3238                                case '_':  case 'a':  case 'b':  case 'c':
3239                                case 'd':  case 'e':  case 'f':
3240                                {
3241                                        {
3242                                        _loop639:
3243                                        do {
3244                                                if ((_tokenSet_4.member(LA(1))) && (_tokenSet_13.member(LA(2)))) {
3245                                                        mHEX_DIGIT(false);
3246                                                }
3247                                                else if ((LA(1)=='_')) {
3248                                                        match('_');
3249                                                }
3250                                                else {
3251                                                        break _loop639;
3252                                                }
3253                                                
3254                                        } while (true);
3255                                        }
3256                                        {
3257                                        mHEX_DIGIT(false);
3258                                        }
3259                                        break;
3260                                }
3261                                case 'P':  case 'p':
3262                                {
3263                                        break;
3264                                }
3265                                default:
3266                                {
3267                                        throw new NoViableAltForCharException((char)LA(1), getFilename(), getLine(), getColumn());
3268                                }
3269                                }
3270                                }
3271                                }
3272                                break;
3273                        }
3274                        default:
3275                        {
3276                                throw new NoViableAltForCharException((char)LA(1), getFilename(), getLine(), getColumn());
3277                        }
3278                        }
3279                        }
3280                }
3281                else if ((_tokenSet_4.member(LA(1))) && (_tokenSet_14.member(LA(2))) && (_tokenSet_15.member(LA(3))) && (true)) {
3282                        {
3283                        {
3284                        mHEX_DIGIT(false);
3285                        }
3286                        {
3287                        switch ( LA(1)) {
3288                        case '0':  case '1':  case '2':  case '3':
3289                        case '4':  case '5':  case '6':  case '7':
3290                        case '8':  case '9':  case 'A':  case 'B':
3291                        case 'C':  case 'D':  case 'E':  case 'F':
3292                        case '_':  case 'a':  case 'b':  case 'c':
3293                        case 'd':  case 'e':  case 'f':
3294                        {
3295                                {
3296                                _loop645:
3297                                do {
3298                                        if ((_tokenSet_4.member(LA(1))) && (_tokenSet_13.member(LA(2)))) {
3299                                                mHEX_DIGIT(false);
3300                                        }
3301                                        else if ((LA(1)=='_')) {
3302                                                match('_');
3303                                        }
3304                                        else {
3305                                                break _loop645;
3306                                        }
3307                                        
3308                                } while (true);
3309                                }
3310                                {
3311                                mHEX_DIGIT(false);
3312                                }
3313                                break;
3314                        }
3315                        case 'P':  case 'p':
3316                        {
3317                                break;
3318                        }
3319                        default:
3320                        {
3321                                throw new NoViableAltForCharException((char)LA(1), getFilename(), getLine(), getColumn());
3322                        }
3323                        }
3324                        }
3325                        }
3326                }
3327                else {
3328                        throw new NoViableAltForCharException((char)LA(1), getFilename(), getLine(), getColumn());
3329                }
3330                
3331                }
3332                mBINARY_EXPONENT(false);
3333                {
3334                switch ( LA(1)) {
3335                case 'f':
3336                {
3337                        match('f');
3338                        break;
3339                }
3340                case 'F':
3341                {
3342                        match('F');
3343                        break;
3344                }
3345                default:
3346                        {
3347                        }
3348                }
3349                }
3350                if ( _createToken && _token==null && _ttype!=Token.SKIP ) {
3351                        _token = makeToken(_ttype);
3352                        _token.setText(new String(text.getBuffer(), _begin, text.length()-_begin));
3353                }
3354                _returnToken = _token;
3355        }
3356        
3357        protected final void mLONG_LITERAL(boolean _createToken) throws RecognitionException, CharStreamException, TokenStreamException {
3358                int _ttype; Token _token=null; int _begin=text.length();
3359                _ttype = LONG_LITERAL;
3360                int _saveIndex;
3361                
3362                {
3363                switch ( LA(1)) {
3364                case '0':
3365                {
3366                        match('0');
3367                        {
3368                        switch ( LA(1)) {
3369                        case 'X':  case 'x':
3370                        {
3371                                {
3372                                switch ( LA(1)) {
3373                                case 'x':
3374                                {
3375                                        match('x');
3376                                        break;
3377                                }
3378                                case 'X':
3379                                {
3380                                        match('X');
3381                                        break;
3382                                }
3383                                default:
3384                                {
3385                                        throw new NoViableAltForCharException((char)LA(1), getFilename(), getLine(), getColumn());
3386                                }
3387                                }
3388                                }
3389                                {
3390                                mHEX_DIGIT(false);
3391                                }
3392                                {
3393                                switch ( LA(1)) {
3394                                case '0':  case '1':  case '2':  case '3':
3395                                case '4':  case '5':  case '6':  case '7':
3396                                case '8':  case '9':  case 'A':  case 'B':
3397                                case 'C':  case 'D':  case 'E':  case 'F':
3398                                case '_':  case 'a':  case 'b':  case 'c':
3399                                case 'd':  case 'e':  case 'f':
3400                                {
3401                                        {
3402                                        _loop514:
3403                                        do {
3404                                                if ((_tokenSet_4.member(LA(1))) && (_tokenSet_13.member(LA(2)))) {
3405                                                        mHEX_DIGIT(false);
3406                                                }
3407                                                else if ((LA(1)=='_')) {
3408                                                        match('_');
3409                                                }
3410                                                else {
3411                                                        break _loop514;
3412                                                }
3413                                                
3414                                        } while (true);
3415                                        }
3416                                        {
3417                                        mHEX_DIGIT(false);
3418                                        }
3419                                        break;
3420                                }
3421                                case 'L':  case 'l':
3422                                {
3423                                        break;
3424                                }
3425                                default:
3426                                {
3427                                        throw new NoViableAltForCharException((char)LA(1), getFilename(), getLine(), getColumn());
3428                                }
3429                                }
3430                                }
3431                                break;
3432                        }
3433                        case 'B':  case 'b':
3434                        {
3435                                {
3436                                switch ( LA(1)) {
3437                                case 'b':
3438                                {
3439                                        match('b');
3440                                        break;
3441                                }
3442                                case 'B':
3443                                {
3444                                        match('B');
3445                                        break;
3446                                }
3447                                default:
3448                                {
3449                                        throw new NoViableAltForCharException((char)LA(1), getFilename(), getLine(), getColumn());
3450                                }
3451                                }
3452                                }
3453                                {
3454                                mBINARY_DIGIT(false);
3455                                }
3456                                {
3457                                switch ( LA(1)) {
3458                                case '0':  case '1':  case '_':
3459                                {
3460                                        {
3461                                        _loop520:
3462                                        do {
3463                                                if ((LA(1)=='0'||LA(1)=='1') && (LA(2)=='0'||LA(2)=='1'||LA(2)=='_')) {
3464                                                        mBINARY_DIGIT(false);
3465                                                }
3466                                                else if ((LA(1)=='_')) {
3467                                                        match('_');
3468                                                }
3469                                                else {
3470                                                        break _loop520;
3471                                                }
3472                                                
3473                                        } while (true);
3474                                        }
3475                                        {
3476                                        mBINARY_DIGIT(false);
3477                                        }
3478                                        break;
3479                                }
3480                                case 'L':  case 'l':
3481                                {
3482                                        break;
3483                                }
3484                                default:
3485                                {
3486                                        throw new NoViableAltForCharException((char)LA(1), getFilename(), getLine(), getColumn());
3487                                }
3488                                }
3489                                }
3490                                break;
3491                        }
3492                        case '0':  case '1':  case '2':  case '3':
3493                        case '4':  case '5':  case '6':  case '7':
3494                        case 'L':  case '_':  case 'l':
3495                        {
3496                                {
3497                                switch ( LA(1)) {
3498                                case '0':  case '1':  case '2':  case '3':
3499                                case '4':  case '5':  case '6':  case '7':
3500                                case '_':
3501                                {
3502                                        {
3503                                        _loop525:
3504                                        do {
3505                                                if (((LA(1) >= '0' && LA(1) <= '7')) && (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)=='_')) {
3506                                                        {
3507                                                        matchRange('0','7');
3508                                                        }
3509                                                }
3510                                                else if ((LA(1)=='_')) {
3511                                                        match('_');
3512                                                }
3513                                                else {
3514                                                        break _loop525;
3515                                                }
3516                                                
3517                                        } while (true);
3518                                        }
3519                                        {
3520                                        matchRange('0','7');
3521                                        }
3522                                        break;
3523                                }
3524                                case 'L':  case 'l':
3525                                {
3526                                        break;
3527                                }
3528                                default:
3529                                {
3530                                        throw new NoViableAltForCharException((char)LA(1), getFilename(), getLine(), getColumn());
3531                                }
3532                                }
3533                                }
3534                                break;
3535                        }
3536                        default:
3537                        {
3538                                throw new NoViableAltForCharException((char)LA(1), getFilename(), getLine(), getColumn());
3539                        }
3540                        }
3541                        }
3542                        break;
3543                }
3544                case '1':  case '2':  case '3':  case '4':
3545                case '5':  case '6':  case '7':  case '8':
3546                case '9':
3547                {
3548                        {
3549                        matchRange('1','9');
3550                        }
3551                        {
3552                        switch ( LA(1)) {
3553                        case '0':  case '1':  case '2':  case '3':
3554                        case '4':  case '5':  case '6':  case '7':
3555                        case '8':  case '9':  case '_':
3556                        {
3557                                {
3558                                _loop530:
3559                                do {
3560                                        if (((LA(1) >= '0' && LA(1) <= '9')) && (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)=='8'||LA(2)=='9'||LA(2)=='_')) {
3561                                                matchRange('0','9');
3562                                        }
3563                                        else if ((LA(1)=='_')) {
3564                                                match('_');
3565                                        }
3566                                        else {
3567                                                break _loop530;
3568                                        }
3569                                        
3570                                } while (true);
3571                                }
3572                                {
3573                                matchRange('0','9');
3574                                }
3575                                break;
3576                        }
3577                        case 'L':  case 'l':
3578                        {
3579                                break;
3580                        }
3581                        default:
3582                        {
3583                                throw new NoViableAltForCharException((char)LA(1), getFilename(), getLine(), getColumn());
3584                        }
3585                        }
3586                        }
3587                        break;
3588                }
3589                default:
3590                {
3591                        throw new NoViableAltForCharException((char)LA(1), getFilename(), getLine(), getColumn());
3592                }
3593                }
3594                }
3595                {
3596                switch ( LA(1)) {
3597                case 'l':
3598                {
3599                        match('l');
3600                        break;
3601                }
3602                case 'L':
3603                {
3604                        match('L');
3605                        break;
3606                }
3607                default:
3608                {
3609                        throw new NoViableAltForCharException((char)LA(1), getFilename(), getLine(), getColumn());
3610                }
3611                }
3612                }
3613                if ( _createToken && _token==null && _ttype!=Token.SKIP ) {
3614                        _token = makeToken(_ttype);
3615                        _token.setText(new String(text.getBuffer(), _begin, text.length()-_begin));
3616                }
3617                _returnToken = _token;
3618        }
3619        
3620        protected final void mINT_LITERAL(boolean _createToken) throws RecognitionException, CharStreamException, TokenStreamException {
3621                int _ttype; Token _token=null; int _begin=text.length();
3622                _ttype = INT_LITERAL;
3623                int _saveIndex;
3624                
3625                {
3626                switch ( LA(1)) {
3627                case '0':
3628                {
3629                        match('0');
3630                        {
3631                        switch ( LA(1)) {
3632                        case 'X':  case 'x':
3633                        {
3634                                {
3635                                switch ( LA(1)) {
3636                                case 'x':
3637                                {
3638                                        match('x');
3639                                        break;
3640                                }
3641                                case 'X':
3642                                {
3643                                        match('X');
3644                                        break;
3645                                }
3646                                default:
3647                                {
3648                                        throw new NoViableAltForCharException((char)LA(1), getFilename(), getLine(), getColumn());
3649                                }
3650                                }
3651                                }
3652                                {
3653                                mHEX_DIGIT(false);
3654                                }
3655                                {
3656                                if ((_tokenSet_13.member(LA(1)))) {
3657                                        {
3658                                        _loop489:
3659                                        do {
3660                                                if ((_tokenSet_4.member(LA(1))) && (_tokenSet_13.member(LA(2)))) {
3661                                                        mHEX_DIGIT(false);
3662                                                }
3663                                                else if ((LA(1)=='_')) {
3664                                                        match('_');
3665                                                }
3666                                                else {
3667                                                        break _loop489;
3668                                                }
3669                                                
3670                                        } while (true);
3671                                        }
3672                                        {
3673                                        mHEX_DIGIT(false);
3674                                        }
3675                                }
3676                                else {
3677                                }
3678                                
3679                                }
3680                                break;
3681                        }
3682                        case 'B':  case 'b':
3683                        {
3684                                {
3685                                switch ( LA(1)) {
3686                                case 'b':
3687                                {
3688                                        match('b');
3689                                        break;
3690                                }
3691                                case 'B':
3692                                {
3693                                        match('B');
3694                                        break;
3695                                }
3696                                default:
3697                                {
3698                                        throw new NoViableAltForCharException((char)LA(1), getFilename(), getLine(), getColumn());
3699                                }
3700                                }
3701                                }
3702                                {
3703                                mBINARY_DIGIT(false);
3704                                }
3705                                {
3706                                if ((LA(1)=='0'||LA(1)=='1'||LA(1)=='_')) {
3707                                        {
3708                                        _loop495:
3709                                        do {
3710                                                if ((LA(1)=='0'||LA(1)=='1') && (LA(2)=='0'||LA(2)=='1'||LA(2)=='_')) {
3711                                                        mBINARY_DIGIT(false);
3712                                                }
3713                                                else if ((LA(1)=='_')) {
3714                                                        match('_');
3715                                                }
3716                                                else {
3717                                                        break _loop495;
3718                                                }
3719                                                
3720                                        } while (true);
3721                                        }
3722                                        {
3723                                        mBINARY_DIGIT(false);
3724                                        }
3725                                }
3726                                else {
3727                                }
3728                                
3729                                }
3730                                break;
3731                        }
3732                        default:
3733                                {
3734                                        {
3735                                        if ((LA(1)=='0'||LA(1)=='1'||LA(1)=='2'||LA(1)=='3'||LA(1)=='4'||LA(1)=='5'||LA(1)=='6'||LA(1)=='7'||LA(1)=='_')) {
3736                                                {
3737                                                _loop500:
3738                                                do {
3739                                                        if (((LA(1) >= '0' && LA(1) <= '7')) && (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)=='_')) {
3740                                                                {
3741                                                                matchRange('0','7');
3742                                                                }
3743                                                        }
3744                                                        else if ((LA(1)=='_')) {
3745                                                                match('_');
3746                                                        }
3747                                                        else {
3748                                                                break _loop500;
3749                                                        }
3750                                                        
3751                                                } while (true);
3752                                                }
3753                                                {
3754                                                matchRange('0','7');
3755                                                }
3756                                        }
3757                                        else {
3758                                        }
3759                                        
3760                                        }
3761                                }
3762                        }
3763                        }
3764                        break;
3765                }
3766                case '1':  case '2':  case '3':  case '4':
3767                case '5':  case '6':  case '7':  case '8':
3768                case '9':
3769                {
3770                        {
3771                        matchRange('1','9');
3772                        }
3773                        {
3774                        if ((LA(1)=='0'||LA(1)=='1'||LA(1)=='2'||LA(1)=='3'||LA(1)=='4'||LA(1)=='5'||LA(1)=='6'||LA(1)=='7'||LA(1)=='8'||LA(1)=='9'||LA(1)=='_')) {
3775                                {
3776                                _loop505:
3777                                do {
3778                                        if (((LA(1) >= '0' && LA(1) <= '9')) && (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)=='8'||LA(2)=='9'||LA(2)=='_')) {
3779                                                matchRange('0','9');
3780                                        }
3781                                        else if ((LA(1)=='_')) {
3782                                                match('_');
3783                                        }
3784                                        else {
3785                                                break _loop505;
3786                                        }
3787                                        
3788                                } while (true);
3789                                }
3790                                {
3791                                matchRange('0','9');
3792                                }
3793                        }
3794                        else {
3795                        }
3796                        
3797                        }
3798                        break;
3799                }
3800                default:
3801                {
3802                        throw new NoViableAltForCharException((char)LA(1), getFilename(), getLine(), getColumn());
3803                }
3804                }
3805                }
3806                if ( _createToken && _token==null && _ttype!=Token.SKIP ) {
3807                        _token = makeToken(_ttype);
3808                        _token.setText(new String(text.getBuffer(), _begin, text.length()-_begin));
3809                }
3810                _returnToken = _token;
3811        }
3812        
3813        protected final void mEXPONENT(boolean _createToken) throws RecognitionException, CharStreamException, TokenStreamException {
3814                int _ttype; Token _token=null; int _begin=text.length();
3815                _ttype = EXPONENT;
3816                int _saveIndex;
3817                
3818                {
3819                switch ( LA(1)) {
3820                case 'e':
3821                {
3822                        match('e');
3823                        break;
3824                }
3825                case 'E':
3826                {
3827                        match('E');
3828                        break;
3829                }
3830                default:
3831                {
3832                        throw new NoViableAltForCharException((char)LA(1), getFilename(), getLine(), getColumn());
3833                }
3834                }
3835                }
3836                mSIGNED_INTEGER(false);
3837                if ( _createToken && _token==null && _ttype!=Token.SKIP ) {
3838                        _token = makeToken(_ttype);
3839                        _token.setText(new String(text.getBuffer(), _begin, text.length()-_begin));
3840                }
3841                _returnToken = _token;
3842        }
3843        
3844        protected final void mBINARY_EXPONENT(boolean _createToken) throws RecognitionException, CharStreamException, TokenStreamException {
3845                int _ttype; Token _token=null; int _begin=text.length();
3846                _ttype = BINARY_EXPONENT;
3847                int _saveIndex;
3848                
3849                {
3850                switch ( LA(1)) {
3851                case 'p':
3852                {
3853                        match('p');
3854                        break;
3855                }
3856                case 'P':
3857                {
3858                        match('P');
3859                        break;
3860                }
3861                default:
3862                {
3863                        throw new NoViableAltForCharException((char)LA(1), getFilename(), getLine(), getColumn());
3864                }
3865                }
3866                }
3867                mSIGNED_INTEGER(false);
3868                if ( _createToken && _token==null && _ttype!=Token.SKIP ) {
3869                        _token = makeToken(_ttype);
3870                        _token.setText(new String(text.getBuffer(), _begin, text.length()-_begin));
3871                }
3872                _returnToken = _token;
3873        }
3874        
3875        protected final void mSIGNED_INTEGER(boolean _createToken) throws RecognitionException, CharStreamException, TokenStreamException {
3876                int _ttype; Token _token=null; int _begin=text.length();
3877                _ttype = SIGNED_INTEGER;
3878                int _saveIndex;
3879                
3880                {
3881                switch ( LA(1)) {
3882                case '+':
3883                {
3884                        match('+');
3885                        break;
3886                }
3887                case '-':
3888                {
3889                        match('-');
3890                        break;
3891                }
3892                case '0':  case '1':  case '2':  case '3':
3893                case '4':  case '5':  case '6':  case '7':
3894                case '8':  case '9':
3895                {
3896                        break;
3897                }
3898                default:
3899                {
3900                        throw new NoViableAltForCharException((char)LA(1), getFilename(), getLine(), getColumn());
3901                }
3902                }
3903                }
3904                {
3905                {
3906                matchRange('0','9');
3907                }
3908                {
3909                if ((LA(1)=='0'||LA(1)=='1'||LA(1)=='2'||LA(1)=='3'||LA(1)=='4'||LA(1)=='5'||LA(1)=='6'||LA(1)=='7'||LA(1)=='8'||LA(1)=='9'||LA(1)=='_')) {
3910                        {
3911                        _loop695:
3912                        do {
3913                                if (((LA(1) >= '0' && LA(1) <= '9')) && (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)=='8'||LA(2)=='9'||LA(2)=='_')) {
3914                                        matchRange('0','9');
3915                                }
3916                                else if ((LA(1)=='_')) {
3917                                        match('_');
3918                                }
3919                                else {
3920                                        break _loop695;
3921                                }
3922                                
3923                        } while (true);
3924                        }
3925                        {
3926                        matchRange('0','9');
3927                        }
3928                }
3929                else {
3930                }
3931                
3932                }
3933                }
3934                if ( _createToken && _token==null && _ttype!=Token.SKIP ) {
3935                        _token = makeToken(_ttype);
3936                        _token.setText(new String(text.getBuffer(), _begin, text.length()-_begin));
3937                }
3938                _returnToken = _token;
3939        }
3940        
3941        protected final void mFLOAT_SUFFIX(boolean _createToken) throws RecognitionException, CharStreamException, TokenStreamException {
3942                int _ttype; Token _token=null; int _begin=text.length();
3943                _ttype = FLOAT_SUFFIX;
3944                int _saveIndex;
3945                
3946                switch ( LA(1)) {
3947                case 'f':
3948                {
3949                        match('f');
3950                        break;
3951                }
3952                case 'F':
3953                {
3954                        match('F');
3955                        break;
3956                }
3957                case 'd':
3958                {
3959                        match('d');
3960                        break;
3961                }
3962                case 'D':
3963                {
3964                        match('D');
3965                        break;
3966                }
3967                default:
3968                {
3969                        throw new NoViableAltForCharException((char)LA(1), getFilename(), getLine(), getColumn());
3970                }
3971                }
3972                if ( _createToken && _token==null && _ttype!=Token.SKIP ) {
3973                        _token = makeToken(_ttype);
3974                        _token.setText(new String(text.getBuffer(), _begin, text.length()-_begin));
3975                }
3976                _returnToken = _token;
3977        }
3978        
3979        
3980        private static final long[] mk_tokenSet_0() {
3981                long[] data = new long[2048];
3982                data[0]=107374168575L;
3983                data[1]=-8646911286564618242L;
3984                for (int i = 2; i<=1022; i++) { data[i]=-1L; }
3985                data[1023]=9223372036854775807L;
3986                return data;
3987        }
3988        public static final BitSet _tokenSet_0 = new BitSet(mk_tokenSet_0());
3989        private static final long[] mk_tokenSet_1() {
3990                long[] data = new long[2048];
3991                data[0]=-9217L;
3992                for (int i = 1; i<=1022; i++) { data[i]=-1L; }
3993                data[1023]=9223372036854775807L;
3994                return data;
3995        }
3996        public static final BitSet _tokenSet_1 = new BitSet(mk_tokenSet_1());
3997        private static final long[] mk_tokenSet_2() {
3998                long[] data = new long[2048];
3999                data[0]=-4398046520321L;
4000                for (int i = 1; i<=1022; i++) { data[i]=-1L; }
4001                data[1023]=9223372036854775807L;
4002                return data;
4003        }
4004        public static final BitSet _tokenSet_2 = new BitSet(mk_tokenSet_2());
4005        private static final long[] mk_tokenSet_3() {
4006                long[] data = new long[2048];
4007                data[0]=-549755813889L;
4008                data[1]=-268435457L;
4009                for (int i = 2; i<=1022; i++) { data[i]=-1L; }
4010                data[1023]=9223372036854775807L;
4011                return data;
4012        }
4013        public static final BitSet _tokenSet_3 = new BitSet(mk_tokenSet_3());
4014        private static final long[] mk_tokenSet_4() {
4015                long[] data = new long[1025];
4016                data[0]=287948901175001088L;
4017                data[1]=541165879422L;
4018                return data;
4019        }
4020        public static final BitSet _tokenSet_4 = new BitSet(mk_tokenSet_4());
4021        private static final long[] mk_tokenSet_5() {
4022                long[] data = new long[2048];
4023                data[0]=-17179869185L;
4024                data[1]=-268435457L;
4025                for (int i = 2; i<=1022; i++) { data[i]=-1L; }
4026                data[1023]=9223372036854775807L;
4027                return data;
4028        }
4029        public static final BitSet _tokenSet_5 = new BitSet(mk_tokenSet_5());
4030        private static final long[] mk_tokenSet_6() {
4031                long[] data = new long[2048];
4032                data[0]=38654691839L;
4033                data[1]=-8646911288712101890L;
4034                for (int i = 2; i<=1022; i++) { data[i]=-1L; }
4035                data[1023]=9223372036854775807L;
4036                return data;
4037        }
4038        public static final BitSet _tokenSet_6 = new BitSet(mk_tokenSet_6());
4039        private static final long[] mk_tokenSet_7() {
4040                long[] data = new long[2048];
4041                data[0]=287948939829692927L;
4042                data[1]=-8646911288712101890L;
4043                for (int i = 2; i<=1022; i++) { data[i]=-1L; }
4044                data[1023]=9223372036854775807L;
4045                return data;
4046        }
4047        public static final BitSet _tokenSet_7 = new BitSet(mk_tokenSet_7());
4048        private static final long[] mk_tokenSet_8() {
4049                long[] data = new long[2048];
4050                data[0]=287949008549169663L;
4051                data[1]=-8646911286564618242L;
4052                for (int i = 2; i<=1022; i++) { data[i]=-1L; }
4053                data[1023]=9223372036854775807L;
4054                return data;
4055        }
4056        public static final BitSet _tokenSet_8 = new BitSet(mk_tokenSet_8());
4057        private static final long[] mk_tokenSet_9() {
4058                long[] data = new long[1025];
4059                data[0]=288019269919178752L;
4060                data[1]=541165879422L;
4061                return data;
4062        }
4063        public static final BitSet _tokenSet_9 = new BitSet(mk_tokenSet_9());
4064        private static final long[] mk_tokenSet_10() {
4065                long[] data = new long[1025];
4066                data[0]=288019269919178752L;
4067                data[1]=282018290139262L;
4068                return data;
4069        }
4070        public static final BitSet _tokenSet_10 = new BitSet(mk_tokenSet_10());
4071        private static final long[] mk_tokenSet_11() {
4072                long[] data = new long[1025];
4073                data[0]=288019269919178752L;
4074                data[1]=543313363070L;
4075                return data;
4076        }
4077        public static final BitSet _tokenSet_11 = new BitSet(mk_tokenSet_11());
4078        private static final long[] mk_tokenSet_12() {
4079                long[] data = new long[1025];
4080                data[0]=288063250384289792L;
4081                data[1]=282018290139262L;
4082                return data;
4083        }
4084        public static final BitSet _tokenSet_12 = new BitSet(mk_tokenSet_12());
4085        private static final long[] mk_tokenSet_13() {
4086                long[] data = new long[1025];
4087                data[0]=287948901175001088L;
4088                data[1]=543313363070L;
4089                return data;
4090        }
4091        public static final BitSet _tokenSet_13 = new BitSet(mk_tokenSet_13());
4092        private static final long[] mk_tokenSet_14() {
4093                long[] data = new long[1025];
4094                data[0]=287948901175001088L;
4095                data[1]=282018290139262L;
4096                return data;
4097        }
4098        public static final BitSet _tokenSet_14 = new BitSet(mk_tokenSet_14());
4099        private static final long[] mk_tokenSet_15() {
4100                long[] data = new long[1025];
4101                data[0]=287992881640112128L;
4102                data[1]=282018290139262L;
4103                return data;
4104        }
4105        public static final BitSet _tokenSet_15 = new BitSet(mk_tokenSet_15());
4106        
4107        }