diff options
Diffstat (limited to 'runtime/ObjC/Framework/examples/fuzzy/Fuzzy.m')
| -rw-r--r-- | runtime/ObjC/Framework/examples/fuzzy/Fuzzy.m | 2373 |
1 files changed, 2373 insertions, 0 deletions
diff --git a/runtime/ObjC/Framework/examples/fuzzy/Fuzzy.m b/runtime/ObjC/Framework/examples/fuzzy/Fuzzy.m new file mode 100644 index 0000000..665f412 --- /dev/null +++ b/runtime/ObjC/Framework/examples/fuzzy/Fuzzy.m @@ -0,0 +1,2373 @@ +/** \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 */
\ No newline at end of file |