Coverage Report - org.apache.commons.flatfile.dsl.EntityLexer
 
Classes in this File Line Coverage Branch Coverage Complexity
EntityLexer
77%
411/536
26%
168/634
9.575
 
 1  
 // $ANTLR 2.7.7 (20060906): "EntityParser.g" -> "EntityLexer.java"$
 2  
 
 3  
 package org.apache.commons.flatfile.dsl;
 4  
 
 5  
 import java.io.IOException;
 6  
 import java.util.Map;
 7  
 
 8  
 import org.apache.commons.flatfile.*;
 9  
 
 10  
 import java.io.InputStream;
 11  
 import antlr.TokenStreamException;
 12  
 import antlr.TokenStreamIOException;
 13  
 import antlr.TokenStreamRecognitionException;
 14  
 import antlr.CharStreamException;
 15  
 import antlr.CharStreamIOException;
 16  
 import antlr.ANTLRException;
 17  
 import java.io.Reader;
 18  
 import java.util.Hashtable;
 19  
 import antlr.CharScanner;
 20  
 import antlr.InputBuffer;
 21  
 import antlr.ByteBuffer;
 22  
 import antlr.CharBuffer;
 23  
 import antlr.Token;
 24  
 import antlr.CommonToken;
 25  
 import antlr.RecognitionException;
 26  
 import antlr.NoViableAltForCharException;
 27  
 import antlr.MismatchedCharException;
 28  
 import antlr.TokenStream;
 29  
 import antlr.ANTLRHashString;
 30  
 import antlr.LexerSharedInputState;
 31  
 import antlr.collections.impl.BitSet;
 32  
 import antlr.SemanticException;
 33  
 
 34  
 public class EntityLexer extends antlr.CharScanner implements EntityTokenTypes, TokenStream
 35  
  {
 36  
 public EntityLexer(InputStream in) {
 37  32
         this(new ByteBuffer(in));
 38  32
 }
 39  
 public EntityLexer(Reader in) {
 40  0
         this(new CharBuffer(in));
 41  0
 }
 42  
 public EntityLexer(InputBuffer ib) {
 43  32
         this(new LexerSharedInputState(ib));
 44  32
 }
 45  
 public EntityLexer(LexerSharedInputState state) {
 46  32
         super(state);
 47  32
         caseSensitiveLiterals = true;
 48  32
         setCaseSensitive(true);
 49  32
         literals = new Hashtable();
 50  32
 }
 51  
 
 52  
 public Token nextToken() throws TokenStreamException {
 53  2652
         Token theRetToken=null;
 54  
 tryAgain:
 55  
         for (;;) {
 56  4243
                 Token _token = null;
 57  4243
                 int _ttype = Token.INVALID_TYPE;
 58  4243
                 resetText();
 59  
                 try {   // for char stream error handling
 60  
                         try {   // for lexical error handling
 61  4243
                                 switch ( LA(1)) {
 62  
                                 case ';':
 63  
                                 {
 64  3
                                         mSEMI(true);
 65  3
                                         theRetToken=_returnToken;
 66  3
                                         break;
 67  
                                 }
 68  
                                 case ',':
 69  
                                 {
 70  9
                                         mCOMMA(true);
 71  9
                                         theRetToken=_returnToken;
 72  9
                                         break;
 73  
                                 }
 74  
                                 case '(':
 75  
                                 {
 76  300
                                         mLPAREN(true);
 77  300
                                         theRetToken=_returnToken;
 78  300
                                         break;
 79  
                                 }
 80  
                                 case ')':
 81  
                                 {
 82  300
                                         mRPAREN(true);
 83  300
                                         theRetToken=_returnToken;
 84  300
                                         break;
 85  
                                 }
 86  
                                 case '{':
 87  
                                 {
 88  44
                                         mLCURLY(true);
 89  44
                                         theRetToken=_returnToken;
 90  44
                                         break;
 91  
                                 }
 92  
                                 case '}':
 93  
                                 {
 94  44
                                         mRCURLY(true);
 95  44
                                         theRetToken=_returnToken;
 96  44
                                         break;
 97  
                                 }
 98  
                                 case '[':
 99  
                                 {
 100  122
                                         mLBRACK(true);
 101  122
                                         theRetToken=_returnToken;
 102  122
                                         break;
 103  
                                 }
 104  
                                 case ']':
 105  
                                 {
 106  122
                                         mRBRACK(true);
 107  122
                                         theRetToken=_returnToken;
 108  122
                                         break;
 109  
                                 }
 110  
                                 case '*':
 111  
                                 {
 112  92
                                         mSTAR(true);
 113  92
                                         theRetToken=_returnToken;
 114  92
                                         break;
 115  
                                 }
 116  
                                 case '?':
 117  
                                 {
 118  32
                                         mANON(true);
 119  32
                                         theRetToken=_returnToken;
 120  32
                                         break;
 121  
                                 }
 122  
                                 case ':':
 123  
                                 {
 124  10
                                         mCOLON(true);
 125  10
                                         theRetToken=_returnToken;
 126  10
                                         break;
 127  
                                 }
 128  
                                 case '!':
 129  
                                 {
 130  32
                                         mBANG(true);
 131  32
                                         theRetToken=_returnToken;
 132  32
                                         break;
 133  
                                 }
 134  
                                 case '=':
 135  
                                 {
 136  109
                                         mASSIGN(true);
 137  109
                                         theRetToken=_returnToken;
 138  109
                                         break;
 139  
                                 }
 140  
                                 case '.':
 141  
                                 {
 142  130
                                         mRANGE(true);
 143  130
                                         theRetToken=_returnToken;
 144  130
                                         break;
 145  
                                 }
 146  
                                 case '\t':  case '\n':  case '\u000c':  case '\r':
 147  
                                 case ' ':
 148  
                                 {
 149  1517
                                         mWS(true);
 150  1517
                                         theRetToken=_returnToken;
 151  1517
                                         break;
 152  
                                 }
 153  
                                 case 'A':  case 'B':  case 'C':  case 'D':
 154  
                                 case 'E':  case 'F':  case 'G':  case 'H':
 155  
                                 case 'I':  case 'J':  case 'K':  case 'L':
 156  
                                 case 'M':  case 'N':  case 'O':  case 'P':
 157  
                                 case 'Q':  case 'R':  case 'S':  case 'T':
 158  
                                 case 'U':  case 'V':  case 'W':  case 'X':
 159  
                                 case 'Y':  case 'Z':  case 'a':  case 'b':
 160  
                                 case 'c':  case 'd':  case 'e':  case 'f':
 161  
                                 case 'g':  case 'h':  case 'i':  case 'j':
 162  
                                 case 'k':  case 'l':  case 'm':  case 'n':
 163  
                                 case 'o':  case 'p':  case 'q':  case 'r':
 164  
                                 case 's':  case 't':  case 'u':  case 'v':
 165  
                                 case 'w':  case 'x':  case 'y':  case 'z':
 166  
                                 {
 167  568
                                         mIDENT(true);
 168  568
                                         theRetToken=_returnToken;
 169  568
                                         break;
 170  
                                 }
 171  
                                 case '$':
 172  
                                 {
 173  27
                                         mTYPEREF(true);
 174  27
                                         theRetToken=_returnToken;
 175  27
                                         break;
 176  
                                 }
 177  
                                 case '@':
 178  
                                 {
 179  3
                                         mOPTION_BLOCK(true);
 180  3
                                         theRetToken=_returnToken;
 181  3
                                         break;
 182  
                                 }
 183  
                                 case '0':  case '1':  case '2':  case '3':
 184  
                                 case '4':  case '5':  case '6':  case '7':
 185  
                                 case '8':  case '9':
 186  
                                 {
 187  432
                                         mNUMBER(true);
 188  432
                                         theRetToken=_returnToken;
 189  432
                                         break;
 190  
                                 }
 191  
                                 case '\'':
 192  
                                 {
 193  70
                                         mCHAR_LITERAL(true);
 194  70
                                         theRetToken=_returnToken;
 195  70
                                         break;
 196  
                                 }
 197  
                                 case '"':
 198  
                                 {
 199  151
                                         mSTRING_LITERAL(true);
 200  151
                                         theRetToken=_returnToken;
 201  151
                                         break;
 202  
                                 }
 203  
                                 default:
 204  126
                                         if ((LA(1)=='/') && (LA(2)=='/')) {
 205  42
                                                 mSL_COMMENT(true);
 206  42
                                                 theRetToken=_returnToken;
 207  
                                         }
 208  84
                                         else if ((LA(1)=='/') && (LA(2)=='*')) {
 209  32
                                                 mML_COMMENT(true);
 210  32
                                                 theRetToken=_returnToken;
 211  
                                         }
 212  
                                 else {
 213  52
                                         if (LA(1)==EOF_CHAR) {uponEOF(); _returnToken = makeToken(Token.EOF_TYPE);}
 214  0
                                 else {throw new NoViableAltForCharException((char)LA(1), getFilename(), getLine(), getColumn());}
 215  
                                 }
 216  
                                 }
 217  4243
                                 if ( _returnToken==null ) continue tryAgain; // found SKIP token
 218  2652
                                 _ttype = _returnToken.getType();
 219  2652
                                 _ttype = testLiteralsTable(_ttype);
 220  2652
                                 _returnToken.setType(_ttype);
 221  2652
                                 return _returnToken;
 222  
                         }
 223  0
                         catch (RecognitionException e) {
 224  0
                                 throw new TokenStreamRecognitionException(e);
 225  
                         }
 226  
                 }
 227  0
                 catch (CharStreamException cse) {
 228  0
                         if ( cse instanceof CharStreamIOException ) {
 229  0
                                 throw new TokenStreamIOException(((CharStreamIOException)cse).io);
 230  
                         }
 231  
                         else {
 232  0
                                 throw new TokenStreamException(cse.getMessage());
 233  
                         }
 234  
                 }
 235  
         }
 236  
 }
 237  
 
 238  
         public final void mSEMI(boolean _createToken) throws RecognitionException, CharStreamException, TokenStreamException {
 239  3
                 int _ttype; Token _token=null; int _begin=text.length();
 240  3
                 _ttype = SEMI;
 241  
                 int _saveIndex;
 242  
                 
 243  3
                 match(';');
 244  3
                 if ( _createToken && _token==null && _ttype!=Token.SKIP ) {
 245  3
                         _token = makeToken(_ttype);
 246  3
                         _token.setText(new String(text.getBuffer(), _begin, text.length()-_begin));
 247  
                 }
 248  3
                 _returnToken = _token;
 249  3
         }
 250  
         
 251  
         public final void mCOMMA(boolean _createToken) throws RecognitionException, CharStreamException, TokenStreamException {
 252  9
                 int _ttype; Token _token=null; int _begin=text.length();
 253  9
                 _ttype = COMMA;
 254  
                 int _saveIndex;
 255  
                 
 256  9
                 match(',');
 257  9
                 if ( _createToken && _token==null && _ttype!=Token.SKIP ) {
 258  9
                         _token = makeToken(_ttype);
 259  9
                         _token.setText(new String(text.getBuffer(), _begin, text.length()-_begin));
 260  
                 }
 261  9
                 _returnToken = _token;
 262  9
         }
 263  
         
 264  
         public final void mLPAREN(boolean _createToken) throws RecognitionException, CharStreamException, TokenStreamException {
 265  300
                 int _ttype; Token _token=null; int _begin=text.length();
 266  300
                 _ttype = LPAREN;
 267  
                 int _saveIndex;
 268  
                 
 269  300
                 match('(');
 270  300
                 if ( _createToken && _token==null && _ttype!=Token.SKIP ) {
 271  300
                         _token = makeToken(_ttype);
 272  300
                         _token.setText(new String(text.getBuffer(), _begin, text.length()-_begin));
 273  
                 }
 274  300
                 _returnToken = _token;
 275  300
         }
 276  
         
 277  
         public final void mRPAREN(boolean _createToken) throws RecognitionException, CharStreamException, TokenStreamException {
 278  300
                 int _ttype; Token _token=null; int _begin=text.length();
 279  300
                 _ttype = RPAREN;
 280  
                 int _saveIndex;
 281  
                 
 282  300
                 match(')');
 283  300
                 if ( _createToken && _token==null && _ttype!=Token.SKIP ) {
 284  300
                         _token = makeToken(_ttype);
 285  300
                         _token.setText(new String(text.getBuffer(), _begin, text.length()-_begin));
 286  
                 }
 287  300
                 _returnToken = _token;
 288  300
         }
 289  
         
 290  
         public final void mLCURLY(boolean _createToken) throws RecognitionException, CharStreamException, TokenStreamException {
 291  44
                 int _ttype; Token _token=null; int _begin=text.length();
 292  44
                 _ttype = LCURLY;
 293  
                 int _saveIndex;
 294  
                 
 295  44
                 match('{');
 296  44
                 if ( _createToken && _token==null && _ttype!=Token.SKIP ) {
 297  44
                         _token = makeToken(_ttype);
 298  44
                         _token.setText(new String(text.getBuffer(), _begin, text.length()-_begin));
 299  
                 }
 300  44
                 _returnToken = _token;
 301  44
         }
 302  
         
 303  
         public final void mRCURLY(boolean _createToken) throws RecognitionException, CharStreamException, TokenStreamException {
 304  44
                 int _ttype; Token _token=null; int _begin=text.length();
 305  44
                 _ttype = RCURLY;
 306  
                 int _saveIndex;
 307  
                 
 308  44
                 match('}');
 309  44
                 if ( _createToken && _token==null && _ttype!=Token.SKIP ) {
 310  44
                         _token = makeToken(_ttype);
 311  44
                         _token.setText(new String(text.getBuffer(), _begin, text.length()-_begin));
 312  
                 }
 313  44
                 _returnToken = _token;
 314  44
         }
 315  
         
 316  
         public final void mLBRACK(boolean _createToken) throws RecognitionException, CharStreamException, TokenStreamException {
 317  122
                 int _ttype; Token _token=null; int _begin=text.length();
 318  122
                 _ttype = LBRACK;
 319  
                 int _saveIndex;
 320  
                 
 321  122
                 match('[');
 322  122
                 if ( _createToken && _token==null && _ttype!=Token.SKIP ) {
 323  122
                         _token = makeToken(_ttype);
 324  122
                         _token.setText(new String(text.getBuffer(), _begin, text.length()-_begin));
 325  
                 }
 326  122
                 _returnToken = _token;
 327  122
         }
 328  
         
 329  
         public final void mRBRACK(boolean _createToken) throws RecognitionException, CharStreamException, TokenStreamException {
 330  122
                 int _ttype; Token _token=null; int _begin=text.length();
 331  122
                 _ttype = RBRACK;
 332  
                 int _saveIndex;
 333  
                 
 334  122
                 match(']');
 335  122
                 if ( _createToken && _token==null && _ttype!=Token.SKIP ) {
 336  122
                         _token = makeToken(_ttype);
 337  122
                         _token.setText(new String(text.getBuffer(), _begin, text.length()-_begin));
 338  
                 }
 339  122
                 _returnToken = _token;
 340  122
         }
 341  
         
 342  
         public final void mSTAR(boolean _createToken) throws RecognitionException, CharStreamException, TokenStreamException {
 343  92
                 int _ttype; Token _token=null; int _begin=text.length();
 344  92
                 _ttype = STAR;
 345  
                 int _saveIndex;
 346  
                 
 347  92
                 match('*');
 348  92
                 if ( _createToken && _token==null && _ttype!=Token.SKIP ) {
 349  92
                         _token = makeToken(_ttype);
 350  92
                         _token.setText(new String(text.getBuffer(), _begin, text.length()-_begin));
 351  
                 }
 352  92
                 _returnToken = _token;
 353  92
         }
 354  
         
 355  
         public final void mANON(boolean _createToken) throws RecognitionException, CharStreamException, TokenStreamException {
 356  32
                 int _ttype; Token _token=null; int _begin=text.length();
 357  32
                 _ttype = ANON;
 358  
                 int _saveIndex;
 359  
                 
 360  32
                 match('?');
 361  32
                 if ( _createToken && _token==null && _ttype!=Token.SKIP ) {
 362  32
                         _token = makeToken(_ttype);
 363  32
                         _token.setText(new String(text.getBuffer(), _begin, text.length()-_begin));
 364  
                 }
 365  32
                 _returnToken = _token;
 366  32
         }
 367  
         
 368  
         public final void mCOLON(boolean _createToken) throws RecognitionException, CharStreamException, TokenStreamException {
 369  10
                 int _ttype; Token _token=null; int _begin=text.length();
 370  10
                 _ttype = COLON;
 371  
                 int _saveIndex;
 372  
                 
 373  10
                 match(':');
 374  10
                 if ( _createToken && _token==null && _ttype!=Token.SKIP ) {
 375  10
                         _token = makeToken(_ttype);
 376  10
                         _token.setText(new String(text.getBuffer(), _begin, text.length()-_begin));
 377  
                 }
 378  10
                 _returnToken = _token;
 379  10
         }
 380  
         
 381  
         public final void mBANG(boolean _createToken) throws RecognitionException, CharStreamException, TokenStreamException {
 382  32
                 int _ttype; Token _token=null; int _begin=text.length();
 383  32
                 _ttype = BANG;
 384  
                 int _saveIndex;
 385  
                 
 386  32
                 match('!');
 387  32
                 if ( _createToken && _token==null && _ttype!=Token.SKIP ) {
 388  32
                         _token = makeToken(_ttype);
 389  32
                         _token.setText(new String(text.getBuffer(), _begin, text.length()-_begin));
 390  
                 }
 391  32
                 _returnToken = _token;
 392  32
         }
 393  
         
 394  
         public final void mASSIGN(boolean _createToken) throws RecognitionException, CharStreamException, TokenStreamException {
 395  109
                 int _ttype; Token _token=null; int _begin=text.length();
 396  109
                 _ttype = ASSIGN;
 397  
                 int _saveIndex;
 398  
                 
 399  109
                 match('=');
 400  109
                 if ( _createToken && _token==null && _ttype!=Token.SKIP ) {
 401  109
                         _token = makeToken(_ttype);
 402  109
                         _token.setText(new String(text.getBuffer(), _begin, text.length()-_begin));
 403  
                 }
 404  109
                 _returnToken = _token;
 405  109
         }
 406  
         
 407  
         public final void mRANGE(boolean _createToken) throws RecognitionException, CharStreamException, TokenStreamException {
 408  130
                 int _ttype; Token _token=null; int _begin=text.length();
 409  130
                 _ttype = RANGE;
 410  
                 int _saveIndex;
 411  
                 
 412  130
                 match("..");
 413  130
                 if ( _createToken && _token==null && _ttype!=Token.SKIP ) {
 414  130
                         _token = makeToken(_ttype);
 415  130
                         _token.setText(new String(text.getBuffer(), _begin, text.length()-_begin));
 416  
                 }
 417  130
                 _returnToken = _token;
 418  130
         }
 419  
         
 420  
         public final void mWS(boolean _createToken) throws RecognitionException, CharStreamException, TokenStreamException {
 421  1517
                 int _ttype; Token _token=null; int _begin=text.length();
 422  1517
                 _ttype = WS;
 423  
                 int _saveIndex;
 424  
                 
 425  
                 {
 426  1517
                 switch ( LA(1)) {
 427  
                 case ' ':
 428  
                 {
 429  804
                         match(' ');
 430  804
                         break;
 431  
                 }
 432  
                 case '\t':
 433  
                 {
 434  185
                         match('\t');
 435  185
                         break;
 436  
                 }
 437  
                 case '\u000c':
 438  
                 {
 439  0
                         match('\f');
 440  0
                         break;
 441  
                 }
 442  
                 case '\n':  case '\r':
 443  
                 {
 444  528
                         mNL(false);
 445  528
                         break;
 446  
                 }
 447  
                 default:
 448  
                 {
 449  0
                         throw new NoViableAltForCharException((char)LA(1), getFilename(), getLine(), getColumn());
 450  
                 }
 451  
                 }
 452  
                 }
 453  1517
                 _ttype = Token.SKIP;
 454  1517
                 if ( _createToken && _token==null && _ttype!=Token.SKIP ) {
 455  0
                         _token = makeToken(_ttype);
 456  0
                         _token.setText(new String(text.getBuffer(), _begin, text.length()-_begin));
 457  
                 }
 458  1517
                 _returnToken = _token;
 459  1517
         }
 460  
         
 461  
         protected final void mNL(boolean _createToken) throws RecognitionException, CharStreamException, TokenStreamException {
 462  1050
                 int _ttype; Token _token=null; int _begin=text.length();
 463  1050
                 _ttype = NL;
 464  
                 int _saveIndex;
 465  
                 
 466  
                 {
 467  1050
                 if (((LA(1)=='\r') && (LA(2)=='\n'))&&(LA(2) == '\n')) {
 468  514
                         match('\r');
 469  514
                         match('\n');
 470  
                 }
 471  536
                 else if ((LA(1)=='\r') && (true)) {
 472  0
                         match('\r');
 473  
                 }
 474  536
                 else if ((LA(1)=='\n')) {
 475  536
                         match('\n');
 476  
                 }
 477  
                 else {
 478  0
                         throw new NoViableAltForCharException((char)LA(1), getFilename(), getLine(), getColumn());
 479  
                 }
 480  
                 
 481  
                 }
 482  1050
                 newline();
 483  1050
                 if ( _createToken && _token==null && _ttype!=Token.SKIP ) {
 484  0
                         _token = makeToken(_ttype);
 485  0
                         _token.setText(new String(text.getBuffer(), _begin, text.length()-_begin));
 486  
                 }
 487  1050
                 _returnToken = _token;
 488  1050
         }
 489  
         
 490  
         public final void mSL_COMMENT(boolean _createToken) throws RecognitionException, CharStreamException, TokenStreamException {
 491  42
                 int _ttype; Token _token=null; int _begin=text.length();
 492  42
                 _ttype = SL_COMMENT;
 493  
                 int _saveIndex;
 494  
                 
 495  42
                 match("//");
 496  
                 {
 497  
                 _loop76:
 498  
                 do {
 499  598
                         if ((_tokenSet_0.member(LA(1)))) {
 500  
                                 {
 501  556
                                 match(_tokenSet_0);
 502  
                                 }
 503  
                         }
 504  
                         else {
 505  
                                 break _loop76;
 506  
                         }
 507  
                         
 508  
                 } while (true);
 509  
                 }
 510  
                 {
 511  42
                 if ((LA(1)=='\n'||LA(1)=='\r')) {
 512  42
                         mNL(false);
 513  
                 }
 514  
                 else {
 515  
                 }
 516  
                 
 517  
                 }
 518  42
                 _ttype = Token.SKIP;
 519  42
                 if ( _createToken && _token==null && _ttype!=Token.SKIP ) {
 520  0
                         _token = makeToken(_ttype);
 521  0
                         _token.setText(new String(text.getBuffer(), _begin, text.length()-_begin));
 522  
                 }
 523  42
                 _returnToken = _token;
 524  42
         }
 525  
         
 526  
         public final void mML_COMMENT(boolean _createToken) throws RecognitionException, CharStreamException, TokenStreamException {
 527  32
                 int _ttype; Token _token=null; int _begin=text.length();
 528  32
                 _ttype = ML_COMMENT;
 529  
                 int _saveIndex;
 530  
                 
 531  32
                 match("/*");
 532  
                 {
 533  
                 _loop81:
 534  
                 do {
 535  25568
                         if (((LA(1)=='*') && ((LA(2) >= '\u0003' && LA(2) <= '\uffff')))&&( LA(2)!='/' )) {
 536  448
                                 match('*');
 537  
                         }
 538  25120
                         else if ((LA(1)=='\n'||LA(1)=='\r')) {
 539  480
                                 mNL(false);
 540  
                         }
 541  24640
                         else if ((_tokenSet_1.member(LA(1)))) {
 542  
                                 {
 543  24608
                                 match(_tokenSet_1);
 544  
                                 }
 545  
                         }
 546  
                         else {
 547  
                                 break _loop81;
 548  
                         }
 549  
                         
 550  
                 } while (true);
 551  
                 }
 552  32
                 match("*/");
 553  32
                 _ttype = Token.SKIP;
 554  32
                 if ( _createToken && _token==null && _ttype!=Token.SKIP ) {
 555  0
                         _token = makeToken(_ttype);
 556  0
                         _token.setText(new String(text.getBuffer(), _begin, text.length()-_begin));
 557  
                 }
 558  32
                 _returnToken = _token;
 559  32
         }
 560  
         
 561  
         public final void mIDENT(boolean _createToken) throws RecognitionException, CharStreamException, TokenStreamException {
 562  568
                 int _ttype; Token _token=null; int _begin=text.length();
 563  568
                 _ttype = IDENT;
 564  
                 int _saveIndex;
 565  
                 
 566  568
                 mPTIDENT(false);
 567  568
                 if ( _createToken && _token==null && _ttype!=Token.SKIP ) {
 568  568
                         _token = makeToken(_ttype);
 569  568
                         _token.setText(new String(text.getBuffer(), _begin, text.length()-_begin));
 570  
                 }
 571  568
                 _returnToken = _token;
 572  568
         }
 573  
         
 574  
         protected final void mPTIDENT(boolean _createToken) throws RecognitionException, CharStreamException, TokenStreamException {
 575  598
                 int _ttype; Token _token=null; int _begin=text.length();
 576  598
                 _ttype = PTIDENT;
 577  
                 int _saveIndex;
 578  
                 
 579  
                 {
 580  598
                 switch ( LA(1)) {
 581  
                 case 'a':  case 'b':  case 'c':  case 'd':
 582  
                 case 'e':  case 'f':  case 'g':  case 'h':
 583  
                 case 'i':  case 'j':  case 'k':  case 'l':
 584  
                 case 'm':  case 'n':  case 'o':  case 'p':
 585  
                 case 'q':  case 'r':  case 's':  case 't':
 586  
                 case 'u':  case 'v':  case 'w':  case 'x':
 587  
                 case 'y':  case 'z':
 588  
                 {
 589  548
                         matchRange('a','z');
 590  548
                         break;
 591  
                 }
 592  
                 case 'A':  case 'B':  case 'C':  case 'D':
 593  
                 case 'E':  case 'F':  case 'G':  case 'H':
 594  
                 case 'I':  case 'J':  case 'K':  case 'L':
 595  
                 case 'M':  case 'N':  case 'O':  case 'P':
 596  
                 case 'Q':  case 'R':  case 'S':  case 'T':
 597  
                 case 'U':  case 'V':  case 'W':  case 'X':
 598  
                 case 'Y':  case 'Z':
 599  
                 {
 600  50
                         matchRange('A','Z');
 601  50
                         break;
 602  
                 }
 603  
                 default:
 604  
                 {
 605  0
                         throw new NoViableAltForCharException((char)LA(1), getFilename(), getLine(), getColumn());
 606  
                 }
 607  
                 }
 608  
                 }
 609  
                 {
 610  
                 _loop88:
 611  
                 do {
 612  4079
                         switch ( LA(1)) {
 613  
                         case 'a':  case 'b':  case 'c':  case 'd':
 614  
                         case 'e':  case 'f':  case 'g':  case 'h':
 615  
                         case 'i':  case 'j':  case 'k':  case 'l':
 616  
                         case 'm':  case 'n':  case 'o':  case 'p':
 617  
                         case 'q':  case 'r':  case 's':  case 't':
 618  
                         case 'u':  case 'v':  case 'w':  case 'x':
 619  
                         case 'y':  case 'z':
 620  
                         {
 621  2935
                                 matchRange('a','z');
 622  2935
                                 break;
 623  
                         }
 624  
                         case 'A':  case 'B':  case 'C':  case 'D':
 625  
                         case 'E':  case 'F':  case 'G':  case 'H':
 626  
                         case 'I':  case 'J':  case 'K':  case 'L':
 627  
                         case 'M':  case 'N':  case 'O':  case 'P':
 628  
                         case 'Q':  case 'R':  case 'S':  case 'T':
 629  
                         case 'U':  case 'V':  case 'W':  case 'X':
 630  
                         case 'Y':  case 'Z':
 631  
                         {
 632  343
                                 matchRange('A','Z');
 633  343
                                 break;
 634  
                         }
 635  
                         case '_':
 636  
                         {
 637  0
                                 match('_');
 638  0
                                 break;
 639  
                         }
 640  
                         case '0':  case '1':  case '2':  case '3':
 641  
                         case '4':  case '5':  case '6':  case '7':
 642  
                         case '8':  case '9':
 643  
                         {
 644  203
                                 matchRange('0','9');
 645  203
                                 break;
 646  
                         }
 647  
                         case '$':
 648  
                         {
 649  0
                                 match('$');
 650  0
                                 break;
 651  
                         }
 652  
                         case '/':
 653  
                         {
 654  0
                                 match('/');
 655  0
                                 break;
 656  
                         }
 657  
                         case '*':
 658  
                         {
 659  0
                                 match('*');
 660  0
                                 break;
 661  
                         }
 662  
                         default:
 663  
                         {
 664  598
                                 break _loop88;
 665  
                         }
 666  
                         }
 667  
                 } while (true);
 668  
                 }
 669  598
                 _ttype = testLiteralsTable(new String(text.getBuffer(),_begin,text.length()-_begin),_ttype);
 670  598
                 if ( _createToken && _token==null && _ttype!=Token.SKIP ) {
 671  30
                         _token = makeToken(_ttype);
 672  30
                         _token.setText(new String(text.getBuffer(), _begin, text.length()-_begin));
 673  
                 }
 674  598
                 _returnToken = _token;
 675  598
         }
 676  
         
 677  
         public final void mTYPEREF(boolean _createToken) throws RecognitionException, CharStreamException, TokenStreamException {
 678  27
                 int _ttype; Token _token=null; int _begin=text.length();
 679  27
                 _ttype = TYPEREF;
 680  
                 int _saveIndex;
 681  27
                 Token i=null;
 682  
                 
 683  27
                 match('$');
 684  27
                 mPTIDENT(true);
 685  27
                 i=_returnToken;
 686  27
                 text.setLength(_begin); text.append(i.getText());
 687  27
                 if ( _createToken && _token==null && _ttype!=Token.SKIP ) {
 688  27
                         _token = makeToken(_ttype);
 689  27
                         _token.setText(new String(text.getBuffer(), _begin, text.length()-_begin));
 690  
                 }
 691  27
                 _returnToken = _token;
 692  27
         }
 693  
         
 694  
         public final void mOPTION_BLOCK(boolean _createToken) throws RecognitionException, CharStreamException, TokenStreamException {
 695  3
                 int _ttype; Token _token=null; int _begin=text.length();
 696  3
                 _ttype = OPTION_BLOCK;
 697  
                 int _saveIndex;
 698  3
                 Token i=null;
 699  
                 
 700  3
                 match('@');
 701  3
                 mPTIDENT(true);
 702  3
                 i=_returnToken;
 703  3
                 text.setLength(_begin); text.append(i.getText());
 704  3
                 if ( _createToken && _token==null && _ttype!=Token.SKIP ) {
 705  3
                         _token = makeToken(_ttype);
 706  3
                         _token.setText(new String(text.getBuffer(), _begin, text.length()-_begin));
 707  
                 }
 708  3
                 _returnToken = _token;
 709  3
         }
 710  
         
 711  
         public final void mNUMBER(boolean _createToken) throws RecognitionException, CharStreamException, TokenStreamException {
 712  432
                 int _ttype; Token _token=null; int _begin=text.length();
 713  432
                 _ttype = NUMBER;
 714  
                 int _saveIndex;
 715  
                 
 716  
                 {
 717  432
                 int _cnt93=0;
 718  
                 _loop93:
 719  
                 do {
 720  899
                         if (((LA(1) >= '0' && LA(1) <= '9'))) {
 721  467
                                 matchRange('0','9');
 722  
                         }
 723  
                         else {
 724  432
                                 if ( _cnt93>=1 ) { break _loop93; } else {throw new NoViableAltForCharException((char)LA(1), getFilename(), getLine(), getColumn());}
 725  
                         }
 726  
                         
 727  467
                         _cnt93++;
 728  467
                 } while (true);
 729  
                 }
 730  432
                 if ( _createToken && _token==null && _ttype!=Token.SKIP ) {
 731  432
                         _token = makeToken(_ttype);
 732  432
                         _token.setText(new String(text.getBuffer(), _begin, text.length()-_begin));
 733  
                 }
 734  432
                 _returnToken = _token;
 735  432
         }
 736  
         
 737  
         public final void mCHAR_LITERAL(boolean _createToken) throws RecognitionException, CharStreamException, TokenStreamException {
 738  70
                 int _ttype; Token _token=null; int _begin=text.length();
 739  70
                 _ttype = CHAR_LITERAL;
 740  
                 int _saveIndex;
 741  70
                 Token c=null;
 742  
                 
 743  70
                 match('\'');
 744  70
                 mCHAR_BODY(true);
 745  70
                 c=_returnToken;
 746  70
                 match('\'');
 747  70
                 text.setLength(_begin); text.append(c.getText());
 748  70
                 if ( _createToken && _token==null && _ttype!=Token.SKIP ) {
 749  70
                         _token = makeToken(_ttype);
 750  70
                         _token.setText(new String(text.getBuffer(), _begin, text.length()-_begin));
 751  
                 }
 752  70
                 _returnToken = _token;
 753  70
         }
 754  
         
 755  
         protected final void mCHAR_BODY(boolean _createToken) throws RecognitionException, CharStreamException, TokenStreamException {
 756  70
                 int _ttype; Token _token=null; int _begin=text.length();
 757  70
                 _ttype = CHAR_BODY;
 758  
                 int _saveIndex;
 759  
                 
 760  70
                 if ((LA(1)=='\\')) {
 761  14
                         mESC(false);
 762  
                 }
 763  56
                 else if ((_tokenSet_2.member(LA(1)))) {
 764  
                         {
 765  56
                         match(_tokenSet_2);
 766  
                         }
 767  
                 }
 768  
                 else {
 769  0
                         throw new NoViableAltForCharException((char)LA(1), getFilename(), getLine(), getColumn());
 770  
                 }
 771  
                 
 772  70
                 if ( _createToken && _token==null && _ttype!=Token.SKIP ) {
 773  70
                         _token = makeToken(_ttype);
 774  70
                         _token.setText(new String(text.getBuffer(), _begin, text.length()-_begin));
 775  
                 }
 776  70
                 _returnToken = _token;
 777  70
         }
 778  
         
 779  
         protected final void mESC(boolean _createToken) throws RecognitionException, CharStreamException, TokenStreamException {
 780  28
                 int _ttype; Token _token=null; int _begin=text.length();
 781  28
                 _ttype = ESC;
 782  
                 int _saveIndex;
 783  28
                 char c = 0;
 784  
                 
 785  28
                 match('\\');
 786  
                 {
 787  28
                 switch ( LA(1)) {
 788  
                 case 'n':
 789  
                 {
 790  21
                         match('n');
 791  21
                         text.setLength(_begin); text.append("\n");
 792  21
                         break;
 793  
                 }
 794  
                 case 'r':
 795  
                 {
 796  7
                         match('r');
 797  7
                         text.setLength(_begin); text.append("\r");
 798  7
                         break;
 799  
                 }
 800  
                 case 't':
 801  
                 {
 802  0
                         match('t');
 803  0
                         text.setLength(_begin); text.append("\t");
 804  0
                         break;
 805  
                 }
 806  
                 case 'b':
 807  
                 {
 808  0
                         match('b');
 809  0
                         text.setLength(_begin); text.append("\b");
 810  0
                         break;
 811  
                 }
 812  
                 case 'f':
 813  
                 {
 814  0
                         match('f');
 815  0
                         text.setLength(_begin); text.append("\f");
 816  0
                         break;
 817  
                 }
 818  
                 case '"':
 819  
                 {
 820  0
                         match('"');
 821  0
                         text.setLength(_begin); text.append("\"");
 822  0
                         break;
 823  
                 }
 824  
                 case '\'':
 825  
                 {
 826  0
                         match('\'');
 827  0
                         text.setLength(_begin); text.append("\'");
 828  0
                         break;
 829  
                 }
 830  
                 case '\\':
 831  
                 {
 832  0
                         match('\\');
 833  0
                         text.setLength(_begin); text.append("\\");
 834  0
                         break;
 835  
                 }
 836  
                 case 'u':
 837  
                 {
 838  0
                         c=mUNICODE(false);
 839  0
                         text.setLength(_begin); text.append(Character.toString(c));
 840  0
                         break;
 841  
                 }
 842  
                 case '0':  case '1':  case '2':  case '3':
 843  
                 case '4':  case '5':  case '6':  case '7':
 844  
                 {
 845  0
                         c=mOCTAL(false);
 846  0
                         text.setLength(_begin); text.append(Character.toString(c));
 847  0
                         break;
 848  
                 }
 849  
                 default:
 850  
                 {
 851  0
                         throw new NoViableAltForCharException((char)LA(1), getFilename(), getLine(), getColumn());
 852  
                 }
 853  
                 }
 854  
                 }
 855  28
                 if ( _createToken && _token==null && _ttype!=Token.SKIP ) {
 856  14
                         _token = makeToken(_ttype);
 857  14
                         _token.setText(new String(text.getBuffer(), _begin, text.length()-_begin));
 858  
                 }
 859  28
                 _returnToken = _token;
 860  28
         }
 861  
         
 862  
         public final void mSTRING_LITERAL(boolean _createToken) throws RecognitionException, CharStreamException, TokenStreamException {
 863  151
                 int _ttype; Token _token=null; int _begin=text.length();
 864  151
                 _ttype = STRING_LITERAL;
 865  
                 int _saveIndex;
 866  151
                 Token s=null;
 867  
                 
 868  151
                 match('"');
 869  151
                 mSTRING_BODY(true);
 870  151
                 s=_returnToken;
 871  151
                 match('"');
 872  151
                 text.setLength(_begin); text.append(s.getText());
 873  151
                 if ( _createToken && _token==null && _ttype!=Token.SKIP ) {
 874  151
                         _token = makeToken(_ttype);
 875  151
                         _token.setText(new String(text.getBuffer(), _begin, text.length()-_begin));
 876  
                 }
 877  151
                 _returnToken = _token;
 878  151
         }
 879  
         
 880  
         protected final void mSTRING_BODY(boolean _createToken) throws RecognitionException, CharStreamException, TokenStreamException {
 881  151
                 int _ttype; Token _token=null; int _begin=text.length();
 882  151
                 _ttype = STRING_BODY;
 883  
                 int _saveIndex;
 884  151
                 Token e=null;
 885  151
                 char  o = '\0';
 886  151
                 StringBuffer sb = new StringBuffer();
 887  
                 
 888  
                 {
 889  
                 _loop101:
 890  
                 do {
 891  868
                         if ((LA(1)=='\\')) {
 892  14
                                 mESC(true);
 893  14
                                 e=_returnToken;
 894  14
                                 sb.append(e.getText());
 895  
                         }
 896  854
                         else if ((_tokenSet_3.member(LA(1)))) {
 897  
                                 {
 898  703
                                 o = LA(1);
 899  703
                                 match(_tokenSet_3);
 900  
                                 }
 901  703
                                 sb.append(o);
 902  
                         }
 903  
                         else {
 904  
                                 break _loop101;
 905  
                         }
 906  
                         
 907  
                 } while (true);
 908  
                 }
 909  151
                 text.setLength(_begin); text.append(sb.toString());
 910  151
                 if ( _createToken && _token==null && _ttype!=Token.SKIP ) {
 911  151
                         _token = makeToken(_ttype);
 912  151
                         _token.setText(new String(text.getBuffer(), _begin, text.length()-_begin));
 913  
                 }
 914  151
                 _returnToken = _token;
 915  151
         }
 916  
         
 917  
         protected final char  mUNICODE(boolean _createToken) throws RecognitionException, CharStreamException, TokenStreamException {
 918  0
                 char c = 0;;
 919  0
                 int _ttype; Token _token=null; int _begin=text.length();
 920  0
                 _ttype = UNICODE;
 921  
                 int _saveIndex;
 922  
                 
 923  
                 {
 924  0
                 int _cnt106=0;
 925  
                 _loop106:
 926  
                 do {
 927  0
                         if ((LA(1)=='u')) {
 928  0
                                 match('u');
 929  
                         }
 930  
                         else {
 931  0
                                 if ( _cnt106>=1 ) { break _loop106; } else {throw new NoViableAltForCharException((char)LA(1), getFilename(), getLine(), getColumn());}
 932  
                         }
 933  
                         
 934  0
                         _cnt106++;
 935  0
                 } while (true);
 936  
                 }
 937  0
                 mHEX_DIGIT(false);
 938  0
                 c <<= 4; c |= Character.digit(LA(0), 16);
 939  0
                 mHEX_DIGIT(false);
 940  0
                 c <<= 4; c |= Character.digit(LA(0), 16);
 941  0
                 mHEX_DIGIT(false);
 942  0
                 c <<= 4; c |= Character.digit(LA(0), 16);
 943  0
                 mHEX_DIGIT(false);
 944  0
                 c <<= 4; c |= Character.digit(LA(0), 16);
 945  0
                 if ( _createToken && _token==null && _ttype!=Token.SKIP ) {
 946  0
                         _token = makeToken(_ttype);
 947  0
                         _token.setText(new String(text.getBuffer(), _begin, text.length()-_begin));
 948  
                 }
 949  0
                 _returnToken = _token;
 950  0
                 return c;
 951  
         }
 952  
         
 953  
         protected final char  mOCTAL(boolean _createToken) throws RecognitionException, CharStreamException, TokenStreamException {
 954  0
                 char c = 0;;
 955  0
                 int _ttype; Token _token=null; int _begin=text.length();
 956  0
                 _ttype = OCTAL;
 957  
                 int _saveIndex;
 958  
                 
 959  0
                 switch ( LA(1)) {
 960  
                 case '0':  case '1':  case '2':  case '3':
 961  
                 {
 962  0
                         matchRange('0','3');
 963  0
                         c <<= 3; c |= Character.digit(LA(0), 8);
 964  
                         {
 965  0
                         if (((LA(1) >= '0' && LA(1) <= '7')) && (_tokenSet_0.member(LA(2)))) {
 966  0
                                 matchRange('0','7');
 967  0
                                 c <<= 3; c |= Character.digit(LA(0), 8);
 968  
                                 {
 969  0
                                 if (((LA(1) >= '0' && LA(1) <= '7')) && (_tokenSet_0.member(LA(2)))) {
 970  0
                                         matchRange('0','7');
 971  0
                                         c <<= 3; c |= Character.digit(LA(0), 8);
 972  
                                 }
 973  0
                                 else if ((_tokenSet_0.member(LA(1))) && (true)) {
 974  
                                 }
 975  
                                 else {
 976  0
                                         throw new NoViableAltForCharException((char)LA(1), getFilename(), getLine(), getColumn());
 977  
                                 }
 978  
                                 
 979  
                                 }
 980  
                         }
 981  0
                         else if ((_tokenSet_0.member(LA(1))) && (true)) {
 982  
                         }
 983  
                         else {
 984  0
                                 throw new NoViableAltForCharException((char)LA(1), getFilename(), getLine(), getColumn());
 985  
                         }
 986  
                         
 987  
                         }
 988  
                         break;
 989  
                 }
 990  
                 case '4':  case '5':  case '6':  case '7':
 991  
                 {
 992  0
                         matchRange('4','7');
 993  0
                         c <<= 3; c |= Character.digit(LA(0), 8);
 994  
                         {
 995  0
                         if (((LA(1) >= '0' && LA(1) <= '7')) && (_tokenSet_0.member(LA(2)))) {
 996  0
                                 matchRange('0','7');
 997  0
                                 c <<= 3; c |= Character.digit(LA(0), 8);
 998  
                         }
 999  0
                         else if ((_tokenSet_0.member(LA(1))) && (true)) {
 1000  
                         }
 1001  
                         else {
 1002  0
                                 throw new NoViableAltForCharException((char)LA(1), getFilename(), getLine(), getColumn());
 1003  
                         }
 1004  
                         
 1005  
                         }
 1006  
                         break;
 1007  
                 }
 1008  
                 default:
 1009  
                 {
 1010  0
                         throw new NoViableAltForCharException((char)LA(1), getFilename(), getLine(), getColumn());
 1011  
                 }
 1012  
                 }
 1013  0
                 if ( _createToken && _token==null && _ttype!=Token.SKIP ) {
 1014  0
                         _token = makeToken(_ttype);
 1015  0
                         _token.setText(new String(text.getBuffer(), _begin, text.length()-_begin));
 1016  
                 }
 1017  0
                 _returnToken = _token;
 1018  0
                 return c;
 1019  
         }
 1020  
         
 1021  
         protected final int  mHEX_DIGIT(boolean _createToken) throws RecognitionException, CharStreamException, TokenStreamException {
 1022  0
                 int i = 0;;
 1023  0
                 int _ttype; Token _token=null; int _begin=text.length();
 1024  0
                 _ttype = HEX_DIGIT;
 1025  
                 int _saveIndex;
 1026  
                 
 1027  
                 {
 1028  0
                 switch ( LA(1)) {
 1029  
                 case '0':  case '1':  case '2':  case '3':
 1030  
                 case '4':  case '5':  case '6':  case '7':
 1031  
                 case '8':  case '9':
 1032  
                 {
 1033  0
                         matchRange('0','9');
 1034  0
                         break;
 1035  
                 }
 1036  
                 case 'A':  case 'B':  case 'C':  case 'D':
 1037  
                 case 'E':  case 'F':
 1038  
                 {
 1039  0
                         matchRange('A','F');
 1040  0
                         break;
 1041  
                 }
 1042  
                 case 'a':  case 'b':  case 'c':  case 'd':
 1043  
                 case 'e':  case 'f':
 1044  
                 {
 1045  0
                         matchRange('a','f');
 1046  0
                         break;
 1047  
                 }
 1048  
                 default:
 1049  
                 {
 1050  0
                         throw new NoViableAltForCharException((char)LA(1), getFilename(), getLine(), getColumn());
 1051  
                 }
 1052  
                 }
 1053  
                 }
 1054  0
                 i = Character.digit(LA(0), 16);
 1055  0
                 if ( _createToken && _token==null && _ttype!=Token.SKIP ) {
 1056  0
                         _token = makeToken(_ttype);
 1057  0
                         _token.setText(new String(text.getBuffer(), _begin, text.length()-_begin));
 1058  
                 }
 1059  0
                 _returnToken = _token;
 1060  0
                 return i;
 1061  
         }
 1062  
         
 1063  
         
 1064  
         private static final long[] mk_tokenSet_0() {
 1065  1
                 long[] data = new long[2048];
 1066  1
                 data[0]=-9224L;
 1067  1
                 for (int i = 1; i<=1023; i++) { data[i]=-1L; }
 1068  1
                 return data;
 1069  
         }
 1070  1
         public static final BitSet _tokenSet_0 = new BitSet(mk_tokenSet_0());
 1071  
         private static final long[] mk_tokenSet_1() {
 1072  1
                 long[] data = new long[2048];
 1073  1
                 data[0]=-4398046520328L;
 1074  1
                 for (int i = 1; i<=1023; i++) { data[i]=-1L; }
 1075  1
                 return data;
 1076  
         }
 1077  1
         public static final BitSet _tokenSet_1 = new BitSet(mk_tokenSet_1());
 1078  
         private static final long[] mk_tokenSet_2() {
 1079  1
                 long[] data = new long[2048];
 1080  1
                 data[0]=-549755823112L;
 1081  1
                 data[1]=-268435457L;
 1082  1
                 for (int i = 2; i<=1023; i++) { data[i]=-1L; }
 1083  1
                 return data;
 1084  
         }
 1085  1
         public static final BitSet _tokenSet_2 = new BitSet(mk_tokenSet_2());
 1086  
         private static final long[] mk_tokenSet_3() {
 1087  1
                 long[] data = new long[2048];
 1088  1
                 data[0]=-17179878408L;
 1089  1
                 data[1]=-268435457L;
 1090  1
                 for (int i = 2; i<=1023; i++) { data[i]=-1L; }
 1091  1
                 return data;
 1092  
         }
 1093  1
         public static final BitSet _tokenSet_3 = new BitSet(mk_tokenSet_3());
 1094  
         
 1095  
         }