| /** \file |
| * This OBJC source file was generated by $ANTLR version ${project.version} ${buildNumber} |
| * |
| * - From the grammar source file : Fuzzy.g |
| * - On : 2011-05-06 11:47:46 |
| * - for the lexer : FuzzyLexer |
| * |
| * Editing it, at least manually, is not wise. |
| * |
| * ObjC language generator and runtime by Alan Condit, acondit|hereisanat|ipns|dotgoeshere|com. |
| * |
| * |
| */ |
| // $ANTLR ${project.version} ${buildNumber} Fuzzy.g 2011-05-06 11:47:46 |
| |
| |
| /* ----------------------------------------- |
| * Include the ANTLR3 generated header file. |
| */ |
| #import "Fuzzy.h" |
| /* ----------------------------------------- */ |
| |
| |
| /* ============================================================================= */ |
| /* ============================================================================= |
| * Start of recognizer |
| */ |
| |
| /** As per Terence: No returns for lexer rules! */ |
| @implementation Fuzzy // line 330 |
| |
| + (void) initialize |
| { |
| [ANTLRBaseRecognizer setGrammarFileName:@"Fuzzy.g"]; |
| } |
| |
| + (NSString *) tokenNameForType:(NSInteger)aTokenType |
| { |
| return [[self getTokenNames] objectAtIndex:aTokenType]; |
| } |
| |
| + (Fuzzy *)newFuzzyWithCharStream:(id<ANTLRCharStream>)anInput |
| { |
| return [[Fuzzy alloc] initWithCharStream:anInput]; |
| } |
| |
| - (id) initWithCharStream:(id<ANTLRCharStream>)anInput |
| { |
| self = [super initWithCharStream:anInput State:[[ANTLRRecognizerSharedState newANTLRRecognizerSharedStateWithRuleLen:30+1] retain]]; |
| if ( self != nil ) { |
| SEL synpred9_FuzzySelector = @selector(synpred9_Fuzzy_fragment); |
| |
| SEL synpred2_FuzzySelector = @selector(synpred2_Fuzzy_fragment); |
| |
| SEL synpred7_FuzzySelector = @selector(synpred7_Fuzzy_fragment); |
| |
| SEL synpred4_FuzzySelector = @selector(synpred4_Fuzzy_fragment); |
| |
| SEL synpred8_FuzzySelector = @selector(synpred8_Fuzzy_fragment); |
| |
| SEL synpred6_FuzzySelector = @selector(synpred6_Fuzzy_fragment); |
| |
| SEL synpred5_FuzzySelector = @selector(synpred5_Fuzzy_fragment); |
| |
| SEL synpred3_FuzzySelector = @selector(synpred3_Fuzzy_fragment); |
| |
| SEL synpred1_FuzzySelector = @selector(synpred1_Fuzzy_fragment); |
| |
| } |
| return self; |
| } |
| |
| - (void) dealloc |
| { |
| [super dealloc]; |
| } |
| |
| /* ObjC Start of actions.lexer.methods */ |
| /* ObjC end of actions.lexer.methods */ |
| /* ObjC start methods() */ |
| /* ObjC end methods() */ |
| |
| - (id<ANTLRToken>) nextToken |
| { |
| while (YES) { |
| if ( [input LA:1] == ANTLRCharStreamEOF ) { |
| return [ANTLRCommonToken eofToken]; |
| } |
| state.token = nil; |
| state.channel = ANTLRTokenChannelDefault; |
| state.tokenStartCharIndex = input.index; |
| state.tokenStartCharPositionInLine = input.charPositionInLine; |
| state.tokenStartLine = input.line; |
| state.text = nil; |
| @try { |
| NSInteger m = [input mark]; |
| state.backtracking = 1; /* means we won't throw slow exception */ |
| state.failed = NO; |
| [self mTokens]; |
| state.backtracking = 0; |
| /* mTokens backtracks with synpred at backtracking==2 |
| and we set the synpredgate to allow actions at level 1. */ |
| if ( state.failed ) { |
| [input rewind:m]; |
| [input consume]; /* advance one char and try again */ |
| } else { |
| [self emit]; |
| return state.token; |
| } |
| } |
| @catch (ANTLRRecognitionException *re) { |
| // shouldn't happen in backtracking mode, but... |
| [self reportError:re]; |
| [self recover:re]; |
| } |
| } |
| } |
| |
| - (void)memoize:(id<ANTLRIntStream>)anInput |
| RuleIndex:(NSInteger)ruleIndex |
| StartIndex:(NSInteger)ruleStartIndex |
| { |
| if ( state.backtracking > 1 ) [super memoize:anInput RuleIndex:ruleIndex StartIndex:ruleStartIndex]; |
| } |
| |
| - (BOOL)alreadyParsedRule:(id<ANTLRIntStream>)anInput RuleIndex:(NSInteger)ruleIndex |
| { |
| if ( state.backtracking > 1 ) return [super alreadyParsedRule:anInput RuleIndex:ruleIndex]; |
| return NO; |
| } |
| /* Start of Rules */ |
| // $ANTLR start "IMPORT" |
| - (void) mIMPORT |
| { |
| // |
| /* my ruleScopeSetUp */ |
| /* Terence's stuff */ |
| |
| @try { |
| NSInteger _type = IMPORT; |
| NSInteger _channel = ANTLRTokenChannelDefault; |
| ANTLRCommonToken *name=nil; |
| |
| // Fuzzy.g:5:2: ( 'import' WS name= QIDStar ( WS )? ';' ) // ruleBlockSingleAlt |
| // Fuzzy.g:5:4: 'import' WS name= QIDStar ( WS )? ';' // alt |
| { |
| [self matchString:@"import"]; if ( state.failed ) return ; |
| |
| |
| |
| [self mWS]; if ( state.failed ) return ; |
| |
| |
| |
| NSInteger nameStart31 = input.index; |
| [self mQIDStar]; if ( state.failed ) return ; |
| |
| name = [[ANTLRCommonToken newToken:input Type:ANTLRTokenTypeInvalid Channel:ANTLRTokenChannelDefault Start:nameStart31 Stop:input.index-1] retain]; |
| name.line = self.line; |
| |
| |
| // Fuzzy.g:5:29: ( WS )? // block |
| NSInteger alt1=2; |
| NSInteger LA1_0 = [input LA:1]; |
| |
| if ( ((LA1_0 >= '\t' && LA1_0 <= '\n')||LA1_0==' ') ) { |
| alt1=1; |
| } |
| switch (alt1) { |
| case 1 : ; |
| // Fuzzy.g:5:29: WS // alt |
| { |
| [self mWS]; if ( state.failed ) return ; |
| |
| |
| |
| } |
| break; |
| |
| } |
| |
| |
| [self matchChar:';']; if ( state.failed ) return ; |
| |
| |
| } |
| |
| // token+rule list labels |
| |
| state.type = _type; |
| state.channel = _channel; |
| } |
| @finally { |
| // |
| /* my stuff */ |
| /* Terence's stuff */ |
| |
| } |
| return; |
| } |
| /* $ANTLR end "IMPORT" */ |
| |
| // $ANTLR start "RETURN" |
| - (void) mRETURN |
| { |
| // |
| /* my ruleScopeSetUp */ |
| /* Terence's stuff */ |
| |
| @try { |
| NSInteger _type = RETURN; |
| NSInteger _channel = ANTLRTokenChannelDefault; |
| // Fuzzy.g:10:2: ( 'return' ( options {greedy=false; } : . )* ';' ) // ruleBlockSingleAlt |
| // Fuzzy.g:10:4: 'return' ( options {greedy=false; } : . )* ';' // alt |
| { |
| [self matchString:@"return"]; if ( state.failed ) return ; |
| |
| |
| |
| do { |
| NSInteger alt2=2; |
| NSInteger LA2_0 = [input LA:1]; |
| if ( (LA2_0==';') ) { |
| alt2=2; |
| } |
| else if ( ((LA2_0 >= 0x0000 && LA2_0 <= ':')||(LA2_0 >= '<' && LA2_0 <= 0xFFFF)) ) { |
| alt2=1; |
| } |
| |
| |
| switch (alt2) { |
| case 1 : ; |
| // Fuzzy.g:10:38: . // alt |
| { |
| [self matchAny]; if ( state.failed ) return ; |
| |
| |
| } |
| break; |
| |
| default : |
| goto loop2; |
| } |
| } while (YES); |
| loop2: ; |
| |
| |
| [self matchChar:';']; if ( state.failed ) return ; |
| |
| |
| } |
| |
| // token+rule list labels |
| |
| state.type = _type; |
| state.channel = _channel; |
| } |
| @finally { |
| // |
| /* my stuff */ |
| /* Terence's stuff */ |
| |
| } |
| return; |
| } |
| /* $ANTLR end "RETURN" */ |
| |
| // $ANTLR start "CLASS" |
| - (void) mCLASS |
| { |
| // |
| /* my ruleScopeSetUp */ |
| /* Terence's stuff */ |
| |
| @try { |
| NSInteger _type = CLASS; |
| NSInteger _channel = ANTLRTokenChannelDefault; |
| ANTLRCommonToken *name=nil; |
| |
| // Fuzzy.g:14:2: ( 'class' WS name= ID ( WS )? ( 'extends' WS QID ( WS )? )? ( 'implements' WS QID ( WS )? ( ',' ( WS )? QID ( WS )? )* )? '{' ) // ruleBlockSingleAlt |
| // Fuzzy.g:14:4: 'class' WS name= ID ( WS )? ( 'extends' WS QID ( WS )? )? ( 'implements' WS QID ( WS )? ( ',' ( WS )? QID ( WS )? )* )? '{' // alt |
| { |
| [self matchString:@"class"]; if ( state.failed ) return ; |
| |
| |
| |
| [self mWS]; if ( state.failed ) return ; |
| |
| |
| |
| NSInteger nameStart81 = input.index; |
| [self mID]; if ( state.failed ) return ; |
| |
| name = [[ANTLRCommonToken newToken:input Type:ANTLRTokenTypeInvalid Channel:ANTLRTokenChannelDefault Start:nameStart81 Stop:input.index-1] retain]; |
| name.line = self.line; |
| |
| |
| // Fuzzy.g:14:23: ( WS )? // block |
| NSInteger alt3=2; |
| NSInteger LA3_0 = [input LA:1]; |
| |
| if ( ((LA3_0 >= '\t' && LA3_0 <= '\n')||LA3_0==' ') ) { |
| alt3=1; |
| } |
| switch (alt3) { |
| case 1 : ; |
| // Fuzzy.g:14:23: WS // alt |
| { |
| [self mWS]; if ( state.failed ) return ; |
| |
| |
| |
| } |
| break; |
| |
| } |
| |
| |
| // Fuzzy.g:14:27: ( 'extends' WS QID ( WS )? )? // block |
| NSInteger alt5=2; |
| NSInteger LA5_0 = [input LA:1]; |
| |
| if ( (LA5_0=='e') ) { |
| alt5=1; |
| } |
| switch (alt5) { |
| case 1 : ; |
| // Fuzzy.g:14:28: 'extends' WS QID ( WS )? // alt |
| { |
| [self matchString:@"extends"]; if ( state.failed ) return ; |
| |
| |
| |
| [self mWS]; if ( state.failed ) return ; |
| |
| |
| |
| [self mQID]; if ( state.failed ) return ; |
| |
| |
| |
| // Fuzzy.g:14:45: ( WS )? // block |
| NSInteger alt4=2; |
| NSInteger LA4_0 = [input LA:1]; |
| |
| if ( ((LA4_0 >= '\t' && LA4_0 <= '\n')||LA4_0==' ') ) { |
| alt4=1; |
| } |
| switch (alt4) { |
| case 1 : ; |
| // Fuzzy.g:14:45: WS // alt |
| { |
| [self mWS]; if ( state.failed ) return ; |
| |
| |
| |
| } |
| break; |
| |
| } |
| |
| |
| } |
| break; |
| |
| } |
| |
| |
| // Fuzzy.g:15:3: ( 'implements' WS QID ( WS )? ( ',' ( WS )? QID ( WS )? )* )? // block |
| NSInteger alt10=2; |
| NSInteger LA10_0 = [input LA:1]; |
| |
| if ( (LA10_0=='i') ) { |
| alt10=1; |
| } |
| switch (alt10) { |
| case 1 : ; |
| // Fuzzy.g:15:4: 'implements' WS QID ( WS )? ( ',' ( WS )? QID ( WS )? )* // alt |
| { |
| [self matchString:@"implements"]; if ( state.failed ) return ; |
| |
| |
| |
| [self mWS]; if ( state.failed ) return ; |
| |
| |
| |
| [self mQID]; if ( state.failed ) return ; |
| |
| |
| |
| // Fuzzy.g:15:24: ( WS )? // block |
| NSInteger alt6=2; |
| NSInteger LA6_0 = [input LA:1]; |
| |
| if ( ((LA6_0 >= '\t' && LA6_0 <= '\n')||LA6_0==' ') ) { |
| alt6=1; |
| } |
| switch (alt6) { |
| case 1 : ; |
| // Fuzzy.g:15:24: WS // alt |
| { |
| [self mWS]; if ( state.failed ) return ; |
| |
| |
| |
| } |
| break; |
| |
| } |
| |
| |
| do { |
| NSInteger alt9=2; |
| NSInteger LA9_0 = [input LA:1]; |
| if ( (LA9_0==',') ) { |
| alt9=1; |
| } |
| |
| |
| switch (alt9) { |
| case 1 : ; |
| // Fuzzy.g:15:29: ',' ( WS )? QID ( WS )? // alt |
| { |
| [self matchChar:',']; if ( state.failed ) return ; |
| |
| |
| // Fuzzy.g:15:33: ( WS )? // block |
| NSInteger alt7=2; |
| NSInteger LA7_0 = [input LA:1]; |
| |
| if ( ((LA7_0 >= '\t' && LA7_0 <= '\n')||LA7_0==' ') ) { |
| alt7=1; |
| } |
| switch (alt7) { |
| case 1 : ; |
| // Fuzzy.g:15:33: WS // alt |
| { |
| [self mWS]; if ( state.failed ) return ; |
| |
| |
| |
| } |
| break; |
| |
| } |
| |
| |
| [self mQID]; if ( state.failed ) return ; |
| |
| |
| |
| // Fuzzy.g:15:41: ( WS )? // block |
| NSInteger alt8=2; |
| NSInteger LA8_0 = [input LA:1]; |
| |
| if ( ((LA8_0 >= '\t' && LA8_0 <= '\n')||LA8_0==' ') ) { |
| alt8=1; |
| } |
| switch (alt8) { |
| case 1 : ; |
| // Fuzzy.g:15:41: WS // alt |
| { |
| [self mWS]; if ( state.failed ) return ; |
| |
| |
| |
| } |
| break; |
| |
| } |
| |
| |
| } |
| break; |
| |
| default : |
| goto loop9; |
| } |
| } while (YES); |
| loop9: ; |
| |
| |
| } |
| break; |
| |
| } |
| |
| |
| [self matchChar:'{']; if ( state.failed ) return ; |
| |
| |
| if ( state.backtracking == 1 ) { |
| NSLog(@"found class %@", (name!=nil?name.text:nil)); |
| } |
| |
| |
| } |
| |
| // token+rule list labels |
| |
| state.type = _type; |
| state.channel = _channel; |
| } |
| @finally { |
| // |
| /* my stuff */ |
| /* Terence's stuff */ |
| |
| } |
| return; |
| } |
| /* $ANTLR end "CLASS" */ |
| |
| // $ANTLR start "METHOD" |
| - (void) mMETHOD |
| { |
| // |
| /* my ruleScopeSetUp */ |
| /* Terence's stuff */ |
| |
| @try { |
| NSInteger _type = METHOD; |
| NSInteger _channel = ANTLRTokenChannelDefault; |
| ANTLRCommonToken *name=nil; |
| |
| // Fuzzy.g:20:5: ( TYPE WS name= ID ( WS )? '(' ( ARG ( WS )? ( ',' ( WS )? ARG ( WS )? )* )? ')' ( WS )? ( 'throws' WS QID ( WS )? ( ',' ( WS )? QID ( WS )? )* )? '{' ) // ruleBlockSingleAlt |
| // Fuzzy.g:20:9: TYPE WS name= ID ( WS )? '(' ( ARG ( WS )? ( ',' ( WS )? ARG ( WS )? )* )? ')' ( WS )? ( 'throws' WS QID ( WS )? ( ',' ( WS )? QID ( WS )? )* )? '{' // alt |
| { |
| [self mTYPE]; if ( state.failed ) return ; |
| |
| |
| |
| [self mWS]; if ( state.failed ) return ; |
| |
| |
| |
| NSInteger nameStart158 = input.index; |
| [self mID]; if ( state.failed ) return ; |
| |
| name = [[ANTLRCommonToken newToken:input Type:ANTLRTokenTypeInvalid Channel:ANTLRTokenChannelDefault Start:nameStart158 Stop:input.index-1] retain]; |
| name.line = self.line; |
| |
| |
| // Fuzzy.g:20:25: ( WS )? // block |
| NSInteger alt11=2; |
| NSInteger LA11_0 = [input LA:1]; |
| |
| if ( ((LA11_0 >= '\t' && LA11_0 <= '\n')||LA11_0==' ') ) { |
| alt11=1; |
| } |
| switch (alt11) { |
| case 1 : ; |
| // Fuzzy.g:20:25: WS // alt |
| { |
| [self mWS]; if ( state.failed ) return ; |
| |
| |
| |
| } |
| break; |
| |
| } |
| |
| |
| [self matchChar:'(']; if ( state.failed ) return ; |
| |
| |
| // Fuzzy.g:20:33: ( ARG ( WS )? ( ',' ( WS )? ARG ( WS )? )* )? // block |
| NSInteger alt16=2; |
| NSInteger LA16_0 = [input LA:1]; |
| |
| if ( ((LA16_0 >= 'A' && LA16_0 <= 'Z')||LA16_0=='_'||(LA16_0 >= 'a' && LA16_0 <= 'z')) ) { |
| alt16=1; |
| } |
| switch (alt16) { |
| case 1 : ; |
| // Fuzzy.g:20:35: ARG ( WS )? ( ',' ( WS )? ARG ( WS )? )* // alt |
| { |
| [self mARG]; if ( state.failed ) return ; |
| |
| |
| |
| // Fuzzy.g:20:39: ( WS )? // block |
| NSInteger alt12=2; |
| NSInteger LA12_0 = [input LA:1]; |
| |
| if ( ((LA12_0 >= '\t' && LA12_0 <= '\n')||LA12_0==' ') ) { |
| alt12=1; |
| } |
| switch (alt12) { |
| case 1 : ; |
| // Fuzzy.g:20:39: WS // alt |
| { |
| [self mWS]; if ( state.failed ) return ; |
| |
| |
| |
| } |
| break; |
| |
| } |
| |
| |
| do { |
| NSInteger alt15=2; |
| NSInteger LA15_0 = [input LA:1]; |
| if ( (LA15_0==',') ) { |
| alt15=1; |
| } |
| |
| |
| switch (alt15) { |
| case 1 : ; |
| // Fuzzy.g:20:44: ',' ( WS )? ARG ( WS )? // alt |
| { |
| [self matchChar:',']; if ( state.failed ) return ; |
| |
| |
| // Fuzzy.g:20:48: ( WS )? // block |
| NSInteger alt13=2; |
| NSInteger LA13_0 = [input LA:1]; |
| |
| if ( ((LA13_0 >= '\t' && LA13_0 <= '\n')||LA13_0==' ') ) { |
| alt13=1; |
| } |
| switch (alt13) { |
| case 1 : ; |
| // Fuzzy.g:20:48: WS // alt |
| { |
| [self mWS]; if ( state.failed ) return ; |
| |
| |
| |
| } |
| break; |
| |
| } |
| |
| |
| [self mARG]; if ( state.failed ) return ; |
| |
| |
| |
| // Fuzzy.g:20:56: ( WS )? // block |
| NSInteger alt14=2; |
| NSInteger LA14_0 = [input LA:1]; |
| |
| if ( ((LA14_0 >= '\t' && LA14_0 <= '\n')||LA14_0==' ') ) { |
| alt14=1; |
| } |
| switch (alt14) { |
| case 1 : ; |
| // Fuzzy.g:20:56: WS // alt |
| { |
| [self mWS]; if ( state.failed ) return ; |
| |
| |
| |
| } |
| break; |
| |
| } |
| |
| |
| } |
| break; |
| |
| default : |
| goto loop15; |
| } |
| } while (YES); |
| loop15: ; |
| |
| |
| } |
| break; |
| |
| } |
| |
| |
| [self matchChar:')']; if ( state.failed ) return ; |
| |
| |
| // Fuzzy.g:20:69: ( WS )? // block |
| NSInteger alt17=2; |
| NSInteger LA17_0 = [input LA:1]; |
| |
| if ( ((LA17_0 >= '\t' && LA17_0 <= '\n')||LA17_0==' ') ) { |
| alt17=1; |
| } |
| switch (alt17) { |
| case 1 : ; |
| // Fuzzy.g:20:69: WS // alt |
| { |
| [self mWS]; if ( state.failed ) return ; |
| |
| |
| |
| } |
| break; |
| |
| } |
| |
| |
| // Fuzzy.g:21:8: ( 'throws' WS QID ( WS )? ( ',' ( WS )? QID ( WS )? )* )? // block |
| NSInteger alt22=2; |
| NSInteger LA22_0 = [input LA:1]; |
| |
| if ( (LA22_0=='t') ) { |
| alt22=1; |
| } |
| switch (alt22) { |
| case 1 : ; |
| // Fuzzy.g:21:9: 'throws' WS QID ( WS )? ( ',' ( WS )? QID ( WS )? )* // alt |
| { |
| [self matchString:@"throws"]; if ( state.failed ) return ; |
| |
| |
| |
| [self mWS]; if ( state.failed ) return ; |
| |
| |
| |
| [self mQID]; if ( state.failed ) return ; |
| |
| |
| |
| // Fuzzy.g:21:25: ( WS )? // block |
| NSInteger alt18=2; |
| NSInteger LA18_0 = [input LA:1]; |
| |
| if ( ((LA18_0 >= '\t' && LA18_0 <= '\n')||LA18_0==' ') ) { |
| alt18=1; |
| } |
| switch (alt18) { |
| case 1 : ; |
| // Fuzzy.g:21:25: WS // alt |
| { |
| [self mWS]; if ( state.failed ) return ; |
| |
| |
| |
| } |
| break; |
| |
| } |
| |
| |
| do { |
| NSInteger alt21=2; |
| NSInteger LA21_0 = [input LA:1]; |
| if ( (LA21_0==',') ) { |
| alt21=1; |
| } |
| |
| |
| switch (alt21) { |
| case 1 : ; |
| // Fuzzy.g:21:30: ',' ( WS )? QID ( WS )? // alt |
| { |
| [self matchChar:',']; if ( state.failed ) return ; |
| |
| |
| // Fuzzy.g:21:34: ( WS )? // block |
| NSInteger alt19=2; |
| NSInteger LA19_0 = [input LA:1]; |
| |
| if ( ((LA19_0 >= '\t' && LA19_0 <= '\n')||LA19_0==' ') ) { |
| alt19=1; |
| } |
| switch (alt19) { |
| case 1 : ; |
| // Fuzzy.g:21:34: WS // alt |
| { |
| [self mWS]; if ( state.failed ) return ; |
| |
| |
| |
| } |
| break; |
| |
| } |
| |
| |
| [self mQID]; if ( state.failed ) return ; |
| |
| |
| |
| // Fuzzy.g:21:42: ( WS )? // block |
| NSInteger alt20=2; |
| NSInteger LA20_0 = [input LA:1]; |
| |
| if ( ((LA20_0 >= '\t' && LA20_0 <= '\n')||LA20_0==' ') ) { |
| alt20=1; |
| } |
| switch (alt20) { |
| case 1 : ; |
| // Fuzzy.g:21:42: WS // alt |
| { |
| [self mWS]; if ( state.failed ) return ; |
| |
| |
| |
| } |
| break; |
| |
| } |
| |
| |
| } |
| break; |
| |
| default : |
| goto loop21; |
| } |
| } while (YES); |
| loop21: ; |
| |
| |
| } |
| break; |
| |
| } |
| |
| |
| [self matchChar:'{']; if ( state.failed ) return ; |
| |
| |
| if ( state.backtracking == 1 ) { |
| NSLog(@"found method %@", (name!=nil?name.text:nil)); |
| } |
| |
| |
| } |
| |
| // token+rule list labels |
| |
| state.type = _type; |
| state.channel = _channel; |
| } |
| @finally { |
| // |
| /* my stuff */ |
| /* Terence's stuff */ |
| |
| } |
| return; |
| } |
| /* $ANTLR end "METHOD" */ |
| |
| // $ANTLR start "FIELD" |
| - (void) mFIELD |
| { |
| // |
| /* my ruleScopeSetUp */ |
| /* Terence's stuff */ |
| |
| @try { |
| NSInteger _type = FIELD; |
| NSInteger _channel = ANTLRTokenChannelDefault; |
| ANTLRCommonToken *name=nil; |
| |
| // Fuzzy.g:26:5: ( TYPE WS name= ID ( '[]' )? ( WS )? ( ';' | '=' ) ) // ruleBlockSingleAlt |
| // Fuzzy.g:26:9: TYPE WS name= ID ( '[]' )? ( WS )? ( ';' | '=' ) // alt |
| { |
| [self mTYPE]; if ( state.failed ) return ; |
| |
| |
| |
| [self mWS]; if ( state.failed ) return ; |
| |
| |
| |
| NSInteger nameStart261 = input.index; |
| [self mID]; if ( state.failed ) return ; |
| |
| name = [[ANTLRCommonToken newToken:input Type:ANTLRTokenTypeInvalid Channel:ANTLRTokenChannelDefault Start:nameStart261 Stop:input.index-1] retain]; |
| name.line = self.line; |
| |
| |
| // Fuzzy.g:26:25: ( '[]' )? // block |
| NSInteger alt23=2; |
| NSInteger LA23_0 = [input LA:1]; |
| |
| if ( (LA23_0=='[') ) { |
| alt23=1; |
| } |
| switch (alt23) { |
| case 1 : ; |
| // Fuzzy.g:26:25: '[]' // alt |
| { |
| [self matchString:@"[]"]; if ( state.failed ) return ; |
| |
| |
| |
| } |
| break; |
| |
| } |
| |
| |
| // Fuzzy.g:26:31: ( WS )? // block |
| NSInteger alt24=2; |
| NSInteger LA24_0 = [input LA:1]; |
| |
| if ( ((LA24_0 >= '\t' && LA24_0 <= '\n')||LA24_0==' ') ) { |
| alt24=1; |
| } |
| switch (alt24) { |
| case 1 : ; |
| // Fuzzy.g:26:31: WS // alt |
| { |
| [self mWS]; if ( state.failed ) return ; |
| |
| |
| |
| } |
| break; |
| |
| } |
| |
| |
| if ([input LA:1] == ';'||[input LA:1] == '=') { |
| [input consume]; |
| state.failed = NO; |
| |
| } else { |
| if ( state.backtracking > 0 ) { state.failed = YES; return ; } |
| |
| ANTLRMismatchedSetException *mse = [ANTLRMismatchedSetException newException:nil stream:input]; |
| [self recover:mse]; |
| @throw mse; |
| } |
| |
| |
| if ( state.backtracking == 1 ) { |
| NSLog(@"found var %@", (name!=nil?name.text:nil)); |
| } |
| |
| |
| } |
| |
| // token+rule list labels |
| |
| state.type = _type; |
| state.channel = _channel; |
| } |
| @finally { |
| // |
| /* my stuff */ |
| /* Terence's stuff */ |
| |
| } |
| return; |
| } |
| /* $ANTLR end "FIELD" */ |
| |
| // $ANTLR start "STAT" |
| - (void) mSTAT |
| { |
| // |
| /* my ruleScopeSetUp */ |
| /* Terence's stuff */ |
| |
| @try { |
| NSInteger _type = STAT; |
| NSInteger _channel = ANTLRTokenChannelDefault; |
| // Fuzzy.g:30:5: ( ( 'if' | 'while' | 'switch' | 'for' ) ( WS )? '(' ) // ruleBlockSingleAlt |
| // Fuzzy.g:30:7: ( 'if' | 'while' | 'switch' | 'for' ) ( WS )? '(' // alt |
| { |
| // Fuzzy.g:30:7: ( 'if' | 'while' | 'switch' | 'for' ) // block |
| NSInteger alt25=4; |
| unichar charLA25 = [input LA:1]; |
| switch (charLA25) { |
| case 'i': ; |
| { |
| alt25=1; |
| } |
| break; |
| case 'w': ; |
| { |
| alt25=2; |
| } |
| break; |
| case 's': ; |
| { |
| alt25=3; |
| } |
| break; |
| case 'f': ; |
| { |
| alt25=4; |
| } |
| break; |
| |
| default: ; |
| if ( state.backtracking > 0 ) { state.failed = YES; return ; } |
| |
| ANTLRNoViableAltException *nvae = [ANTLRNoViableAltException newException:25 state:0 stream:input]; |
| nvae.c = charLA25; |
| @throw nvae; |
| |
| } |
| |
| switch (alt25) { |
| case 1 : ; |
| // Fuzzy.g:30:8: 'if' // alt |
| { |
| [self matchString:@"if"]; if ( state.failed ) return ; |
| |
| |
| |
| } |
| break; |
| case 2 : ; |
| // Fuzzy.g:30:13: 'while' // alt |
| { |
| [self matchString:@"while"]; if ( state.failed ) return ; |
| |
| |
| |
| } |
| break; |
| case 3 : ; |
| // Fuzzy.g:30:21: 'switch' // alt |
| { |
| [self matchString:@"switch"]; if ( state.failed ) return ; |
| |
| |
| |
| } |
| break; |
| case 4 : ; |
| // Fuzzy.g:30:30: 'for' // alt |
| { |
| [self matchString:@"for"]; if ( state.failed ) return ; |
| |
| |
| |
| } |
| break; |
| |
| } |
| |
| |
| // Fuzzy.g:30:37: ( WS )? // block |
| NSInteger alt26=2; |
| NSInteger LA26_0 = [input LA:1]; |
| |
| if ( ((LA26_0 >= '\t' && LA26_0 <= '\n')||LA26_0==' ') ) { |
| alt26=1; |
| } |
| switch (alt26) { |
| case 1 : ; |
| // Fuzzy.g:30:37: WS // alt |
| { |
| [self mWS]; if ( state.failed ) return ; |
| |
| |
| |
| } |
| break; |
| |
| } |
| |
| |
| [self matchChar:'(']; if ( state.failed ) return ; |
| |
| |
| } |
| |
| // token+rule list labels |
| |
| state.type = _type; |
| state.channel = _channel; |
| } |
| @finally { |
| // |
| /* my stuff */ |
| /* Terence's stuff */ |
| |
| } |
| return; |
| } |
| /* $ANTLR end "STAT" */ |
| |
| // $ANTLR start "CALL" |
| - (void) mCALL |
| { |
| // |
| /* my ruleScopeSetUp */ |
| /* Terence's stuff */ |
| |
| @try { |
| NSInteger _type = CALL; |
| NSInteger _channel = ANTLRTokenChannelDefault; |
| ANTLRCommonToken *name=nil; |
| |
| // Fuzzy.g:33:5: (name= QID ( WS )? '(' ) // ruleBlockSingleAlt |
| // Fuzzy.g:33:9: name= QID ( WS )? '(' // alt |
| { |
| NSInteger nameStart326 = input.index; |
| [self mQID]; if ( state.failed ) return ; |
| |
| name = [[ANTLRCommonToken newToken:input Type:ANTLRTokenTypeInvalid Channel:ANTLRTokenChannelDefault Start:nameStart326 Stop:input.index-1] retain]; |
| name.line = self.line; |
| |
| |
| // Fuzzy.g:33:18: ( WS )? // block |
| NSInteger alt27=2; |
| NSInteger LA27_0 = [input LA:1]; |
| |
| if ( ((LA27_0 >= '\t' && LA27_0 <= '\n')||LA27_0==' ') ) { |
| alt27=1; |
| } |
| switch (alt27) { |
| case 1 : ; |
| // Fuzzy.g:33:18: WS // alt |
| { |
| [self mWS]; if ( state.failed ) return ; |
| |
| |
| |
| } |
| break; |
| |
| } |
| |
| |
| [self matchChar:'(']; if ( state.failed ) return ; |
| |
| |
| if ( state.backtracking == 1 ) { |
| /*ignore if this/super */ NSLog(@"found call %@",(name!=nil?name.text:nil)); |
| } |
| |
| |
| } |
| |
| // token+rule list labels |
| |
| state.type = _type; |
| state.channel = _channel; |
| } |
| @finally { |
| // |
| /* my stuff */ |
| /* Terence's stuff */ |
| |
| } |
| return; |
| } |
| /* $ANTLR end "CALL" */ |
| |
| // $ANTLR start "COMMENT" |
| - (void) mCOMMENT |
| { |
| // |
| /* my ruleScopeSetUp */ |
| /* Terence's stuff */ |
| |
| @try { |
| NSInteger _type = COMMENT; |
| NSInteger _channel = ANTLRTokenChannelDefault; |
| // Fuzzy.g:38:5: ( '/*' ( options {greedy=false; } : . )* '*/' ) // ruleBlockSingleAlt |
| // Fuzzy.g:38:9: '/*' ( options {greedy=false; } : . )* '*/' // alt |
| { |
| [self matchString:@"/*"]; if ( state.failed ) return ; |
| |
| |
| |
| do { |
| NSInteger alt28=2; |
| NSInteger LA28_0 = [input LA:1]; |
| if ( (LA28_0=='*') ) { |
| NSInteger LA28_1 = [input LA:2]; |
| if ( (LA28_1=='/') ) { |
| alt28=2; |
| } |
| else if ( ((LA28_1 >= 0x0000 && LA28_1 <= '.')||(LA28_1 >= '0' && LA28_1 <= 0xFFFF)) ) { |
| alt28=1; |
| } |
| |
| |
| } |
| else if ( ((LA28_0 >= 0x0000 && LA28_0 <= ')')||(LA28_0 >= '+' && LA28_0 <= 0xFFFF)) ) { |
| alt28=1; |
| } |
| |
| |
| switch (alt28) { |
| case 1 : ; |
| // Fuzzy.g:38:41: . // alt |
| { |
| [self matchAny]; if ( state.failed ) return ; |
| |
| |
| } |
| break; |
| |
| default : |
| goto loop28; |
| } |
| } while (YES); |
| loop28: ; |
| |
| |
| [self matchString:@"*/"]; if ( state.failed ) return ; |
| |
| |
| |
| if ( state.backtracking == 1 ) { |
| NSLog(@"found comment %@", [self text]); |
| } |
| |
| |
| } |
| |
| // token+rule list labels |
| |
| state.type = _type; |
| state.channel = _channel; |
| } |
| @finally { |
| // |
| /* my stuff */ |
| /* Terence's stuff */ |
| |
| } |
| return; |
| } |
| /* $ANTLR end "COMMENT" */ |
| |
| // $ANTLR start "SL_COMMENT" |
| - (void) mSL_COMMENT |
| { |
| // |
| /* my ruleScopeSetUp */ |
| /* Terence's stuff */ |
| |
| @try { |
| NSInteger _type = SL_COMMENT; |
| NSInteger _channel = ANTLRTokenChannelDefault; |
| // Fuzzy.g:43:5: ( '//' ( options {greedy=false; } : . )* '\\n' ) // ruleBlockSingleAlt |
| // Fuzzy.g:43:9: '//' ( options {greedy=false; } : . )* '\\n' // alt |
| { |
| [self matchString:@"//"]; if ( state.failed ) return ; |
| |
| |
| |
| do { |
| NSInteger alt29=2; |
| NSInteger LA29_0 = [input LA:1]; |
| if ( (LA29_0=='\n') ) { |
| alt29=2; |
| } |
| else if ( ((LA29_0 >= 0x0000 && LA29_0 <= '\t')||(LA29_0 >= 0x000B && LA29_0 <= 0xFFFF)) ) { |
| alt29=1; |
| } |
| |
| |
| switch (alt29) { |
| case 1 : ; |
| // Fuzzy.g:43:41: . // alt |
| { |
| [self matchAny]; if ( state.failed ) return ; |
| |
| |
| } |
| break; |
| |
| default : |
| goto loop29; |
| } |
| } while (YES); |
| loop29: ; |
| |
| |
| [self matchChar:'\n']; if ( state.failed ) return ; |
| |
| |
| if ( state.backtracking == 1 ) { |
| NSLog(@"found // comment %@", [self text]); |
| } |
| |
| |
| } |
| |
| // token+rule list labels |
| |
| state.type = _type; |
| state.channel = _channel; |
| } |
| @finally { |
| // |
| /* my stuff */ |
| /* Terence's stuff */ |
| |
| } |
| return; |
| } |
| /* $ANTLR end "SL_COMMENT" */ |
| |
| // $ANTLR start "STRING" |
| - (void) mSTRING |
| { |
| // |
| /* my ruleScopeSetUp */ |
| /* Terence's stuff */ |
| |
| @try { |
| NSInteger _type = STRING; |
| NSInteger _channel = ANTLRTokenChannelDefault; |
| // Fuzzy.g:48:2: ( '\"' ( options {greedy=false; } : ESC | . )* '\"' ) // ruleBlockSingleAlt |
| // Fuzzy.g:48:4: '\"' ( options {greedy=false; } : ESC | . )* '\"' // alt |
| { |
| [self matchChar:'"']; if ( state.failed ) return ; |
| |
| |
| do { |
| NSInteger alt30=3; |
| NSInteger LA30_0 = [input LA:1]; |
| if ( (LA30_0=='"') ) { |
| alt30=3; |
| } |
| else if ( (LA30_0=='\\') ) { |
| NSInteger LA30_2 = [input LA:2]; |
| if ( (LA30_2=='"') ) { |
| alt30=1; |
| } |
| else if ( (LA30_2=='\\') ) { |
| alt30=1; |
| } |
| else if ( (LA30_2=='\'') ) { |
| alt30=1; |
| } |
| else if ( ((LA30_2 >= 0x0000 && LA30_2 <= '!')||(LA30_2 >= '#' && LA30_2 <= '&')||(LA30_2 >= '(' && LA30_2 <= '[')||(LA30_2 >= ']' && LA30_2 <= 0xFFFF)) ) { |
| alt30=2; |
| } |
| |
| |
| } |
| else if ( ((LA30_0 >= 0x0000 && LA30_0 <= '!')||(LA30_0 >= '#' && LA30_0 <= '[')||(LA30_0 >= ']' && LA30_0 <= 0xFFFF)) ) { |
| alt30=2; |
| } |
| |
| |
| switch (alt30) { |
| case 1 : ; |
| // Fuzzy.g:48:34: ESC // alt |
| { |
| [self mESC]; if ( state.failed ) return ; |
| |
| |
| |
| } |
| break; |
| case 2 : ; |
| // Fuzzy.g:48:40: . // alt |
| { |
| [self matchAny]; if ( state.failed ) return ; |
| |
| |
| } |
| break; |
| |
| default : |
| goto loop30; |
| } |
| } while (YES); |
| loop30: ; |
| |
| |
| [self matchChar:'"']; if ( state.failed ) return ; |
| |
| |
| } |
| |
| // token+rule list labels |
| |
| state.type = _type; |
| state.channel = _channel; |
| } |
| @finally { |
| // |
| /* my stuff */ |
| /* Terence's stuff */ |
| |
| } |
| return; |
| } |
| /* $ANTLR end "STRING" */ |
| |
| // $ANTLR start "CHAR" |
| - (void) mCHAR |
| { |
| // |
| /* my ruleScopeSetUp */ |
| /* Terence's stuff */ |
| |
| @try { |
| NSInteger _type = CHAR; |
| NSInteger _channel = ANTLRTokenChannelDefault; |
| // Fuzzy.g:52:2: ( '\\'' ( options {greedy=false; } : ESC | . )* '\\'' ) // ruleBlockSingleAlt |
| // Fuzzy.g:52:4: '\\'' ( options {greedy=false; } : ESC | . )* '\\'' // alt |
| { |
| [self matchChar:'\'']; if ( state.failed ) return ; |
| |
| |
| do { |
| NSInteger alt31=3; |
| NSInteger LA31_0 = [input LA:1]; |
| if ( (LA31_0=='\'') ) { |
| alt31=3; |
| } |
| else if ( (LA31_0=='\\') ) { |
| NSInteger LA31_2 = [input LA:2]; |
| if ( (LA31_2=='\'') ) { |
| alt31=1; |
| } |
| else if ( (LA31_2=='\\') ) { |
| alt31=1; |
| } |
| else if ( (LA31_2=='"') ) { |
| alt31=1; |
| } |
| else if ( ((LA31_2 >= 0x0000 && LA31_2 <= '!')||(LA31_2 >= '#' && LA31_2 <= '&')||(LA31_2 >= '(' && LA31_2 <= '[')||(LA31_2 >= ']' && LA31_2 <= 0xFFFF)) ) { |
| alt31=2; |
| } |
| |
| |
| } |
| else if ( ((LA31_0 >= 0x0000 && LA31_0 <= '&')||(LA31_0 >= '(' && LA31_0 <= '[')||(LA31_0 >= ']' && LA31_0 <= 0xFFFF)) ) { |
| alt31=2; |
| } |
| |
| |
| switch (alt31) { |
| case 1 : ; |
| // Fuzzy.g:52:35: ESC // alt |
| { |
| [self mESC]; if ( state.failed ) return ; |
| |
| |
| |
| } |
| break; |
| case 2 : ; |
| // Fuzzy.g:52:41: . // alt |
| { |
| [self matchAny]; if ( state.failed ) return ; |
| |
| |
| } |
| break; |
| |
| default : |
| goto loop31; |
| } |
| } while (YES); |
| loop31: ; |
| |
| |
| [self matchChar:'\'']; if ( state.failed ) return ; |
| |
| |
| } |
| |
| // token+rule list labels |
| |
| state.type = _type; |
| state.channel = _channel; |
| } |
| @finally { |
| // |
| /* my stuff */ |
| /* Terence's stuff */ |
| |
| } |
| return; |
| } |
| /* $ANTLR end "CHAR" */ |
| |
| // $ANTLR start "WS" |
| - (void) mWS |
| { |
| // |
| /* my ruleScopeSetUp */ |
| /* Terence's stuff */ |
| |
| @try { |
| NSInteger _type = WS; |
| NSInteger _channel = ANTLRTokenChannelDefault; |
| // Fuzzy.g:55:5: ( ( ' ' | '\\t' | '\\n' )+ ) // ruleBlockSingleAlt |
| // Fuzzy.g:55:9: ( ' ' | '\\t' | '\\n' )+ // alt |
| { |
| // Fuzzy.g:55:9: ( ' ' | '\\t' | '\\n' )+ // positiveClosureBlock |
| NSInteger cnt32 = 0; |
| do { |
| NSInteger alt32 = 2; |
| NSInteger LA32_0 = [input LA:1]; |
| if ( ((LA32_0 >= '\t' && LA32_0 <= '\n')||LA32_0==' ') ) { |
| alt32=1; |
| } |
| |
| |
| switch (alt32) { |
| case 1 : ; |
| // Fuzzy.g: // alt |
| { |
| if ((([input LA:1] >= '\t') && ([input LA:1] <= '\n'))||[input LA:1] == ' ') { |
| [input consume]; |
| state.failed = NO; |
| |
| } else { |
| if ( state.backtracking > 0 ) { state.failed = YES; return ; } |
| |
| ANTLRMismatchedSetException *mse = [ANTLRMismatchedSetException newException:nil stream:input]; |
| [self recover:mse]; |
| @throw mse; |
| } |
| |
| |
| } |
| break; |
| |
| default : |
| if ( cnt32 >= 1 ) |
| goto loop32; |
| if ( state.backtracking > 0 ) { state.failed = YES; return ; } |
| |
| ANTLREarlyExitException *eee = |
| [ANTLREarlyExitException newException:input decisionNumber:32]; |
| @throw eee; |
| } |
| cnt32++; |
| } while (YES); |
| loop32: ; |
| |
| |
| } |
| |
| // token+rule list labels |
| |
| state.type = _type; |
| state.channel = _channel; |
| } |
| @finally { |
| // |
| /* my stuff */ |
| /* Terence's stuff */ |
| |
| } |
| return; |
| } |
| /* $ANTLR end "WS" */ |
| |
| // $ANTLR start "QID" |
| - (void) mQID |
| { |
| // |
| /* my ruleScopeSetUp */ |
| /* Terence's stuff */ |
| |
| @try { |
| // Fuzzy.g:59:5: ( ID ( '.' ID )* ) // ruleBlockSingleAlt |
| // Fuzzy.g:59:7: ID ( '.' ID )* // alt |
| { |
| [self mID]; if ( state.failed ) return ; |
| |
| |
| |
| do { |
| NSInteger alt33=2; |
| NSInteger LA33_0 = [input LA:1]; |
| if ( (LA33_0=='.') ) { |
| alt33=1; |
| } |
| |
| |
| switch (alt33) { |
| case 1 : ; |
| // Fuzzy.g:59:11: '.' ID // alt |
| { |
| [self matchChar:'.']; if ( state.failed ) return ; |
| |
| |
| [self mID]; if ( state.failed ) return ; |
| |
| |
| |
| } |
| break; |
| |
| default : |
| goto loop33; |
| } |
| } while (YES); |
| loop33: ; |
| |
| |
| } |
| |
| |
| } |
| @finally { |
| // |
| /* my stuff */ |
| /* Terence's stuff */ |
| |
| } |
| return; |
| } |
| /* $ANTLR end "QID" */ |
| |
| // $ANTLR start "QIDStar" |
| - (void) mQIDStar |
| { |
| // |
| /* my ruleScopeSetUp */ |
| /* Terence's stuff */ |
| |
| @try { |
| // Fuzzy.g:68:2: ( ID ( '.' ID )* ( '.*' )? ) // ruleBlockSingleAlt |
| // Fuzzy.g:68:4: ID ( '.' ID )* ( '.*' )? // alt |
| { |
| [self mID]; if ( state.failed ) return ; |
| |
| |
| |
| do { |
| NSInteger alt34=2; |
| NSInteger LA34_0 = [input LA:1]; |
| if ( (LA34_0=='.') ) { |
| NSInteger LA34_1 = [input LA:2]; |
| if ( ((LA34_1 >= 'A' && LA34_1 <= 'Z')||LA34_1=='_'||(LA34_1 >= 'a' && LA34_1 <= 'z')) ) { |
| alt34=1; |
| } |
| |
| |
| } |
| |
| |
| switch (alt34) { |
| case 1 : ; |
| // Fuzzy.g:68:8: '.' ID // alt |
| { |
| [self matchChar:'.']; if ( state.failed ) return ; |
| |
| |
| [self mID]; if ( state.failed ) return ; |
| |
| |
| |
| } |
| break; |
| |
| default : |
| goto loop34; |
| } |
| } while (YES); |
| loop34: ; |
| |
| |
| // Fuzzy.g:68:17: ( '.*' )? // block |
| NSInteger alt35=2; |
| NSInteger LA35_0 = [input LA:1]; |
| |
| if ( (LA35_0=='.') ) { |
| alt35=1; |
| } |
| switch (alt35) { |
| case 1 : ; |
| // Fuzzy.g:68:17: '.*' // alt |
| { |
| [self matchString:@".*"]; if ( state.failed ) return ; |
| |
| |
| |
| } |
| break; |
| |
| } |
| |
| |
| } |
| |
| |
| } |
| @finally { |
| // |
| /* my stuff */ |
| /* Terence's stuff */ |
| |
| } |
| return; |
| } |
| /* $ANTLR end "QIDStar" */ |
| |
| // $ANTLR start "TYPE" |
| - (void) mTYPE |
| { |
| // |
| /* my ruleScopeSetUp */ |
| /* Terence's stuff */ |
| |
| @try { |
| // Fuzzy.g:72:5: ( QID ( '[]' )? ) // ruleBlockSingleAlt |
| // Fuzzy.g:72:9: QID ( '[]' )? // alt |
| { |
| [self mQID]; if ( state.failed ) return ; |
| |
| |
| |
| // Fuzzy.g:72:13: ( '[]' )? // block |
| NSInteger alt36=2; |
| NSInteger LA36_0 = [input LA:1]; |
| |
| if ( (LA36_0=='[') ) { |
| alt36=1; |
| } |
| switch (alt36) { |
| case 1 : ; |
| // Fuzzy.g:72:13: '[]' // alt |
| { |
| [self matchString:@"[]"]; if ( state.failed ) return ; |
| |
| |
| |
| } |
| break; |
| |
| } |
| |
| |
| } |
| |
| |
| } |
| @finally { |
| // |
| /* my stuff */ |
| /* Terence's stuff */ |
| |
| } |
| return; |
| } |
| /* $ANTLR end "TYPE" */ |
| |
| // $ANTLR start "ARG" |
| - (void) mARG |
| { |
| // |
| /* my ruleScopeSetUp */ |
| /* Terence's stuff */ |
| |
| @try { |
| // Fuzzy.g:76:5: ( TYPE WS ID ) // ruleBlockSingleAlt |
| // Fuzzy.g:76:9: TYPE WS ID // alt |
| { |
| [self mTYPE]; if ( state.failed ) return ; |
| |
| |
| |
| [self mWS]; if ( state.failed ) return ; |
| |
| |
| |
| [self mID]; if ( state.failed ) return ; |
| |
| |
| |
| } |
| |
| |
| } |
| @finally { |
| // |
| /* my stuff */ |
| /* Terence's stuff */ |
| |
| } |
| return; |
| } |
| /* $ANTLR end "ARG" */ |
| |
| // $ANTLR start "ID" |
| - (void) mID |
| { |
| // |
| /* my ruleScopeSetUp */ |
| /* Terence's stuff */ |
| |
| @try { |
| // Fuzzy.g:80:5: ( ( 'a' .. 'z' | 'A' .. 'Z' | '_' ) ( 'a' .. 'z' | 'A' .. 'Z' | '_' | '0' .. '9' )* ) // ruleBlockSingleAlt |
| // Fuzzy.g:80:9: ( 'a' .. 'z' | 'A' .. 'Z' | '_' ) ( 'a' .. 'z' | 'A' .. 'Z' | '_' | '0' .. '9' )* // alt |
| { |
| if ((([input LA:1] >= 'A') && ([input LA:1] <= 'Z'))||[input LA:1] == '_'||(([input LA:1] >= 'a') && ([input LA:1] <= 'z'))) { |
| [input consume]; |
| state.failed = NO; |
| |
| } else { |
| if ( state.backtracking > 0 ) { state.failed = YES; return ; } |
| |
| ANTLRMismatchedSetException *mse = [ANTLRMismatchedSetException newException:nil stream:input]; |
| [self recover:mse]; |
| @throw mse; |
| } |
| |
| |
| do { |
| NSInteger alt37=2; |
| NSInteger LA37_0 = [input LA:1]; |
| if ( ((LA37_0 >= '0' && LA37_0 <= '9')||(LA37_0 >= 'A' && LA37_0 <= 'Z')||LA37_0=='_'||(LA37_0 >= 'a' && LA37_0 <= 'z')) ) { |
| alt37=1; |
| } |
| |
| |
| switch (alt37) { |
| case 1 : ; |
| // Fuzzy.g: // alt |
| { |
| 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'))) { |
| [input consume]; |
| state.failed = NO; |
| |
| } else { |
| if ( state.backtracking > 0 ) { state.failed = YES; return ; } |
| |
| ANTLRMismatchedSetException *mse = [ANTLRMismatchedSetException newException:nil stream:input]; |
| [self recover:mse]; |
| @throw mse; |
| } |
| |
| |
| } |
| break; |
| |
| default : |
| goto loop37; |
| } |
| } while (YES); |
| loop37: ; |
| |
| |
| } |
| |
| |
| } |
| @finally { |
| // |
| /* my stuff */ |
| /* Terence's stuff */ |
| |
| } |
| return; |
| } |
| /* $ANTLR end "ID" */ |
| |
| // $ANTLR start "ESC" |
| - (void) mESC |
| { |
| // |
| /* my ruleScopeSetUp */ |
| /* Terence's stuff */ |
| |
| @try { |
| // Fuzzy.g:84:5: ( '\\\\' ( '\"' | '\\'' | '\\\\' ) ) // ruleBlockSingleAlt |
| // Fuzzy.g:84:7: '\\\\' ( '\"' | '\\'' | '\\\\' ) // alt |
| { |
| [self matchChar:'\\']; if ( state.failed ) return ; |
| |
| |
| if ([input LA:1] == '"'||[input LA:1] == '\''||[input LA:1] == '\\') { |
| [input consume]; |
| state.failed = NO; |
| |
| } else { |
| if ( state.backtracking > 0 ) { state.failed = YES; return ; } |
| |
| ANTLRMismatchedSetException *mse = [ANTLRMismatchedSetException newException:nil stream:input]; |
| [self recover:mse]; |
| @throw mse; |
| } |
| |
| |
| } |
| |
| |
| } |
| @finally { |
| // |
| /* my stuff */ |
| /* Terence's stuff */ |
| |
| } |
| return; |
| } |
| /* $ANTLR end "ESC" */ |
| |
| - (void) mTokens |
| { |
| // Fuzzy.g:1:39: ( IMPORT | RETURN | CLASS | METHOD | FIELD | STAT | CALL | COMMENT | SL_COMMENT | STRING | CHAR | WS ) //ruleblock |
| NSInteger alt38=12; |
| unichar charLA38 = [input LA:1]; |
| switch (charLA38) { |
| case 'i': ; |
| { |
| NSInteger LA38_1 = [input LA:2]; |
| |
| if ( ([self evaluateSyntacticPredicate:@selector(synpred1_Fuzzy_fragment)]) ) { |
| alt38=1; |
| } |
| else if ( ([self evaluateSyntacticPredicate:@selector(synpred4_Fuzzy_fragment)]) ) { |
| alt38=4; |
| } |
| else if ( ([self evaluateSyntacticPredicate:@selector(synpred5_Fuzzy_fragment)]) ) { |
| alt38=5; |
| } |
| else if ( ([self evaluateSyntacticPredicate:@selector(synpred6_Fuzzy_fragment)]) ) { |
| alt38=6; |
| } |
| else if ( ([self evaluateSyntacticPredicate:@selector(synpred7_Fuzzy_fragment)]) ) { |
| alt38=7; |
| } |
| else { |
| if ( state.backtracking > 0 ) { state.failed = YES; return ; } |
| |
| ANTLRNoViableAltException *nvae = [ANTLRNoViableAltException newException:38 state:1 stream:input]; |
| nvae.c = LA38_1; |
| @throw nvae; |
| |
| } |
| } |
| break; |
| case 'r': ; |
| { |
| NSInteger LA38_7 = [input LA:2]; |
| |
| if ( ([self evaluateSyntacticPredicate:@selector(synpred2_Fuzzy_fragment)]) ) { |
| alt38=2; |
| } |
| else if ( ([self evaluateSyntacticPredicate:@selector(synpred4_Fuzzy_fragment)]) ) { |
| alt38=4; |
| } |
| else if ( ([self evaluateSyntacticPredicate:@selector(synpred5_Fuzzy_fragment)]) ) { |
| alt38=5; |
| } |
| else if ( ([self evaluateSyntacticPredicate:@selector(synpred7_Fuzzy_fragment)]) ) { |
| alt38=7; |
| } |
| else { |
| if ( state.backtracking > 0 ) { state.failed = YES; return ; } |
| |
| ANTLRNoViableAltException *nvae = [ANTLRNoViableAltException newException:38 state:7 stream:input]; |
| nvae.c = LA38_7; |
| @throw nvae; |
| |
| } |
| } |
| break; |
| case 'c': ; |
| { |
| NSInteger LA38_9 = [input LA:2]; |
| |
| if ( ([self evaluateSyntacticPredicate:@selector(synpred3_Fuzzy_fragment)]) ) { |
| alt38=3; |
| } |
| else if ( ([self evaluateSyntacticPredicate:@selector(synpred4_Fuzzy_fragment)]) ) { |
| alt38=4; |
| } |
| else if ( ([self evaluateSyntacticPredicate:@selector(synpred5_Fuzzy_fragment)]) ) { |
| alt38=5; |
| } |
| else if ( ([self evaluateSyntacticPredicate:@selector(synpred7_Fuzzy_fragment)]) ) { |
| alt38=7; |
| } |
| else { |
| if ( state.backtracking > 0 ) { state.failed = YES; return ; } |
| |
| ANTLRNoViableAltException *nvae = [ANTLRNoViableAltException newException:38 state:9 stream:input]; |
| nvae.c = LA38_9; |
| @throw nvae; |
| |
| } |
| } |
| break; |
| case 'f': ; |
| case 's': ; |
| case 'w': ; |
| { |
| NSInteger LA38_11 = [input LA:2]; |
| |
| if ( ([self evaluateSyntacticPredicate:@selector(synpred4_Fuzzy_fragment)]) ) { |
| alt38=4; |
| } |
| else if ( ([self evaluateSyntacticPredicate:@selector(synpred5_Fuzzy_fragment)]) ) { |
| alt38=5; |
| } |
| else if ( ([self evaluateSyntacticPredicate:@selector(synpred6_Fuzzy_fragment)]) ) { |
| alt38=6; |
| } |
| else if ( ([self evaluateSyntacticPredicate:@selector(synpred7_Fuzzy_fragment)]) ) { |
| alt38=7; |
| } |
| else { |
| if ( state.backtracking > 0 ) { state.failed = YES; return ; } |
| |
| ANTLRNoViableAltException *nvae = [ANTLRNoViableAltException newException:38 state:11 stream:input]; |
| nvae.c = LA38_11; |
| @throw nvae; |
| |
| } |
| } |
| break; |
| case 'A': ; |
| case 'B': ; |
| case 'C': ; |
| case 'D': ; |
| case 'E': ; |
| case 'F': ; |
| case 'G': ; |
| case 'H': ; |
| case 'I': ; |
| case 'J': ; |
| case 'K': ; |
| case 'L': ; |
| case 'M': ; |
| case 'N': ; |
| case 'O': ; |
| case 'P': ; |
| case 'Q': ; |
| case 'R': ; |
| case 'S': ; |
| case 'T': ; |
| case 'U': ; |
| case 'V': ; |
| case 'W': ; |
| case 'X': ; |
| case 'Y': ; |
| case 'Z': ; |
| case '_': ; |
| case 'a': ; |
| case 'b': ; |
| case 'd': ; |
| case 'e': ; |
| case 'g': ; |
| case 'h': ; |
| case 'j': ; |
| case 'k': ; |
| case 'l': ; |
| case 'm': ; |
| case 'n': ; |
| case 'o': ; |
| case 'p': ; |
| case 'q': ; |
| case 't': ; |
| case 'u': ; |
| case 'v': ; |
| case 'x': ; |
| case 'y': ; |
| case 'z': ; |
| { |
| NSInteger LA38_12 = [input LA:2]; |
| |
| if ( ([self evaluateSyntacticPredicate:@selector(synpred4_Fuzzy_fragment)]) ) { |
| alt38=4; |
| } |
| else if ( ([self evaluateSyntacticPredicate:@selector(synpred5_Fuzzy_fragment)]) ) { |
| alt38=5; |
| } |
| else if ( ([self evaluateSyntacticPredicate:@selector(synpred7_Fuzzy_fragment)]) ) { |
| alt38=7; |
| } |
| else { |
| if ( state.backtracking > 0 ) { state.failed = YES; return ; } |
| |
| ANTLRNoViableAltException *nvae = [ANTLRNoViableAltException newException:38 state:12 stream:input]; |
| nvae.c = LA38_12; |
| @throw nvae; |
| |
| } |
| } |
| break; |
| case '/': ; |
| { |
| NSInteger LA38_13 = [input LA:2]; |
| |
| if ( ([self evaluateSyntacticPredicate:@selector(synpred8_Fuzzy_fragment)]) ) { |
| alt38=8; |
| } |
| else if ( ([self evaluateSyntacticPredicate:@selector(synpred9_Fuzzy_fragment)]) ) { |
| alt38=9; |
| } |
| else { |
| if ( state.backtracking > 0 ) { state.failed = YES; return ; } |
| |
| ANTLRNoViableAltException *nvae = [ANTLRNoViableAltException newException:38 state:13 stream:input]; |
| nvae.c = LA38_13; |
| @throw nvae; |
| |
| } |
| } |
| break; |
| case '"': ; |
| { |
| alt38=10; |
| } |
| break; |
| case '\'': ; |
| { |
| alt38=11; |
| } |
| break; |
| case '\t': ; |
| case '\n': ; |
| case ' ': ; |
| { |
| alt38=12; |
| } |
| break; |
| |
| default: ; |
| if ( state.backtracking > 0 ) { state.failed = YES; return ; } |
| |
| ANTLRNoViableAltException *nvae = [ANTLRNoViableAltException newException:38 state:0 stream:input]; |
| nvae.c = charLA38; |
| @throw nvae; |
| |
| } |
| |
| switch (alt38) { |
| case 1 : ; |
| // Fuzzy.g:1:41: IMPORT // alt |
| { |
| [self mIMPORT]; if ( state.failed ) return ; |
| |
| |
| |
| } |
| break; |
| case 2 : ; |
| // Fuzzy.g:1:48: RETURN // alt |
| { |
| [self mRETURN]; if ( state.failed ) return ; |
| |
| |
| |
| } |
| break; |
| case 3 : ; |
| // Fuzzy.g:1:55: CLASS // alt |
| { |
| [self mCLASS]; if ( state.failed ) return ; |
| |
| |
| |
| } |
| break; |
| case 4 : ; |
| // Fuzzy.g:1:61: METHOD // alt |
| { |
| [self mMETHOD]; if ( state.failed ) return ; |
| |
| |
| |
| } |
| break; |
| case 5 : ; |
| // Fuzzy.g:1:68: FIELD // alt |
| { |
| [self mFIELD]; if ( state.failed ) return ; |
| |
| |
| |
| } |
| break; |
| case 6 : ; |
| // Fuzzy.g:1:74: STAT // alt |
| { |
| [self mSTAT]; if ( state.failed ) return ; |
| |
| |
| |
| } |
| break; |
| case 7 : ; |
| // Fuzzy.g:1:79: CALL // alt |
| { |
| [self mCALL]; if ( state.failed ) return ; |
| |
| |
| |
| } |
| break; |
| case 8 : ; |
| // Fuzzy.g:1:84: COMMENT // alt |
| { |
| [self mCOMMENT]; if ( state.failed ) return ; |
| |
| |
| |
| } |
| break; |
| case 9 : ; |
| // Fuzzy.g:1:92: SL_COMMENT // alt |
| { |
| [self mSL_COMMENT]; if ( state.failed ) return ; |
| |
| |
| |
| } |
| break; |
| case 10 : ; |
| // Fuzzy.g:1:103: STRING // alt |
| { |
| [self mSTRING]; if ( state.failed ) return ; |
| |
| |
| |
| } |
| break; |
| case 11 : ; |
| // Fuzzy.g:1:110: CHAR // alt |
| { |
| [self mCHAR]; if ( state.failed ) return ; |
| |
| |
| |
| } |
| break; |
| case 12 : ; |
| // Fuzzy.g:1:115: WS // alt |
| { |
| [self mWS]; if ( state.failed ) return ; |
| |
| |
| |
| } |
| break; |
| |
| } |
| |
| } |
| |
| // $ANTLR start synpred1_Fuzzy_fragment |
| - (void) synpred1_Fuzzy_fragment |
| { |
| // Fuzzy.g:1:41: ( IMPORT ) // ruleBlockSingleAlt |
| // Fuzzy.g:1:41: IMPORT // alt |
| { |
| [self mIMPORT]; if ( state.failed ) return ; |
| |
| |
| |
| } |
| |
| } // $ANTLR end synpred1_Fuzzy_fragment |
| |
| // $ANTLR start synpred2_Fuzzy_fragment |
| - (void) synpred2_Fuzzy_fragment |
| { |
| // Fuzzy.g:1:48: ( RETURN ) // ruleBlockSingleAlt |
| // Fuzzy.g:1:48: RETURN // alt |
| { |
| [self mRETURN]; if ( state.failed ) return ; |
| |
| |
| |
| } |
| |
| } // $ANTLR end synpred2_Fuzzy_fragment |
| |
| // $ANTLR start synpred3_Fuzzy_fragment |
| - (void) synpred3_Fuzzy_fragment |
| { |
| // Fuzzy.g:1:55: ( CLASS ) // ruleBlockSingleAlt |
| // Fuzzy.g:1:55: CLASS // alt |
| { |
| [self mCLASS]; if ( state.failed ) return ; |
| |
| |
| |
| } |
| |
| } // $ANTLR end synpred3_Fuzzy_fragment |
| |
| // $ANTLR start synpred4_Fuzzy_fragment |
| - (void) synpred4_Fuzzy_fragment |
| { |
| // Fuzzy.g:1:61: ( METHOD ) // ruleBlockSingleAlt |
| // Fuzzy.g:1:61: METHOD // alt |
| { |
| [self mMETHOD]; if ( state.failed ) return ; |
| |
| |
| |
| } |
| |
| } // $ANTLR end synpred4_Fuzzy_fragment |
| |
| // $ANTLR start synpred5_Fuzzy_fragment |
| - (void) synpred5_Fuzzy_fragment |
| { |
| // Fuzzy.g:1:68: ( FIELD ) // ruleBlockSingleAlt |
| // Fuzzy.g:1:68: FIELD // alt |
| { |
| [self mFIELD]; if ( state.failed ) return ; |
| |
| |
| |
| } |
| |
| } // $ANTLR end synpred5_Fuzzy_fragment |
| |
| // $ANTLR start synpred6_Fuzzy_fragment |
| - (void) synpred6_Fuzzy_fragment |
| { |
| // Fuzzy.g:1:74: ( STAT ) // ruleBlockSingleAlt |
| // Fuzzy.g:1:74: STAT // alt |
| { |
| [self mSTAT]; if ( state.failed ) return ; |
| |
| |
| |
| } |
| |
| } // $ANTLR end synpred6_Fuzzy_fragment |
| |
| // $ANTLR start synpred7_Fuzzy_fragment |
| - (void) synpred7_Fuzzy_fragment |
| { |
| // Fuzzy.g:1:79: ( CALL ) // ruleBlockSingleAlt |
| // Fuzzy.g:1:79: CALL // alt |
| { |
| [self mCALL]; if ( state.failed ) return ; |
| |
| |
| |
| } |
| |
| } // $ANTLR end synpred7_Fuzzy_fragment |
| |
| // $ANTLR start synpred8_Fuzzy_fragment |
| - (void) synpred8_Fuzzy_fragment |
| { |
| // Fuzzy.g:1:84: ( COMMENT ) // ruleBlockSingleAlt |
| // Fuzzy.g:1:84: COMMENT // alt |
| { |
| [self mCOMMENT]; if ( state.failed ) return ; |
| |
| |
| |
| } |
| |
| } // $ANTLR end synpred8_Fuzzy_fragment |
| |
| // $ANTLR start synpred9_Fuzzy_fragment |
| - (void) synpred9_Fuzzy_fragment |
| { |
| // Fuzzy.g:1:92: ( SL_COMMENT ) // ruleBlockSingleAlt |
| // Fuzzy.g:1:92: SL_COMMENT // alt |
| { |
| [self mSL_COMMENT]; if ( state.failed ) return ; |
| |
| |
| |
| } |
| |
| } // $ANTLR end synpred9_Fuzzy_fragment |
| |
| @end /* end of Fuzzy implementation line 397 */ |
