dataparser.cpp

基于ANTLR的简单编译器源码version0.1

/* $ANTLR 2.7.7 (2006-11-01): "syntax.g" -> "DataParser.cpp"$ */
#include "DataParser.hpp"
#include <antlr/NoViableAltException.hpp>
#include <antlr/SemanticException.hpp>
#include <antlr/ASTFactory.hpp>
#line 1 "syntax.g"
#line 8 "DataParser.cpp"
DataParser::DataParser(ANTLR_USE_NAMESPACE(antlr)TokenBuffer& tokenBuf, int k)
: ANTLR_USE_NAMESPACE(antlr)LLkParser(tokenBuf,k)
{
}

DataParser::DataParser(ANTLR_USE_NAMESPACE(antlr)TokenBuffer& tokenBuf)
: ANTLR_USE_NAMESPACE(antlr)LLkParser(tokenBuf,3)
{
}

DataParser::DataParser(ANTLR_USE_NAMESPACE(antlr)TokenStream& lexer, int k)
: ANTLR_USE_NAMESPACE(antlr)LLkParser(lexer,k)
{
}

DataParser::DataParser(ANTLR_USE_NAMESPACE(antlr)TokenStream& lexer)
: ANTLR_USE_NAMESPACE(antlr)LLkParser(lexer,3)
{
}

DataParser::DataParser(const ANTLR_USE_NAMESPACE(antlr)ParserSharedInputState& state)
: ANTLR_USE_NAMESPACE(antlr)LLkParser(state,3)
{
}

void DataParser::program() {
	returnAST = RefASTNodeExt(ANTLR_USE_NAMESPACE(antlr)nullAST);
	ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
	RefASTNodeExt program_AST = RefASTNodeExt(ANTLR_USE_NAMESPACE(antlr)nullAST);
	
	{ // ( ... )*
	for (;;) {
		if ((_tokenSet_0.member(LA(1)))) {
			statement();
			astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
		}
		else {
			goto _loop64;
		}
		
	}
	_loop64:;
	} // ( ... )*
	program_AST = RefASTNodeExt(currentAST.root);
#line 171 "syntax.g"
	program_AST =RefASTNodeExt(astFactory->make((new ANTLR_USE_NAMESPACE(antlr)ASTArray(2))->add(ANTLR_USE_NAMESPACE(antlr)RefAST(astFactory->create(PROGRAM,"PROGRAM")))->add(ANTLR_USE_NAMESPACE(antlr)RefAST(program_AST))));
#line 55 "DataParser.cpp"
	currentAST.root = program_AST;
	if ( program_AST!=RefASTNodeExt(ANTLR_USE_NAMESPACE(antlr)nullAST) &&
		program_AST->getFirstChild() != RefASTNodeExt(ANTLR_USE_NAMESPACE(antlr)nullAST) )
		  currentAST.child = program_AST->getFirstChild();
	else
		currentAST.child = program_AST;
	currentAST.advanceChildToEnd();
	program_AST = RefASTNodeExt(currentAST.root);
	returnAST = program_AST;
}

void DataParser::statement() {
	returnAST = RefASTNodeExt(ANTLR_USE_NAMESPACE(antlr)nullAST);
	ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
	RefASTNodeExt statement_AST = RefASTNodeExt(ANTLR_USE_NAMESPACE(antlr)nullAST);
	
	switch ( LA(1)) {
	case LITERAL_bit:
	case LITERAL_bits:
	case 29:
	case LITERAL_char:
	case LITERAL_string:
	case 32:
	case 33:
	case LITERAL_int:
	case LITERAL_uint:
	case LITERAL_float:
	case LITERAL_double:
	case LITERAL_bool:
	{
		definition();
		astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
		statement_AST = RefASTNodeExt(currentAST.root);
		break;
	}
	case IDENT:
	{
		assign_statement();
		astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
		statement_AST = RefASTNodeExt(currentAST.root);
		break;
	}
	case LCURLY:
	{
		block();
		astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
		statement_AST = RefASTNodeExt(currentAST.root);
		break;
	}
	default:
	{
		throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename());
	}
	}
	returnAST = statement_AST;
}

void DataParser::definition() {
	returnAST = RefASTNodeExt(ANTLR_USE_NAMESPACE(antlr)nullAST);
	ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
	RefASTNodeExt definition_AST = RefASTNodeExt(ANTLR_USE_NAMESPACE(antlr)nullAST);
	
	var_def();
	astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
	definition_AST = RefASTNodeExt(currentAST.root);
	returnAST = definition_AST;
}

void DataParser::var_def() {
	returnAST = RefASTNodeExt(ANTLR_USE_NAMESPACE(antlr)nullAST);
	ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
	RefASTNodeExt var_def_AST = RefASTNodeExt(ANTLR_USE_NAMESPACE(antlr)nullAST);
	
	type_name();
	astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
	match(COLON);
	{
	if ((LA(1) == IDENT) && (LA(2) == ASSIGN)) {
		RefASTNodeExt tmp20_AST = RefASTNodeExt(ANTLR_USE_NAMESPACE(antlr)nullAST);
		tmp20_AST = astFactory->create(LT(1));
		astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(tmp20_AST));
		match(IDENT);
		{
		match(ASSIGN);
		expression();
		astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
		}
		var_def_AST = RefASTNodeExt(currentAST.root);
#line 181 "syntax.g"
		var_def_AST =RefASTNodeExt(astFactory->make((new ANTLR_USE_NAMESPACE(antlr)ASTArray(2))->add(ANTLR_USE_NAMESPACE(antlr)RefAST(astFactory->create(DEFASSIGN,"DEFASSIGN")))->add(ANTLR_USE_NAMESPACE(antlr)RefAST(var_def_AST))));
#line 146 "DataParser.cpp"
		currentAST.root = var_def_AST;
		if ( var_def_AST!=RefASTNodeExt(ANTLR_USE_NAMESPACE(antlr)nullAST) &&
			var_def_AST->getFirstChild() != RefASTNodeExt(ANTLR_USE_NAMESPACE(antlr)nullAST) )
			  currentAST.child = var_def_AST->getFirstChild();
		else
			currentAST.child = var_def_AST;
		currentAST.advanceChildToEnd();
	}
	else if ((LA(1) == IDENT) && (LA(2) == SEMI || LA(2) == COMMA)) {
		RefASTNodeExt tmp22_AST = RefASTNodeExt(ANTLR_USE_NAMESPACE(antlr)nullAST);
		tmp22_AST = astFactory->create(LT(1));
		astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(tmp22_AST));
		match(IDENT);
		{ // ( ... )*
		for (;;) {
			if ((LA(1) == COMMA)) {
				match(COMMA);
				RefASTNodeExt tmp24_AST = RefASTNodeExt(ANTLR_USE_NAMESPACE(antlr)nullAST);
				tmp24_AST = astFactory->create(LT(1));
				astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(tmp24_AST));
				match(IDENT);
			}
			else {
				goto _loop70;
			}
			
		}
		_loop70:;
		} // ( ... )*
	}
	else {
		throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename());
	}
	
	}
	match(SEMI);
	var_def_AST = RefASTNodeExt(currentAST.root);
	returnAST = var_def_AST;
}

void DataParser::type_name() {
	returnAST = RefASTNodeExt(ANTLR_USE_NAMESPACE(antlr)nullAST);
	ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
	RefASTNodeExt type_name_AST = RefASTNodeExt(ANTLR_USE_NAMESPACE(antlr)nullAST);
	
	switch ( LA(1)) {
	case LITERAL_bit:
	{
		RefASTNodeExt tmp26_AST = RefASTNodeExt(ANTLR_USE_NAMESPACE(antlr)nullAST);
		tmp26_AST = astFactory->create(LT(1));
		astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(tmp26_AST));
		match(LITERAL_bit);
		type_name_AST = RefASTNodeExt(currentAST.root);
		break;
	}
	case LITERAL_bits:
	{
		RefASTNodeExt tmp27_AST = RefASTNodeExt(ANTLR_USE_NAMESPACE(antlr)nullAST);
		tmp27_AST = astFactory->create(LT(1));
		astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(tmp27_AST));
		match(LITERAL_bits);
		type_name_AST = RefASTNodeExt(currentAST.root);
		break;
	}
	case 29:
	{
		RefASTNodeExt tmp28_AST = RefASTNodeExt(ANTLR_USE_NAMESPACE(antlr)nullAST);
		tmp28_AST = astFactory->create(LT(1));
		astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(tmp28_AST));
		match(29);
		type_name_AST = RefASTNodeExt(currentAST.root);
		break;
	}
	case LITERAL_char:
	{
		RefASTNodeExt tmp29_AST = RefASTNodeExt(ANTLR_USE_NAMESPACE(antlr)nullAST);
		tmp29_AST = astFactory->create(LT(1));
		astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(tmp29_AST));
		match(LITERAL_char);
		type_name_AST = RefASTNodeExt(currentAST.root);
		break;
	}
	case LITERAL_string:
	{
		RefASTNodeExt tmp30_AST = RefASTNodeExt(ANTLR_USE_NAMESPACE(antlr)nullAST);
		tmp30_AST = astFactory->create(LT(1));
		astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(tmp30_AST));
		match(LITERAL_string);
		type_name_AST = RefASTNodeExt(currentAST.root);
		break;
	}
	case 32:
	{
		RefASTNodeExt tmp31_AST = RefASTNodeExt(ANTLR_USE_NAMESPACE(antlr)nullAST);
		tmp31_AST = astFactory->create(LT(1));
		astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(tmp31_AST));
		match(32);
		type_name_AST = RefASTNodeExt(currentAST.root);
		break;
	}
	case 33:
	{
		RefASTNodeExt tmp32_AST = RefASTNodeExt(ANTLR_USE_NAMESPACE(antlr)nullAST);
		tmp32_AST = astFactory->create(LT(1));
		astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(tmp32_AST));
		match(33);
		type_name_AST = RefASTNodeExt(currentAST.root);
		break;
	}
	case LITERAL_int:
	{
		RefASTNodeExt tmp33_AST = RefASTNodeExt(ANTLR_USE_NAMESPACE(antlr)nullAST);
		tmp33_AST = astFactory->create(LT(1));
		astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(tmp33_AST));
		match(LITERAL_int);
		type_name_AST = RefASTNodeExt(currentAST.root);
		break;
	}
	case LITERAL_uint:
	{
		RefASTNodeExt tmp34_AST = RefASTNodeExt(ANTLR_USE_NAMESPACE(antlr)nullAST);
		tmp34_AST = astFactory->create(LT(1));
		astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(tmp34_AST));
		match(LITERAL_uint);
		type_name_AST = RefASTNodeExt(currentAST.root);
		break;
	}
	case LITERAL_float:
	{
		RefASTNodeExt tmp35_AST = RefASTNodeExt(ANTLR_USE_NAMESPACE(antlr)nullAST);
		tmp35_AST = astFactory->create(LT(1));