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