1/** \file 2 * This OBJC source file was generated by $ANTLR version 3.4 3 * 4 * - From the grammar source file : /Users/acondit/source/antlr/code/antlr3/runtime/ObjC/Framework/examples/simplecTreeParser/SimpleC.g 5 * - On : 2012-02-16 17:40:52 6 * - for the parser : SimpleCParserParser 7 * 8 * Editing it, at least manually, is not wise. 9 * 10 * ObjC language generator and runtime by Alan Condit, acondit|hereisanat|ipns|dotgoeshere|com. 11 * 12 * 13*/ 14// $ANTLR 3.4 /Users/acondit/source/antlr/code/antlr3/runtime/ObjC/Framework/examples/simplecTreeParser/SimpleC.g 2012-02-16 17:40:52 15 16 17/* ----------------------------------------- 18 * Include the ANTLR3 generated header file. 19 */ 20#import "SimpleCParser.h" 21/* ----------------------------------------- */ 22 23 24/* ============================================================================= */ 25/* ============================================================================= 26 * Start of recognizer 27 */ 28#pragma mark Cyclic DFA implementation start DFA2 29 30@implementation DFA2 31const static NSInteger dfa2_eot[13] = 32 {-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1}; 33const static NSInteger dfa2_eof[13] = 34 {-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1}; 35const static unichar dfa2_min[13] = 36 {9,14,18,9,-1,14,17,10,-1,-1,9,14,10}; 37const static unichar dfa2_max[13] = 38 {24,14,23,24,-1,14,23,22,-1,-1,24,14,22}; 39const static NSInteger dfa2_accept[13] = 40 {-1,-1,-1,-1,1,-1,-1,-1,2,3,-1,-1,-1}; 41const static NSInteger dfa2_special[13] = 42 {-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1}; 43 44/** Used when there is no transition table entry for a particular state */ 45#define dfa2_T_empty nil 46 47const static NSInteger dfa2_T0[] = 48{ 49 9, -1, -1, -1, -1, -1, 8 50}; 51const static NSInteger dfa2_T1[] = 52{ 53 10, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 6 54}; 55const static NSInteger dfa2_T2[] = 56{ 57 5, -1, -1, -1, -1, 5, -1, 5, -1, -1, -1, -1, -1, 6, -1, 5 58}; 59const static NSInteger dfa2_T3[] = 60{ 61 11, -1, -1, -1, -1, 11, -1, 11, -1, -1, -1, -1, -1, -1, -1, 11 62}; 63const static NSInteger dfa2_T4[] = 64{ 65 3, -1, -1, -1, -1, 4 66}; 67const static NSInteger dfa2_T5[] = 68{ 69 1, -1, -1, -1, -1, 1, -1, 1, -1, -1, -1, -1, -1, -1, -1, 1 70}; 71const static NSInteger dfa2_T6[] = 72{ 73 7 74}; 75const static NSInteger dfa2_T7[] = 76{ 77 12 78}; 79const static NSInteger dfa2_T8[] = 80{ 81 2 82}; 83 84 85const static NSInteger *dfa2_transition[] = 86{ 87 dfa2_T5, dfa2_T8, dfa2_T4, dfa2_T2, nil, dfa2_T6, dfa2_T0, dfa2_T1, 88 nil, nil, dfa2_T3, dfa2_T7, dfa2_T1 89}; 90 91//const static NSInteger dfa2_transition[] = {}; 92 93+ (DFA2 *) newDFA2WithRecognizer:(BaseRecognizer *)aRecognizer 94{ 95 return [[[DFA2 alloc] initWithRecognizer:aRecognizer] retain]; 96} 97 98- (id) initWithRecognizer:(BaseRecognizer *) theRecognizer 99{ 100 self = [super initWithRecognizer:theRecognizer]; 101 if ( self != nil ) { 102 decisionNumber = 2; 103 eot = dfa2_eot; 104 eof = dfa2_eof; 105 min = dfa2_min; 106 max = dfa2_max; 107 accept = dfa2_accept; 108 special = dfa2_special; 109 transition = dfa2_transition; 110/* 111 if (!(transition = calloc(13, sizeof(void*)))) { 112 [self release]; 113 return nil; 114 } 115 len = 13; 116 transition[0] = dfa2_transition5; 117 transition[1] = dfa2_transition8; 118 transition[2] = dfa2_transition4; 119 transition[3] = dfa2_transition2; 120 121 transition[4] = dfa2_transition6; 122 transition[5] = dfa2_transition0; 123 transition[6] = dfa2_transition1; 124 125 126 transition[7] = dfa2_transition3; 127 transition[8] = dfa2_transition7; 128 transition[9] = dfa2_transition1; 129 */ 130 } 131 return self; 132} 133 134- (void) dealloc 135{ 136 free(transition); 137 [super dealloc]; 138} 139 140- (NSString *) description 141{ 142 return @"20:1: declaration : ( variable | functionHeader K_SEMICOLON -> ^( FUNC_DECL functionHeader ) | functionHeader block -> ^( FUNC_DEF functionHeader block ) );"; 143} 144 145 146@end /* end DFA2 implementation */ 147 148#pragma mark Cyclic DFA implementation end DFA2 149 150 151 152#pragma mark Bitsets 153static ANTLRBitSet *FOLLOW_declaration_in_program85; 154static const unsigned long long FOLLOW_declaration_in_program85_data[] = { 0x0000000001014202LL}; 155static ANTLRBitSet *FOLLOW_variable_in_declaration105; 156static const unsigned long long FOLLOW_variable_in_declaration105_data[] = { 0x0000000000000002LL}; 157static ANTLRBitSet *FOLLOW_functionHeader_in_declaration115; 158static const unsigned long long FOLLOW_functionHeader_in_declaration115_data[] = { 0x0000000000800000LL}; 159static ANTLRBitSet *FOLLOW_K_SEMICOLON_in_declaration117; 160static const unsigned long long FOLLOW_K_SEMICOLON_in_declaration117_data[] = { 0x0000000000000002LL}; 161static ANTLRBitSet *FOLLOW_functionHeader_in_declaration135; 162static const unsigned long long FOLLOW_functionHeader_in_declaration135_data[] = { 0x0000000000020000LL}; 163static ANTLRBitSet *FOLLOW_block_in_declaration137; 164static const unsigned long long FOLLOW_block_in_declaration137_data[] = { 0x0000000000000002LL}; 165static ANTLRBitSet *FOLLOW_type_in_variable166; 166static const unsigned long long FOLLOW_type_in_variable166_data[] = { 0x0000000000004000LL}; 167static ANTLRBitSet *FOLLOW_declarator_in_variable168; 168static const unsigned long long FOLLOW_declarator_in_variable168_data[] = { 0x0000000000800000LL}; 169static ANTLRBitSet *FOLLOW_K_SEMICOLON_in_variable170; 170static const unsigned long long FOLLOW_K_SEMICOLON_in_variable170_data[] = { 0x0000000000000002LL}; 171static ANTLRBitSet *FOLLOW_K_ID_in_declarator199; 172static const unsigned long long FOLLOW_K_ID_in_declarator199_data[] = { 0x0000000000000002LL}; 173static ANTLRBitSet *FOLLOW_type_in_functionHeader219; 174static const unsigned long long FOLLOW_type_in_functionHeader219_data[] = { 0x0000000000004000LL}; 175static ANTLRBitSet *FOLLOW_K_ID_in_functionHeader221; 176static const unsigned long long FOLLOW_K_ID_in_functionHeader221_data[] = { 0x0000000000040000LL}; 177static ANTLRBitSet *FOLLOW_K_LCURVE_in_functionHeader223; 178static const unsigned long long FOLLOW_K_LCURVE_in_functionHeader223_data[] = { 0x0000000001414200LL}; 179static ANTLRBitSet *FOLLOW_formalParameter_in_functionHeader227; 180static const unsigned long long FOLLOW_formalParameter_in_functionHeader227_data[] = { 0x0000000000400400LL}; 181static ANTLRBitSet *FOLLOW_K_COMMA_in_functionHeader231; 182static const unsigned long long FOLLOW_K_COMMA_in_functionHeader231_data[] = { 0x0000000001014200LL}; 183static ANTLRBitSet *FOLLOW_formalParameter_in_functionHeader233; 184static const unsigned long long FOLLOW_formalParameter_in_functionHeader233_data[] = { 0x0000000000400400LL}; 185static ANTLRBitSet *FOLLOW_K_RCURVE_in_functionHeader241; 186static const unsigned long long FOLLOW_K_RCURVE_in_functionHeader241_data[] = { 0x0000000000000002LL}; 187static ANTLRBitSet *FOLLOW_type_in_formalParameter281; 188static const unsigned long long FOLLOW_type_in_formalParameter281_data[] = { 0x0000000000004000LL}; 189static ANTLRBitSet *FOLLOW_declarator_in_formalParameter283; 190static const unsigned long long FOLLOW_declarator_in_formalParameter283_data[] = { 0x0000000000000002LL}; 191static ANTLRBitSet *FOLLOW_K_LCURLY_in_block376; 192static const unsigned long long FOLLOW_K_LCURLY_in_block376_data[] = { 0x0000000001A7E200LL}; 193static ANTLRBitSet *FOLLOW_variable_in_block390; 194static const unsigned long long FOLLOW_variable_in_block390_data[] = { 0x0000000001A7E200LL}; 195static ANTLRBitSet *FOLLOW_stat_in_block405; 196static const unsigned long long FOLLOW_stat_in_block405_data[] = { 0x0000000000A6E000LL}; 197static ANTLRBitSet *FOLLOW_K_RCURLY_in_block416; 198static const unsigned long long FOLLOW_K_RCURLY_in_block416_data[] = { 0x0000000000000002LL}; 199static ANTLRBitSet *FOLLOW_forStat_in_stat449; 200static const unsigned long long FOLLOW_forStat_in_stat449_data[] = { 0x0000000000000002LL}; 201static ANTLRBitSet *FOLLOW_expr_in_stat457; 202static const unsigned long long FOLLOW_expr_in_stat457_data[] = { 0x0000000000800000LL}; 203static ANTLRBitSet *FOLLOW_K_SEMICOLON_in_stat459; 204static const unsigned long long FOLLOW_K_SEMICOLON_in_stat459_data[] = { 0x0000000000000002LL}; 205static ANTLRBitSet *FOLLOW_block_in_stat468; 206static const unsigned long long FOLLOW_block_in_stat468_data[] = { 0x0000000000000002LL}; 207static ANTLRBitSet *FOLLOW_assignStat_in_stat476; 208static const unsigned long long FOLLOW_assignStat_in_stat476_data[] = { 0x0000000000800000LL}; 209static ANTLRBitSet *FOLLOW_K_SEMICOLON_in_stat478; 210static const unsigned long long FOLLOW_K_SEMICOLON_in_stat478_data[] = { 0x0000000000000002LL}; 211static ANTLRBitSet *FOLLOW_K_SEMICOLON_in_stat487; 212static const unsigned long long FOLLOW_K_SEMICOLON_in_stat487_data[] = { 0x0000000000000002LL}; 213static ANTLRBitSet *FOLLOW_K_FOR_in_forStat507; 214static const unsigned long long FOLLOW_K_FOR_in_forStat507_data[] = { 0x0000000000040000LL}; 215static ANTLRBitSet *FOLLOW_K_LCURVE_in_forStat509; 216static const unsigned long long FOLLOW_K_LCURVE_in_forStat509_data[] = { 0x0000000000004000LL}; 217static ANTLRBitSet *FOLLOW_assignStat_in_forStat513; 218static const unsigned long long FOLLOW_assignStat_in_forStat513_data[] = { 0x0000000000800000LL}; 219static ANTLRBitSet *FOLLOW_K_SEMICOLON_in_forStat515; 220static const unsigned long long FOLLOW_K_SEMICOLON_in_forStat515_data[] = { 0x000000000004C000LL}; 221static ANTLRBitSet *FOLLOW_expr_in_forStat517; 222static const unsigned long long FOLLOW_expr_in_forStat517_data[] = { 0x0000000000800000LL}; 223static ANTLRBitSet *FOLLOW_K_SEMICOLON_in_forStat519; 224static const unsigned long long FOLLOW_K_SEMICOLON_in_forStat519_data[] = { 0x0000000000004000LL}; 225static ANTLRBitSet *FOLLOW_assignStat_in_forStat523; 226static const unsigned long long FOLLOW_assignStat_in_forStat523_data[] = { 0x0000000000400000LL}; 227static ANTLRBitSet *FOLLOW_K_RCURVE_in_forStat525; 228static const unsigned long long FOLLOW_K_RCURVE_in_forStat525_data[] = { 0x0000000000020000LL}; 229static ANTLRBitSet *FOLLOW_block_in_forStat527; 230static const unsigned long long FOLLOW_block_in_forStat527_data[] = { 0x0000000000000002LL}; 231static ANTLRBitSet *FOLLOW_K_ID_in_assignStat570; 232static const unsigned long long FOLLOW_K_ID_in_assignStat570_data[] = { 0x0000000000000800LL}; 233static ANTLRBitSet *FOLLOW_K_EQ_in_assignStat572; 234static const unsigned long long FOLLOW_K_EQ_in_assignStat572_data[] = { 0x000000000004C000LL}; 235static ANTLRBitSet *FOLLOW_expr_in_assignStat574; 236static const unsigned long long FOLLOW_expr_in_assignStat574_data[] = { 0x0000000000000002LL}; 237static ANTLRBitSet *FOLLOW_condExpr_in_expr598; 238static const unsigned long long FOLLOW_condExpr_in_expr598_data[] = { 0x0000000000000002LL}; 239static ANTLRBitSet *FOLLOW_aexpr_in_condExpr617; 240static const unsigned long long FOLLOW_aexpr_in_condExpr617_data[] = { 0x0000000000081002LL}; 241static ANTLRBitSet *FOLLOW_K_EQEQ_in_condExpr622; 242static const unsigned long long FOLLOW_K_EQEQ_in_condExpr622_data[] = { 0x000000000004C000LL}; 243static ANTLRBitSet *FOLLOW_K_LT_in_condExpr627; 244static const unsigned long long FOLLOW_K_LT_in_condExpr627_data[] = { 0x000000000004C000LL}; 245static ANTLRBitSet *FOLLOW_aexpr_in_condExpr631; 246static const unsigned long long FOLLOW_aexpr_in_condExpr631_data[] = { 0x0000000000000002LL}; 247static ANTLRBitSet *FOLLOW_atom_in_aexpr653; 248static const unsigned long long FOLLOW_atom_in_aexpr653_data[] = { 0x0000000000100002LL}; 249static ANTLRBitSet *FOLLOW_K_PLUS_in_aexpr657; 250static const unsigned long long FOLLOW_K_PLUS_in_aexpr657_data[] = { 0x000000000004C000LL}; 251static ANTLRBitSet *FOLLOW_atom_in_aexpr660; 252static const unsigned long long FOLLOW_atom_in_aexpr660_data[] = { 0x0000000000100002LL}; 253static ANTLRBitSet *FOLLOW_K_ID_in_atom680; 254static const unsigned long long FOLLOW_K_ID_in_atom680_data[] = { 0x0000000000000002LL}; 255static ANTLRBitSet *FOLLOW_K_INT_in_atom694; 256static const unsigned long long FOLLOW_K_INT_in_atom694_data[] = { 0x0000000000000002LL}; 257static ANTLRBitSet *FOLLOW_K_LCURVE_in_atom708; 258static const unsigned long long FOLLOW_K_LCURVE_in_atom708_data[] = { 0x000000000004C000LL}; 259static ANTLRBitSet *FOLLOW_expr_in_atom710; 260static const unsigned long long FOLLOW_expr_in_atom710_data[] = { 0x0000000000400000LL}; 261static ANTLRBitSet *FOLLOW_K_RCURVE_in_atom712; 262static const unsigned long long FOLLOW_K_RCURVE_in_atom712_data[] = { 0x0000000000000002LL}; 263 264 265#pragma mark Dynamic Global globalAttributeScopeImplementation 266 267#pragma mark Dynamic Rule Scopes ruleAttributeScopeImplementation 268 269#pragma mark Rule Return Scopes returnScopeImplementation 270@implementation SimpleCParser_program_return /* returnScopeImplementation */ 271/* AST returnScope.synthesize */ 272@synthesize tree; /* start of synthesize -- OBJC-Line 1837 */ 273+ (SimpleCParser_program_return *)newSimpleCParser_program_return 274{ 275return [[[SimpleCParser_program_return alloc] init] retain]; 276} 277 278- (id) init 279{ 280self = [super init]; 281return self; 282} 283 284/* AST returnScope.methods */ 285- (CommonTree *)getTree 286{ 287 return tree; 288} 289 290- (void) setTree:(CommonTree *)aTree 291{ 292 if (tree != aTree) { 293 if (tree != nil) [tree release]; 294 if (aTree != nil) [aTree retain]; 295 tree = aTree; 296 } 297} 298 299- (void) dealloc 300{ 301 self.tree = nil; 302 [super dealloc]; 303} 304 305 306@end /* end of returnScope implementation */ 307 308@implementation SimpleCParser_declaration_return /* returnScopeImplementation */ 309/* AST returnScope.synthesize */ 310@synthesize tree; /* start of synthesize -- OBJC-Line 1837 */ 311+ (SimpleCParser_declaration_return *)newSimpleCParser_declaration_return 312{ 313return [[[SimpleCParser_declaration_return alloc] init] retain]; 314} 315 316- (id) init 317{ 318self = [super init]; 319return self; 320} 321 322/* AST returnScope.methods */ 323- (CommonTree *)getTree 324{ 325 return tree; 326} 327 328- (void) setTree:(CommonTree *)aTree 329{ 330 if (tree != aTree) { 331 if (tree != nil) [tree release]; 332 if (aTree != nil) [aTree retain]; 333 tree = aTree; 334 } 335} 336 337- (void) dealloc 338{ 339 self.tree = nil; 340 [super dealloc]; 341} 342 343 344@end /* end of returnScope implementation */ 345 346@implementation SimpleCParser_variable_return /* returnScopeImplementation */ 347/* AST returnScope.synthesize */ 348@synthesize tree; /* start of synthesize -- OBJC-Line 1837 */ 349+ (SimpleCParser_variable_return *)newSimpleCParser_variable_return 350{ 351return [[[SimpleCParser_variable_return alloc] init] retain]; 352} 353 354- (id) init 355{ 356self = [super init]; 357return self; 358} 359 360/* AST returnScope.methods */ 361- (CommonTree *)getTree 362{ 363 return tree; 364} 365 366- (void) setTree:(CommonTree *)aTree 367{ 368 if (tree != aTree) { 369 if (tree != nil) [tree release]; 370 if (aTree != nil) [aTree retain]; 371 tree = aTree; 372 } 373} 374 375- (void) dealloc 376{ 377 self.tree = nil; 378 [super dealloc]; 379} 380 381 382@end /* end of returnScope implementation */ 383 384@implementation SimpleCParser_declarator_return /* returnScopeImplementation */ 385/* AST returnScope.synthesize */ 386@synthesize tree; /* start of synthesize -- OBJC-Line 1837 */ 387+ (SimpleCParser_declarator_return *)newSimpleCParser_declarator_return 388{ 389return [[[SimpleCParser_declarator_return alloc] init] retain]; 390} 391 392- (id) init 393{ 394self = [super init]; 395return self; 396} 397 398/* AST returnScope.methods */ 399- (CommonTree *)getTree 400{ 401 return tree; 402} 403 404- (void) setTree:(CommonTree *)aTree 405{ 406 if (tree != aTree) { 407 if (tree != nil) [tree release]; 408 if (aTree != nil) [aTree retain]; 409 tree = aTree; 410 } 411} 412 413- (void) dealloc 414{ 415 self.tree = nil; 416 [super dealloc]; 417} 418 419 420@end /* end of returnScope implementation */ 421 422@implementation SimpleCParser_functionHeader_return /* returnScopeImplementation */ 423/* AST returnScope.synthesize */ 424@synthesize tree; /* start of synthesize -- OBJC-Line 1837 */ 425+ (SimpleCParser_functionHeader_return *)newSimpleCParser_functionHeader_return 426{ 427return [[[SimpleCParser_functionHeader_return alloc] init] retain]; 428} 429 430- (id) init 431{ 432self = [super init]; 433return self; 434} 435 436/* AST returnScope.methods */ 437- (CommonTree *)getTree 438{ 439 return tree; 440} 441 442- (void) setTree:(CommonTree *)aTree 443{ 444 if (tree != aTree) { 445 if (tree != nil) [tree release]; 446 if (aTree != nil) [aTree retain]; 447 tree = aTree; 448 } 449} 450 451- (void) dealloc 452{ 453 self.tree = nil; 454 [super dealloc]; 455} 456 457 458@end /* end of returnScope implementation */ 459 460@implementation SimpleCParser_formalParameter_return /* returnScopeImplementation */ 461/* AST returnScope.synthesize */ 462@synthesize tree; /* start of synthesize -- OBJC-Line 1837 */ 463+ (SimpleCParser_formalParameter_return *)newSimpleCParser_formalParameter_return 464{ 465return [[[SimpleCParser_formalParameter_return alloc] init] retain]; 466} 467 468- (id) init 469{ 470self = [super init]; 471return self; 472} 473 474/* AST returnScope.methods */ 475- (CommonTree *)getTree 476{ 477 return tree; 478} 479 480- (void) setTree:(CommonTree *)aTree 481{ 482 if (tree != aTree) { 483 if (tree != nil) [tree release]; 484 if (aTree != nil) [aTree retain]; 485 tree = aTree; 486 } 487} 488 489- (void) dealloc 490{ 491 self.tree = nil; 492 [super dealloc]; 493} 494 495 496@end /* end of returnScope implementation */ 497 498@implementation SimpleCParser_type_return /* returnScopeImplementation */ 499/* AST returnScope.synthesize */ 500@synthesize tree; /* start of synthesize -- OBJC-Line 1837 */ 501+ (SimpleCParser_type_return *)newSimpleCParser_type_return 502{ 503return [[[SimpleCParser_type_return alloc] init] retain]; 504} 505 506- (id) init 507{ 508self = [super init]; 509return self; 510} 511 512/* AST returnScope.methods */ 513- (CommonTree *)getTree 514{ 515 return tree; 516} 517 518- (void) setTree:(CommonTree *)aTree 519{ 520 if (tree != aTree) { 521 if (tree != nil) [tree release]; 522 if (aTree != nil) [aTree retain]; 523 tree = aTree; 524 } 525} 526 527- (void) dealloc 528{ 529 self.tree = nil; 530 [super dealloc]; 531} 532 533 534@end /* end of returnScope implementation */ 535 536@implementation SimpleCParser_block_return /* returnScopeImplementation */ 537/* AST returnScope.synthesize */ 538@synthesize tree; /* start of synthesize -- OBJC-Line 1837 */ 539+ (SimpleCParser_block_return *)newSimpleCParser_block_return 540{ 541return [[[SimpleCParser_block_return alloc] init] retain]; 542} 543 544- (id) init 545{ 546self = [super init]; 547return self; 548} 549 550/* AST returnScope.methods */ 551- (CommonTree *)getTree 552{ 553 return tree; 554} 555 556- (void) setTree:(CommonTree *)aTree 557{ 558 if (tree != aTree) { 559 if (tree != nil) [tree release]; 560 if (aTree != nil) [aTree retain]; 561 tree = aTree; 562 } 563} 564 565- (void) dealloc 566{ 567 self.tree = nil; 568 [super dealloc]; 569} 570 571 572@end /* end of returnScope implementation */ 573 574@implementation SimpleCParser_stat_return /* returnScopeImplementation */ 575/* AST returnScope.synthesize */ 576@synthesize tree; /* start of synthesize -- OBJC-Line 1837 */ 577+ (SimpleCParser_stat_return *)newSimpleCParser_stat_return 578{ 579return [[[SimpleCParser_stat_return alloc] init] retain]; 580} 581 582- (id) init 583{ 584self = [super init]; 585return self; 586} 587 588/* AST returnScope.methods */ 589- (CommonTree *)getTree 590{ 591 return tree; 592} 593 594- (void) setTree:(CommonTree *)aTree 595{ 596 if (tree != aTree) { 597 if (tree != nil) [tree release]; 598 if (aTree != nil) [aTree retain]; 599 tree = aTree; 600 } 601} 602 603- (void) dealloc 604{ 605 self.tree = nil; 606 [super dealloc]; 607} 608 609 610@end /* end of returnScope implementation */ 611 612@implementation SimpleCParser_forStat_return /* returnScopeImplementation */ 613/* AST returnScope.synthesize */ 614@synthesize tree; /* start of synthesize -- OBJC-Line 1837 */ 615+ (SimpleCParser_forStat_return *)newSimpleCParser_forStat_return 616{ 617return [[[SimpleCParser_forStat_return alloc] init] retain]; 618} 619 620- (id) init 621{ 622self = [super init]; 623return self; 624} 625 626/* AST returnScope.methods */ 627- (CommonTree *)getTree 628{ 629 return tree; 630} 631 632- (void) setTree:(CommonTree *)aTree 633{ 634 if (tree != aTree) { 635 if (tree != nil) [tree release]; 636 if (aTree != nil) [aTree retain]; 637 tree = aTree; 638 } 639} 640 641- (void) dealloc 642{ 643 self.tree = nil; 644 [super dealloc]; 645} 646 647 648@end /* end of returnScope implementation */ 649 650@implementation SimpleCParser_assignStat_return /* returnScopeImplementation */ 651/* AST returnScope.synthesize */ 652@synthesize tree; /* start of synthesize -- OBJC-Line 1837 */ 653+ (SimpleCParser_assignStat_return *)newSimpleCParser_assignStat_return 654{ 655return [[[SimpleCParser_assignStat_return alloc] init] retain]; 656} 657 658- (id) init 659{ 660self = [super init]; 661return self; 662} 663 664/* AST returnScope.methods */ 665- (CommonTree *)getTree 666{ 667 return tree; 668} 669 670- (void) setTree:(CommonTree *)aTree 671{ 672 if (tree != aTree) { 673 if (tree != nil) [tree release]; 674 if (aTree != nil) [aTree retain]; 675 tree = aTree; 676 } 677} 678 679- (void) dealloc 680{ 681 self.tree = nil; 682 [super dealloc]; 683} 684 685 686@end /* end of returnScope implementation */ 687 688@implementation SimpleCParser_expr_return /* returnScopeImplementation */ 689/* AST returnScope.synthesize */ 690@synthesize tree; /* start of synthesize -- OBJC-Line 1837 */ 691+ (SimpleCParser_expr_return *)newSimpleCParser_expr_return 692{ 693return [[[SimpleCParser_expr_return alloc] init] retain]; 694} 695 696- (id) init 697{ 698self = [super init]; 699return self; 700} 701 702/* AST returnScope.methods */ 703- (CommonTree *)getTree 704{ 705 return tree; 706} 707 708- (void) setTree:(CommonTree *)aTree 709{ 710 if (tree != aTree) { 711 if (tree != nil) [tree release]; 712 if (aTree != nil) [aTree retain]; 713 tree = aTree; 714 } 715} 716 717- (void) dealloc 718{ 719 self.tree = nil; 720 [super dealloc]; 721} 722 723 724@end /* end of returnScope implementation */ 725 726@implementation SimpleCParser_condExpr_return /* returnScopeImplementation */ 727/* AST returnScope.synthesize */ 728@synthesize tree; /* start of synthesize -- OBJC-Line 1837 */ 729+ (SimpleCParser_condExpr_return *)newSimpleCParser_condExpr_return 730{ 731return [[[SimpleCParser_condExpr_return alloc] init] retain]; 732} 733 734- (id) init 735{ 736self = [super init]; 737return self; 738} 739 740/* AST returnScope.methods */ 741- (CommonTree *)getTree 742{ 743 return tree; 744} 745 746- (void) setTree:(CommonTree *)aTree 747{ 748 if (tree != aTree) { 749 if (tree != nil) [tree release]; 750 if (aTree != nil) [aTree retain]; 751 tree = aTree; 752 } 753} 754 755- (void) dealloc 756{ 757 self.tree = nil; 758 [super dealloc]; 759} 760 761 762@end /* end of returnScope implementation */ 763 764@implementation SimpleCParser_aexpr_return /* returnScopeImplementation */ 765/* AST returnScope.synthesize */ 766@synthesize tree; /* start of synthesize -- OBJC-Line 1837 */ 767+ (SimpleCParser_aexpr_return *)newSimpleCParser_aexpr_return 768{ 769return [[[SimpleCParser_aexpr_return alloc] init] retain]; 770} 771 772- (id) init 773{ 774self = [super init]; 775return self; 776} 777 778/* AST returnScope.methods */ 779- (CommonTree *)getTree 780{ 781 return tree; 782} 783 784- (void) setTree:(CommonTree *)aTree 785{ 786 if (tree != aTree) { 787 if (tree != nil) [tree release]; 788 if (aTree != nil) [aTree retain]; 789 tree = aTree; 790 } 791} 792 793- (void) dealloc 794{ 795 self.tree = nil; 796 [super dealloc]; 797} 798 799 800@end /* end of returnScope implementation */ 801 802@implementation SimpleCParser_atom_return /* returnScopeImplementation */ 803/* AST returnScope.synthesize */ 804@synthesize tree; /* start of synthesize -- OBJC-Line 1837 */ 805+ (SimpleCParser_atom_return *)newSimpleCParser_atom_return 806{ 807return [[[SimpleCParser_atom_return alloc] init] retain]; 808} 809 810- (id) init 811{ 812self = [super init]; 813return self; 814} 815 816/* AST returnScope.methods */ 817- (CommonTree *)getTree 818{ 819 return tree; 820} 821 822- (void) setTree:(CommonTree *)aTree 823{ 824 if (tree != aTree) { 825 if (tree != nil) [tree release]; 826 if (aTree != nil) [aTree retain]; 827 tree = aTree; 828 } 829} 830 831- (void) dealloc 832{ 833 self.tree = nil; 834 [super dealloc]; 835} 836 837 838@end /* end of returnScope implementation */ 839 840 841 842@implementation SimpleCParser // line 637 843 844/* ObjC start of ruleAttributeScope */ 845#pragma mark Dynamic Rule Scopes ruleAttributeScope 846/* ObjC end of ruleAttributeScope */ 847#pragma mark global Attribute Scopes globalAttributeScope 848/* ObjC start globalAttributeScope */ 849/* ObjC end globalAttributeScope */ 850/* ObjC start actions.(actionScope).synthesize */ 851/* ObjC start synthesize() */ 852/* AST genericParser.synthesize */ 853/* AST parserProperties */ 854@synthesize treeAdaptor; 855 856+ (void) initialize 857{ 858 #pragma mark Bitsets 859 FOLLOW_declaration_in_program85 = [[ANTLRBitSet newBitSetWithBits:(const unsigned long long *)FOLLOW_declaration_in_program85_data Count:(NSUInteger)1] retain]; 860 FOLLOW_variable_in_declaration105 = [[ANTLRBitSet newBitSetWithBits:(const unsigned long long *)FOLLOW_variable_in_declaration105_data Count:(NSUInteger)1] retain]; 861 FOLLOW_functionHeader_in_declaration115 = [[ANTLRBitSet newBitSetWithBits:(const unsigned long long *)FOLLOW_functionHeader_in_declaration115_data Count:(NSUInteger)1] retain]; 862 FOLLOW_K_SEMICOLON_in_declaration117 = [[ANTLRBitSet newBitSetWithBits:(const unsigned long long *)FOLLOW_K_SEMICOLON_in_declaration117_data Count:(NSUInteger)1] retain]; 863 FOLLOW_functionHeader_in_declaration135 = [[ANTLRBitSet newBitSetWithBits:(const unsigned long long *)FOLLOW_functionHeader_in_declaration135_data Count:(NSUInteger)1] retain]; 864 FOLLOW_block_in_declaration137 = [[ANTLRBitSet newBitSetWithBits:(const unsigned long long *)FOLLOW_block_in_declaration137_data Count:(NSUInteger)1] retain]; 865 FOLLOW_type_in_variable166 = [[ANTLRBitSet newBitSetWithBits:(const unsigned long long *)FOLLOW_type_in_variable166_data Count:(NSUInteger)1] retain]; 866 FOLLOW_declarator_in_variable168 = [[ANTLRBitSet newBitSetWithBits:(const unsigned long long *)FOLLOW_declarator_in_variable168_data Count:(NSUInteger)1] retain]; 867 FOLLOW_K_SEMICOLON_in_variable170 = [[ANTLRBitSet newBitSetWithBits:(const unsigned long long *)FOLLOW_K_SEMICOLON_in_variable170_data Count:(NSUInteger)1] retain]; 868 FOLLOW_K_ID_in_declarator199 = [[ANTLRBitSet newBitSetWithBits:(const unsigned long long *)FOLLOW_K_ID_in_declarator199_data Count:(NSUInteger)1] retain]; 869 FOLLOW_type_in_functionHeader219 = [[ANTLRBitSet newBitSetWithBits:(const unsigned long long *)FOLLOW_type_in_functionHeader219_data Count:(NSUInteger)1] retain]; 870 FOLLOW_K_ID_in_functionHeader221 = [[ANTLRBitSet newBitSetWithBits:(const unsigned long long *)FOLLOW_K_ID_in_functionHeader221_data Count:(NSUInteger)1] retain]; 871 FOLLOW_K_LCURVE_in_functionHeader223 = [[ANTLRBitSet newBitSetWithBits:(const unsigned long long *)FOLLOW_K_LCURVE_in_functionHeader223_data Count:(NSUInteger)1] retain]; 872 FOLLOW_formalParameter_in_functionHeader227 = [[ANTLRBitSet newBitSetWithBits:(const unsigned long long *)FOLLOW_formalParameter_in_functionHeader227_data Count:(NSUInteger)1] retain]; 873 FOLLOW_K_COMMA_in_functionHeader231 = [[ANTLRBitSet newBitSetWithBits:(const unsigned long long *)FOLLOW_K_COMMA_in_functionHeader231_data Count:(NSUInteger)1] retain]; 874 FOLLOW_formalParameter_in_functionHeader233 = [[ANTLRBitSet newBitSetWithBits:(const unsigned long long *)FOLLOW_formalParameter_in_functionHeader233_data Count:(NSUInteger)1] retain]; 875 FOLLOW_K_RCURVE_in_functionHeader241 = [[ANTLRBitSet newBitSetWithBits:(const unsigned long long *)FOLLOW_K_RCURVE_in_functionHeader241_data Count:(NSUInteger)1] retain]; 876 FOLLOW_type_in_formalParameter281 = [[ANTLRBitSet newBitSetWithBits:(const unsigned long long *)FOLLOW_type_in_formalParameter281_data Count:(NSUInteger)1] retain]; 877 FOLLOW_declarator_in_formalParameter283 = [[ANTLRBitSet newBitSetWithBits:(const unsigned long long *)FOLLOW_declarator_in_formalParameter283_data Count:(NSUInteger)1] retain]; 878 FOLLOW_K_LCURLY_in_block376 = [[ANTLRBitSet newBitSetWithBits:(const unsigned long long *)FOLLOW_K_LCURLY_in_block376_data Count:(NSUInteger)1] retain]; 879 FOLLOW_variable_in_block390 = [[ANTLRBitSet newBitSetWithBits:(const unsigned long long *)FOLLOW_variable_in_block390_data Count:(NSUInteger)1] retain]; 880 FOLLOW_stat_in_block405 = [[ANTLRBitSet newBitSetWithBits:(const unsigned long long *)FOLLOW_stat_in_block405_data Count:(NSUInteger)1] retain]; 881 FOLLOW_K_RCURLY_in_block416 = [[ANTLRBitSet newBitSetWithBits:(const unsigned long long *)FOLLOW_K_RCURLY_in_block416_data Count:(NSUInteger)1] retain]; 882 FOLLOW_forStat_in_stat449 = [[ANTLRBitSet newBitSetWithBits:(const unsigned long long *)FOLLOW_forStat_in_stat449_data Count:(NSUInteger)1] retain]; 883 FOLLOW_expr_in_stat457 = [[ANTLRBitSet newBitSetWithBits:(const unsigned long long *)FOLLOW_expr_in_stat457_data Count:(NSUInteger)1] retain]; 884 FOLLOW_K_SEMICOLON_in_stat459 = [[ANTLRBitSet newBitSetWithBits:(const unsigned long long *)FOLLOW_K_SEMICOLON_in_stat459_data Count:(NSUInteger)1] retain]; 885 FOLLOW_block_in_stat468 = [[ANTLRBitSet newBitSetWithBits:(const unsigned long long *)FOLLOW_block_in_stat468_data Count:(NSUInteger)1] retain]; 886 FOLLOW_assignStat_in_stat476 = [[ANTLRBitSet newBitSetWithBits:(const unsigned long long *)FOLLOW_assignStat_in_stat476_data Count:(NSUInteger)1] retain]; 887 FOLLOW_K_SEMICOLON_in_stat478 = [[ANTLRBitSet newBitSetWithBits:(const unsigned long long *)FOLLOW_K_SEMICOLON_in_stat478_data Count:(NSUInteger)1] retain]; 888 FOLLOW_K_SEMICOLON_in_stat487 = [[ANTLRBitSet newBitSetWithBits:(const unsigned long long *)FOLLOW_K_SEMICOLON_in_stat487_data Count:(NSUInteger)1] retain]; 889 FOLLOW_K_FOR_in_forStat507 = [[ANTLRBitSet newBitSetWithBits:(const unsigned long long *)FOLLOW_K_FOR_in_forStat507_data Count:(NSUInteger)1] retain]; 890 FOLLOW_K_LCURVE_in_forStat509 = [[ANTLRBitSet newBitSetWithBits:(const unsigned long long *)FOLLOW_K_LCURVE_in_forStat509_data Count:(NSUInteger)1] retain]; 891 FOLLOW_assignStat_in_forStat513 = [[ANTLRBitSet newBitSetWithBits:(const unsigned long long *)FOLLOW_assignStat_in_forStat513_data Count:(NSUInteger)1] retain]; 892 FOLLOW_K_SEMICOLON_in_forStat515 = [[ANTLRBitSet newBitSetWithBits:(const unsigned long long *)FOLLOW_K_SEMICOLON_in_forStat515_data Count:(NSUInteger)1] retain]; 893 FOLLOW_expr_in_forStat517 = [[ANTLRBitSet newBitSetWithBits:(const unsigned long long *)FOLLOW_expr_in_forStat517_data Count:(NSUInteger)1] retain]; 894 FOLLOW_K_SEMICOLON_in_forStat519 = [[ANTLRBitSet newBitSetWithBits:(const unsigned long long *)FOLLOW_K_SEMICOLON_in_forStat519_data Count:(NSUInteger)1] retain]; 895 FOLLOW_assignStat_in_forStat523 = [[ANTLRBitSet newBitSetWithBits:(const unsigned long long *)FOLLOW_assignStat_in_forStat523_data Count:(NSUInteger)1] retain]; 896 FOLLOW_K_RCURVE_in_forStat525 = [[ANTLRBitSet newBitSetWithBits:(const unsigned long long *)FOLLOW_K_RCURVE_in_forStat525_data Count:(NSUInteger)1] retain]; 897 FOLLOW_block_in_forStat527 = [[ANTLRBitSet newBitSetWithBits:(const unsigned long long *)FOLLOW_block_in_forStat527_data Count:(NSUInteger)1] retain]; 898 FOLLOW_K_ID_in_assignStat570 = [[ANTLRBitSet newBitSetWithBits:(const unsigned long long *)FOLLOW_K_ID_in_assignStat570_data Count:(NSUInteger)1] retain]; 899 FOLLOW_K_EQ_in_assignStat572 = [[ANTLRBitSet newBitSetWithBits:(const unsigned long long *)FOLLOW_K_EQ_in_assignStat572_data Count:(NSUInteger)1] retain]; 900 FOLLOW_expr_in_assignStat574 = [[ANTLRBitSet newBitSetWithBits:(const unsigned long long *)FOLLOW_expr_in_assignStat574_data Count:(NSUInteger)1] retain]; 901 FOLLOW_condExpr_in_expr598 = [[ANTLRBitSet newBitSetWithBits:(const unsigned long long *)FOLLOW_condExpr_in_expr598_data Count:(NSUInteger)1] retain]; 902 FOLLOW_aexpr_in_condExpr617 = [[ANTLRBitSet newBitSetWithBits:(const unsigned long long *)FOLLOW_aexpr_in_condExpr617_data Count:(NSUInteger)1] retain]; 903 FOLLOW_K_EQEQ_in_condExpr622 = [[ANTLRBitSet newBitSetWithBits:(const unsigned long long *)FOLLOW_K_EQEQ_in_condExpr622_data Count:(NSUInteger)1] retain]; 904 FOLLOW_K_LT_in_condExpr627 = [[ANTLRBitSet newBitSetWithBits:(const unsigned long long *)FOLLOW_K_LT_in_condExpr627_data Count:(NSUInteger)1] retain]; 905 FOLLOW_aexpr_in_condExpr631 = [[ANTLRBitSet newBitSetWithBits:(const unsigned long long *)FOLLOW_aexpr_in_condExpr631_data Count:(NSUInteger)1] retain]; 906 FOLLOW_atom_in_aexpr653 = [[ANTLRBitSet newBitSetWithBits:(const unsigned long long *)FOLLOW_atom_in_aexpr653_data Count:(NSUInteger)1] retain]; 907 FOLLOW_K_PLUS_in_aexpr657 = [[ANTLRBitSet newBitSetWithBits:(const unsigned long long *)FOLLOW_K_PLUS_in_aexpr657_data Count:(NSUInteger)1] retain]; 908 FOLLOW_atom_in_aexpr660 = [[ANTLRBitSet newBitSetWithBits:(const unsigned long long *)FOLLOW_atom_in_aexpr660_data Count:(NSUInteger)1] retain]; 909 FOLLOW_K_ID_in_atom680 = [[ANTLRBitSet newBitSetWithBits:(const unsigned long long *)FOLLOW_K_ID_in_atom680_data Count:(NSUInteger)1] retain]; 910 FOLLOW_K_INT_in_atom694 = [[ANTLRBitSet newBitSetWithBits:(const unsigned long long *)FOLLOW_K_INT_in_atom694_data Count:(NSUInteger)1] retain]; 911 FOLLOW_K_LCURVE_in_atom708 = [[ANTLRBitSet newBitSetWithBits:(const unsigned long long *)FOLLOW_K_LCURVE_in_atom708_data Count:(NSUInteger)1] retain]; 912 FOLLOW_expr_in_atom710 = [[ANTLRBitSet newBitSetWithBits:(const unsigned long long *)FOLLOW_expr_in_atom710_data Count:(NSUInteger)1] retain]; 913 FOLLOW_K_RCURVE_in_atom712 = [[ANTLRBitSet newBitSetWithBits:(const unsigned long long *)FOLLOW_K_RCURVE_in_atom712_data Count:(NSUInteger)1] retain]; 914 915 [BaseRecognizer setTokenNames:[[AMutableArray arrayWithObjects:@"<invalid>", @"<EOR>", @"<DOWN>", @"<UP>", 916 @"ARG_DEF", @"BLOCK", @"FUNC_DECL", @"FUNC_DEF", @"FUNC_HDR", @"K_CHAR", 917 @"K_COMMA", @"K_EQ", @"K_EQEQ", @"K_FOR", @"K_ID", @"K_INT", @"K_INT_TYPE", 918 @"K_LCURLY", @"K_LCURVE", @"K_LT", @"K_PLUS", @"K_RCURLY", @"K_RCURVE", 919 @"K_SEMICOLON", @"K_VOID", @"VAR_DEF", @"WS", nil] retain]]; 920 [BaseRecognizer setGrammarFileName:@"/Users/acondit/source/antlr/code/antlr3/runtime/ObjC/Framework/examples/simplecTreeParser/SimpleC.g"]; 921} 922 923+ (SimpleCParser *)newSimpleCParser:(id<TokenStream>)aStream 924{ 925 return [[SimpleCParser alloc] initWithTokenStream:aStream]; 926} 927 928- (id) initWithTokenStream:(id<TokenStream>)aStream 929{ 930 self = [super initWithTokenStream:aStream State:[[RecognizerSharedState newRecognizerSharedStateWithRuleLen:15+1] retain]]; 931 if ( self != nil ) { 932 dfa2 = [DFA2 newDFA2WithRecognizer:self]; 933 /* start of actions-actionScope-init */ 934 /* start of init */ 935 /* AST genericParser.init */ 936 [self setTreeAdaptor:[[CommonTreeAdaptor newTreeAdaptor] retain]]; 937 } 938 return self; 939} 940 941- (void) dealloc 942{ 943 [dfa2 release]; 944 /* AST genericParser.dealloc */ 945 [self setTreeAdaptor:nil]; 946 947 [super dealloc]; 948} 949 950/* ObjC start actions.(actionScope).methods */ 951/* ObjC end actions.(actionScope).methods */ 952/* ObjC start methods() */ 953/* AST genericParser.methods */ 954/* AST parserMethods */ 955- (id<TreeAdaptor>) getTreeAdaptor 956{ 957 return treeAdaptor; 958} 959 960- (void) setTreeAdaptor:(id<TreeAdaptor>)aTreeAdaptor 961{ 962 if (aTreeAdaptor != treeAdaptor) { 963 treeAdaptor = aTreeAdaptor; 964 } 965} 966/* ObjC end methods() */ 967/* ObjC start rules */ 968/* 969 * $ANTLR start program 970 * /Users/acondit/source/antlr/code/antlr3/runtime/ObjC/Framework/examples/simplecTreeParser/SimpleC.g:16:1: program : ( declaration )+ ; 971 */ 972- (SimpleCParser_program_return *) program 973{ 974 /* ruleScopeSetUp */ 975 976 /* AST ruleDeclarations */ 977 /* ruleDeclarations */ 978 SimpleCParser_program_return * retval = [SimpleCParser_program_return newSimpleCParser_program_return]; 979 [retval setStart:[input LT:1]]; 980 981 982 CommonTree *root_0 = nil; 983 984 @try { 985 /* AST ruleLabelDefs */ 986 /* ruleLabelDefs entry */ 987 SimpleCParser_declaration_return * declaration1 = nil ; 988 989 990 991 // /Users/acondit/source/antlr/code/antlr3/runtime/ObjC/Framework/examples/simplecTreeParser/SimpleC.g:17:5: ( ( declaration )+ ) // ruleBlockSingleAlt 992 // /Users/acondit/source/antlr/code/antlr3/runtime/ObjC/Framework/examples/simplecTreeParser/SimpleC.g:17:9: ( declaration )+ // alt 993 { 994 root_0 = (CommonTree *)[[[treeAdaptor class] newEmptyTree] retain]; 995 996 997 998 // /Users/acondit/source/antlr/code/antlr3/runtime/ObjC/Framework/examples/simplecTreeParser/SimpleC.g:17:9: ( declaration )+ // positiveClosureBlock 999 NSInteger cnt1 = 0; 1000 do { 1001 NSInteger alt1 = 2; 1002 NSInteger LA1_0 = [input LA:1]; 1003 if ( (LA1_0==K_CHAR||LA1_0==K_ID||LA1_0==K_INT_TYPE||LA1_0==K_VOID) ) { 1004 alt1=1; 1005 } 1006 1007 1008 switch (alt1) { 1009 case 1 : ; 1010 // /Users/acondit/source/antlr/code/antlr3/runtime/ObjC/Framework/examples/simplecTreeParser/SimpleC.g:17:9: declaration // alt 1011 { 1012 1013 /* ASTParser ruleRef */ 1014 /* ruleRef */ 1015 [self pushFollow:FOLLOW_declaration_in_program85]; 1016 declaration1 = [self declaration]; 1017 1018 [self popFollow]; 1019 1020 1021 [treeAdaptor addChild:[declaration1 getTree] toTree:root_0]; 1022 1023 } 1024 break; 1025 1026 default : 1027 if ( cnt1 >= 1 ) 1028 goto loop1; 1029 EarlyExitException *eee = 1030 [EarlyExitException newException:input decisionNumber:1]; 1031 @throw eee; 1032 } 1033 cnt1++; 1034 } while (YES); 1035 loop1: ; 1036 1037 1038 } 1039 1040 /* ASTParser ruleCleanUp */ 1041 /* AST ruleCleanUp */ 1042 /* token+rule list labels */ 1043 [retval setStop:[input LT:-1]]; 1044 1045 1046 1047 retval.tree = (CommonTree *)[treeAdaptor rulePostProcessing:root_0]; 1048 [treeAdaptor setTokenBoundaries:retval.tree From:retval.start To:retval.stopToken]; 1049 1050 } 1051 @catch (RecognitionException *re) { 1052 [self reportError:re]; 1053 [self recover:input Exception:re]; 1054 /* ASTParser rule.setErrorReturnValue */ 1055 retval.tree = (CommonTree *)[treeAdaptor errorNode:input From:retval.start To:[input LT:-1] Exception:re]; 1056 1057 } 1058 1059 @finally { 1060 /* ruleScopeCleanUp */ 1061 1062 } 1063 return retval; 1064} 1065/* $ANTLR end program */ 1066 1067/* 1068 * $ANTLR start declaration 1069 * /Users/acondit/source/antlr/code/antlr3/runtime/ObjC/Framework/examples/simplecTreeParser/SimpleC.g:20:1: declaration : ( variable | functionHeader K_SEMICOLON -> ^( FUNC_DECL functionHeader ) | functionHeader block -> ^( FUNC_DEF functionHeader block ) ); 1070 */ 1071- (SimpleCParser_declaration_return *) declaration 1072{ 1073 /* ruleScopeSetUp */ 1074 1075 /* AST ruleDeclarations */ 1076 /* ruleDeclarations */ 1077 SimpleCParser_declaration_return * retval = [SimpleCParser_declaration_return newSimpleCParser_declaration_return]; 1078 [retval setStart:[input LT:1]]; 1079 1080 1081 CommonTree *root_0 = nil; 1082 1083 @try { 1084 /* AST ruleLabelDefs */ 1085 /* ruleLabelDefs entry */ 1086 CommonToken *K_SEMICOLON4 = nil;SimpleCParser_variable_return * variable2 = nil ; 1087 1088 SimpleCParser_functionHeader_return * functionHeader3 = nil ; 1089 1090 SimpleCParser_functionHeader_return * functionHeader5 = nil ; 1091 1092 SimpleCParser_block_return * block6 = nil ; 1093 1094 1095 CommonTree *K_SEMICOLON4_tree=nil; 1096 RewriteRuleTokenStream *stream_K_SEMICOLON = 1097 [[RewriteRuleTokenStream newRewriteRuleTokenStream:treeAdaptor 1098 description:@"token K_SEMICOLON"] retain]; 1099 RewriteRuleSubtreeStream *stream_functionHeader = 1100 [[RewriteRuleSubtreeStream newRewriteRuleSubtreeStream:treeAdaptor 1101 description:@"rule functionHeader"] retain]; 1102 RewriteRuleSubtreeStream *stream_block = 1103 [[RewriteRuleSubtreeStream newRewriteRuleSubtreeStream:treeAdaptor 1104 description:@"rule block"] retain]; 1105 // /Users/acondit/source/antlr/code/antlr3/runtime/ObjC/Framework/examples/simplecTreeParser/SimpleC.g:21:5: ( variable | functionHeader K_SEMICOLON -> ^( FUNC_DECL functionHeader ) | functionHeader block -> ^( FUNC_DEF functionHeader block ) ) //ruleblock 1106 NSInteger alt2=3; 1107 alt2 = [dfa2 predict:input]; 1108 switch (alt2) { 1109 case 1 : ; 1110 // /Users/acondit/source/antlr/code/antlr3/runtime/ObjC/Framework/examples/simplecTreeParser/SimpleC.g:21:9: variable // alt 1111 { 1112 root_0 = (CommonTree *)[[[treeAdaptor class] newEmptyTree] retain]; 1113 1114 1115 1116 /* ASTParser ruleRef */ 1117 /* ruleRef */ 1118 [self pushFollow:FOLLOW_variable_in_declaration105]; 1119 variable2 = [self variable]; 1120 1121 [self popFollow]; 1122 1123 1124 [treeAdaptor addChild:[variable2 getTree] toTree:root_0]; 1125 1126 } 1127 break; 1128 case 2 : ; 1129 // /Users/acondit/source/antlr/code/antlr3/runtime/ObjC/Framework/examples/simplecTreeParser/SimpleC.g:22:9: functionHeader K_SEMICOLON // alt 1130 { 1131 1132 /* ruleRef */ 1133 [self pushFollow:FOLLOW_functionHeader_in_declaration115]; 1134 functionHeader3 = [self functionHeader]; 1135 1136 [self popFollow]; 1137 1138 1139 [stream_functionHeader addElement:[functionHeader3 getTree]]; 1140 1141 K_SEMICOLON4=(CommonToken *)[self match:input TokenType:K_SEMICOLON Follow:FOLLOW_K_SEMICOLON_in_declaration117]; 1142 [stream_K_SEMICOLON addElement:K_SEMICOLON4]; 1143 1144 1145 // AST REWRITE 1146 // elements: functionHeader 1147 // token labels: 1148 // rule labels: retval 1149 // token list labels: 1150 // rule list labels: 1151 // wildcard labels: 1152 retval.tree = root_0; 1153 1154 RewriteRuleSubtreeStream *stream_retval = 1155 [[RewriteRuleSubtreeStream newRewriteRuleSubtreeStream:treeAdaptor 1156 description:@"token retval" element:retval!=nil?[retval getTree]:nil] retain]; 1157 1158 root_0 = (CommonTree *)[[[treeAdaptor class] newEmptyTree] retain]; 1159 1160 // 22:36: -> ^( FUNC_DECL functionHeader ) 1161 { 1162 // /Users/acondit/source/antlr/code/antlr3/runtime/ObjC/Framework/examples/simplecTreeParser/SimpleC.g:22:39: ^( FUNC_DECL functionHeader ) 1163 { 1164 CommonTree *root_1 = (CommonTree *)[[[treeAdaptor class] newEmptyTree] retain]; 1165 root_1 = (CommonTree *)[treeAdaptor becomeRoot: 1166 [[treeAdaptor createTree:FUNC_DECL Text:@"FUNC_DECL"] retain] 1167 old:root_1]; 1168 1169 [treeAdaptor addChild:[stream_functionHeader nextTree] toTree:root_1]; 1170 1171 [treeAdaptor addChild:root_1 toTree:root_0]; 1172 } 1173 1174 } 1175 1176 1177 retval.tree = root_0; 1178 1179 1180 } 1181 break; 1182 case 3 : ; 1183 // /Users/acondit/source/antlr/code/antlr3/runtime/ObjC/Framework/examples/simplecTreeParser/SimpleC.g:23:9: functionHeader block // alt 1184 { 1185 1186 /* ruleRef */ 1187 [self pushFollow:FOLLOW_functionHeader_in_declaration135]; 1188 functionHeader5 = [self functionHeader]; 1189 1190 [self popFollow]; 1191 1192 1193 [stream_functionHeader addElement:[functionHeader5 getTree]]; 1194 1195 /* ruleRef */ 1196 [self pushFollow:FOLLOW_block_in_declaration137]; 1197 block6 = [self block]; 1198 1199 [self popFollow]; 1200 1201 1202 [stream_block addElement:[block6 getTree]]; 1203 1204 // AST REWRITE 1205 // elements: functionHeader, block 1206 // token labels: 1207 // rule labels: retval 1208 // token list labels: 1209 // rule list labels: 1210 // wildcard labels: 1211 retval.tree = root_0; 1212 1213 RewriteRuleSubtreeStream *stream_retval = 1214 [[RewriteRuleSubtreeStream newRewriteRuleSubtreeStream:treeAdaptor 1215 description:@"token retval" element:retval!=nil?[retval getTree]:nil] retain]; 1216 1217 root_0 = (CommonTree *)[[[treeAdaptor class] newEmptyTree] retain]; 1218 1219 // 23:30: -> ^( FUNC_DEF functionHeader block ) 1220 { 1221 // /Users/acondit/source/antlr/code/antlr3/runtime/ObjC/Framework/examples/simplecTreeParser/SimpleC.g:23:33: ^( FUNC_DEF functionHeader block ) 1222 { 1223 CommonTree *root_1 = (CommonTree *)[[[treeAdaptor class] newEmptyTree] retain]; 1224 root_1 = (CommonTree *)[treeAdaptor becomeRoot: 1225 [[treeAdaptor createTree:FUNC_DEF Text:@"FUNC_DEF"] retain] 1226 old:root_1]; 1227 1228 [treeAdaptor addChild:[stream_functionHeader nextTree] toTree:root_1]; 1229 1230 [treeAdaptor addChild:[stream_block nextTree] toTree:root_1]; 1231 1232 [treeAdaptor addChild:root_1 toTree:root_0]; 1233 } 1234 1235 } 1236 1237 1238 retval.tree = root_0; 1239 1240 1241 } 1242 break; 1243 1244 } 1245 /* ASTParser ruleCleanUp */ 1246 /* AST ruleCleanUp */ 1247 /* token+rule list labels */ 1248 [retval setStop:[input LT:-1]]; 1249 1250 1251 [stream_K_SEMICOLON release]; 1252 [stream_functionHeader release]; 1253 [stream_block release]; 1254 1255 retval.tree = (CommonTree *)[treeAdaptor rulePostProcessing:root_0]; 1256 [treeAdaptor setTokenBoundaries:retval.tree From:retval.start To:retval.stopToken]; 1257 1258 } 1259 @catch (RecognitionException *re) { 1260 [self reportError:re]; 1261 [self recover:input Exception:re]; 1262 /* ASTParser rule.setErrorReturnValue */ 1263 retval.tree = (CommonTree *)[treeAdaptor errorNode:input From:retval.start To:[input LT:-1] Exception:re]; 1264 1265 } 1266 1267 @finally { 1268 /* ruleScopeCleanUp */ 1269 1270 } 1271 return retval; 1272} 1273/* $ANTLR end declaration */ 1274 1275/* 1276 * $ANTLR start variable 1277 * /Users/acondit/source/antlr/code/antlr3/runtime/ObjC/Framework/examples/simplecTreeParser/SimpleC.g:26:1: variable : type declarator K_SEMICOLON -> ^( VAR_DEF type declarator ) ; 1278 */ 1279- (SimpleCParser_variable_return *) variable 1280{ 1281 /* ruleScopeSetUp */ 1282 1283 /* AST ruleDeclarations */ 1284 /* ruleDeclarations */ 1285 SimpleCParser_variable_return * retval = [SimpleCParser_variable_return newSimpleCParser_variable_return]; 1286 [retval setStart:[input LT:1]]; 1287 1288 1289 CommonTree *root_0 = nil; 1290 1291 @try { 1292 /* AST ruleLabelDefs */ 1293 /* ruleLabelDefs entry */ 1294 CommonToken *K_SEMICOLON9 = nil;SimpleCParser_type_return * type7 = nil ; 1295 1296 SimpleCParser_declarator_return * declarator8 = nil ; 1297 1298 1299 CommonTree *K_SEMICOLON9_tree=nil; 1300 RewriteRuleTokenStream *stream_K_SEMICOLON = 1301 [[RewriteRuleTokenStream newRewriteRuleTokenStream:treeAdaptor 1302 description:@"token K_SEMICOLON"] retain]; 1303 RewriteRuleSubtreeStream *stream_declarator = 1304 [[RewriteRuleSubtreeStream newRewriteRuleSubtreeStream:treeAdaptor 1305 description:@"rule declarator"] retain]; 1306 RewriteRuleSubtreeStream *stream_type = 1307 [[RewriteRuleSubtreeStream newRewriteRuleSubtreeStream:treeAdaptor 1308 description:@"rule type"] retain]; 1309 // /Users/acondit/source/antlr/code/antlr3/runtime/ObjC/Framework/examples/simplecTreeParser/SimpleC.g:27:5: ( type declarator K_SEMICOLON -> ^( VAR_DEF type declarator ) ) // ruleBlockSingleAlt 1310 // /Users/acondit/source/antlr/code/antlr3/runtime/ObjC/Framework/examples/simplecTreeParser/SimpleC.g:27:9: type declarator K_SEMICOLON // alt 1311 { 1312 1313 /* ruleRef */ 1314 [self pushFollow:FOLLOW_type_in_variable166]; 1315 type7 = [self type]; 1316 1317 [self popFollow]; 1318 1319 1320 [stream_type addElement:[type7 getTree]]; 1321 1322 /* ruleRef */ 1323 [self pushFollow:FOLLOW_declarator_in_variable168]; 1324 declarator8 = [self declarator]; 1325 1326 [self popFollow]; 1327 1328 1329 [stream_declarator addElement:[declarator8 getTree]]; 1330 1331 K_SEMICOLON9=(CommonToken *)[self match:input TokenType:K_SEMICOLON Follow:FOLLOW_K_SEMICOLON_in_variable170]; 1332 [stream_K_SEMICOLON addElement:K_SEMICOLON9]; 1333 1334 1335 // AST REWRITE 1336 // elements: declarator, type 1337 // token labels: 1338 // rule labels: retval 1339 // token list labels: 1340 // rule list labels: 1341 // wildcard labels: 1342 retval.tree = root_0; 1343 1344 RewriteRuleSubtreeStream *stream_retval = 1345 [[RewriteRuleSubtreeStream newRewriteRuleSubtreeStream:treeAdaptor 1346 description:@"token retval" element:retval!=nil?[retval getTree]:nil] retain]; 1347 1348 root_0 = (CommonTree *)[[[treeAdaptor class] newEmptyTree] retain]; 1349 1350 // 27:37: -> ^( VAR_DEF type declarator ) 1351 { 1352 // /Users/acondit/source/antlr/code/antlr3/runtime/ObjC/Framework/examples/simplecTreeParser/SimpleC.g:27:40: ^( VAR_DEF type declarator ) 1353 { 1354 CommonTree *root_1 = (CommonTree *)[[[treeAdaptor class] newEmptyTree] retain]; 1355 root_1 = (CommonTree *)[treeAdaptor becomeRoot: 1356 [[treeAdaptor createTree:VAR_DEF Text:@"VAR_DEF"] retain] 1357 old:root_1]; 1358 1359 [treeAdaptor addChild:[stream_type nextTree] toTree:root_1]; 1360 1361 [treeAdaptor addChild:[stream_declarator nextTree] toTree:root_1]; 1362 1363 [treeAdaptor addChild:root_1 toTree:root_0]; 1364 } 1365 1366 } 1367 1368 1369 retval.tree = root_0; 1370 1371 1372 } 1373 1374 /* ASTParser ruleCleanUp */ 1375 /* AST ruleCleanUp */ 1376 /* token+rule list labels */ 1377 [retval setStop:[input LT:-1]]; 1378 1379 1380 [stream_K_SEMICOLON release]; 1381 [stream_declarator release]; 1382 [stream_type release]; 1383 1384 retval.tree = (CommonTree *)[treeAdaptor rulePostProcessing:root_0]; 1385 [treeAdaptor setTokenBoundaries:retval.tree From:retval.start To:retval.stopToken]; 1386 1387 } 1388 @catch (RecognitionException *re) { 1389 [self reportError:re]; 1390 [self recover:input Exception:re]; 1391 /* ASTParser rule.setErrorReturnValue */ 1392 retval.tree = (CommonTree *)[treeAdaptor errorNode:input From:retval.start To:[input LT:-1] Exception:re]; 1393 1394 } 1395 1396 @finally { 1397 /* ruleScopeCleanUp */ 1398 1399 } 1400 return retval; 1401} 1402/* $ANTLR end variable */ 1403 1404/* 1405 * $ANTLR start declarator 1406 * /Users/acondit/source/antlr/code/antlr3/runtime/ObjC/Framework/examples/simplecTreeParser/SimpleC.g:30:1: declarator : K_ID ; 1407 */ 1408- (SimpleCParser_declarator_return *) declarator 1409{ 1410 /* ruleScopeSetUp */ 1411 1412 /* AST ruleDeclarations */ 1413 /* ruleDeclarations */ 1414 SimpleCParser_declarator_return * retval = [SimpleCParser_declarator_return newSimpleCParser_declarator_return]; 1415 [retval setStart:[input LT:1]]; 1416 1417 1418 CommonTree *root_0 = nil; 1419 1420 @try { 1421 /* AST ruleLabelDefs */ 1422 /* ruleLabelDefs entry */ 1423 CommonToken *K_ID10 = nil; 1424 1425 CommonTree *K_ID10_tree=nil; 1426 1427 // /Users/acondit/source/antlr/code/antlr3/runtime/ObjC/Framework/examples/simplecTreeParser/SimpleC.g:31:5: ( K_ID ) // ruleBlockSingleAlt 1428 // /Users/acondit/source/antlr/code/antlr3/runtime/ObjC/Framework/examples/simplecTreeParser/SimpleC.g:31:9: K_ID // alt 1429 { 1430 root_0 = (CommonTree *)[[[treeAdaptor class] newEmptyTree] retain]; 1431 1432 1433 1434 /* ASTParser tokenRef */ 1435 K_ID10=(CommonToken *)[self match:input TokenType:K_ID Follow:FOLLOW_K_ID_in_declarator199]; 1436 K_ID10_tree = /* ASTParser createNodeFromToken */ 1437 (CommonTree *)[[treeAdaptor create:K_ID10] retain] 1438 ; 1439 [treeAdaptor addChild:K_ID10_tree toTree:root_0]; 1440 1441 1442 } 1443 1444 /* ASTParser ruleCleanUp */ 1445 /* AST ruleCleanUp */ 1446 /* token+rule list labels */ 1447 [retval setStop:[input LT:-1]]; 1448 1449 1450 1451 retval.tree = (CommonTree *)[treeAdaptor rulePostProcessing:root_0]; 1452 [treeAdaptor setTokenBoundaries:retval.tree From:retval.start To:retval.stopToken]; 1453 1454 } 1455 @catch (RecognitionException *re) { 1456 [self reportError:re]; 1457 [self recover:input Exception:re]; 1458 /* ASTParser rule.setErrorReturnValue */ 1459 retval.tree = (CommonTree *)[treeAdaptor errorNode:input From:retval.start To:[input LT:-1] Exception:re]; 1460 1461 } 1462 1463 @finally { 1464 /* ruleScopeCleanUp */ 1465 1466 } 1467 return retval; 1468} 1469/* $ANTLR end declarator */ 1470 1471/* 1472 * $ANTLR start functionHeader 1473 * /Users/acondit/source/antlr/code/antlr3/runtime/ObjC/Framework/examples/simplecTreeParser/SimpleC.g:34:1: functionHeader : type K_ID K_LCURVE ( formalParameter ( K_COMMA formalParameter )* )? K_RCURVE -> ^( FUNC_HDR type K_ID ( formalParameter )+ ) ; 1474 */ 1475- (SimpleCParser_functionHeader_return *) functionHeader 1476{ 1477 /* ruleScopeSetUp */ 1478 1479 /* AST ruleDeclarations */ 1480 /* ruleDeclarations */ 1481 SimpleCParser_functionHeader_return * retval = [SimpleCParser_functionHeader_return newSimpleCParser_functionHeader_return]; 1482 [retval setStart:[input LT:1]]; 1483 1484 1485 CommonTree *root_0 = nil; 1486 1487 @try { 1488 /* AST ruleLabelDefs */ 1489 /* ruleLabelDefs entry */ 1490 CommonToken *K_ID12 = nil; 1491 CommonToken *K_LCURVE13 = nil; 1492 CommonToken *K_COMMA15 = nil; 1493 CommonToken *K_RCURVE17 = nil;SimpleCParser_type_return * type11 = nil ; 1494 1495 SimpleCParser_formalParameter_return * formalParameter14 = nil ; 1496 1497 SimpleCParser_formalParameter_return * formalParameter16 = nil ; 1498 1499 1500 CommonTree *K_ID12_tree=nil; 1501 CommonTree *K_LCURVE13_tree=nil; 1502 CommonTree *K_COMMA15_tree=nil; 1503 CommonTree *K_RCURVE17_tree=nil; 1504 RewriteRuleTokenStream *stream_K_ID = 1505 [[RewriteRuleTokenStream newRewriteRuleTokenStream:treeAdaptor 1506 description:@"token K_ID"] retain]; 1507 RewriteRuleTokenStream *stream_K_LCURVE = 1508 [[RewriteRuleTokenStream newRewriteRuleTokenStream:treeAdaptor 1509 description:@"token K_LCURVE"] retain]; 1510 RewriteRuleTokenStream *stream_K_RCURVE = 1511 [[RewriteRuleTokenStream newRewriteRuleTokenStream:treeAdaptor 1512 description:@"token K_RCURVE"] retain]; 1513 RewriteRuleTokenStream *stream_K_COMMA = 1514 [[RewriteRuleTokenStream newRewriteRuleTokenStream:treeAdaptor 1515 description:@"token K_COMMA"] retain]; 1516 RewriteRuleSubtreeStream *stream_formalParameter = 1517 [[RewriteRuleSubtreeStream newRewriteRuleSubtreeStream:treeAdaptor 1518 description:@"rule formalParameter"] retain]; 1519 RewriteRuleSubtreeStream *stream_type = 1520 [[RewriteRuleSubtreeStream newRewriteRuleSubtreeStream:treeAdaptor 1521 description:@"rule type"] retain]; 1522 // /Users/acondit/source/antlr/code/antlr3/runtime/ObjC/Framework/examples/simplecTreeParser/SimpleC.g:35:5: ( type K_ID K_LCURVE ( formalParameter ( K_COMMA formalParameter )* )? K_RCURVE -> ^( FUNC_HDR type K_ID ( formalParameter )+ ) ) // ruleBlockSingleAlt 1523 // /Users/acondit/source/antlr/code/antlr3/runtime/ObjC/Framework/examples/simplecTreeParser/SimpleC.g:35:9: type K_ID K_LCURVE ( formalParameter ( K_COMMA formalParameter )* )? K_RCURVE // alt 1524 { 1525 1526 /* ruleRef */ 1527 [self pushFollow:FOLLOW_type_in_functionHeader219]; 1528 type11 = [self type]; 1529 1530 [self popFollow]; 1531 1532 1533 [stream_type addElement:[type11 getTree]]; 1534 1535 K_ID12=(CommonToken *)[self match:input TokenType:K_ID Follow:FOLLOW_K_ID_in_functionHeader221]; 1536 [stream_K_ID addElement:K_ID12]; 1537 1538 1539 K_LCURVE13=(CommonToken *)[self match:input TokenType:K_LCURVE Follow:FOLLOW_K_LCURVE_in_functionHeader223]; 1540 [stream_K_LCURVE addElement:K_LCURVE13]; 1541 1542 1543 // /Users/acondit/source/antlr/code/antlr3/runtime/ObjC/Framework/examples/simplecTreeParser/SimpleC.g:35:28: ( formalParameter ( K_COMMA formalParameter )* )? // block 1544 NSInteger alt4=2; 1545 NSInteger LA4_0 = [input LA:1]; 1546 1547 if ( (LA4_0==K_CHAR||LA4_0==K_ID||LA4_0==K_INT_TYPE||LA4_0==K_VOID) ) { 1548 alt4=1; 1549 } 1550 switch (alt4) { 1551 case 1 : ; 1552 // /Users/acondit/source/antlr/code/antlr3/runtime/ObjC/Framework/examples/simplecTreeParser/SimpleC.g:35:30: formalParameter ( K_COMMA formalParameter )* // alt 1553 { 1554 1555 /* ruleRef */ 1556 [self pushFollow:FOLLOW_formalParameter_in_functionHeader227]; 1557 formalParameter14 = [self formalParameter]; 1558 1559 [self popFollow]; 1560 1561 1562 [stream_formalParameter addElement:[formalParameter14 getTree]]; 1563 1564 1565 do { 1566 NSInteger alt3=2; 1567 NSInteger LA3_0 = [input LA:1]; 1568 if ( (LA3_0==K_COMMA) ) { 1569 alt3=1; 1570 } 1571 1572 1573 switch (alt3) { 1574 case 1 : ; 1575 // /Users/acondit/source/antlr/code/antlr3/runtime/ObjC/Framework/examples/simplecTreeParser/SimpleC.g:35:48: K_COMMA formalParameter // alt 1576 { 1577 1578 K_COMMA15=(CommonToken *)[self match:input TokenType:K_COMMA Follow:FOLLOW_K_COMMA_in_functionHeader231]; 1579 [stream_K_COMMA addElement:K_COMMA15]; 1580 1581 1582 /* ruleRef */ 1583 [self pushFollow:FOLLOW_formalParameter_in_functionHeader233]; 1584 formalParameter16 = [self formalParameter]; 1585 1586 [self popFollow]; 1587 1588 1589 [stream_formalParameter addElement:[formalParameter16 getTree]]; 1590 1591 } 1592 break; 1593 1594 default : 1595 goto loop3; 1596 } 1597 } while (YES); 1598 loop3: ; 1599 1600 1601 } 1602 break; 1603 1604 } 1605 1606 1607 K_RCURVE17=(CommonToken *)[self match:input TokenType:K_RCURVE Follow:FOLLOW_K_RCURVE_in_functionHeader241]; 1608 [stream_K_RCURVE addElement:K_RCURVE17]; 1609 1610 1611 // AST REWRITE 1612 // elements: K_ID, type, formalParameter 1613 // token labels: 1614 // rule labels: retval 1615 // token list labels: 1616 // rule list labels: 1617 // wildcard labels: 1618 retval.tree = root_0; 1619 1620 RewriteRuleSubtreeStream *stream_retval = 1621 [[RewriteRuleSubtreeStream newRewriteRuleSubtreeStream:treeAdaptor 1622 description:@"token retval" element:retval!=nil?[retval getTree]:nil] retain]; 1623 1624 root_0 = (CommonTree *)[[[treeAdaptor class] newEmptyTree] retain]; 1625 1626 // 36:9: -> ^( FUNC_HDR type K_ID ( formalParameter )+ ) 1627 { 1628 // /Users/acondit/source/antlr/code/antlr3/runtime/ObjC/Framework/examples/simplecTreeParser/SimpleC.g:36:12: ^( FUNC_HDR type K_ID ( formalParameter )+ ) 1629 { 1630 CommonTree *root_1 = (CommonTree *)[[[treeAdaptor class] newEmptyTree] retain]; 1631 root_1 = (CommonTree *)[treeAdaptor becomeRoot: 1632 [[treeAdaptor createTree:FUNC_HDR Text:@"FUNC_HDR"] retain] 1633 old:root_1]; 1634 1635 [treeAdaptor addChild:[stream_type nextTree] toTree:root_1]; 1636 1637 // TODO: args: 1638 [treeAdaptor addChild: 1639 [stream_K_ID nextNode] 1640 toTree:root_1]; 1641 1642 // /Users/acondit/source/antlr/code/antlr3/runtime/ObjC/Framework/examples/simplecTreeParser/SimpleC.g:36:33: ( formalParameter )+ 1643 { 1644 if ( !([stream_formalParameter hasNext]) ) { 1645 @throw [RewriteEarlyExitException newException]; 1646 } 1647 while ( [stream_formalParameter hasNext] ) { 1648 [treeAdaptor addChild:[stream_formalParameter nextTree] toTree:root_1]; 1649 1650 } 1651 [stream_formalParameter reset]; 1652 1653 } 1654 [treeAdaptor addChild:root_1 toTree:root_0]; 1655 } 1656 1657 } 1658 1659 1660 retval.tree = root_0; 1661 1662 1663 } 1664 1665 /* ASTParser ruleCleanUp */ 1666 /* AST ruleCleanUp */ 1667 /* token+rule list labels */ 1668 [retval setStop:[input LT:-1]]; 1669 1670 1671 [stream_K_ID release]; 1672 [stream_K_LCURVE release]; 1673 [stream_K_RCURVE release]; 1674 [stream_K_COMMA release]; 1675 [stream_formalParameter release]; 1676 [stream_type release]; 1677 1678 retval.tree = (CommonTree *)[treeAdaptor rulePostProcessing:root_0]; 1679 [treeAdaptor setTokenBoundaries:retval.tree From:retval.start To:retval.stopToken]; 1680 1681 } 1682 @catch (RecognitionException *re) { 1683 [self reportError:re]; 1684 [self recover:input Exception:re]; 1685 /* ASTParser rule.setErrorReturnValue */ 1686 retval.tree = (CommonTree *)[treeAdaptor errorNode:input From:retval.start To:[input LT:-1] Exception:re]; 1687 1688 } 1689 1690 @finally { 1691 /* ruleScopeCleanUp */ 1692 1693 } 1694 return retval; 1695} 1696/* $ANTLR end functionHeader */ 1697 1698/* 1699 * $ANTLR start formalParameter 1700 * /Users/acondit/source/antlr/code/antlr3/runtime/ObjC/Framework/examples/simplecTreeParser/SimpleC.g:39:1: formalParameter : type declarator -> ^( ARG_DEF type declarator ) ; 1701 */ 1702- (SimpleCParser_formalParameter_return *) formalParameter 1703{ 1704 /* ruleScopeSetUp */ 1705 1706 /* AST ruleDeclarations */ 1707 /* ruleDeclarations */ 1708 SimpleCParser_formalParameter_return * retval = [SimpleCParser_formalParameter_return newSimpleCParser_formalParameter_return]; 1709 [retval setStart:[input LT:1]]; 1710 1711 1712 CommonTree *root_0 = nil; 1713 1714 @try { 1715 /* AST ruleLabelDefs */ 1716 /* ruleLabelDefs entry */ 1717 SimpleCParser_type_return * type18 = nil ; 1718 1719 SimpleCParser_declarator_return * declarator19 = nil ; 1720 1721 1722 RewriteRuleSubtreeStream *stream_declarator = 1723 [[RewriteRuleSubtreeStream newRewriteRuleSubtreeStream:treeAdaptor 1724 description:@"rule declarator"] retain]; 1725 RewriteRuleSubtreeStream *stream_type = 1726 [[RewriteRuleSubtreeStream newRewriteRuleSubtreeStream:treeAdaptor 1727 description:@"rule type"] retain]; 1728 // /Users/acondit/source/antlr/code/antlr3/runtime/ObjC/Framework/examples/simplecTreeParser/SimpleC.g:40:5: ( type declarator -> ^( ARG_DEF type declarator ) ) // ruleBlockSingleAlt 1729 // /Users/acondit/source/antlr/code/antlr3/runtime/ObjC/Framework/examples/simplecTreeParser/SimpleC.g:40:9: type declarator // alt 1730 { 1731 1732 /* ruleRef */ 1733 [self pushFollow:FOLLOW_type_in_formalParameter281]; 1734 type18 = [self type]; 1735 1736 [self popFollow]; 1737 1738 1739 [stream_type addElement:[type18 getTree]]; 1740 1741 /* ruleRef */ 1742 [self pushFollow:FOLLOW_declarator_in_formalParameter283]; 1743 declarator19 = [self declarator]; 1744 1745 [self popFollow]; 1746 1747 1748 [stream_declarator addElement:[declarator19 getTree]]; 1749 1750 // AST REWRITE 1751 // elements: type, declarator 1752 // token labels: 1753 // rule labels: retval 1754 // token list labels: 1755 // rule list labels: 1756 // wildcard labels: 1757 retval.tree = root_0; 1758 1759 RewriteRuleSubtreeStream *stream_retval = 1760 [[RewriteRuleSubtreeStream newRewriteRuleSubtreeStream:treeAdaptor 1761 description:@"token retval" element:retval!=nil?[retval getTree]:nil] retain]; 1762 1763 root_0 = (CommonTree *)[[[treeAdaptor class] newEmptyTree] retain]; 1764 1765 // 40:25: -> ^( ARG_DEF type declarator ) 1766 { 1767 // /Users/acondit/source/antlr/code/antlr3/runtime/ObjC/Framework/examples/simplecTreeParser/SimpleC.g:40:28: ^( ARG_DEF type declarator ) 1768 { 1769 CommonTree *root_1 = (CommonTree *)[[[treeAdaptor class] newEmptyTree] retain]; 1770 root_1 = (CommonTree *)[treeAdaptor becomeRoot: 1771 [[treeAdaptor createTree:ARG_DEF Text:@"ARG_DEF"] retain] 1772 old:root_1]; 1773 1774 [treeAdaptor addChild:[stream_type nextTree] toTree:root_1]; 1775 1776 [treeAdaptor addChild:[stream_declarator nextTree] toTree:root_1]; 1777 1778 [treeAdaptor addChild:root_1 toTree:root_0]; 1779 } 1780 1781 } 1782 1783 1784 retval.tree = root_0; 1785 1786 1787 } 1788 1789 /* ASTParser ruleCleanUp */ 1790 /* AST ruleCleanUp */ 1791 /* token+rule list labels */ 1792 [retval setStop:[input LT:-1]]; 1793 1794 1795 [stream_declarator release]; 1796 [stream_type release]; 1797 1798 retval.tree = (CommonTree *)[treeAdaptor rulePostProcessing:root_0]; 1799 [treeAdaptor setTokenBoundaries:retval.tree From:retval.start To:retval.stopToken]; 1800 1801 } 1802 @catch (RecognitionException *re) { 1803 [self reportError:re]; 1804 [self recover:input Exception:re]; 1805 /* ASTParser rule.setErrorReturnValue */ 1806 retval.tree = (CommonTree *)[treeAdaptor errorNode:input From:retval.start To:[input LT:-1] Exception:re]; 1807 1808 } 1809 1810 @finally { 1811 /* ruleScopeCleanUp */ 1812 1813 } 1814 return retval; 1815} 1816/* $ANTLR end formalParameter */ 1817 1818/* 1819 * $ANTLR start type 1820 * /Users/acondit/source/antlr/code/antlr3/runtime/ObjC/Framework/examples/simplecTreeParser/SimpleC.g:43:1: type : ( K_INT_TYPE | K_CHAR | K_VOID | K_ID ); 1821 */ 1822- (SimpleCParser_type_return *) type 1823{ 1824 /* ruleScopeSetUp */ 1825 1826 /* AST ruleDeclarations */ 1827 /* ruleDeclarations */ 1828 SimpleCParser_type_return * retval = [SimpleCParser_type_return newSimpleCParser_type_return]; 1829 [retval setStart:[input LT:1]]; 1830 1831 1832 CommonTree *root_0 = nil; 1833 1834 @try { 1835 /* AST ruleLabelDefs */ 1836 /* ruleLabelDefs entry */ 1837 CommonToken *set20 = nil; 1838 1839 CommonTree *set20_tree=nil; 1840 1841 // /Users/acondit/source/antlr/code/antlr3/runtime/ObjC/Framework/examples/simplecTreeParser/SimpleC.g:44:5: ( K_INT_TYPE | K_CHAR | K_VOID | K_ID ) // ruleBlockSingleAlt 1842 // /Users/acondit/source/antlr/code/antlr3/runtime/ObjC/Framework/examples/simplecTreeParser/SimpleC.g: // alt 1843 { 1844 root_0 = (CommonTree *)[[[treeAdaptor class] newEmptyTree] retain]; 1845 1846 1847 1848 /* ASTParser matchRuleBlockSet */ 1849 /* ASTParser matchSet */ 1850 set20 = (CommonToken *)[input LT:1]; /* matchSet */ 1851 1852 if ([input LA:1] == K_CHAR||[input LA:1] == K_ID||[input LA:1] == K_INT_TYPE||[input LA:1] == K_VOID) { 1853 [input consume]; 1854 [treeAdaptor addChild:/* ASTParser createNodeFromToken */ 1855 (CommonTree *)[[treeAdaptor create:set20] retain] 1856 toTree:root_0 ]; 1857 [state setIsErrorRecovery:NO]; 1858 } else { 1859 MismatchedSetException *mse = [MismatchedSetException newException:nil stream:input]; 1860 @throw mse; 1861 } 1862 1863 1864 } 1865 1866 /* ASTParser ruleCleanUp */ 1867 /* AST ruleCleanUp */ 1868 /* token+rule list labels */ 1869 [retval setStop:[input LT:-1]]; 1870 1871 1872 1873 retval.tree = (CommonTree *)[treeAdaptor rulePostProcessing:root_0]; 1874 [treeAdaptor setTokenBoundaries:retval.tree From:retval.start To:retval.stopToken]; 1875 1876 } 1877 @catch (RecognitionException *re) { 1878 [self reportError:re]; 1879 [self recover:input Exception:re]; 1880 /* ASTParser rule.setErrorReturnValue */ 1881 retval.tree = (CommonTree *)[treeAdaptor errorNode:input From:retval.start To:[input LT:-1] Exception:re]; 1882 1883 } 1884 1885 @finally { 1886 /* ruleScopeCleanUp */ 1887 1888 } 1889 return retval; 1890} 1891/* $ANTLR end type */ 1892 1893/* 1894 * $ANTLR start block 1895 * /Users/acondit/source/antlr/code/antlr3/runtime/ObjC/Framework/examples/simplecTreeParser/SimpleC.g:50:1: block : lc= K_LCURLY ( variable )* ( stat )* K_RCURLY -> ^( BLOCK[$lc,@\"BLOCK\"] ( variable )* ( stat )* ) ; 1896 */ 1897- (SimpleCParser_block_return *) block 1898{ 1899 /* ruleScopeSetUp */ 1900 1901 /* AST ruleDeclarations */ 1902 /* ruleDeclarations */ 1903 SimpleCParser_block_return * retval = [SimpleCParser_block_return newSimpleCParser_block_return]; 1904 [retval setStart:[input LT:1]]; 1905 1906 1907 CommonTree *root_0 = nil; 1908 1909 @try { 1910 /* AST ruleLabelDefs */ 1911 /* ruleLabelDefs entry */ 1912 CommonToken *lc = nil; 1913 CommonToken *K_RCURLY23 = nil;SimpleCParser_variable_return * variable21 = nil ; 1914 1915 SimpleCParser_stat_return * stat22 = nil ; 1916 1917 1918 CommonTree *lc_tree=nil; 1919 CommonTree *K_RCURLY23_tree=nil; 1920 RewriteRuleTokenStream *stream_K_LCURLY = 1921 [[RewriteRuleTokenStream newRewriteRuleTokenStream:treeAdaptor 1922 description:@"token K_LCURLY"] retain]; 1923 RewriteRuleTokenStream *stream_K_RCURLY = 1924 [[RewriteRuleTokenStream newRewriteRuleTokenStream:treeAdaptor 1925 description:@"token K_RCURLY"] retain]; 1926 RewriteRuleSubtreeStream *stream_variable = 1927 [[RewriteRuleSubtreeStream newRewriteRuleSubtreeStream:treeAdaptor 1928 description:@"rule variable"] retain]; 1929 RewriteRuleSubtreeStream *stream_stat = 1930 [[RewriteRuleSubtreeStream newRewriteRuleSubtreeStream:treeAdaptor 1931 description:@"rule stat"] retain]; 1932 // /Users/acondit/source/antlr/code/antlr3/runtime/ObjC/Framework/examples/simplecTreeParser/SimpleC.g:51:5: (lc= K_LCURLY ( variable )* ( stat )* K_RCURLY -> ^( BLOCK[$lc,@\"BLOCK\"] ( variable )* ( stat )* ) ) // ruleBlockSingleAlt 1933 // /Users/acondit/source/antlr/code/antlr3/runtime/ObjC/Framework/examples/simplecTreeParser/SimpleC.g:51:9: lc= K_LCURLY ( variable )* ( stat )* K_RCURLY // alt 1934 { 1935 1936 lc=(CommonToken *)[self match:input TokenType:K_LCURLY Follow:FOLLOW_K_LCURLY_in_block376]; 1937 [stream_K_LCURLY addElement:lc]; 1938 1939 1940 1941 do { 1942 NSInteger alt5=2; 1943 NSInteger LA5_0 = [input LA:1]; 1944 if ( (LA5_0==K_ID) ) { 1945 NSInteger LA5_2 = [input LA:2]; 1946 if ( (LA5_2==K_ID) ) { 1947 alt5=1; 1948 } 1949 1950 1951 } 1952 else if ( (LA5_0==K_CHAR||LA5_0==K_INT_TYPE||LA5_0==K_VOID) ) { 1953 alt5=1; 1954 } 1955 1956 1957 switch (alt5) { 1958 case 1 : ; 1959 // /Users/acondit/source/antlr/code/antlr3/runtime/ObjC/Framework/examples/simplecTreeParser/SimpleC.g:52:13: variable // alt 1960 { 1961 1962 /* ruleRef */ 1963 [self pushFollow:FOLLOW_variable_in_block390]; 1964 variable21 = [self variable]; 1965 1966 [self popFollow]; 1967 1968 1969 [stream_variable addElement:[variable21 getTree]]; 1970 1971 } 1972 break; 1973 1974 default : 1975 goto loop5; 1976 } 1977 } while (YES); 1978 loop5: ; 1979 1980 1981 1982 do { 1983 NSInteger alt6=2; 1984 NSInteger LA6_0 = [input LA:1]; 1985 if ( ((LA6_0 >= K_FOR && LA6_0 <= K_INT)||(LA6_0 >= K_LCURLY && LA6_0 <= K_LCURVE)||LA6_0==K_SEMICOLON) ) { 1986 alt6=1; 1987 } 1988 1989 1990 switch (alt6) { 1991 case 1 : ; 1992 // /Users/acondit/source/antlr/code/antlr3/runtime/ObjC/Framework/examples/simplecTreeParser/SimpleC.g:53:13: stat // alt 1993 { 1994 1995 /* ruleRef */ 1996 [self pushFollow:FOLLOW_stat_in_block405]; 1997 stat22 = [self stat]; 1998 1999 [self popFollow]; 2000 2001 2002 [stream_stat addElement:[stat22 getTree]]; 2003 2004 } 2005 break; 2006 2007 default : 2008 goto loop6; 2009 } 2010 } while (YES); 2011 loop6: ; 2012 2013 2014 K_RCURLY23=(CommonToken *)[self match:input TokenType:K_RCURLY Follow:FOLLOW_K_RCURLY_in_block416]; 2015 [stream_K_RCURLY addElement:K_RCURLY23]; 2016 2017 2018 // AST REWRITE 2019 // elements: stat, variable 2020 // token labels: 2021 // rule labels: retval 2022 // token list labels: 2023 // rule list labels: 2024 // wildcard labels: 2025 retval.tree = root_0; 2026 2027 RewriteRuleSubtreeStream *stream_retval = 2028 [[RewriteRuleSubtreeStream newRewriteRuleSubtreeStream:treeAdaptor 2029 description:@"token retval" element:retval!=nil?[retval getTree]:nil] retain]; 2030 2031 root_0 = (CommonTree *)[[[treeAdaptor class] newEmptyTree] retain]; 2032 2033 // 55:9: -> ^( BLOCK[$lc,@\"BLOCK\"] ( variable )* ( stat )* ) 2034 { 2035 // /Users/acondit/source/antlr/code/antlr3/runtime/ObjC/Framework/examples/simplecTreeParser/SimpleC.g:55:12: ^( BLOCK[$lc,@\"BLOCK\"] ( variable )* ( stat )* ) 2036 { 2037 CommonTree *root_1 = (CommonTree *)[[[treeAdaptor class] newEmptyTree] retain]; 2038 root_1 = (CommonTree *)[treeAdaptor becomeRoot: 2039 [[treeAdaptor createTree:BLOCK FromToken:lc Text:@"BLOCK"] retain] 2040 old:root_1]; 2041 2042 // /Users/acondit/source/antlr/code/antlr3/runtime/ObjC/Framework/examples/simplecTreeParser/SimpleC.g:55:34: ( variable )* 2043 while ( [stream_variable hasNext] ) { 2044 [treeAdaptor addChild:[stream_variable nextTree] toTree:root_1]; 2045 2046 } 2047 [stream_variable reset]; 2048 2049 // /Users/acondit/source/antlr/code/antlr3/runtime/ObjC/Framework/examples/simplecTreeParser/SimpleC.g:55:44: ( stat )* 2050 while ( [stream_stat hasNext] ) { 2051 [treeAdaptor addChild:[stream_stat nextTree] toTree:root_1]; 2052 2053 } 2054 [stream_stat reset]; 2055 2056 [treeAdaptor addChild:root_1 toTree:root_0]; 2057 } 2058 2059 } 2060 2061 2062 retval.tree = root_0; 2063 2064 2065 } 2066 2067 /* ASTParser ruleCleanUp */ 2068 /* AST ruleCleanUp */ 2069 /* token+rule list labels */ 2070 [retval setStop:[input LT:-1]]; 2071 2072 2073 [stream_K_LCURLY release]; 2074 [stream_K_RCURLY release]; 2075 [stream_variable release]; 2076 [stream_stat release]; 2077 2078 retval.tree = (CommonTree *)[treeAdaptor rulePostProcessing:root_0]; 2079 [treeAdaptor setTokenBoundaries:retval.tree From:retval.start To:retval.stopToken]; 2080 2081 } 2082 @catch (RecognitionException *re) { 2083 [self reportError:re]; 2084 [self recover:input Exception:re]; 2085 /* ASTParser rule.setErrorReturnValue */ 2086 retval.tree = (CommonTree *)[treeAdaptor errorNode:input From:retval.start To:[input LT:-1] Exception:re]; 2087 2088 } 2089 2090 @finally { 2091 /* ruleScopeCleanUp */ 2092 2093 } 2094 return retval; 2095} 2096/* $ANTLR end block */ 2097 2098/* 2099 * $ANTLR start stat 2100 * /Users/acondit/source/antlr/code/antlr3/runtime/ObjC/Framework/examples/simplecTreeParser/SimpleC.g:58:1: stat : ( forStat | expr K_SEMICOLON !| block | assignStat K_SEMICOLON !| K_SEMICOLON !); 2101 */ 2102- (SimpleCParser_stat_return *) stat 2103{ 2104 /* ruleScopeSetUp */ 2105 2106 /* AST ruleDeclarations */ 2107 /* ruleDeclarations */ 2108 SimpleCParser_stat_return * retval = [SimpleCParser_stat_return newSimpleCParser_stat_return]; 2109 [retval setStart:[input LT:1]]; 2110 2111 2112 CommonTree *root_0 = nil; 2113 2114 @try { 2115 /* AST ruleLabelDefs */ 2116 /* ruleLabelDefs entry */ 2117 CommonToken *K_SEMICOLON26 = nil; 2118 CommonToken *K_SEMICOLON29 = nil; 2119 CommonToken *K_SEMICOLON30 = nil;SimpleCParser_forStat_return * forStat24 = nil ; 2120 2121 SimpleCParser_expr_return * expr25 = nil ; 2122 2123 SimpleCParser_block_return * block27 = nil ; 2124 2125 SimpleCParser_assignStat_return * assignStat28 = nil ; 2126 2127 2128 CommonTree *K_SEMICOLON26_tree=nil; 2129 CommonTree *K_SEMICOLON29_tree=nil; 2130 CommonTree *K_SEMICOLON30_tree=nil; 2131 2132 // /Users/acondit/source/antlr/code/antlr3/runtime/ObjC/Framework/examples/simplecTreeParser/SimpleC.g:58:5: ( forStat | expr K_SEMICOLON !| block | assignStat K_SEMICOLON !| K_SEMICOLON !) //ruleblock 2133 NSInteger alt7=5; 2134 unichar charLA7 = [input LA:1]; 2135 switch (charLA7) { 2136 case K_FOR: ; 2137 { 2138 alt7=1; 2139 } 2140 break; 2141 case K_ID: ; 2142 { 2143 NSInteger LA7_2 = [input LA:2]; 2144 2145 if ( (LA7_2==K_EQ) ) { 2146 alt7=4; 2147 } 2148 else if ( (LA7_2==K_EQEQ||(LA7_2 >= K_LT && LA7_2 <= K_PLUS)||LA7_2==K_SEMICOLON) ) { 2149 alt7=2; 2150 } 2151 else { 2152 NoViableAltException *nvae = [NoViableAltException newException:7 state:2 stream:input]; 2153 nvae.c = LA7_2; 2154 @throw nvae; 2155 2156 } 2157 } 2158 break; 2159 case K_INT: ; 2160 case K_LCURVE: ; 2161 { 2162 alt7=2; 2163 } 2164 break; 2165 case K_LCURLY: ; 2166 { 2167 alt7=3; 2168 } 2169 break; 2170 case K_SEMICOLON: ; 2171 { 2172 alt7=5; 2173 } 2174 break; 2175 2176 default: ; 2177 NoViableAltException *nvae = [NoViableAltException newException:7 state:0 stream:input]; 2178 nvae.c = charLA7; 2179 @throw nvae; 2180 2181 } 2182 2183 switch (alt7) { 2184 case 1 : ; 2185 // /Users/acondit/source/antlr/code/antlr3/runtime/ObjC/Framework/examples/simplecTreeParser/SimpleC.g:58:7: forStat // alt 2186 { 2187 root_0 = (CommonTree *)[[[treeAdaptor class] newEmptyTree] retain]; 2188 2189 2190 2191 /* ASTParser ruleRef */ 2192 /* ruleRef */ 2193 [self pushFollow:FOLLOW_forStat_in_stat449]; 2194 forStat24 = [self forStat]; 2195 2196 [self popFollow]; 2197 2198 2199 [treeAdaptor addChild:[forStat24 getTree] toTree:root_0]; 2200 2201 } 2202 break; 2203 case 2 : ; 2204 // /Users/acondit/source/antlr/code/antlr3/runtime/ObjC/Framework/examples/simplecTreeParser/SimpleC.g:59:7: expr K_SEMICOLON ! // alt 2205 { 2206 root_0 = (CommonTree *)[[[treeAdaptor class] newEmptyTree] retain]; 2207 2208 2209 2210 /* ASTParser ruleRef */ 2211 /* ruleRef */ 2212 [self pushFollow:FOLLOW_expr_in_stat457]; 2213 expr25 = [self expr]; 2214 2215 [self popFollow]; 2216 2217 2218 [treeAdaptor addChild:[expr25 getTree] toTree:root_0]; 2219 2220 K_SEMICOLON26=(CommonToken *)[self match:input TokenType:K_SEMICOLON Follow:FOLLOW_K_SEMICOLON_in_stat459]; 2221 2222 } 2223 break; 2224 case 3 : ; 2225 // /Users/acondit/source/antlr/code/antlr3/runtime/ObjC/Framework/examples/simplecTreeParser/SimpleC.g:60:7: block // alt 2226 { 2227 root_0 = (CommonTree *)[[[treeAdaptor class] newEmptyTree] retain]; 2228 2229 2230 2231 /* ASTParser ruleRef */ 2232 /* ruleRef */ 2233 [self pushFollow:FOLLOW_block_in_stat468]; 2234 block27 = [self block]; 2235 2236 [self popFollow]; 2237 2238 2239 [treeAdaptor addChild:[block27 getTree] toTree:root_0]; 2240 2241 } 2242 break; 2243 case 4 : ; 2244 // /Users/acondit/source/antlr/code/antlr3/runtime/ObjC/Framework/examples/simplecTreeParser/SimpleC.g:61:7: assignStat K_SEMICOLON ! // alt 2245 { 2246 root_0 = (CommonTree *)[[[treeAdaptor class] newEmptyTree] retain]; 2247 2248 2249 2250 /* ASTParser ruleRef */ 2251 /* ruleRef */ 2252 [self pushFollow:FOLLOW_assignStat_in_stat476]; 2253 assignStat28 = [self assignStat]; 2254 2255 [self popFollow]; 2256 2257 2258 [treeAdaptor addChild:[assignStat28 getTree] toTree:root_0]; 2259 2260 K_SEMICOLON29=(CommonToken *)[self match:input TokenType:K_SEMICOLON Follow:FOLLOW_K_SEMICOLON_in_stat478]; 2261 2262 } 2263 break; 2264 case 5 : ; 2265 // /Users/acondit/source/antlr/code/antlr3/runtime/ObjC/Framework/examples/simplecTreeParser/SimpleC.g:62:7: K_SEMICOLON ! // alt 2266 { 2267 root_0 = (CommonTree *)[[[treeAdaptor class] newEmptyTree] retain]; 2268 2269 2270 2271 K_SEMICOLON30=(CommonToken *)[self match:input TokenType:K_SEMICOLON Follow:FOLLOW_K_SEMICOLON_in_stat487]; 2272 2273 } 2274 break; 2275 2276 } 2277 /* ASTParser ruleCleanUp */ 2278 /* AST ruleCleanUp */ 2279 /* token+rule list labels */ 2280 [retval setStop:[input LT:-1]]; 2281 2282 2283 2284 retval.tree = (CommonTree *)[treeAdaptor rulePostProcessing:root_0]; 2285 [treeAdaptor setTokenBoundaries:retval.tree From:retval.start To:retval.stopToken]; 2286 2287 } 2288 @catch (RecognitionException *re) { 2289 [self reportError:re]; 2290 [self recover:input Exception:re]; 2291 /* ASTParser rule.setErrorReturnValue */ 2292 retval.tree = (CommonTree *)[treeAdaptor errorNode:input From:retval.start To:[input LT:-1] Exception:re]; 2293 2294 } 2295 2296 @finally { 2297 /* ruleScopeCleanUp */ 2298 2299 } 2300 return retval; 2301} 2302/* $ANTLR end stat */ 2303 2304/* 2305 * $ANTLR start forStat 2306 * /Users/acondit/source/antlr/code/antlr3/runtime/ObjC/Framework/examples/simplecTreeParser/SimpleC.g:65:1: forStat : K_FOR K_LCURVE start= assignStat K_SEMICOLON expr K_SEMICOLON next= assignStat K_RCURVE block -> ^( K_FOR $start expr $next block ) ; 2307 */ 2308- (SimpleCParser_forStat_return *) forStat 2309{ 2310 /* ruleScopeSetUp */ 2311 2312 /* AST ruleDeclarations */ 2313 /* ruleDeclarations */ 2314 SimpleCParser_forStat_return * retval = [SimpleCParser_forStat_return newSimpleCParser_forStat_return]; 2315 [retval setStart:[input LT:1]]; 2316 2317 2318 CommonTree *root_0 = nil; 2319 2320 @try { 2321 /* AST ruleLabelDefs */ 2322 /* ruleLabelDefs entry */ 2323 CommonToken *K_FOR31 = nil; 2324 CommonToken *K_LCURVE32 = nil; 2325 CommonToken *K_SEMICOLON33 = nil; 2326 CommonToken *K_SEMICOLON35 = nil; 2327 CommonToken *K_RCURVE36 = nil;SimpleCParser_assignStat_return * start = nil ; 2328 2329 SimpleCParser_assignStat_return * next = nil ; 2330 2331 SimpleCParser_expr_return * expr34 = nil ; 2332 2333 SimpleCParser_block_return * block37 = nil ; 2334 2335 2336 CommonTree *K_FOR31_tree=nil; 2337 CommonTree *K_LCURVE32_tree=nil; 2338 CommonTree *K_SEMICOLON33_tree=nil; 2339 CommonTree *K_SEMICOLON35_tree=nil; 2340 CommonTree *K_RCURVE36_tree=nil; 2341 RewriteRuleTokenStream *stream_K_LCURVE = 2342 [[RewriteRuleTokenStream newRewriteRuleTokenStream:treeAdaptor 2343 description:@"token K_LCURVE"] retain]; 2344 RewriteRuleTokenStream *stream_K_RCURVE = 2345 [[RewriteRuleTokenStream newRewriteRuleTokenStream:treeAdaptor 2346 description:@"token K_RCURVE"] retain]; 2347 RewriteRuleTokenStream *stream_K_SEMICOLON = 2348 [[RewriteRuleTokenStream newRewriteRuleTokenStream:treeAdaptor 2349 description:@"token K_SEMICOLON"] retain]; 2350 RewriteRuleTokenStream *stream_K_FOR = 2351 [[RewriteRuleTokenStream newRewriteRuleTokenStream:treeAdaptor 2352 description:@"token K_FOR"] retain]; 2353 RewriteRuleSubtreeStream *stream_assignStat = 2354 [[RewriteRuleSubtreeStream newRewriteRuleSubtreeStream:treeAdaptor 2355 description:@"rule assignStat"] retain]; 2356 RewriteRuleSubtreeStream *stream_block = 2357 [[RewriteRuleSubtreeStream newRewriteRuleSubtreeStream:treeAdaptor 2358 description:@"rule block"] retain]; 2359 RewriteRuleSubtreeStream *stream_expr = 2360 [[RewriteRuleSubtreeStream newRewriteRuleSubtreeStream:treeAdaptor 2361 description:@"rule expr"] retain]; 2362 // /Users/acondit/source/antlr/code/antlr3/runtime/ObjC/Framework/examples/simplecTreeParser/SimpleC.g:66:5: ( K_FOR K_LCURVE start= assignStat K_SEMICOLON expr K_SEMICOLON next= assignStat K_RCURVE block -> ^( K_FOR $start expr $next block ) ) // ruleBlockSingleAlt 2363 // /Users/acondit/source/antlr/code/antlr3/runtime/ObjC/Framework/examples/simplecTreeParser/SimpleC.g:66:9: K_FOR K_LCURVE start= assignStat K_SEMICOLON expr K_SEMICOLON next= assignStat K_RCURVE block // alt 2364 { 2365 2366 K_FOR31=(CommonToken *)[self match:input TokenType:K_FOR Follow:FOLLOW_K_FOR_in_forStat507]; 2367 [stream_K_FOR addElement:K_FOR31]; 2368 2369 2370 K_LCURVE32=(CommonToken *)[self match:input TokenType:K_LCURVE Follow:FOLLOW_K_LCURVE_in_forStat509]; 2371 [stream_K_LCURVE addElement:K_LCURVE32]; 2372 2373 2374 /* ruleRef */ 2375 [self pushFollow:FOLLOW_assignStat_in_forStat513]; 2376 start = [self assignStat]; 2377 2378 [self popFollow]; 2379 2380 2381 [stream_assignStat addElement:[start getTree]]; 2382 2383 K_SEMICOLON33=(CommonToken *)[self match:input TokenType:K_SEMICOLON Follow:FOLLOW_K_SEMICOLON_in_forStat515]; 2384 [stream_K_SEMICOLON addElement:K_SEMICOLON33]; 2385 2386 2387 /* ruleRef */ 2388 [self pushFollow:FOLLOW_expr_in_forStat517]; 2389 expr34 = [self expr]; 2390 2391 [self popFollow]; 2392 2393 2394 [stream_expr addElement:[expr34 getTree]]; 2395 2396 K_SEMICOLON35=(CommonToken *)[self match:input TokenType:K_SEMICOLON Follow:FOLLOW_K_SEMICOLON_in_forStat519]; 2397 [stream_K_SEMICOLON addElement:K_SEMICOLON35]; 2398 2399 2400 /* ruleRef */ 2401 [self pushFollow:FOLLOW_assignStat_in_forStat523]; 2402 next = [self assignStat]; 2403 2404 [self popFollow]; 2405 2406 2407 [stream_assignStat addElement:[next getTree]]; 2408 2409 K_RCURVE36=(CommonToken *)[self match:input TokenType:K_RCURVE Follow:FOLLOW_K_RCURVE_in_forStat525]; 2410 [stream_K_RCURVE addElement:K_RCURVE36]; 2411 2412 2413 /* ruleRef */ 2414 [self pushFollow:FOLLOW_block_in_forStat527]; 2415 block37 = [self block]; 2416 2417 [self popFollow]; 2418 2419 2420 [stream_block addElement:[block37 getTree]]; 2421 2422 // AST REWRITE 2423 // elements: block, start, K_FOR, next, expr 2424 // token labels: 2425 // rule labels: retval, start, next 2426 // token list labels: 2427 // rule list labels: 2428 // wildcard labels: 2429 retval.tree = root_0; 2430 2431 RewriteRuleSubtreeStream *stream_retval = 2432 [[RewriteRuleSubtreeStream newRewriteRuleSubtreeStream:treeAdaptor 2433 description:@"token retval" element:retval!=nil?[retval getTree]:nil] retain]; 2434 RewriteRuleSubtreeStream *stream_start = 2435 [[RewriteRuleSubtreeStream newRewriteRuleSubtreeStream:treeAdaptor 2436 description:@"token start" element:start!=nil?[start getTree]:nil] retain]; 2437 RewriteRuleSubtreeStream *stream_next = 2438 [[RewriteRuleSubtreeStream newRewriteRuleSubtreeStream:treeAdaptor 2439 description:@"token next" element:next!=nil?[next getTree]:nil] retain]; 2440 2441 root_0 = (CommonTree *)[[[treeAdaptor class] newEmptyTree] retain]; 2442 2443 // 67:9: -> ^( K_FOR $start expr $next block ) 2444 { 2445 // /Users/acondit/source/antlr/code/antlr3/runtime/ObjC/Framework/examples/simplecTreeParser/SimpleC.g:67:12: ^( K_FOR $start expr $next block ) 2446 { 2447 CommonTree *root_1 = (CommonTree *)[[[treeAdaptor class] newEmptyTree] retain]; 2448 root_1 = (CommonTree *)[treeAdaptor becomeRoot: 2449 [stream_K_FOR nextNode] 2450 old:root_1]; 2451 2452 [treeAdaptor addChild:[stream_start nextTree] toTree:root_1]; 2453 2454 [treeAdaptor addChild:[stream_expr nextTree] toTree:root_1]; 2455 2456 [treeAdaptor addChild:[stream_next nextTree] toTree:root_1]; 2457 2458 [treeAdaptor addChild:[stream_block nextTree] toTree:root_1]; 2459 2460 [treeAdaptor addChild:root_1 toTree:root_0]; 2461 } 2462 2463 } 2464 2465 2466 retval.tree = root_0; 2467 2468 2469 } 2470 2471 /* ASTParser ruleCleanUp */ 2472 /* AST ruleCleanUp */ 2473 /* token+rule list labels */ 2474 [retval setStop:[input LT:-1]]; 2475 2476 2477 [stream_K_LCURVE release]; 2478 [stream_K_RCURVE release]; 2479 [stream_K_SEMICOLON release]; 2480 [stream_K_FOR release]; 2481 [stream_assignStat release]; 2482 [stream_block release]; 2483 [stream_expr release]; 2484 2485 retval.tree = (CommonTree *)[treeAdaptor rulePostProcessing:root_0]; 2486 [treeAdaptor setTokenBoundaries:retval.tree From:retval.start To:retval.stopToken]; 2487 2488 } 2489 @catch (RecognitionException *re) { 2490 [self reportError:re]; 2491 [self recover:input Exception:re]; 2492 /* ASTParser rule.setErrorReturnValue */ 2493 retval.tree = (CommonTree *)[treeAdaptor errorNode:input From:retval.start To:[input LT:-1] Exception:re]; 2494 2495 } 2496 2497 @finally { 2498 /* ruleScopeCleanUp */ 2499 2500 } 2501 return retval; 2502} 2503/* $ANTLR end forStat */ 2504 2505/* 2506 * $ANTLR start assignStat 2507 * /Users/acondit/source/antlr/code/antlr3/runtime/ObjC/Framework/examples/simplecTreeParser/SimpleC.g:70:1: assignStat : K_ID K_EQ expr -> ^( K_EQ K_ID expr ) ; 2508 */ 2509- (SimpleCParser_assignStat_return *) assignStat 2510{ 2511 /* ruleScopeSetUp */ 2512 2513 /* AST ruleDeclarations */ 2514 /* ruleDeclarations */ 2515 SimpleCParser_assignStat_return * retval = [SimpleCParser_assignStat_return newSimpleCParser_assignStat_return]; 2516 [retval setStart:[input LT:1]]; 2517 2518 2519 CommonTree *root_0 = nil; 2520 2521 @try { 2522 /* AST ruleLabelDefs */ 2523 /* ruleLabelDefs entry */ 2524 CommonToken *K_ID38 = nil; 2525 CommonToken *K_EQ39 = nil;SimpleCParser_expr_return * expr40 = nil ; 2526 2527 2528 CommonTree *K_ID38_tree=nil; 2529 CommonTree *K_EQ39_tree=nil; 2530 RewriteRuleTokenStream *stream_K_ID = 2531 [[RewriteRuleTokenStream newRewriteRuleTokenStream:treeAdaptor 2532 description:@"token K_ID"] retain]; 2533 RewriteRuleTokenStream *stream_K_EQ = 2534 [[RewriteRuleTokenStream newRewriteRuleTokenStream:treeAdaptor 2535 description:@"token K_EQ"] retain]; 2536 RewriteRuleSubtreeStream *stream_expr = 2537 [[RewriteRuleSubtreeStream newRewriteRuleSubtreeStream:treeAdaptor 2538 description:@"rule expr"] retain]; 2539 // /Users/acondit/source/antlr/code/antlr3/runtime/ObjC/Framework/examples/simplecTreeParser/SimpleC.g:71:5: ( K_ID K_EQ expr -> ^( K_EQ K_ID expr ) ) // ruleBlockSingleAlt 2540 // /Users/acondit/source/antlr/code/antlr3/runtime/ObjC/Framework/examples/simplecTreeParser/SimpleC.g:71:9: K_ID K_EQ expr // alt 2541 { 2542 2543 K_ID38=(CommonToken *)[self match:input TokenType:K_ID Follow:FOLLOW_K_ID_in_assignStat570]; 2544 [stream_K_ID addElement:K_ID38]; 2545 2546 2547 K_EQ39=(CommonToken *)[self match:input TokenType:K_EQ Follow:FOLLOW_K_EQ_in_assignStat572]; 2548 [stream_K_EQ addElement:K_EQ39]; 2549 2550 2551 /* ruleRef */ 2552 [self pushFollow:FOLLOW_expr_in_assignStat574]; 2553 expr40 = [self expr]; 2554 2555 [self popFollow]; 2556 2557 2558 [stream_expr addElement:[expr40 getTree]]; 2559 2560 // AST REWRITE 2561 // elements: expr, K_ID, K_EQ 2562 // token labels: 2563 // rule labels: retval 2564 // token list labels: 2565 // rule list labels: 2566 // wildcard labels: 2567 retval.tree = root_0; 2568 2569 RewriteRuleSubtreeStream *stream_retval = 2570 [[RewriteRuleSubtreeStream newRewriteRuleSubtreeStream:treeAdaptor 2571 description:@"token retval" element:retval!=nil?[retval getTree]:nil] retain]; 2572 2573 root_0 = (CommonTree *)[[[treeAdaptor class] newEmptyTree] retain]; 2574 2575 // 71:24: -> ^( K_EQ K_ID expr ) 2576 { 2577 // /Users/acondit/source/antlr/code/antlr3/runtime/ObjC/Framework/examples/simplecTreeParser/SimpleC.g:71:27: ^( K_EQ K_ID expr ) 2578 { 2579 CommonTree *root_1 = (CommonTree *)[[[treeAdaptor class] newEmptyTree] retain]; 2580 root_1 = (CommonTree *)[treeAdaptor becomeRoot: 2581 [stream_K_EQ nextNode] 2582 old:root_1]; 2583 2584 // TODO: args: 2585 [treeAdaptor addChild: 2586 [stream_K_ID nextNode] 2587 toTree:root_1]; 2588 2589 [treeAdaptor addChild:[stream_expr nextTree] toTree:root_1]; 2590 2591 [treeAdaptor addChild:root_1 toTree:root_0]; 2592 } 2593 2594 } 2595 2596 2597 retval.tree = root_0; 2598 2599 2600 } 2601 2602 /* ASTParser ruleCleanUp */ 2603 /* AST ruleCleanUp */ 2604 /* token+rule list labels */ 2605 [retval setStop:[input LT:-1]]; 2606 2607 2608 [stream_K_ID release]; 2609 [stream_K_EQ release]; 2610 [stream_expr release]; 2611 2612 retval.tree = (CommonTree *)[treeAdaptor rulePostProcessing:root_0]; 2613 [treeAdaptor setTokenBoundaries:retval.tree From:retval.start To:retval.stopToken]; 2614 2615 } 2616 @catch (RecognitionException *re) { 2617 [self reportError:re]; 2618 [self recover:input Exception:re]; 2619 /* ASTParser rule.setErrorReturnValue */ 2620 retval.tree = (CommonTree *)[treeAdaptor errorNode:input From:retval.start To:[input LT:-1] Exception:re]; 2621 2622 } 2623 2624 @finally { 2625 /* ruleScopeCleanUp */ 2626 2627 } 2628 return retval; 2629} 2630/* $ANTLR end assignStat */ 2631 2632/* 2633 * $ANTLR start expr 2634 * /Users/acondit/source/antlr/code/antlr3/runtime/ObjC/Framework/examples/simplecTreeParser/SimpleC.g:74:1: expr : condExpr ; 2635 */ 2636- (SimpleCParser_expr_return *) expr 2637{ 2638 /* ruleScopeSetUp */ 2639 2640 /* AST ruleDeclarations */ 2641 /* ruleDeclarations */ 2642 SimpleCParser_expr_return * retval = [SimpleCParser_expr_return newSimpleCParser_expr_return]; 2643 [retval setStart:[input LT:1]]; 2644 2645 2646 CommonTree *root_0 = nil; 2647 2648 @try { 2649 /* AST ruleLabelDefs */ 2650 /* ruleLabelDefs entry */ 2651 SimpleCParser_condExpr_return * condExpr41 = nil ; 2652 2653 2654 2655 // /Users/acondit/source/antlr/code/antlr3/runtime/ObjC/Framework/examples/simplecTreeParser/SimpleC.g:74:5: ( condExpr ) // ruleBlockSingleAlt 2656 // /Users/acondit/source/antlr/code/antlr3/runtime/ObjC/Framework/examples/simplecTreeParser/SimpleC.g:74:9: condExpr // alt 2657 { 2658 root_0 = (CommonTree *)[[[treeAdaptor class] newEmptyTree] retain]; 2659 2660 2661 2662 /* ASTParser ruleRef */ 2663 /* ruleRef */ 2664 [self pushFollow:FOLLOW_condExpr_in_expr598]; 2665 condExpr41 = [self condExpr]; 2666 2667 [self popFollow]; 2668 2669 2670 [treeAdaptor addChild:[condExpr41 getTree] toTree:root_0]; 2671 2672 } 2673 2674 /* ASTParser ruleCleanUp */ 2675 /* AST ruleCleanUp */ 2676 /* token+rule list labels */ 2677 [retval setStop:[input LT:-1]]; 2678 2679 2680 2681 retval.tree = (CommonTree *)[treeAdaptor rulePostProcessing:root_0]; 2682 [treeAdaptor setTokenBoundaries:retval.tree From:retval.start To:retval.stopToken]; 2683 2684 } 2685 @catch (RecognitionException *re) { 2686 [self reportError:re]; 2687 [self recover:input Exception:re]; 2688 /* ASTParser rule.setErrorReturnValue */ 2689 retval.tree = (CommonTree *)[treeAdaptor errorNode:input From:retval.start To:[input LT:-1] Exception:re]; 2690 2691 } 2692 2693 @finally { 2694 /* ruleScopeCleanUp */ 2695 2696 } 2697 return retval; 2698} 2699/* $ANTLR end expr */ 2700 2701/* 2702 * $ANTLR start condExpr 2703 * /Users/acondit/source/antlr/code/antlr3/runtime/ObjC/Framework/examples/simplecTreeParser/SimpleC.g:77:1: condExpr : aexpr ( ( K_EQEQ ^| K_LT ^) aexpr )? ; 2704 */ 2705- (SimpleCParser_condExpr_return *) condExpr 2706{ 2707 /* ruleScopeSetUp */ 2708 2709 /* AST ruleDeclarations */ 2710 /* ruleDeclarations */ 2711 SimpleCParser_condExpr_return * retval = [SimpleCParser_condExpr_return newSimpleCParser_condExpr_return]; 2712 [retval setStart:[input LT:1]]; 2713 2714 2715 CommonTree *root_0 = nil; 2716 2717 @try { 2718 /* AST ruleLabelDefs */ 2719 /* ruleLabelDefs entry */ 2720 CommonToken *K_EQEQ43 = nil; 2721 CommonToken *K_LT44 = nil;SimpleCParser_aexpr_return * aexpr42 = nil ; 2722 2723 SimpleCParser_aexpr_return * aexpr45 = nil ; 2724 2725 2726 CommonTree *K_EQEQ43_tree=nil; 2727 CommonTree *K_LT44_tree=nil; 2728 2729 // /Users/acondit/source/antlr/code/antlr3/runtime/ObjC/Framework/examples/simplecTreeParser/SimpleC.g:78:5: ( aexpr ( ( K_EQEQ ^| K_LT ^) aexpr )? ) // ruleBlockSingleAlt 2730 // /Users/acondit/source/antlr/code/antlr3/runtime/ObjC/Framework/examples/simplecTreeParser/SimpleC.g:78:9: aexpr ( ( K_EQEQ ^| K_LT ^) aexpr )? // alt 2731 { 2732 root_0 = (CommonTree *)[[[treeAdaptor class] newEmptyTree] retain]; 2733 2734 2735 2736 /* ASTParser ruleRef */ 2737 /* ruleRef */ 2738 [self pushFollow:FOLLOW_aexpr_in_condExpr617]; 2739 aexpr42 = [self aexpr]; 2740 2741 [self popFollow]; 2742 2743 2744 [treeAdaptor addChild:[aexpr42 getTree] toTree:root_0]; 2745 2746 // /Users/acondit/source/antlr/code/antlr3/runtime/ObjC/Framework/examples/simplecTreeParser/SimpleC.g:78:15: ( ( K_EQEQ ^| K_LT ^) aexpr )? // block 2747 NSInteger alt9=2; 2748 NSInteger LA9_0 = [input LA:1]; 2749 2750 if ( (LA9_0==K_EQEQ||LA9_0==K_LT) ) { 2751 alt9=1; 2752 } 2753 switch (alt9) { 2754 case 1 : ; 2755 // /Users/acondit/source/antlr/code/antlr3/runtime/ObjC/Framework/examples/simplecTreeParser/SimpleC.g:78:17: ( K_EQEQ ^| K_LT ^) aexpr // alt 2756 { 2757 2758 // /Users/acondit/source/antlr/code/antlr3/runtime/ObjC/Framework/examples/simplecTreeParser/SimpleC.g:78:17: ( K_EQEQ ^| K_LT ^) // block 2759 NSInteger alt8=2; 2760 NSInteger LA8_0 = [input LA:1]; 2761 2762 if ( (LA8_0==K_EQEQ) ) { 2763 alt8=1; 2764 } 2765 else if ( (LA8_0==K_LT) ) { 2766 alt8=2; 2767 } 2768 else { 2769 NoViableAltException *nvae = [NoViableAltException newException:8 state:0 stream:input]; 2770 nvae.c = LA8_0; 2771 @throw nvae; 2772 2773 } 2774 switch (alt8) { 2775 case 1 : ; 2776 // /Users/acondit/source/antlr/code/antlr3/runtime/ObjC/Framework/examples/simplecTreeParser/SimpleC.g:78:18: K_EQEQ ^ // alt 2777 { 2778 2779 K_EQEQ43=(CommonToken *)[self match:input TokenType:K_EQEQ Follow:FOLLOW_K_EQEQ_in_condExpr622]; 2780 K_EQEQ43_tree = /* ASTParser createNodeFromToken */ 2781 (CommonTree *)[[treeAdaptor create:K_EQEQ43] retain] 2782 ; 2783 root_0 = (CommonTree *)[treeAdaptor becomeRoot:K_EQEQ43_tree old:root_0]; 2784 2785 2786 } 2787 break; 2788 case 2 : ; 2789 // /Users/acondit/source/antlr/code/antlr3/runtime/ObjC/Framework/examples/simplecTreeParser/SimpleC.g:78:28: K_LT ^ // alt 2790 { 2791 2792 K_LT44=(CommonToken *)[self match:input TokenType:K_LT Follow:FOLLOW_K_LT_in_condExpr627]; 2793 K_LT44_tree = /* ASTParser createNodeFromToken */ 2794 (CommonTree *)[[treeAdaptor create:K_LT44] retain] 2795 ; 2796 root_0 = (CommonTree *)[treeAdaptor becomeRoot:K_LT44_tree old:root_0]; 2797 2798 2799 } 2800 break; 2801 2802 } 2803 2804 2805 /* ASTParser ruleRef */ 2806 /* ruleRef */ 2807 [self pushFollow:FOLLOW_aexpr_in_condExpr631]; 2808 aexpr45 = [self aexpr]; 2809 2810 [self popFollow]; 2811 2812 2813 [treeAdaptor addChild:[aexpr45 getTree] toTree:root_0]; 2814 2815 } 2816 break; 2817 2818 } 2819 2820 2821 } 2822 2823 /* ASTParser ruleCleanUp */ 2824 /* AST ruleCleanUp */ 2825 /* token+rule list labels */ 2826 [retval setStop:[input LT:-1]]; 2827 2828 2829 2830 retval.tree = (CommonTree *)[treeAdaptor rulePostProcessing:root_0]; 2831 [treeAdaptor setTokenBoundaries:retval.tree From:retval.start To:retval.stopToken]; 2832 2833 } 2834 @catch (RecognitionException *re) { 2835 [self reportError:re]; 2836 [self recover:input Exception:re]; 2837 /* ASTParser rule.setErrorReturnValue */ 2838 retval.tree = (CommonTree *)[treeAdaptor errorNode:input From:retval.start To:[input LT:-1] Exception:re]; 2839 2840 } 2841 2842 @finally { 2843 /* ruleScopeCleanUp */ 2844 2845 } 2846 return retval; 2847} 2848/* $ANTLR end condExpr */ 2849 2850/* 2851 * $ANTLR start aexpr 2852 * /Users/acondit/source/antlr/code/antlr3/runtime/ObjC/Framework/examples/simplecTreeParser/SimpleC.g:81:1: aexpr : atom ( K_PLUS ^ atom )* ; 2853 */ 2854- (SimpleCParser_aexpr_return *) aexpr 2855{ 2856 /* ruleScopeSetUp */ 2857 2858 /* AST ruleDeclarations */ 2859 /* ruleDeclarations */ 2860 SimpleCParser_aexpr_return * retval = [SimpleCParser_aexpr_return newSimpleCParser_aexpr_return]; 2861 [retval setStart:[input LT:1]]; 2862 2863 2864 CommonTree *root_0 = nil; 2865 2866 @try { 2867 /* AST ruleLabelDefs */ 2868 /* ruleLabelDefs entry */ 2869 CommonToken *K_PLUS47 = nil;SimpleCParser_atom_return * atom46 = nil ; 2870 2871 SimpleCParser_atom_return * atom48 = nil ; 2872 2873 2874 CommonTree *K_PLUS47_tree=nil; 2875 2876 // /Users/acondit/source/antlr/code/antlr3/runtime/ObjC/Framework/examples/simplecTreeParser/SimpleC.g:82:5: ( atom ( K_PLUS ^ atom )* ) // ruleBlockSingleAlt 2877 // /Users/acondit/source/antlr/code/antlr3/runtime/ObjC/Framework/examples/simplecTreeParser/SimpleC.g:82:9: atom ( K_PLUS ^ atom )* // alt 2878 { 2879 root_0 = (CommonTree *)[[[treeAdaptor class] newEmptyTree] retain]; 2880 2881 2882 2883 /* ASTParser ruleRef */ 2884 /* ruleRef */ 2885 [self pushFollow:FOLLOW_atom_in_aexpr653]; 2886 atom46 = [self atom]; 2887 2888 [self popFollow]; 2889 2890 2891 [treeAdaptor addChild:[atom46 getTree] toTree:root_0]; 2892 2893 2894 do { 2895 NSInteger alt10=2; 2896 NSInteger LA10_0 = [input LA:1]; 2897 if ( (LA10_0==K_PLUS) ) { 2898 alt10=1; 2899 } 2900 2901 2902 switch (alt10) { 2903 case 1 : ; 2904 // /Users/acondit/source/antlr/code/antlr3/runtime/ObjC/Framework/examples/simplecTreeParser/SimpleC.g:82:16: K_PLUS ^ atom // alt 2905 { 2906 2907 K_PLUS47=(CommonToken *)[self match:input TokenType:K_PLUS Follow:FOLLOW_K_PLUS_in_aexpr657]; 2908 K_PLUS47_tree = /* ASTParser createNodeFromToken */ 2909 (CommonTree *)[[treeAdaptor create:K_PLUS47] retain] 2910 ; 2911 root_0 = (CommonTree *)[treeAdaptor becomeRoot:K_PLUS47_tree old:root_0]; 2912 2913 2914 /* ASTParser ruleRef */ 2915 /* ruleRef */ 2916 [self pushFollow:FOLLOW_atom_in_aexpr660]; 2917 atom48 = [self atom]; 2918 2919 [self popFollow]; 2920 2921 2922 [treeAdaptor addChild:[atom48 getTree] toTree:root_0]; 2923 2924 } 2925 break; 2926 2927 default : 2928 goto loop10; 2929 } 2930 } while (YES); 2931 loop10: ; 2932 2933 2934 } 2935 2936 /* ASTParser ruleCleanUp */ 2937 /* AST ruleCleanUp */ 2938 /* token+rule list labels */ 2939 [retval setStop:[input LT:-1]]; 2940 2941 2942 2943 retval.tree = (CommonTree *)[treeAdaptor rulePostProcessing:root_0]; 2944 [treeAdaptor setTokenBoundaries:retval.tree From:retval.start To:retval.stopToken]; 2945 2946 } 2947 @catch (RecognitionException *re) { 2948 [self reportError:re]; 2949 [self recover:input Exception:re]; 2950 /* ASTParser rule.setErrorReturnValue */ 2951 retval.tree = (CommonTree *)[treeAdaptor errorNode:input From:retval.start To:[input LT:-1] Exception:re]; 2952 2953 } 2954 2955 @finally { 2956 /* ruleScopeCleanUp */ 2957 2958 } 2959 return retval; 2960} 2961/* $ANTLR end aexpr */ 2962 2963/* 2964 * $ANTLR start atom 2965 * /Users/acondit/source/antlr/code/antlr3/runtime/ObjC/Framework/examples/simplecTreeParser/SimpleC.g:85:1: atom : ( K_ID | K_INT | K_LCURVE expr K_RCURVE -> expr ); 2966 */ 2967- (SimpleCParser_atom_return *) atom 2968{ 2969 /* ruleScopeSetUp */ 2970 2971 /* AST ruleDeclarations */ 2972 /* ruleDeclarations */ 2973 SimpleCParser_atom_return * retval = [SimpleCParser_atom_return newSimpleCParser_atom_return]; 2974 [retval setStart:[input LT:1]]; 2975 2976 2977 CommonTree *root_0 = nil; 2978 2979 @try { 2980 /* AST ruleLabelDefs */ 2981 /* ruleLabelDefs entry */ 2982 CommonToken *K_ID49 = nil; 2983 CommonToken *K_INT50 = nil; 2984 CommonToken *K_LCURVE51 = nil; 2985 CommonToken *K_RCURVE53 = nil;SimpleCParser_expr_return * expr52 = nil ; 2986 2987 2988 CommonTree *K_ID49_tree=nil; 2989 CommonTree *K_INT50_tree=nil; 2990 CommonTree *K_LCURVE51_tree=nil; 2991 CommonTree *K_RCURVE53_tree=nil; 2992 RewriteRuleTokenStream *stream_K_LCURVE = 2993 [[RewriteRuleTokenStream newRewriteRuleTokenStream:treeAdaptor 2994 description:@"token K_LCURVE"] retain]; 2995 RewriteRuleTokenStream *stream_K_RCURVE = 2996 [[RewriteRuleTokenStream newRewriteRuleTokenStream:treeAdaptor 2997 description:@"token K_RCURVE"] retain]; 2998 RewriteRuleSubtreeStream *stream_expr = 2999 [[RewriteRuleSubtreeStream newRewriteRuleSubtreeStream:treeAdaptor 3000 description:@"rule expr"] retain]; 3001 // /Users/acondit/source/antlr/code/antlr3/runtime/ObjC/Framework/examples/simplecTreeParser/SimpleC.g:86:5: ( K_ID | K_INT | K_LCURVE expr K_RCURVE -> expr ) //ruleblock 3002 NSInteger alt11=3; 3003 unichar charLA11 = [input LA:1]; 3004 switch (charLA11) { 3005 case K_ID: ; 3006 { 3007 alt11=1; 3008 } 3009 break; 3010 case K_INT: ; 3011 { 3012 alt11=2; 3013 } 3014 break; 3015 case K_LCURVE: ; 3016 { 3017 alt11=3; 3018 } 3019 break; 3020 3021 default: ; 3022 NoViableAltException *nvae = [NoViableAltException newException:11 state:0 stream:input]; 3023 nvae.c = charLA11; 3024 @throw nvae; 3025 3026 } 3027 3028 switch (alt11) { 3029 case 1 : ; 3030 // /Users/acondit/source/antlr/code/antlr3/runtime/ObjC/Framework/examples/simplecTreeParser/SimpleC.g:86:7: K_ID // alt 3031 { 3032 root_0 = (CommonTree *)[[[treeAdaptor class] newEmptyTree] retain]; 3033 3034 3035 3036 /* ASTParser tokenRef */ 3037 K_ID49=(CommonToken *)[self match:input TokenType:K_ID Follow:FOLLOW_K_ID_in_atom680]; 3038 K_ID49_tree = /* ASTParser createNodeFromToken */ 3039 (CommonTree *)[[treeAdaptor create:K_ID49] retain] 3040 ; 3041 [treeAdaptor addChild:K_ID49_tree toTree:root_0]; 3042 3043 3044 } 3045 break; 3046 case 2 : ; 3047 // /Users/acondit/source/antlr/code/antlr3/runtime/ObjC/Framework/examples/simplecTreeParser/SimpleC.g:87:7: K_INT // alt 3048 { 3049 root_0 = (CommonTree *)[[[treeAdaptor class] newEmptyTree] retain]; 3050 3051 3052 3053 /* ASTParser tokenRef */ 3054 K_INT50=(CommonToken *)[self match:input TokenType:K_INT Follow:FOLLOW_K_INT_in_atom694]; 3055 K_INT50_tree = /* ASTParser createNodeFromToken */ 3056 (CommonTree *)[[treeAdaptor create:K_INT50] retain] 3057 ; 3058 [treeAdaptor addChild:K_INT50_tree toTree:root_0]; 3059 3060 3061 } 3062 break; 3063 case 3 : ; 3064 // /Users/acondit/source/antlr/code/antlr3/runtime/ObjC/Framework/examples/simplecTreeParser/SimpleC.g:88:7: K_LCURVE expr K_RCURVE // alt 3065 { 3066 3067 K_LCURVE51=(CommonToken *)[self match:input TokenType:K_LCURVE Follow:FOLLOW_K_LCURVE_in_atom708]; 3068 [stream_K_LCURVE addElement:K_LCURVE51]; 3069 3070 3071 /* ruleRef */ 3072 [self pushFollow:FOLLOW_expr_in_atom710]; 3073 expr52 = [self expr]; 3074 3075 [self popFollow]; 3076 3077 3078 [stream_expr addElement:[expr52 getTree]]; 3079 3080 K_RCURVE53=(CommonToken *)[self match:input TokenType:K_RCURVE Follow:FOLLOW_K_RCURVE_in_atom712]; 3081 [stream_K_RCURVE addElement:K_RCURVE53]; 3082 3083 3084 // AST REWRITE 3085 // elements: expr 3086 // token labels: 3087 // rule labels: retval 3088 // token list labels: 3089 // rule list labels: 3090 // wildcard labels: 3091 retval.tree = root_0; 3092 3093 RewriteRuleSubtreeStream *stream_retval = 3094 [[RewriteRuleSubtreeStream newRewriteRuleSubtreeStream:treeAdaptor 3095 description:@"token retval" element:retval!=nil?[retval getTree]:nil] retain]; 3096 3097 root_0 = (CommonTree *)[[[treeAdaptor class] newEmptyTree] retain]; 3098 3099 // 88:30: -> expr 3100 { 3101 [treeAdaptor addChild:[stream_expr nextTree] toTree:root_0]; 3102 3103 } 3104 3105 3106 retval.tree = root_0; 3107 3108 3109 } 3110 break; 3111 3112 } 3113 /* ASTParser ruleCleanUp */ 3114 /* AST ruleCleanUp */ 3115 /* token+rule list labels */ 3116 [retval setStop:[input LT:-1]]; 3117 3118 3119 [stream_K_LCURVE release]; 3120 [stream_K_RCURVE release]; 3121 [stream_expr release]; 3122 3123 retval.tree = (CommonTree *)[treeAdaptor rulePostProcessing:root_0]; 3124 [treeAdaptor setTokenBoundaries:retval.tree From:retval.start To:retval.stopToken]; 3125 3126 } 3127 @catch (RecognitionException *re) { 3128 [self reportError:re]; 3129 [self recover:input Exception:re]; 3130 /* ASTParser rule.setErrorReturnValue */ 3131 retval.tree = (CommonTree *)[treeAdaptor errorNode:input From:retval.start To:[input LT:-1] Exception:re]; 3132 3133 } 3134 3135 @finally { 3136 /* ruleScopeCleanUp */ 3137 3138 } 3139 return retval; 3140} 3141/* $ANTLR end atom */ 3142/* ObjC end rules */ 3143 3144@end /* end of SimpleCParser implementation line 692 */ 3145