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