1/** \file 2 * This OBJC source file was generated by $ANTLR version ${project.version} ${buildNumber} 3 * 4 * - From the grammar source file : SimpleC.g 5 * - On : 2011-05-06 15:09:17 6 * - for the lexer : SimpleCLexerLexer 7 * 8 * Editing it, at least manually, is not wise. 9 * 10 * ObjC language generator and runtime by Alan Condit, acondit|hereisanat|ipns|dotgoeshere|com. 11 * 12 * 13*/ 14// $ANTLR ${project.version} ${buildNumber} SimpleC.g 2011-05-06 15:09:17 15 16 17/* ----------------------------------------- 18 * Include the ANTLR3 generated header file. 19 */ 20#import "SimpleCLexer.h" 21/* ----------------------------------------- */ 22 23 24/* ============================================================================= */ 25/* ============================================================================= 26 * Start of recognizer 27 */ 28 29/** As per Terence: No returns for lexer rules! */ 30@implementation SimpleCLexer // line 330 31 32+ (void) initialize 33{ 34 [ANTLRBaseRecognizer setGrammarFileName:@"SimpleC.g"]; 35} 36 37+ (NSString *) tokenNameForType:(NSInteger)aTokenType 38{ 39 return [[self getTokenNames] objectAtIndex:aTokenType]; 40} 41 42+ (SimpleCLexer *)newSimpleCLexerWithCharStream:(id<ANTLRCharStream>)anInput 43{ 44 return [[SimpleCLexer alloc] initWithCharStream:anInput]; 45} 46 47- (id) initWithCharStream:(id<ANTLRCharStream>)anInput 48{ 49 self = [super initWithCharStream:anInput State:[[ANTLRRecognizerSharedState newANTLRRecognizerSharedStateWithRuleLen:18+1] retain]]; 50 if ( self != nil ) { 51 } 52 return self; 53} 54 55- (void) dealloc 56{ 57 [super dealloc]; 58} 59 60/* ObjC Start of actions.lexer.methods */ 61/* ObjC end of actions.lexer.methods */ 62/* ObjC start methods() */ 63/* ObjC end methods() */ 64 65/* Start of Rules */ 66// $ANTLR start "K_FOR" 67- (void) mK_FOR 68{ 69 // 70 /* my ruleScopeSetUp */ 71 /* Terence's stuff */ 72 73 @try { 74 NSInteger _type = K_FOR; 75 NSInteger _channel = ANTLRTokenChannelDefault; 76 // SimpleC.g:91:7: ( 'for' ) // ruleBlockSingleAlt 77 // SimpleC.g:91:9: 'for' // alt 78 { 79 [self matchString:@"for"]; 80 81 82 83 } 84 85 // token+rule list labels 86 87 state.type = _type; 88 state.channel = _channel; 89 } 90 @finally { 91 // 92 /* Terence's stuff */ 93 94 } 95 return; 96} 97/* $ANTLR end "K_FOR" */ 98 99// $ANTLR start "K_CHAR" 100- (void) mK_CHAR 101{ 102 // 103 /* my ruleScopeSetUp */ 104 /* Terence's stuff */ 105 106 @try { 107 NSInteger _type = K_CHAR; 108 NSInteger _channel = ANTLRTokenChannelDefault; 109 // SimpleC.g:92:7: ( 'char' ) // ruleBlockSingleAlt 110 // SimpleC.g:92:9: 'char' // alt 111 { 112 [self matchString:@"char"]; 113 114 115 116 } 117 118 // token+rule list labels 119 120 state.type = _type; 121 state.channel = _channel; 122 } 123 @finally { 124 // 125 /* Terence's stuff */ 126 127 } 128 return; 129} 130/* $ANTLR end "K_CHAR" */ 131 132// $ANTLR start "K_INT_TYPE" 133- (void) mK_INT_TYPE 134{ 135 // 136 /* my ruleScopeSetUp */ 137 /* Terence's stuff */ 138 139 @try { 140 NSInteger _type = K_INT_TYPE; 141 NSInteger _channel = ANTLRTokenChannelDefault; 142 // SimpleC.g:93:12: ( 'int' ) // ruleBlockSingleAlt 143 // SimpleC.g:93:14: 'int' // alt 144 { 145 [self matchString:@"int"]; 146 147 148 149 } 150 151 // token+rule list labels 152 153 state.type = _type; 154 state.channel = _channel; 155 } 156 @finally { 157 // 158 /* Terence's stuff */ 159 160 } 161 return; 162} 163/* $ANTLR end "K_INT_TYPE" */ 164 165// $ANTLR start "K_VOID" 166- (void) mK_VOID 167{ 168 // 169 /* my ruleScopeSetUp */ 170 /* Terence's stuff */ 171 172 @try { 173 NSInteger _type = K_VOID; 174 NSInteger _channel = ANTLRTokenChannelDefault; 175 // SimpleC.g:94:7: ( 'void' ) // ruleBlockSingleAlt 176 // SimpleC.g:94:9: 'void' // alt 177 { 178 [self matchString:@"void"]; 179 180 181 182 } 183 184 // token+rule list labels 185 186 state.type = _type; 187 state.channel = _channel; 188 } 189 @finally { 190 // 191 /* Terence's stuff */ 192 193 } 194 return; 195} 196/* $ANTLR end "K_VOID" */ 197 198// $ANTLR start "K_ID" 199- (void) mK_ID 200{ 201 // 202 /* my ruleScopeSetUp */ 203 /* Terence's stuff */ 204 205 @try { 206 NSInteger _type = K_ID; 207 NSInteger _channel = ANTLRTokenChannelDefault; 208 // SimpleC.g:96:7: ( ( 'a' .. 'z' | 'A' .. 'Z' | '_' ) ( 'a' .. 'z' | 'A' .. 'Z' | '0' .. '9' | '_' )* ) // ruleBlockSingleAlt 209 // SimpleC.g:96:11: ( 'a' .. 'z' | 'A' .. 'Z' | '_' ) ( 'a' .. 'z' | 'A' .. 'Z' | '0' .. '9' | '_' )* // alt 210 { 211 if ((([input LA:1] >= 'A') && ([input LA:1] <= 'Z'))||[input LA:1] == '_'||(([input LA:1] >= 'a') && ([input LA:1] <= 'z'))) { 212 [input consume]; 213 } else { 214 ANTLRMismatchedSetException *mse = [ANTLRMismatchedSetException newException:nil stream:input]; 215 [self recover:mse]; 216 @throw mse; 217 } 218 219 220 do { 221 NSInteger alt1=2; 222 NSInteger LA1_0 = [input LA:1]; 223 if ( ((LA1_0 >= '0' && LA1_0 <= '9')||(LA1_0 >= 'A' && LA1_0 <= 'Z')||LA1_0=='_'||(LA1_0 >= 'a' && LA1_0 <= 'z')) ) { 224 alt1=1; 225 } 226 227 228 switch (alt1) { 229 case 1 : ; 230 // SimpleC.g: // alt 231 { 232 if ((([input LA:1] >= '0') && ([input LA:1] <= '9'))||(([input LA:1] >= 'A') && ([input LA:1] <= 'Z'))||[input LA:1] == '_'||(([input LA:1] >= 'a') && ([input LA:1] <= 'z'))) { 233 [input consume]; 234 } else { 235 ANTLRMismatchedSetException *mse = [ANTLRMismatchedSetException newException:nil stream:input]; 236 [self recover:mse]; 237 @throw mse; 238 } 239 240 241 } 242 break; 243 244 default : 245 goto loop1; 246 } 247 } while (YES); 248 loop1: ; 249 250 251 } 252 253 // token+rule list labels 254 255 state.type = _type; 256 state.channel = _channel; 257 } 258 @finally { 259 // 260 /* Terence's stuff */ 261 262 } 263 return; 264} 265/* $ANTLR end "K_ID" */ 266 267// $ANTLR start "K_INT" 268- (void) mK_INT 269{ 270 // 271 /* my ruleScopeSetUp */ 272 /* Terence's stuff */ 273 274 @try { 275 NSInteger _type = K_INT; 276 NSInteger _channel = ANTLRTokenChannelDefault; 277 ANTLRCommonToken *anInt=nil; 278 AMutableArray *list_anInt=nil; 279 // SimpleC.g:99:7: ( (anInt+= ( '0' .. '9' ) )+ ) // ruleBlockSingleAlt 280 // SimpleC.g:99:9: (anInt+= ( '0' .. '9' ) )+ // alt 281 { 282 // SimpleC.g:99:14: (anInt+= ( '0' .. '9' ) )+ // positiveClosureBlock 283 NSInteger cnt2 = 0; 284 do { 285 NSInteger alt2 = 2; 286 NSInteger LA2_0 = [input LA:1]; 287 if ( ((LA2_0 >= '0' && LA2_0 <= '9')) ) { 288 alt2=1; 289 } 290 291 292 switch (alt2) { 293 case 1 : ; 294 // SimpleC.g:99:14: anInt+= ( '0' .. '9' ) // alt 295 { 296 anInt = [input LA:1]; 297 298 if ((([input LA:1] >= '0') && ([input LA:1] <= '9'))) { 299 [input consume]; 300 } else { 301 ANTLRMismatchedSetException *mse = [ANTLRMismatchedSetException newException:nil stream:input]; 302 mse.c = anInt; 303 [self recover:mse]; 304 @throw mse; 305 } 306 307 308 } 309 break; 310 311 default : 312 if ( cnt2 >= 1 ) 313 goto loop2; 314 ANTLREarlyExitException *eee = 315 [ANTLREarlyExitException newException:input decisionNumber:2]; 316 @throw eee; 317 } 318 cnt2++; 319 } while (YES); 320 loop2: ; 321 322 323 NSLog(@"%@", list_anInt); 324 325 326 } 327 328 // token+rule list labels 329 [list_anInt release]; 330 331 state.type = _type; 332 state.channel = _channel; 333 } 334 @finally { 335 // 336 /* Terence's stuff */ 337 338 } 339 return; 340} 341/* $ANTLR end "K_INT" */ 342 343// $ANTLR start "K_LCURVE" 344- (void) mK_LCURVE 345{ 346 // 347 /* my ruleScopeSetUp */ 348 /* Terence's stuff */ 349 350 @try { 351 NSInteger _type = K_LCURVE; 352 NSInteger _channel = ANTLRTokenChannelDefault; 353 // SimpleC.g:102:10: ( '(' ) // ruleBlockSingleAlt 354 // SimpleC.g:102:12: '(' // alt 355 { 356 [self matchChar:'(']; 357 358 359 } 360 361 // token+rule list labels 362 363 state.type = _type; 364 state.channel = _channel; 365 } 366 @finally { 367 // 368 /* Terence's stuff */ 369 370 } 371 return; 372} 373/* $ANTLR end "K_LCURVE" */ 374 375// $ANTLR start "K_RCURVE" 376- (void) mK_RCURVE 377{ 378 // 379 /* my ruleScopeSetUp */ 380 /* Terence's stuff */ 381 382 @try { 383 NSInteger _type = K_RCURVE; 384 NSInteger _channel = ANTLRTokenChannelDefault; 385 // SimpleC.g:103:10: ( ')' ) // ruleBlockSingleAlt 386 // SimpleC.g:103:12: ')' // alt 387 { 388 [self matchChar:')']; 389 390 391 } 392 393 // token+rule list labels 394 395 state.type = _type; 396 state.channel = _channel; 397 } 398 @finally { 399 // 400 /* Terence's stuff */ 401 402 } 403 return; 404} 405/* $ANTLR end "K_RCURVE" */ 406 407// $ANTLR start "K_PLUS" 408- (void) mK_PLUS 409{ 410 // 411 /* my ruleScopeSetUp */ 412 /* Terence's stuff */ 413 414 @try { 415 NSInteger _type = K_PLUS; 416 NSInteger _channel = ANTLRTokenChannelDefault; 417 // SimpleC.g:104:8: ( '+' ) // ruleBlockSingleAlt 418 // SimpleC.g:104:10: '+' // alt 419 { 420 [self matchChar:'+']; 421 422 423 } 424 425 // token+rule list labels 426 427 state.type = _type; 428 state.channel = _channel; 429 } 430 @finally { 431 // 432 /* Terence's stuff */ 433 434 } 435 return; 436} 437/* $ANTLR end "K_PLUS" */ 438 439// $ANTLR start "K_COMMA" 440- (void) mK_COMMA 441{ 442 // 443 /* my ruleScopeSetUp */ 444 /* Terence's stuff */ 445 446 @try { 447 NSInteger _type = K_COMMA; 448 NSInteger _channel = ANTLRTokenChannelDefault; 449 // SimpleC.g:105:9: ( ',' ) // ruleBlockSingleAlt 450 // SimpleC.g:105:11: ',' // alt 451 { 452 [self matchChar:',']; 453 454 455 } 456 457 // token+rule list labels 458 459 state.type = _type; 460 state.channel = _channel; 461 } 462 @finally { 463 // 464 /* Terence's stuff */ 465 466 } 467 return; 468} 469/* $ANTLR end "K_COMMA" */ 470 471// $ANTLR start "K_SEMICOLON" 472- (void) mK_SEMICOLON 473{ 474 // 475 /* my ruleScopeSetUp */ 476 /* Terence's stuff */ 477 478 @try { 479 NSInteger _type = K_SEMICOLON; 480 NSInteger _channel = ANTLRTokenChannelDefault; 481 // SimpleC.g:106:13: ( ';' ) // ruleBlockSingleAlt 482 // SimpleC.g:106:15: ';' // alt 483 { 484 [self matchChar:';']; 485 486 487 } 488 489 // token+rule list labels 490 491 state.type = _type; 492 state.channel = _channel; 493 } 494 @finally { 495 // 496 /* Terence's stuff */ 497 498 } 499 return; 500} 501/* $ANTLR end "K_SEMICOLON" */ 502 503// $ANTLR start "K_LT" 504- (void) mK_LT 505{ 506 // 507 /* my ruleScopeSetUp */ 508 /* Terence's stuff */ 509 510 @try { 511 NSInteger _type = K_LT; 512 NSInteger _channel = ANTLRTokenChannelDefault; 513 // SimpleC.g:107:8: ( '<' ) // ruleBlockSingleAlt 514 // SimpleC.g:107:10: '<' // alt 515 { 516 [self matchChar:'<']; 517 518 519 } 520 521 // token+rule list labels 522 523 state.type = _type; 524 state.channel = _channel; 525 } 526 @finally { 527 // 528 /* Terence's stuff */ 529 530 } 531 return; 532} 533/* $ANTLR end "K_LT" */ 534 535// $ANTLR start "K_EQ" 536- (void) mK_EQ 537{ 538 // 539 /* my ruleScopeSetUp */ 540 /* Terence's stuff */ 541 542 @try { 543 NSInteger _type = K_EQ; 544 NSInteger _channel = ANTLRTokenChannelDefault; 545 // SimpleC.g:108:8: ( '=' ) // ruleBlockSingleAlt 546 // SimpleC.g:108:10: '=' // alt 547 { 548 [self matchChar:'=']; 549 550 551 } 552 553 // token+rule list labels 554 555 state.type = _type; 556 state.channel = _channel; 557 } 558 @finally { 559 // 560 /* Terence's stuff */ 561 562 } 563 return; 564} 565/* $ANTLR end "K_EQ" */ 566 567// $ANTLR start "K_EQEQ" 568- (void) mK_EQEQ 569{ 570 // 571 /* my ruleScopeSetUp */ 572 /* Terence's stuff */ 573 574 @try { 575 NSInteger _type = K_EQEQ; 576 NSInteger _channel = ANTLRTokenChannelDefault; 577 // SimpleC.g:109:8: ( '==' ) // ruleBlockSingleAlt 578 // SimpleC.g:109:10: '==' // alt 579 { 580 [self matchString:@"=="]; 581 582 583 584 } 585 586 // token+rule list labels 587 588 state.type = _type; 589 state.channel = _channel; 590 } 591 @finally { 592 // 593 /* Terence's stuff */ 594 595 } 596 return; 597} 598/* $ANTLR end "K_EQEQ" */ 599 600// $ANTLR start "K_LCURLY" 601- (void) mK_LCURLY 602{ 603 // 604 /* my ruleScopeSetUp */ 605 /* Terence's stuff */ 606 607 @try { 608 NSInteger _type = K_LCURLY; 609 NSInteger _channel = ANTLRTokenChannelDefault; 610 // SimpleC.g:110:10: ( '{' ) // ruleBlockSingleAlt 611 // SimpleC.g:110:12: '{' // alt 612 { 613 [self matchChar:'{']; 614 615 616 } 617 618 // token+rule list labels 619 620 state.type = _type; 621 state.channel = _channel; 622 } 623 @finally { 624 // 625 /* Terence's stuff */ 626 627 } 628 return; 629} 630/* $ANTLR end "K_LCURLY" */ 631 632// $ANTLR start "K_RCURLY" 633- (void) mK_RCURLY 634{ 635 // 636 /* my ruleScopeSetUp */ 637 /* Terence's stuff */ 638 639 @try { 640 NSInteger _type = K_RCURLY; 641 NSInteger _channel = ANTLRTokenChannelDefault; 642 // SimpleC.g:111:10: ( '}' ) // ruleBlockSingleAlt 643 // SimpleC.g:111:12: '}' // alt 644 { 645 [self matchChar:'}']; 646 647 648 } 649 650 // token+rule list labels 651 652 state.type = _type; 653 state.channel = _channel; 654 } 655 @finally { 656 // 657 /* Terence's stuff */ 658 659 } 660 return; 661} 662/* $ANTLR end "K_RCURLY" */ 663 664// $ANTLR start "WS" 665- (void) mWS 666{ 667 // 668 /* my ruleScopeSetUp */ 669 /* Terence's stuff */ 670 671 @try { 672 NSInteger _type = WS; 673 NSInteger _channel = ANTLRTokenChannelDefault; 674 // SimpleC.g:113:5: ( ( ' ' | '\\t' | '\\r' | '\\n' )+ ) // ruleBlockSingleAlt 675 // SimpleC.g:113:9: ( ' ' | '\\t' | '\\r' | '\\n' )+ // alt 676 { 677 // SimpleC.g:113:9: ( ' ' | '\\t' | '\\r' | '\\n' )+ // positiveClosureBlock 678 NSInteger cnt3 = 0; 679 do { 680 NSInteger alt3 = 2; 681 NSInteger LA3_0 = [input LA:1]; 682 if ( ((LA3_0 >= '\t' && LA3_0 <= '\n')||LA3_0=='\r'||LA3_0==' ') ) { 683 alt3=1; 684 } 685 686 687 switch (alt3) { 688 case 1 : ; 689 // SimpleC.g: // alt 690 { 691 if ((([input LA:1] >= '\t') && ([input LA:1] <= '\n'))||[input LA:1] == '\r'||[input LA:1] == ' ') { 692 [input consume]; 693 } else { 694 ANTLRMismatchedSetException *mse = [ANTLRMismatchedSetException newException:nil stream:input]; 695 [self recover:mse]; 696 @throw mse; 697 } 698 699 700 } 701 break; 702 703 default : 704 if ( cnt3 >= 1 ) 705 goto loop3; 706 ANTLREarlyExitException *eee = 707 [ANTLREarlyExitException newException:input decisionNumber:3]; 708 @throw eee; 709 } 710 cnt3++; 711 } while (YES); 712 loop3: ; 713 714 715 _channel=HIDDEN; 716 717 718 } 719 720 // token+rule list labels 721 722 state.type = _type; 723 state.channel = _channel; 724 } 725 @finally { 726 // 727 /* Terence's stuff */ 728 729 } 730 return; 731} 732/* $ANTLR end "WS" */ 733 734- (void) mTokens 735{ 736 // SimpleC.g:1:8: ( K_FOR | K_CHAR | K_INT_TYPE | K_VOID | K_ID | K_INT | K_LCURVE | K_RCURVE | K_PLUS | K_COMMA | K_SEMICOLON | K_LT | K_EQ | K_EQEQ | K_LCURLY | K_RCURLY | WS ) //ruleblock 737 NSInteger alt4=17; 738 unichar charLA4 = [input LA:1]; 739 switch (charLA4) { 740 case 'f': ; 741 { 742 NSInteger LA4_1 = [input LA:2]; 743 744 if ( (LA4_1=='o') ) { 745 NSInteger LA4_17 = [input LA:3]; 746 747 if ( (LA4_17=='r') ) { 748 NSInteger LA4_23 = [input LA:4]; 749 750 if ( ((LA4_23 >= '0' && LA4_23 <= '9')||(LA4_23 >= 'A' && LA4_23 <= 'Z')||LA4_23=='_'||(LA4_23 >= 'a' && LA4_23 <= 'z')) ) { 751 alt4=5; 752 } 753 else { 754 alt4 = 1; 755 } 756 } 757 else { 758 alt4 = 5; 759 } 760 } 761 else { 762 alt4 = 5; 763 } 764 } 765 break; 766 case 'c': ; 767 { 768 NSInteger LA4_2 = [input LA:2]; 769 770 if ( (LA4_2=='h') ) { 771 NSInteger LA4_18 = [input LA:3]; 772 773 if ( (LA4_18=='a') ) { 774 NSInteger LA4_24 = [input LA:4]; 775 776 if ( (LA4_24=='r') ) { 777 NSInteger LA4_28 = [input LA:5]; 778 779 if ( ((LA4_28 >= '0' && LA4_28 <= '9')||(LA4_28 >= 'A' && LA4_28 <= 'Z')||LA4_28=='_'||(LA4_28 >= 'a' && LA4_28 <= 'z')) ) { 780 alt4=5; 781 } 782 else { 783 alt4 = 2; 784 } 785 } 786 else { 787 alt4 = 5; 788 } 789 } 790 else { 791 alt4 = 5; 792 } 793 } 794 else { 795 alt4 = 5; 796 } 797 } 798 break; 799 case 'i': ; 800 { 801 NSInteger LA4_3 = [input LA:2]; 802 803 if ( (LA4_3=='n') ) { 804 NSInteger LA4_19 = [input LA:3]; 805 806 if ( (LA4_19=='t') ) { 807 NSInteger LA4_25 = [input LA:4]; 808 809 if ( ((LA4_25 >= '0' && LA4_25 <= '9')||(LA4_25 >= 'A' && LA4_25 <= 'Z')||LA4_25=='_'||(LA4_25 >= 'a' && LA4_25 <= 'z')) ) { 810 alt4=5; 811 } 812 else { 813 alt4 = 3; 814 } 815 } 816 else { 817 alt4 = 5; 818 } 819 } 820 else { 821 alt4 = 5; 822 } 823 } 824 break; 825 case 'v': ; 826 { 827 NSInteger LA4_4 = [input LA:2]; 828 829 if ( (LA4_4=='o') ) { 830 NSInteger LA4_20 = [input LA:3]; 831 832 if ( (LA4_20=='i') ) { 833 NSInteger LA4_26 = [input LA:4]; 834 835 if ( (LA4_26=='d') ) { 836 NSInteger LA4_30 = [input LA:5]; 837 838 if ( ((LA4_30 >= '0' && LA4_30 <= '9')||(LA4_30 >= 'A' && LA4_30 <= 'Z')||LA4_30=='_'||(LA4_30 >= 'a' && LA4_30 <= 'z')) ) { 839 alt4=5; 840 } 841 else { 842 alt4 = 4; 843 } 844 } 845 else { 846 alt4 = 5; 847 } 848 } 849 else { 850 alt4 = 5; 851 } 852 } 853 else { 854 alt4 = 5; 855 } 856 } 857 break; 858 case 'A': ; 859 case 'B': ; 860 case 'C': ; 861 case 'D': ; 862 case 'E': ; 863 case 'F': ; 864 case 'G': ; 865 case 'H': ; 866 case 'I': ; 867 case 'J': ; 868 case 'K': ; 869 case 'L': ; 870 case 'M': ; 871 case 'N': ; 872 case 'O': ; 873 case 'P': ; 874 case 'Q': ; 875 case 'R': ; 876 case 'S': ; 877 case 'T': ; 878 case 'U': ; 879 case 'V': ; 880 case 'W': ; 881 case 'X': ; 882 case 'Y': ; 883 case 'Z': ; 884 case '_': ; 885 case 'a': ; 886 case 'b': ; 887 case 'd': ; 888 case 'e': ; 889 case 'g': ; 890 case 'h': ; 891 case 'j': ; 892 case 'k': ; 893 case 'l': ; 894 case 'm': ; 895 case 'n': ; 896 case 'o': ; 897 case 'p': ; 898 case 'q': ; 899 case 'r': ; 900 case 's': ; 901 case 't': ; 902 case 'u': ; 903 case 'w': ; 904 case 'x': ; 905 case 'y': ; 906 case 'z': ; 907 { 908 alt4=5; 909 } 910 break; 911 case '0': ; 912 case '1': ; 913 case '2': ; 914 case '3': ; 915 case '4': ; 916 case '5': ; 917 case '6': ; 918 case '7': ; 919 case '8': ; 920 case '9': ; 921 { 922 alt4=6; 923 } 924 break; 925 case '(': ; 926 { 927 alt4=7; 928 } 929 break; 930 case ')': ; 931 { 932 alt4=8; 933 } 934 break; 935 case '+': ; 936 { 937 alt4=9; 938 } 939 break; 940 case ',': ; 941 { 942 alt4=10; 943 } 944 break; 945 case ';': ; 946 { 947 alt4=11; 948 } 949 break; 950 case '<': ; 951 { 952 alt4=12; 953 } 954 break; 955 case '=': ; 956 { 957 NSInteger LA4_13 = [input LA:2]; 958 959 if ( (LA4_13=='=') ) { 960 alt4=14; 961 } 962 else { 963 alt4 = 13; 964 } 965 } 966 break; 967 case '{': ; 968 { 969 alt4=15; 970 } 971 break; 972 case '}': ; 973 { 974 alt4=16; 975 } 976 break; 977 case '\t': ; 978 case '\n': ; 979 case '\r': ; 980 case ' ': ; 981 { 982 alt4=17; 983 } 984 break; 985 986 default: ; 987 ANTLRNoViableAltException *nvae = [ANTLRNoViableAltException newException:4 state:0 stream:input]; 988 nvae.c = charLA4; 989 @throw nvae; 990 991 } 992 993 switch (alt4) { 994 case 1 : ; 995 // SimpleC.g:1:10: K_FOR // alt 996 { 997 [self mK_FOR]; 998 999 1000 1001 } 1002 break; 1003 case 2 : ; 1004 // SimpleC.g:1:16: K_CHAR // alt 1005 { 1006 [self mK_CHAR]; 1007 1008 1009 1010 } 1011 break; 1012 case 3 : ; 1013 // SimpleC.g:1:23: K_INT_TYPE // alt 1014 { 1015 [self mK_INT_TYPE]; 1016 1017 1018 1019 } 1020 break; 1021 case 4 : ; 1022 // SimpleC.g:1:34: K_VOID // alt 1023 { 1024 [self mK_VOID]; 1025 1026 1027 1028 } 1029 break; 1030 case 5 : ; 1031 // SimpleC.g:1:41: K_ID // alt 1032 { 1033 [self mK_ID]; 1034 1035 1036 1037 } 1038 break; 1039 case 6 : ; 1040 // SimpleC.g:1:46: K_INT // alt 1041 { 1042 [self mK_INT]; 1043 1044 1045 1046 } 1047 break; 1048 case 7 : ; 1049 // SimpleC.g:1:52: K_LCURVE // alt 1050 { 1051 [self mK_LCURVE]; 1052 1053 1054 1055 } 1056 break; 1057 case 8 : ; 1058 // SimpleC.g:1:61: K_RCURVE // alt 1059 { 1060 [self mK_RCURVE]; 1061 1062 1063 1064 } 1065 break; 1066 case 9 : ; 1067 // SimpleC.g:1:70: K_PLUS // alt 1068 { 1069 [self mK_PLUS]; 1070 1071 1072 1073 } 1074 break; 1075 case 10 : ; 1076 // SimpleC.g:1:77: K_COMMA // alt 1077 { 1078 [self mK_COMMA]; 1079 1080 1081 1082 } 1083 break; 1084 case 11 : ; 1085 // SimpleC.g:1:85: K_SEMICOLON // alt 1086 { 1087 [self mK_SEMICOLON]; 1088 1089 1090 1091 } 1092 break; 1093 case 12 : ; 1094 // SimpleC.g:1:97: K_LT // alt 1095 { 1096 [self mK_LT]; 1097 1098 1099 1100 } 1101 break; 1102 case 13 : ; 1103 // SimpleC.g:1:102: K_EQ // alt 1104 { 1105 [self mK_EQ]; 1106 1107 1108 1109 } 1110 break; 1111 case 14 : ; 1112 // SimpleC.g:1:107: K_EQEQ // alt 1113 { 1114 [self mK_EQEQ]; 1115 1116 1117 1118 } 1119 break; 1120 case 15 : ; 1121 // SimpleC.g:1:114: K_LCURLY // alt 1122 { 1123 [self mK_LCURLY]; 1124 1125 1126 1127 } 1128 break; 1129 case 16 : ; 1130 // SimpleC.g:1:123: K_RCURLY // alt 1131 { 1132 [self mK_RCURLY]; 1133 1134 1135 1136 } 1137 break; 1138 case 17 : ; 1139 // SimpleC.g:1:132: WS // alt 1140 { 1141 [self mWS]; 1142 1143 1144 1145 } 1146 break; 1147 1148 } 1149 1150} 1151 1152@end /* end of SimpleCLexer implementation line 397 */