Coverage Report - org.apache.commons.flatfile.dsl.EntityParser
 
Classes in this File Line Coverage Branch Coverage Complexity
EntityParser
91%
563/618
30%
119/396
5.778
 
 1  
 // $ANTLR 2.7.7 (20060906): "EntityParser.g" -> "EntityParser.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 antlr.TokenBuffer;
 11  
 import antlr.TokenStreamException;
 12  
 import antlr.TokenStreamIOException;
 13  
 import antlr.ANTLRException;
 14  
 import antlr.LLkParser;
 15  
 import antlr.Token;
 16  
 import antlr.TokenStream;
 17  
 import antlr.RecognitionException;
 18  
 import antlr.NoViableAltException;
 19  
 import antlr.MismatchedTokenException;
 20  
 import antlr.SemanticException;
 21  
 import antlr.ParserSharedInputState;
 22  
 import antlr.collections.impl.BitSet;
 23  
 import antlr.collections.AST;
 24  
 import java.util.Hashtable;
 25  
 import antlr.ASTFactory;
 26  
 import antlr.ASTPair;
 27  
 import antlr.collections.impl.ASTArray;
 28  
 
 29  
 public class EntityParser extends antlr.LLkParser       implements EntityTokenTypes
 30  
  {
 31  
 
 32  
 protected EntityParser(TokenBuffer tokenBuf, int k) {
 33  32
   super(tokenBuf,k);
 34  32
   tokenNames = _tokenNames;
 35  32
   buildTokenTypeASTClassMap();
 36  32
   astFactory = new ASTFactory(getTokenTypeToASTClassMap());
 37  32
 }
 38  
 
 39  
 public EntityParser(TokenBuffer tokenBuf) {
 40  32
   this(tokenBuf,2);
 41  32
 }
 42  
 
 43  
 protected EntityParser(TokenStream lexer, int k) {
 44  0
   super(lexer,k);
 45  0
   tokenNames = _tokenNames;
 46  0
   buildTokenTypeASTClassMap();
 47  0
   astFactory = new ASTFactory(getTokenTypeToASTClassMap());
 48  0
 }
 49  
 
 50  
 public EntityParser(TokenStream lexer) {
 51  0
   this(lexer,2);
 52  0
 }
 53  
 
 54  
 public EntityParser(ParserSharedInputState state) {
 55  0
   super(state,2);
 56  0
   tokenNames = _tokenNames;
 57  0
   buildTokenTypeASTClassMap();
 58  0
   astFactory = new ASTFactory(getTokenTypeToASTClassMap());
 59  0
 }
 60  
 
 61  
         public final void parse() throws RecognitionException, TokenStreamException {
 62  
                 
 63  32
                 returnAST = null;
 64  32
                 ASTPair currentAST = new ASTPair();
 65  32
                 AST parse_AST = null;
 66  
                 
 67  
                 {
 68  
                 _loop3:
 69  
                 do {
 70  35
                         if ((LA(1)==OPTION_BLOCK)) {
 71  3
                                 optionBlock();
 72  3
                                 astFactory.addASTChild(currentAST, returnAST);
 73  
                         }
 74  
                         else {
 75  
                                 break _loop3;
 76  
                         }
 77  
                         
 78  
                 } while (true);
 79  
                 }
 80  
                 {
 81  32
                 int _cnt6=0;
 82  
                 _loop6:
 83  
                 do {
 84  305
                         if ((LA(1)==IDENT)) {
 85  273
                                 explicitAssign();
 86  273
                                 astFactory.addASTChild(currentAST, returnAST);
 87  
                                 {
 88  273
                                 switch ( LA(1)) {
 89  
                                 case COLON:
 90  
                                 {
 91  10
                                         lengthcheck();
 92  10
                                         astFactory.addASTChild(currentAST, returnAST);
 93  10
                                         break;
 94  
                                 }
 95  
                                 case EOF:
 96  
                                 case IDENT:
 97  
                                 {
 98  263
                                         break;
 99  
                                 }
 100  
                                 default:
 101  
                                 {
 102  0
                                         throw new NoViableAltException(LT(1), getFilename());
 103  
                                 }
 104  
                                 }
 105  
                                 }
 106  
                         }
 107  
                         else {
 108  32
                                 if ( _cnt6>=1 ) { break _loop6; } else {throw new NoViableAltException(LT(1), getFilename());}
 109  
                         }
 110  
                         
 111  273
                         _cnt6++;
 112  273
                 } while (true);
 113  
                 }
 114  32
                 match(Token.EOF_TYPE);
 115  32
                 parse_AST = (AST)currentAST.root;
 116  32
                 parse_AST = (AST)astFactory.make( (new ASTArray(2)).add(astFactory.create(ROOT,"root")).add(parse_AST));
 117  32
                 currentAST.root = parse_AST;
 118  32
                 currentAST.child = parse_AST!=null &&parse_AST.getFirstChild()!=null ?
 119  
                         parse_AST.getFirstChild() : parse_AST;
 120  32
                 currentAST.advanceChildToEnd();
 121  32
                 parse_AST = (AST)currentAST.root;
 122  32
                 returnAST = parse_AST;
 123  32
         }
 124  
         
 125  
         protected final void optionBlock() throws RecognitionException, TokenStreamException {
 126  
                 
 127  3
                 returnAST = null;
 128  3
                 ASTPair currentAST = new ASTPair();
 129  3
                 AST optionBlock_AST = null;
 130  3
                 Token  o = null;
 131  3
                 AST o_AST = null;
 132  
                 
 133  3
                 o = LT(1);
 134  3
                 o_AST = astFactory.create(o);
 135  3
                 astFactory.makeASTRoot(currentAST, o_AST);
 136  3
                 match(OPTION_BLOCK);
 137  3
                 o_AST.setType(OPTIONS);
 138  
                 {
 139  3
                 int _cnt9=0;
 140  
                 _loop9:
 141  
                 do {
 142  7
                         if ((_tokenSet_0.member(LA(1)))) {
 143  4
                                 entityOption();
 144  4
                                 astFactory.addASTChild(currentAST, returnAST);
 145  
                         }
 146  
                         else {
 147  3
                                 if ( _cnt9>=1 ) { break _loop9; } else {throw new NoViableAltException(LT(1), getFilename());}
 148  
                         }
 149  
                         
 150  4
                         _cnt9++;
 151  4
                 } while (true);
 152  
                 }
 153  3
                 match(SEMI);
 154  3
                 optionBlock_AST = (AST)currentAST.root;
 155  3
                 returnAST = optionBlock_AST;
 156  3
         }
 157  
         
 158  
         protected final void explicitAssign() throws RecognitionException, TokenStreamException {
 159  
                 
 160  402
                 returnAST = null;
 161  402
                 ASTPair currentAST = new ASTPair();
 162  402
                 AST explicitAssign_AST = null;
 163  
                 
 164  402
                 AST tmp3_AST = null;
 165  402
                 tmp3_AST = astFactory.create(LT(1));
 166  402
                 astFactory.addASTChild(currentAST, tmp3_AST);
 167  402
                 match(IDENT);
 168  402
                 entity();
 169  402
                 astFactory.addASTChild(currentAST, returnAST);
 170  402
                 explicitAssign_AST = (AST)currentAST.root;
 171  402
                 explicitAssign_AST = (AST)astFactory.make( (new ASTArray(2)).add(astFactory.create(ASSIGN,"=")).add(explicitAssign_AST));
 172  402
                 currentAST.root = explicitAssign_AST;
 173  402
                 currentAST.child = explicitAssign_AST!=null &&explicitAssign_AST.getFirstChild()!=null ?
 174  
                         explicitAssign_AST.getFirstChild() : explicitAssign_AST;
 175  402
                 currentAST.advanceChildToEnd();
 176  402
                 explicitAssign_AST = (AST)currentAST.root;
 177  402
                 returnAST = explicitAssign_AST;
 178  402
         }
 179  
         
 180  
         protected final void lengthcheck() throws RecognitionException, TokenStreamException {
 181  
                 
 182  10
                 returnAST = null;
 183  10
                 ASTPair currentAST = new ASTPair();
 184  10
                 AST lengthcheck_AST = null;
 185  10
                 Token  c = null;
 186  10
                 AST c_AST = null;
 187  
                 
 188  10
                 c = LT(1);
 189  10
                 c_AST = astFactory.create(c);
 190  10
                 astFactory.addASTChild(currentAST, c_AST);
 191  10
                 match(COLON);
 192  10
                 c_AST.setType(CHECK);
 193  10
                 length();
 194  10
                 astFactory.addASTChild(currentAST, returnAST);
 195  10
                 lengthcheck_AST = (AST)currentAST.root;
 196  10
                 returnAST = lengthcheck_AST;
 197  10
         }
 198  
         
 199  
         protected final void entityOption() throws RecognitionException, TokenStreamException {
 200  
                 
 201  109
                 returnAST = null;
 202  109
                 ASTPair currentAST = new ASTPair();
 203  109
                 AST entityOption_AST = null;
 204  
                 
 205  
                 {
 206  109
                 switch ( LA(1)) {
 207  
                 case IDENT:
 208  
                 {
 209  104
                         AST tmp4_AST = null;
 210  104
                         tmp4_AST = astFactory.create(LT(1));
 211  104
                         astFactory.addASTChild(currentAST, tmp4_AST);
 212  104
                         match(IDENT);
 213  104
                         break;
 214  
                 }
 215  
                 case STRING_LITERAL:
 216  
                 {
 217  5
                         AST tmp5_AST = null;
 218  5
                         tmp5_AST = astFactory.create(LT(1));
 219  5
                         astFactory.addASTChild(currentAST, tmp5_AST);
 220  5
                         match(STRING_LITERAL);
 221  5
                         break;
 222  
                 }
 223  
                 case CHAR_LITERAL:
 224  
                 {
 225  0
                         AST tmp6_AST = null;
 226  0
                         tmp6_AST = astFactory.create(LT(1));
 227  0
                         astFactory.addASTChild(currentAST, tmp6_AST);
 228  0
                         match(CHAR_LITERAL);
 229  0
                         break;
 230  
                 }
 231  
                 case NUMBER:
 232  
                 {
 233  0
                         AST tmp7_AST = null;
 234  0
                         tmp7_AST = astFactory.create(LT(1));
 235  0
                         astFactory.addASTChild(currentAST, tmp7_AST);
 236  0
                         match(NUMBER);
 237  0
                         break;
 238  
                 }
 239  
                 default:
 240  
                 {
 241  0
                         throw new NoViableAltException(LT(1), getFilename());
 242  
                 }
 243  
                 }
 244  
                 }
 245  109
                 AST tmp8_AST = null;
 246  109
                 tmp8_AST = astFactory.create(LT(1));
 247  109
                 astFactory.makeASTRoot(currentAST, tmp8_AST);
 248  109
                 match(ASSIGN);
 249  
                 {
 250  109
                 switch ( LA(1)) {
 251  
                 case IDENT:
 252  
                 {
 253  62
                         AST tmp9_AST = null;
 254  62
                         tmp9_AST = astFactory.create(LT(1));
 255  62
                         astFactory.addASTChild(currentAST, tmp9_AST);
 256  62
                         match(IDENT);
 257  62
                         break;
 258  
                 }
 259  
                 case STRING_LITERAL:
 260  
                 {
 261  7
                         AST tmp10_AST = null;
 262  7
                         tmp10_AST = astFactory.create(LT(1));
 263  7
                         astFactory.addASTChild(currentAST, tmp10_AST);
 264  7
                         match(STRING_LITERAL);
 265  7
                         break;
 266  
                 }
 267  
                 case CHAR_LITERAL:
 268  
                 {
 269  40
                         AST tmp11_AST = null;
 270  40
                         tmp11_AST = astFactory.create(LT(1));
 271  40
                         astFactory.addASTChild(currentAST, tmp11_AST);
 272  40
                         match(CHAR_LITERAL);
 273  40
                         break;
 274  
                 }
 275  
                 case NUMBER:
 276  
                 {
 277  0
                         AST tmp12_AST = null;
 278  0
                         tmp12_AST = astFactory.create(LT(1));
 279  0
                         astFactory.addASTChild(currentAST, tmp12_AST);
 280  0
                         match(NUMBER);
 281  0
                         break;
 282  
                 }
 283  
                 default:
 284  
                 {
 285  0
                         throw new NoViableAltException(LT(1), getFilename());
 286  
                 }
 287  
                 }
 288  
                 }
 289  109
                 entityOption_AST = (AST)currentAST.root;
 290  109
                 returnAST = entityOption_AST;
 291  109
         }
 292  
         
 293  
         protected final void entity() throws RecognitionException, TokenStreamException {
 294  
                 
 295  434
                 returnAST = null;
 296  434
                 ASTPair currentAST = new ASTPair();
 297  434
                 AST entity_AST = null;
 298  434
                 String junk = null;
 299  
                 
 300  434
                 switch ( LA(1)) {
 301  
                 case CHAR_LITERAL:
 302  
                 case STRING_LITERAL:
 303  
                 {
 304  72
                         valueOnlyEntity();
 305  72
                         astFactory.addASTChild(currentAST, returnAST);
 306  72
                         entity_AST = (AST)currentAST.root;
 307  72
                         break;
 308  
                 }
 309  
                 case TYPEREF:
 310  
                 {
 311  18
                         junk=typeRefEntity();
 312  18
                         astFactory.addASTChild(currentAST, returnAST);
 313  18
                         entity_AST = (AST)currentAST.root;
 314  18
                         break;
 315  
                 }
 316  
                 case LPAREN:
 317  
                 case LCURLY:
 318  
                 {
 319  344
                         fieldOrMapEntity();
 320  344
                         astFactory.addASTChild(currentAST, returnAST);
 321  344
                         entity_AST = (AST)currentAST.root;
 322  344
                         break;
 323  
                 }
 324  
                 default:
 325  
                 {
 326  0
                         throw new NoViableAltException(LT(1), getFilename());
 327  
                 }
 328  
                 }
 329  434
                 returnAST = entity_AST;
 330  434
         }
 331  
         
 332  
         protected final void anonymousAssign() throws RecognitionException, TokenStreamException {
 333  
                 
 334  32
                 returnAST = null;
 335  32
                 ASTPair currentAST = new ASTPair();
 336  32
                 AST anonymousAssign_AST = null;
 337  
                 
 338  32
                 AST tmp13_AST = null;
 339  32
                 tmp13_AST = astFactory.create(LT(1));
 340  32
                 astFactory.addASTChild(currentAST, tmp13_AST);
 341  32
                 match(ANON);
 342  32
                 entity();
 343  32
                 astFactory.addASTChild(currentAST, returnAST);
 344  32
                 anonymousAssign_AST = (AST)currentAST.root;
 345  32
                 anonymousAssign_AST = (AST)astFactory.make( (new ASTArray(2)).add(astFactory.create(ASSIGN,"=")).add(anonymousAssign_AST));
 346  32
                 currentAST.root = anonymousAssign_AST;
 347  32
                 currentAST.child = anonymousAssign_AST!=null &&anonymousAssign_AST.getFirstChild()!=null ?
 348  
                         anonymousAssign_AST.getFirstChild() : anonymousAssign_AST;
 349  32
                 currentAST.advanceChildToEnd();
 350  32
                 anonymousAssign_AST = (AST)currentAST.root;
 351  32
                 returnAST = anonymousAssign_AST;
 352  32
         }
 353  
         
 354  
         protected final void length() throws RecognitionException, TokenStreamException {
 355  
                 
 356  216
                 returnAST = null;
 357  216
                 ASTPair currentAST = new ASTPair();
 358  216
                 AST length_AST = null;
 359  216
                 Token  n = null;
 360  216
                 AST n_AST = null;
 361  
                 
 362  216
                 n = LT(1);
 363  216
                 n_AST = astFactory.create(n);
 364  216
                 astFactory.addASTChild(currentAST, n_AST);
 365  216
                 match(NUMBER);
 366  216
                 n_AST.setType(LENGTH);
 367  216
                 length_AST = (AST)currentAST.root;
 368  216
                 returnAST = length_AST;
 369  216
         }
 370  
         
 371  
         protected final void valueOnlyEntity() throws RecognitionException, TokenStreamException {
 372  
                 
 373  72
                 returnAST = null;
 374  72
                 ASTPair currentAST = new ASTPair();
 375  72
                 AST valueOnlyEntity_AST = null;
 376  72
                 AST a_AST = null;
 377  72
                 AST ast = null;
 378  
                 
 379  72
                 explicitValue();
 380  72
                 astFactory.addASTChild(currentAST, returnAST);
 381  72
                 valueOnlyEntity_AST = (AST)currentAST.root;
 382  72
                 valueOnlyEntity_AST = (AST)astFactory.make( (new ASTArray(2)).add(astFactory.create(FIELD,"field")).add(valueOnlyEntity_AST)); ast = valueOnlyEntity_AST;
 383  72
                 currentAST.root = valueOnlyEntity_AST;
 384  72
                 currentAST.child = valueOnlyEntity_AST!=null &&valueOnlyEntity_AST.getFirstChild()!=null ?
 385  
                         valueOnlyEntity_AST.getFirstChild() : valueOnlyEntity_AST;
 386  72
                 currentAST.advanceChildToEnd();
 387  
                 {
 388  72
                 switch ( LA(1)) {
 389  
                 case BANG:
 390  
                 {
 391  24
                         immutable();
 392  24
                         astFactory.addASTChild(currentAST, returnAST);
 393  24
                         break;
 394  
                 }
 395  
                 case EOF:
 396  
                 case IDENT:
 397  
                 case ANON:
 398  
                 case COLON:
 399  
                 case TYPEREF:
 400  
                 case LBRACK:
 401  
                 case COMMA:
 402  
                 case RCURLY:
 403  
                 {
 404  48
                         break;
 405  
                 }
 406  
                 default:
 407  
                 {
 408  0
                         throw new NoViableAltException(LT(1), getFilename());
 409  
                 }
 410  
                 }
 411  
                 }
 412  
                 {
 413  72
                 switch ( LA(1)) {
 414  
                 case LBRACK:
 415  
                 {
 416  5
                         array(ast);
 417  5
                         a_AST = (AST)returnAST;
 418  5
                         valueOnlyEntity_AST = (AST)currentAST.root;
 419  5
                         valueOnlyEntity_AST = a_AST;
 420  5
                         currentAST.root = valueOnlyEntity_AST;
 421  5
                         currentAST.child = valueOnlyEntity_AST!=null &&valueOnlyEntity_AST.getFirstChild()!=null ?
 422  
                                 valueOnlyEntity_AST.getFirstChild() : valueOnlyEntity_AST;
 423  5
                         currentAST.advanceChildToEnd();
 424  5
                         break;
 425  
                 }
 426  
                 case EOF:
 427  
                 case IDENT:
 428  
                 case ANON:
 429  
                 case COLON:
 430  
                 case TYPEREF:
 431  
                 case COMMA:
 432  
                 case RCURLY:
 433  
                 {
 434  67
                         break;
 435  
                 }
 436  
                 default:
 437  
                 {
 438  0
                         throw new NoViableAltException(LT(1), getFilename());
 439  
                 }
 440  
                 }
 441  
                 }
 442  72
                 valueOnlyEntity_AST = (AST)currentAST.root;
 443  72
                 returnAST = valueOnlyEntity_AST;
 444  72
         }
 445  
         
 446  
         protected final String  typeRefEntity() throws RecognitionException, TokenStreamException {
 447  
                 String name;
 448  
                 
 449  27
                 returnAST = null;
 450  27
                 ASTPair currentAST = new ASTPair();
 451  27
                 AST typeRefEntity_AST = null;
 452  27
                 Token  t = null;
 453  27
                 AST t_AST = null;
 454  27
                 AST a_AST = null;
 455  27
                 AST ast = null;
 456  
                 
 457  
                 {
 458  27
                 t = LT(1);
 459  27
                 t_AST = astFactory.create(t);
 460  27
                 astFactory.makeASTRoot(currentAST, t_AST);
 461  27
                 match(TYPEREF);
 462  27
                 name = t.getText();
 463  
                 {
 464  27
                 if ((_tokenSet_0.member(LA(1))) && (LA(2)==ASSIGN)) {
 465  0
                         entityOptions();
 466  0
                         astFactory.addASTChild(currentAST, returnAST);
 467  
                 }
 468  27
                 else if ((_tokenSet_1.member(LA(1))) && (_tokenSet_2.member(LA(2)))) {
 469  
                 }
 470  
                 else {
 471  0
                         throw new NoViableAltException(LT(1), getFilename());
 472  
                 }
 473  
                 
 474  
                 }
 475  
                 {
 476  27
                 switch ( LA(1)) {
 477  
                 case CHAR_LITERAL:
 478  
                 case STRING_LITERAL:
 479  
                 {
 480  6
                         value();
 481  6
                         astFactory.addASTChild(currentAST, returnAST);
 482  6
                         break;
 483  
                 }
 484  
                 case EOF:
 485  
                 case IDENT:
 486  
                 case ANON:
 487  
                 case COLON:
 488  
                 case TYPEREF:
 489  
                 case LBRACK:
 490  
                 case COMMA:
 491  
                 case RCURLY:
 492  
                 {
 493  21
                         break;
 494  
                 }
 495  
                 default:
 496  
                 {
 497  0
                         throw new NoViableAltException(LT(1), getFilename());
 498  
                 }
 499  
                 }
 500  
                 }
 501  
                 }
 502  27
                 typeRefEntity_AST = (AST)currentAST.root;
 503  27
                 ast = typeRefEntity_AST;
 504  
                 {
 505  27
                 switch ( LA(1)) {
 506  
                 case LBRACK:
 507  
                 {
 508  10
                         array(ast);
 509  10
                         a_AST = (AST)returnAST;
 510  10
                         typeRefEntity_AST = (AST)currentAST.root;
 511  10
                         typeRefEntity_AST = a_AST;
 512  10
                         currentAST.root = typeRefEntity_AST;
 513  10
                         currentAST.child = typeRefEntity_AST!=null &&typeRefEntity_AST.getFirstChild()!=null ?
 514  
                                 typeRefEntity_AST.getFirstChild() : typeRefEntity_AST;
 515  10
                         currentAST.advanceChildToEnd();
 516  10
                         break;
 517  
                 }
 518  
                 case EOF:
 519  
                 case IDENT:
 520  
                 case ANON:
 521  
                 case COLON:
 522  
                 case TYPEREF:
 523  
                 case COMMA:
 524  
                 case RCURLY:
 525  
                 {
 526  17
                         break;
 527  
                 }
 528  
                 default:
 529  
                 {
 530  0
                         throw new NoViableAltException(LT(1), getFilename());
 531  
                 }
 532  
                 }
 533  
                 }
 534  27
                 typeRefEntity_AST = (AST)currentAST.root;
 535  27
                 returnAST = typeRefEntity_AST;
 536  27
                 return name;
 537  
         }
 538  
         
 539  
         protected final void fieldOrMapEntity() throws RecognitionException, TokenStreamException {
 540  
                 
 541  344
                 returnAST = null;
 542  344
                 ASTPair currentAST = new ASTPair();
 543  344
                 AST fieldOrMapEntity_AST = null;
 544  344
                 AST a_AST = null;
 545  344
                 AST ast = null;
 546  
                 
 547  
                 {
 548  344
                 switch ( LA(1)) {
 549  
                 case LPAREN:
 550  
                 {
 551  300
                         field();
 552  300
                         astFactory.addASTChild(currentAST, returnAST);
 553  300
                         break;
 554  
                 }
 555  
                 case LCURLY:
 556  
                 {
 557  44
                         map();
 558  44
                         astFactory.addASTChild(currentAST, returnAST);
 559  44
                         break;
 560  
                 }
 561  
                 default:
 562  
                 {
 563  0
                         throw new NoViableAltException(LT(1), getFilename());
 564  
                 }
 565  
                 }
 566  
                 }
 567  344
                 fieldOrMapEntity_AST = (AST)currentAST.root;
 568  344
                 ast = fieldOrMapEntity_AST;
 569  
                 {
 570  344
                 switch ( LA(1)) {
 571  
                 case LBRACK:
 572  
                 {
 573  107
                         array(ast);
 574  107
                         a_AST = (AST)returnAST;
 575  107
                         fieldOrMapEntity_AST = (AST)currentAST.root;
 576  107
                         fieldOrMapEntity_AST = a_AST;
 577  107
                         currentAST.root = fieldOrMapEntity_AST;
 578  107
                         currentAST.child = fieldOrMapEntity_AST!=null &&fieldOrMapEntity_AST.getFirstChild()!=null ?
 579  
                                 fieldOrMapEntity_AST.getFirstChild() : fieldOrMapEntity_AST;
 580  107
                         currentAST.advanceChildToEnd();
 581  107
                         break;
 582  
                 }
 583  
                 case EOF:
 584  
                 case IDENT:
 585  
                 case ANON:
 586  
                 case COLON:
 587  
                 case TYPEREF:
 588  
                 case COMMA:
 589  
                 case RCURLY:
 590  
                 {
 591  237
                         break;
 592  
                 }
 593  
                 default:
 594  
                 {
 595  0
                         throw new NoViableAltException(LT(1), getFilename());
 596  
                 }
 597  
                 }
 598  
                 }
 599  344
                 fieldOrMapEntity_AST = (AST)currentAST.root;
 600  344
                 returnAST = fieldOrMapEntity_AST;
 601  344
         }
 602  
         
 603  
         protected final void explicitValue() throws RecognitionException, TokenStreamException {
 604  
                 
 605  147
                 returnAST = null;
 606  147
                 ASTPair currentAST = new ASTPair();
 607  147
                 AST explicitValue_AST = null;
 608  147
                 Token  c = null;
 609  147
                 AST c_AST = null;
 610  147
                 Token  s = null;
 611  147
                 AST s_AST = null;
 612  
                 
 613  147
                 switch ( LA(1)) {
 614  
                 case CHAR_LITERAL:
 615  
                 {
 616  8
                         c = LT(1);
 617  8
                         c_AST = astFactory.create(c);
 618  8
                         astFactory.addASTChild(currentAST, c_AST);
 619  8
                         match(CHAR_LITERAL);
 620  8
                         c_AST.setType(VALUE);
 621  8
                         explicitValue_AST = (AST)currentAST.root;
 622  8
                         break;
 623  
                 }
 624  
                 case STRING_LITERAL:
 625  
                 {
 626  139
                         s = LT(1);
 627  139
                         s_AST = astFactory.create(s);
 628  139
                         astFactory.addASTChild(currentAST, s_AST);
 629  139
                         match(STRING_LITERAL);
 630  139
                         s_AST.setType(VALUE);
 631  139
                         explicitValue_AST = (AST)currentAST.root;
 632  139
                         break;
 633  
                 }
 634  
                 default:
 635  
                 {
 636  0
                         throw new NoViableAltException(LT(1), getFilename());
 637  
                 }
 638  
                 }
 639  147
                 returnAST = explicitValue_AST;
 640  147
         }
 641  
         
 642  
         protected final void immutable() throws RecognitionException, TokenStreamException {
 643  
                 
 644  32
                 returnAST = null;
 645  32
                 ASTPair currentAST = new ASTPair();
 646  32
                 AST immutable_AST = null;
 647  32
                 Token  b = null;
 648  32
                 AST b_AST = null;
 649  
                 
 650  32
                 b = LT(1);
 651  32
                 b_AST = astFactory.create(b);
 652  32
                 astFactory.addASTChild(currentAST, b_AST);
 653  32
                 match(BANG);
 654  32
                 b_AST.setType(IMMUTABLE);
 655  32
                 immutable_AST = (AST)currentAST.root;
 656  32
                 returnAST = immutable_AST;
 657  32
         }
 658  
         
 659  
         protected final void array(
 660  
                 AST p
 661  
         ) throws RecognitionException, TokenStreamException {
 662  
                 
 663  122
                 returnAST = null;
 664  122
                 ASTPair currentAST = new ASTPair();
 665  122
                 AST array_AST = null;
 666  122
                 Token  a = null;
 667  122
                 AST a_AST = null;
 668  122
                 AST o_AST = null;
 669  122
                 AST v_AST = null;
 670  
                 
 671  122
                 a = LT(1);
 672  122
                 a_AST = astFactory.create(a);
 673  122
                 astFactory.makeASTRoot(currentAST, a_AST);
 674  122
                 match(LBRACK);
 675  122
                 a_AST.setType(ARRAY);
 676  
                 {
 677  122
                 switch ( LA(1)) {
 678  
                 case NUMBER:
 679  
                 case RANGE:
 680  
                 {
 681  106
                         arrayLength();
 682  106
                         astFactory.addASTChild(currentAST, returnAST);
 683  106
                         break;
 684  
                 }
 685  
                 case RBRACK:
 686  
                 {
 687  16
                         break;
 688  
                 }
 689  
                 default:
 690  
                 {
 691  0
                         throw new NoViableAltException(LT(1), getFilename());
 692  
                 }
 693  
                 }
 694  
                 }
 695  122
                 match(RBRACK);
 696  122
                 array_AST = (AST)currentAST.root;
 697  122
                 array_AST.addChild((AST)astFactory.make( (new ASTArray(2)).add(astFactory.create(PROTOTYPE,"prototype")).add(p)));
 698  
                 {
 699  122
                 if ((_tokenSet_0.member(LA(1))) && (LA(2)==ASSIGN)) {
 700  34
                         entityOptions();
 701  34
                         o_AST = (AST)returnAST;
 702  34
                         array_AST = (AST)currentAST.root;
 703  34
                         array_AST.addChild(o_AST);
 704  
                 }
 705  88
                 else if ((_tokenSet_3.member(LA(1))) && (_tokenSet_4.member(LA(2)))) {
 706  
                 }
 707  
                 else {
 708  0
                         throw new NoViableAltException(LT(1), getFilename());
 709  
                 }
 710  
                 
 711  
                 }
 712  
                 {
 713  122
                 switch ( LA(1)) {
 714  
                 case CHAR_LITERAL:
 715  
                 case STRING_LITERAL:
 716  
                 {
 717  13
                         value();
 718  13
                         v_AST = (AST)returnAST;
 719  13
                         array_AST = (AST)currentAST.root;
 720  13
                         array_AST.addChild(v_AST);
 721  13
                         break;
 722  
                 }
 723  
                 case EOF:
 724  
                 case IDENT:
 725  
                 case ANON:
 726  
                 case COLON:
 727  
                 case TYPEREF:
 728  
                 case COMMA:
 729  
                 case RCURLY:
 730  
                 {
 731  109
                         break;
 732  
                 }
 733  
                 default:
 734  
                 {
 735  0
                         throw new NoViableAltException(LT(1), getFilename());
 736  
                 }
 737  
                 }
 738  
                 }
 739  122
                 array_AST = (AST)currentAST.root;
 740  122
                 returnAST = array_AST;
 741  122
         }
 742  
         
 743  
         protected final void entityOptions() throws RecognitionException, TokenStreamException {
 744  
                 
 745  58
                 returnAST = null;
 746  58
                 ASTPair currentAST = new ASTPair();
 747  58
                 AST entityOptions_AST = null;
 748  
                 
 749  
                 {
 750  58
                 int _cnt53=0;
 751  
                 _loop53:
 752  
                 do {
 753  163
                         if ((_tokenSet_0.member(LA(1))) && (LA(2)==ASSIGN)) {
 754  105
                                 entityOption();
 755  105
                                 astFactory.addASTChild(currentAST, returnAST);
 756  
                         }
 757  
                         else {
 758  58
                                 if ( _cnt53>=1 ) { break _loop53; } else {throw new NoViableAltException(LT(1), getFilename());}
 759  
                         }
 760  
                         
 761  105
                         _cnt53++;
 762  105
                 } while (true);
 763  
                 }
 764  58
                 entityOptions_AST = (AST)currentAST.root;
 765  58
                 entityOptions_AST = (AST)astFactory.make( (new ASTArray(2)).add(astFactory.create(OPTIONS,"options")).add(entityOptions_AST));
 766  58
                 currentAST.root = entityOptions_AST;
 767  58
                 currentAST.child = entityOptions_AST!=null &&entityOptions_AST.getFirstChild()!=null ?
 768  
                         entityOptions_AST.getFirstChild() : entityOptions_AST;
 769  58
                 currentAST.advanceChildToEnd();
 770  58
                 entityOptions_AST = (AST)currentAST.root;
 771  58
                 returnAST = entityOptions_AST;
 772  58
         }
 773  
         
 774  
         protected final void value() throws RecognitionException, TokenStreamException {
 775  
                 
 776  97
                 returnAST = null;
 777  97
                 ASTPair currentAST = new ASTPair();
 778  97
                 AST value_AST = null;
 779  
                 
 780  
                 {
 781  97
                 if ((LA(1)==CHAR_LITERAL) && (LA(2)==STAR)) {
 782  22
                         fillValue();
 783  22
                         astFactory.addASTChild(currentAST, returnAST);
 784  
                 }
 785  75
                 else if ((LA(1)==CHAR_LITERAL||LA(1)==STRING_LITERAL) && (_tokenSet_5.member(LA(2)))) {
 786  75
                         explicitValue();
 787  75
                         astFactory.addASTChild(currentAST, returnAST);
 788  
                 }
 789  
                 else {
 790  0
                         throw new NoViableAltException(LT(1), getFilename());
 791  
                 }
 792  
                 
 793  
                 }
 794  
                 {
 795  97
                 switch ( LA(1)) {
 796  
                 case BANG:
 797  
                 {
 798  8
                         immutable();
 799  8
                         astFactory.addASTChild(currentAST, returnAST);
 800  8
                         break;
 801  
                 }
 802  
                 case EOF:
 803  
                 case IDENT:
 804  
                 case ANON:
 805  
                 case COLON:
 806  
                 case TYPEREF:
 807  
                 case LBRACK:
 808  
                 case COMMA:
 809  
                 case RCURLY:
 810  
                 {
 811  89
                         break;
 812  
                 }
 813  
                 default:
 814  
                 {
 815  0
                         throw new NoViableAltException(LT(1), getFilename());
 816  
                 }
 817  
                 }
 818  
                 }
 819  97
                 value_AST = (AST)currentAST.root;
 820  97
                 returnAST = value_AST;
 821  97
         }
 822  
         
 823  
         protected final void field() throws RecognitionException, TokenStreamException {
 824  
                 
 825  300
                 returnAST = null;
 826  300
                 ASTPair currentAST = new ASTPair();
 827  300
                 AST field_AST = null;
 828  
                 
 829  300
                 match(LPAREN);
 830  
                 {
 831  300
                 switch ( LA(1)) {
 832  
                 case NUMBER:
 833  
                 case RANGE:
 834  
                 {
 835  230
                         arrayLength();
 836  230
                         astFactory.addASTChild(currentAST, returnAST);
 837  230
                         break;
 838  
                 }
 839  
                 case STAR:
 840  
                 {
 841  70
                         unboundedDynamicField();
 842  70
                         astFactory.addASTChild(currentAST, returnAST);
 843  70
                         break;
 844  
                 }
 845  
                 default:
 846  
                 {
 847  0
                         throw new NoViableAltException(LT(1), getFilename());
 848  
                 }
 849  
                 }
 850  
                 }
 851  300
                 match(RPAREN);
 852  
                 {
 853  300
                 if ((_tokenSet_0.member(LA(1))) && (LA(2)==ASSIGN)) {
 854  17
                         entityOptions();
 855  17
                         astFactory.addASTChild(currentAST, returnAST);
 856  
                 }
 857  283
                 else if ((_tokenSet_1.member(LA(1))) && (_tokenSet_2.member(LA(2)))) {
 858  
                 }
 859  
                 else {
 860  0
                         throw new NoViableAltException(LT(1), getFilename());
 861  
                 }
 862  
                 
 863  
                 }
 864  
                 {
 865  300
                 switch ( LA(1)) {
 866  
                 case CHAR_LITERAL:
 867  
                 case STRING_LITERAL:
 868  
                 {
 869  59
                         value();
 870  59
                         astFactory.addASTChild(currentAST, returnAST);
 871  59
                         break;
 872  
                 }
 873  
                 case EOF:
 874  
                 case IDENT:
 875  
                 case ANON:
 876  
                 case COLON:
 877  
                 case TYPEREF:
 878  
                 case LBRACK:
 879  
                 case COMMA:
 880  
                 case RCURLY:
 881  
                 {
 882  241
                         break;
 883  
                 }
 884  
                 default:
 885  
                 {
 886  0
                         throw new NoViableAltException(LT(1), getFilename());
 887  
                 }
 888  
                 }
 889  
                 }
 890  300
                 field_AST = (AST)currentAST.root;
 891  300
                 field_AST = (AST)astFactory.make( (new ASTArray(2)).add(astFactory.create(FIELD,"field")).add(field_AST));
 892  300
                 currentAST.root = field_AST;
 893  300
                 currentAST.child = field_AST!=null &&field_AST.getFirstChild()!=null ?
 894  
                         field_AST.getFirstChild() : field_AST;
 895  300
                 currentAST.advanceChildToEnd();
 896  300
                 field_AST = (AST)currentAST.root;
 897  300
                 returnAST = field_AST;
 898  300
         }
 899  
         
 900  
         protected final void map() throws RecognitionException, TokenStreamException {
 901  
                 
 902  44
                 returnAST = null;
 903  44
                 ASTPair currentAST = new ASTPair();
 904  44
                 AST map_AST = null;
 905  44
                 Token  m = null;
 906  44
                 AST m_AST = null;
 907  
                 
 908  44
                 m = LT(1);
 909  44
                 m_AST = astFactory.create(m);
 910  44
                 astFactory.makeASTRoot(currentAST, m_AST);
 911  44
                 match(LCURLY);
 912  44
                 m_AST.setType(MAP);
 913  44
                 mapChild();
 914  44
                 astFactory.addASTChild(currentAST, returnAST);
 915  
                 {
 916  
                 _loop42:
 917  
                 do {
 918  170
                         if ((_tokenSet_6.member(LA(1)))) {
 919  
                                 {
 920  126
                                 switch ( LA(1)) {
 921  
                                 case COMMA:
 922  
                                 {
 923  9
                                         match(COMMA);
 924  9
                                         break;
 925  
                                 }
 926  
                                 case IDENT:
 927  
                                 case ANON:
 928  
                                 case TYPEREF:
 929  
                                 {
 930  117
                                         break;
 931  
                                 }
 932  
                                 default:
 933  
                                 {
 934  0
                                         throw new NoViableAltException(LT(1), getFilename());
 935  
                                 }
 936  
                                 }
 937  
                                 }
 938  126
                                 mapChild();
 939  126
                                 astFactory.addASTChild(currentAST, returnAST);
 940  
                         }
 941  
                         else {
 942  
                                 break _loop42;
 943  
                         }
 944  
                         
 945  
                 } while (true);
 946  
                 }
 947  44
                 match(RCURLY);
 948  
                 {
 949  44
                 if ((_tokenSet_0.member(LA(1))) && (LA(2)==ASSIGN)) {
 950  7
                         entityOptions();
 951  7
                         astFactory.addASTChild(currentAST, returnAST);
 952  
                 }
 953  37
                 else if ((_tokenSet_1.member(LA(1))) && (_tokenSet_2.member(LA(2)))) {
 954  
                 }
 955  
                 else {
 956  0
                         throw new NoViableAltException(LT(1), getFilename());
 957  
                 }
 958  
                 
 959  
                 }
 960  
                 {
 961  44
                 switch ( LA(1)) {
 962  
                 case CHAR_LITERAL:
 963  
                 case STRING_LITERAL:
 964  
                 {
 965  19
                         value();
 966  19
                         astFactory.addASTChild(currentAST, returnAST);
 967  19
                         break;
 968  
                 }
 969  
                 case EOF:
 970  
                 case IDENT:
 971  
                 case ANON:
 972  
                 case COLON:
 973  
                 case TYPEREF:
 974  
                 case LBRACK:
 975  
                 case COMMA:
 976  
                 case RCURLY:
 977  
                 {
 978  25
                         break;
 979  
                 }
 980  
                 default:
 981  
                 {
 982  0
                         throw new NoViableAltException(LT(1), getFilename());
 983  
                 }
 984  
                 }
 985  
                 }
 986  44
                 map_AST = (AST)currentAST.root;
 987  44
                 returnAST = map_AST;
 988  44
         }
 989  
         
 990  
         protected final void arrayLength() throws RecognitionException, TokenStreamException {
 991  
                 
 992  336
                 returnAST = null;
 993  336
                 ASTPair currentAST = new ASTPair();
 994  336
                 AST arrayLength_AST = null;
 995  336
                 Token  n = null;
 996  336
                 AST n_AST = null;
 997  336
                 Token  n2 = null;
 998  336
                 AST n2_AST = null;
 999  336
                 Token  n3 = null;
 1000  336
                 AST n3_AST = null;
 1001  
                 
 1002  336
                 if ((LA(1)==NUMBER) && (LA(2)==RANGE)) {
 1003  101
                         n = LT(1);
 1004  101
                         n_AST = astFactory.create(n);
 1005  101
                         astFactory.addASTChild(currentAST, n_AST);
 1006  101
                         match(NUMBER);
 1007  101
                         n_AST.setType(MIN);
 1008  101
                         AST tmp19_AST = null;
 1009  101
                         tmp19_AST = astFactory.create(LT(1));
 1010  101
                         astFactory.makeASTRoot(currentAST, tmp19_AST);
 1011  101
                         match(RANGE);
 1012  
                         {
 1013  101
                         switch ( LA(1)) {
 1014  
                         case NUMBER:
 1015  
                         {
 1016  86
                                 n2 = LT(1);
 1017  86
                                 n2_AST = astFactory.create(n2);
 1018  86
                                 astFactory.addASTChild(currentAST, n2_AST);
 1019  86
                                 match(NUMBER);
 1020  86
                                 n2_AST.setType(MAX);
 1021  86
                                 break;
 1022  
                         }
 1023  
                         case RBRACK:
 1024  
                         case RPAREN:
 1025  
                         {
 1026  15
                                 break;
 1027  
                         }
 1028  
                         default:
 1029  
                         {
 1030  0
                                 throw new NoViableAltException(LT(1), getFilename());
 1031  
                         }
 1032  
                         }
 1033  
                         }
 1034  101
                         arrayLength_AST = (AST)currentAST.root;
 1035  101
                 }
 1036  235
                 else if ((LA(1)==RANGE)) {
 1037  29
                         AST tmp20_AST = null;
 1038  29
                         tmp20_AST = astFactory.create(LT(1));
 1039  29
                         astFactory.makeASTRoot(currentAST, tmp20_AST);
 1040  29
                         match(RANGE);
 1041  29
                         n3 = LT(1);
 1042  29
                         n3_AST = astFactory.create(n3);
 1043  29
                         astFactory.addASTChild(currentAST, n3_AST);
 1044  29
                         match(NUMBER);
 1045  29
                         n3_AST.setType(MAX);
 1046  29
                         arrayLength_AST = (AST)currentAST.root;
 1047  29
                 }
 1048  206
                 else if ((LA(1)==NUMBER) && (LA(2)==RBRACK||LA(2)==RPAREN)) {
 1049  206
                         length();
 1050  206
                         astFactory.addASTChild(currentAST, returnAST);
 1051  206
                         arrayLength_AST = (AST)currentAST.root;
 1052  
                 }
 1053  
                 else {
 1054  0
                         throw new NoViableAltException(LT(1), getFilename());
 1055  
                 }
 1056  
                 
 1057  336
                 returnAST = arrayLength_AST;
 1058  336
         }
 1059  
         
 1060  
         protected final void fillValue() throws RecognitionException, TokenStreamException {
 1061  
                 
 1062  22
                 returnAST = null;
 1063  22
                 ASTPair currentAST = new ASTPair();
 1064  22
                 AST fillValue_AST = null;
 1065  22
                 Token  c = null;
 1066  22
                 AST c_AST = null;
 1067  
                 
 1068  22
                 c = LT(1);
 1069  22
                 c_AST = astFactory.create(c);
 1070  22
                 astFactory.addASTChild(currentAST, c_AST);
 1071  22
                 match(CHAR_LITERAL);
 1072  22
                 match(STAR);
 1073  22
                 c_AST.setType(ALL);
 1074  22
                 fillValue_AST = (AST)currentAST.root;
 1075  22
                 returnAST = fillValue_AST;
 1076  22
         }
 1077  
         
 1078  
         protected final void unboundedDynamicField() throws RecognitionException, TokenStreamException {
 1079  
                 
 1080  70
                 returnAST = null;
 1081  70
                 ASTPair currentAST = new ASTPair();
 1082  70
                 AST unboundedDynamicField_AST = null;
 1083  70
                 Token  s = null;
 1084  70
                 AST s_AST = null;
 1085  
                 
 1086  70
                 s = LT(1);
 1087  70
                 s_AST = astFactory.create(s);
 1088  70
                 astFactory.makeASTRoot(currentAST, s_AST);
 1089  70
                 match(STAR);
 1090  70
                 s_AST.setType(RANGE);
 1091  70
                 unboundedDynamicField_AST = (AST)currentAST.root;
 1092  70
                 returnAST = unboundedDynamicField_AST;
 1093  70
         }
 1094  
         
 1095  
         protected final void mapChild() throws RecognitionException, TokenStreamException {
 1096  
                 
 1097  170
                 returnAST = null;
 1098  170
                 ASTPair currentAST = new ASTPair();
 1099  170
                 AST mapChild_AST = null;
 1100  
                 
 1101  170
                 switch ( LA(1)) {
 1102  
                 case IDENT:
 1103  
                 {
 1104  129
                         explicitAssign();
 1105  129
                         astFactory.addASTChild(currentAST, returnAST);
 1106  129
                         mapChild_AST = (AST)currentAST.root;
 1107  129
                         break;
 1108  
                 }
 1109  
                 case ANON:
 1110  
                 {
 1111  32
                         anonymousAssign();
 1112  32
                         astFactory.addASTChild(currentAST, returnAST);
 1113  32
                         mapChild_AST = (AST)currentAST.root;
 1114  32
                         break;
 1115  
                 }
 1116  
                 case TYPEREF:
 1117  
                 {
 1118  9
                         implicitTypeAssign();
 1119  9
                         astFactory.addASTChild(currentAST, returnAST);
 1120  9
                         mapChild_AST = (AST)currentAST.root;
 1121  9
                         break;
 1122  
                 }
 1123  
                 default:
 1124  
                 {
 1125  0
                         throw new NoViableAltException(LT(1), getFilename());
 1126  
                 }
 1127  
                 }
 1128  170
                 returnAST = mapChild_AST;
 1129  170
         }
 1130  
         
 1131  
         protected final void implicitTypeAssign() throws RecognitionException, TokenStreamException {
 1132  
                 
 1133  9
                 returnAST = null;
 1134  9
                 ASTPair currentAST = new ASTPair();
 1135  9
                 AST implicitTypeAssign_AST = null;
 1136  9
                 String name = null;
 1137  
                 
 1138  9
                 name=typeRefEntity();
 1139  9
                 astFactory.addASTChild(currentAST, returnAST);
 1140  9
                 implicitTypeAssign_AST = (AST)currentAST.root;
 1141  9
                 implicitTypeAssign_AST = (AST)astFactory.make( (new ASTArray(3)).add(astFactory.create(ASSIGN)).add(astFactory.create(IDENT,name)).add(implicitTypeAssign_AST));
 1142  9
                 currentAST.root = implicitTypeAssign_AST;
 1143  9
                 currentAST.child = implicitTypeAssign_AST!=null &&implicitTypeAssign_AST.getFirstChild()!=null ?
 1144  
                         implicitTypeAssign_AST.getFirstChild() : implicitTypeAssign_AST;
 1145  9
                 currentAST.advanceChildToEnd();
 1146  9
                 implicitTypeAssign_AST = (AST)currentAST.root;
 1147  9
                 returnAST = implicitTypeAssign_AST;
 1148  9
         }
 1149  
         
 1150  
         
 1151  1
         public static final String[] _tokenNames = {
 1152  
                 "<0>",
 1153  
                 "EOF",
 1154  
                 "<2>",
 1155  
                 "NULL_TREE_LOOKAHEAD",
 1156  
                 "ROOT",
 1157  
                 "CHECK",
 1158  
                 "VALUE",
 1159  
                 "ALL",
 1160  
                 "FIELD",
 1161  
                 "LENGTH",
 1162  
                 "ARRAY",
 1163  
                 "IMMUTABLE",
 1164  
                 "MAP",
 1165  
                 "PROTOTYPE",
 1166  
                 "OPTIONS",
 1167  
                 "MIN",
 1168  
                 "MAX",
 1169  
                 "OPTION_BLOCK",
 1170  
                 "SEMI",
 1171  
                 "IDENT",
 1172  
                 "ANON",
 1173  
                 "COLON",
 1174  
                 "TYPEREF",
 1175  
                 "LBRACK",
 1176  
                 "RBRACK",
 1177  
                 "CHAR_LITERAL",
 1178  
                 "STAR",
 1179  
                 "STRING_LITERAL",
 1180  
                 "BANG",
 1181  
                 "LPAREN",
 1182  
                 "RPAREN",
 1183  
                 "LCURLY",
 1184  
                 "COMMA",
 1185  
                 "RCURLY",
 1186  
                 "NUMBER",
 1187  
                 "RANGE",
 1188  
                 "ASSIGN",
 1189  
                 "WS",
 1190  
                 "SL_COMMENT",
 1191  
                 "ML_COMMENT",
 1192  
                 "NL",
 1193  
                 "PTIDENT",
 1194  
                 "CHAR_BODY",
 1195  
                 "STRING_BODY",
 1196  
                 "ESC",
 1197  
                 "UNICODE",
 1198  
                 "OCTAL",
 1199  
                 "HEX_DIGIT"
 1200  
         };
 1201  
         
 1202  
         protected void buildTokenTypeASTClassMap() {
 1203  32
                 tokenTypeToASTClassMap=null;
 1204  32
         };
 1205  
         
 1206  
         private static final long[] mk_tokenSet_0() {
 1207  1
                 long[] data = { 17348165632L, 0L};
 1208  1
                 return data;
 1209  
         }
 1210  1
         public static final BitSet _tokenSet_0 = new BitSet(mk_tokenSet_0());
 1211  
         private static final long[] mk_tokenSet_1() {
 1212  1
                 long[] data = { 13068926978L, 0L};
 1213  1
                 return data;
 1214  
         }
 1215  1
         public static final BitSet _tokenSet_1 = new BitSet(mk_tokenSet_1());
 1216  
         private static final long[] mk_tokenSet_2() {
 1217  1
                 long[] data = { 67645210626L, 0L};
 1218  1
                 return data;
 1219  
         }
 1220  1
         public static final BitSet _tokenSet_2 = new BitSet(mk_tokenSet_2());
 1221  
         private static final long[] mk_tokenSet_3() {
 1222  1
                 long[] data = { 13060538370L, 0L};
 1223  1
                 return data;
 1224  
         }
 1225  1
         public static final BitSet _tokenSet_3 = new BitSet(mk_tokenSet_3());
 1226  
         private static final long[] mk_tokenSet_4() {
 1227  1
                 long[] data = { 33268695042L, 0L};
 1228  1
                 return data;
 1229  
         }
 1230  1
         public static final BitSet _tokenSet_4 = new BitSet(mk_tokenSet_4());
 1231  
         private static final long[] mk_tokenSet_5() {
 1232  1
                 long[] data = { 13169590274L, 0L};
 1233  1
                 return data;
 1234  
         }
 1235  1
         public static final BitSet _tokenSet_5 = new BitSet(mk_tokenSet_5());
 1236  
         private static final long[] mk_tokenSet_6() {
 1237  1
                 long[] data = { 4300734464L, 0L};
 1238  1
                 return data;
 1239  
         }
 1240  1
         public static final BitSet _tokenSet_6 = new BitSet(mk_tokenSet_6());
 1241  
         
 1242  
         }