simplectp.m

antlr最新版本V3源代码

	}
	return ;
}
// $ANTLR end block

// $ANTLR start stat
// SimpleCTP.gtp:45:1: stat : ( forStat | expr | block );
- (void) stat
{
    // token labels
    // token+rule list labels
    // rule labels
    // rule list labels
    // rule refs in alts with rewrites

    @try {
        // SimpleCTP.gtp:45:7: ( forStat | expr | block ) //ruleblock
        int alt6=3;
        switch ([input LA:1]) {
        	case SimpleCTP_FOR:
        		alt6 = 1;
        		break;
        	case SimpleCTP_ID:
        	case SimpleCTP_EQ:
        	case SimpleCTP_INT:
        	case SimpleCTP_EQEQ:
        	case SimpleCTP_LT:
        	case SimpleCTP_PLUS:
        		alt6 = 2;
        		break;
        	case SimpleCTP_BLOCK:
        		alt6 = 3;
        		break;
        default:
         {
            ANTLRNoViableAltException *nvae = [ANTLRNoViableAltException exceptionWithDecision:6 state:0 stream:input];
        	@throw nvae;

        	}}
        switch (alt6) {
        	case 1 :
        	    // SimpleCTP.gtp:45:7: forStat // alt
        	    {
        	    [following addObject:FOLLOW_forStat_in_stat292];
        	    [self forStat];
        	    [following removeLastObject];



        	    }
        	    break;
        	case 2 :
        	    // SimpleCTP.gtp:46:7: expr // alt
        	    {
        	    [following addObject:FOLLOW_expr_in_stat300];
        	    [self expr];
        	    [following removeLastObject];



        	    }
        	    break;
        	case 3 :
        	    // SimpleCTP.gtp:47:7: block // alt
        	    {
        	    [following addObject:FOLLOW_block_in_stat308];
        	    [self block];
        	    [following removeLastObject];



        	    }
        	    break;

        }
    }
	@catch (ANTLRRecognitionException *re) {
		[self reportError:re];
		[self recover:input exception:re];
	}
	@finally {
		// token labels
		// token+rule list labels
		// rule labels
		// rule refs in alts with rewrites

	}
	return ;
}
// $ANTLR end stat

// $ANTLR start forStat
// SimpleCTP.gtp:50:1: forStat : ^( 'for' expr expr expr block ) ;
- (void) forStat
{
    // token labels
    // token+rule list labels
    // rule labels
    // rule list labels
    // rule refs in alts with rewrites

    @try {
        // SimpleCTP.gtp:51:9: ( ^( 'for' expr expr expr block ) ) // ruleBlockSingleAlt
        // SimpleCTP.gtp:51:9: ^( 'for' expr expr expr block ) // alt
        {
        [self match:input tokenType:SimpleCTP_FOR follow:FOLLOW_SimpleCTP_FOR_in_forStat328]; 

        [self match:input tokenType:ANTLRTokenTypeDOWN follow:nil]; 
        [following addObject:FOLLOW_expr_in_forStat330];
        [self expr];
        [following removeLastObject];


        [following addObject:FOLLOW_expr_in_forStat332];
        [self expr];
        [following removeLastObject];


        [following addObject:FOLLOW_expr_in_forStat334];
        [self expr];
        [following removeLastObject];


        [following addObject:FOLLOW_block_in_forStat336];
        [self block];
        [following removeLastObject];



        [self match:input tokenType:ANTLRTokenTypeUP follow:nil]; 

        }

    }
	@catch (ANTLRRecognitionException *re) {
		[self reportError:re];
		[self recover:input exception:re];
	}
	@finally {
		// token labels
		// token+rule list labels
		// rule labels
		// rule refs in alts with rewrites

	}
	return ;
}
// $ANTLR end forStat

// $ANTLR start expr
// SimpleCTP.gtp:54:1: expr : ( ^( EQEQ expr expr ) | ^( LT expr expr ) | ^( PLUS expr expr ) | ^( EQ ID expr ) | atom );
- (void) expr
{
    // token labels
    // token+rule list labels
    // rule labels
    // rule list labels
    // rule refs in alts with rewrites

    @try {
        // SimpleCTP.gtp:54:9: ( ^( EQEQ expr expr ) | ^( LT expr expr ) | ^( PLUS expr expr ) | ^( EQ ID expr ) | atom ) //ruleblock
        int alt7=5;
        switch ([input LA:1]) {
        	case SimpleCTP_EQEQ:
        		alt7 = 1;
        		break;
        	case SimpleCTP_LT:
        		alt7 = 2;
        		break;
        	case SimpleCTP_PLUS:
        		alt7 = 3;
        		break;
        	case SimpleCTP_EQ:
        		alt7 = 4;
        		break;
        	case SimpleCTP_ID:
        	case SimpleCTP_INT:
        		alt7 = 5;
        		break;
        default:
         {
            ANTLRNoViableAltException *nvae = [ANTLRNoViableAltException exceptionWithDecision:7 state:0 stream:input];
        	@throw nvae;

        	}}
        switch (alt7) {
        	case 1 :
        	    // SimpleCTP.gtp:54:9: ^( EQEQ expr expr ) // alt
        	    {
        	    [self match:input tokenType:SimpleCTP_EQEQ follow:FOLLOW_SimpleCTP_EQEQ_in_expr352]; 

        	    [self match:input tokenType:ANTLRTokenTypeDOWN follow:nil]; 
        	    [following addObject:FOLLOW_expr_in_expr354];
        	    [self expr];
        	    [following removeLastObject];


        	    [following addObject:FOLLOW_expr_in_expr356];
        	    [self expr];
        	    [following removeLastObject];



        	    [self match:input tokenType:ANTLRTokenTypeUP follow:nil]; 

        	    }
        	    break;
        	case 2 :
        	    // SimpleCTP.gtp:55:9: ^( LT expr expr ) // alt
        	    {
        	    [self match:input tokenType:SimpleCTP_LT follow:FOLLOW_SimpleCTP_LT_in_expr368]; 

        	    [self match:input tokenType:ANTLRTokenTypeDOWN follow:nil]; 
        	    [following addObject:FOLLOW_expr_in_expr370];
        	    [self expr];
        	    [following removeLastObject];


        	    [following addObject:FOLLOW_expr_in_expr372];
        	    [self expr];
        	    [following removeLastObject];



        	    [self match:input tokenType:ANTLRTokenTypeUP follow:nil]; 

        	    }
        	    break;
        	case 3 :
        	    // SimpleCTP.gtp:56:9: ^( PLUS expr expr ) // alt
        	    {
        	    [self match:input tokenType:SimpleCTP_PLUS follow:FOLLOW_SimpleCTP_PLUS_in_expr384]; 

        	    [self match:input tokenType:ANTLRTokenTypeDOWN follow:nil]; 
        	    [following addObject:FOLLOW_expr_in_expr386];
        	    [self expr];
        	    [following removeLastObject];


        	    [following addObject:FOLLOW_expr_in_expr388];
        	    [self expr];
        	    [following removeLastObject];



        	    [self match:input tokenType:ANTLRTokenTypeUP follow:nil]; 

        	    }
        	    break;
        	case 4 :
        	    // SimpleCTP.gtp:57:9: ^( EQ ID expr ) // alt
        	    {
        	    [self match:input tokenType:SimpleCTP_EQ follow:FOLLOW_SimpleCTP_EQ_in_expr400]; 

        	    [self match:input tokenType:ANTLRTokenTypeDOWN follow:nil]; 
        	    [self match:input tokenType:SimpleCTP_ID follow:FOLLOW_SimpleCTP_ID_in_expr402]; 
        	    [following addObject:FOLLOW_expr_in_expr404];
        	    [self expr];
        	    [following removeLastObject];



        	    [self match:input tokenType:ANTLRTokenTypeUP follow:nil]; 

        	    }
        	    break;
        	case 5 :
        	    // SimpleCTP.gtp:58:9: atom // alt
        	    {
        	    [following addObject:FOLLOW_atom_in_expr415];
        	    [self atom];
        	    [following removeLastObject];



        	    }
        	    break;

        }
    }
	@catch (ANTLRRecognitionException *re) {
		[self reportError:re];
		[self recover:input exception:re];
	}
	@finally {
		// token labels
		// token+rule list labels
		// rule labels
		// rule refs in alts with rewrites

	}
	return ;
}
// $ANTLR end expr

// $ANTLR start atom
// SimpleCTP.gtp:61:1: atom : (ID|INT);
- (void) atom
{
    // token labels
    // token+rule list labels
    // rule labels
    // rule list labels
    // rule refs in alts with rewrites

    @try {
        // SimpleCTP.gtp:62:5: ( (ID|INT)) // ruleBlockSingleAlt
        // SimpleCTP.gtp:62:7: (ID|INT) // alt
        {
        if ([input LA:1]==SimpleCTP_ID||[input LA:1]==SimpleCTP_INT) {
        	[input consume];
        	errorRecovery = NO;
        } else {
        	ANTLRMismatchedSetException *mse = [ANTLRMismatchedSetException exceptionWithSet:nil stream:input];
        	[self recoverFromMismatchedSet:input exception:mse follow:FOLLOW_set_in_atom432];	@throw mse;
        }


        }

    }
	@catch (ANTLRRecognitionException *re) {
		[self reportError:re];
		[self recover:input exception:re];
	}
	@finally {
		// token labels
		// token+rule list labels
		// rule labels
		// rule refs in alts with rewrites

	}
	return ;
}
// $ANTLR end atom



@end