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