dataparser.cpp

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

		astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(tmp35_AST));
		match(LITERAL_float);
		type_name_AST = RefASTNodeExt(currentAST.root);
		break;
	}
	case LITERAL_double:
	{
		RefASTNodeExt tmp36_AST = RefASTNodeExt(ANTLR_USE_NAMESPACE(antlr)nullAST);
		tmp36_AST = astFactory->create(LT(1));
		astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(tmp36_AST));
		match(LITERAL_double);
		type_name_AST = RefASTNodeExt(currentAST.root);
		break;
	}
	case LITERAL_bool:
	{
		RefASTNodeExt tmp37_AST = RefASTNodeExt(ANTLR_USE_NAMESPACE(antlr)nullAST);
		tmp37_AST = astFactory->create(LT(1));
		astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(tmp37_AST));
		match(LITERAL_bool);
		type_name_AST = RefASTNodeExt(currentAST.root);
		break;
	}
	default:
	{
		throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename());
	}
	}
	returnAST = type_name_AST;
}

void DataParser::expression() {
	returnAST = RefASTNodeExt(ANTLR_USE_NAMESPACE(antlr)nullAST);
	ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
	RefASTNodeExt expression_AST = RefASTNodeExt(ANTLR_USE_NAMESPACE(antlr)nullAST);
	
	switch ( LA(1)) {
	case INT:
	case HEX:
	case DOUBLE:
	case BIT:
	case BITS:
	case CHAR:
	case STRING:
	case LITERAL_true:
	case LITERAL_false:
	{
		const_value();
		astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
		expression_AST = RefASTNodeExt(currentAST.root);
		break;
	}
	case IDENT:
	{
		RefASTNodeExt tmp38_AST = RefASTNodeExt(ANTLR_USE_NAMESPACE(antlr)nullAST);
		tmp38_AST = astFactory->create(LT(1));
		astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(tmp38_AST));
		match(IDENT);
		expression_AST = RefASTNodeExt(currentAST.root);
		break;
	}
	default:
	{
		throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename());
	}
	}
	returnAST = expression_AST;
}

void DataParser::const_value() {
	returnAST = RefASTNodeExt(ANTLR_USE_NAMESPACE(antlr)nullAST);
	ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
	RefASTNodeExt const_value_AST = RefASTNodeExt(ANTLR_USE_NAMESPACE(antlr)nullAST);
	
	switch ( LA(1)) {
	case BIT:
	{
		RefASTNodeExt tmp39_AST = RefASTNodeExt(ANTLR_USE_NAMESPACE(antlr)nullAST);
		tmp39_AST = astFactory->create(LT(1));
		astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(tmp39_AST));
		match(BIT);
		const_value_AST = RefASTNodeExt(currentAST.root);
		break;
	}
	case BITS:
	{
		RefASTNodeExt tmp40_AST = RefASTNodeExt(ANTLR_USE_NAMESPACE(antlr)nullAST);
		tmp40_AST = astFactory->create(LT(1));
		astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(tmp40_AST));
		match(BITS);
		const_value_AST = RefASTNodeExt(currentAST.root);
		break;
	}
	case INT:
	{
		RefASTNodeExt tmp41_AST = RefASTNodeExt(ANTLR_USE_NAMESPACE(antlr)nullAST);
		tmp41_AST = astFactory->create(LT(1));
		astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(tmp41_AST));
		match(INT);
		const_value_AST = RefASTNodeExt(currentAST.root);
		break;
	}
	case HEX:
	{
		RefASTNodeExt tmp42_AST = RefASTNodeExt(ANTLR_USE_NAMESPACE(antlr)nullAST);
		tmp42_AST = astFactory->create(LT(1));
		astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(tmp42_AST));
		match(HEX);
		const_value_AST = RefASTNodeExt(currentAST.root);
		break;
	}
	case DOUBLE:
	{
		RefASTNodeExt tmp43_AST = RefASTNodeExt(ANTLR_USE_NAMESPACE(antlr)nullAST);
		tmp43_AST = astFactory->create(LT(1));
		astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(tmp43_AST));
		match(DOUBLE);
		const_value_AST = RefASTNodeExt(currentAST.root);
		break;
	}
	case CHAR:
	{
		RefASTNodeExt tmp44_AST = RefASTNodeExt(ANTLR_USE_NAMESPACE(antlr)nullAST);
		tmp44_AST = astFactory->create(LT(1));
		astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(tmp44_AST));
		match(CHAR);
		const_value_AST = RefASTNodeExt(currentAST.root);
		break;
	}
	case STRING:
	{
		RefASTNodeExt tmp45_AST = RefASTNodeExt(ANTLR_USE_NAMESPACE(antlr)nullAST);
		tmp45_AST = astFactory->create(LT(1));
		astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(tmp45_AST));
		match(STRING);
		const_value_AST = RefASTNodeExt(currentAST.root);
		break;
	}
	case LITERAL_true:
	{
		RefASTNodeExt tmp46_AST = RefASTNodeExt(ANTLR_USE_NAMESPACE(antlr)nullAST);
		tmp46_AST = astFactory->create(LT(1));
		astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(tmp46_AST));
		match(LITERAL_true);
		const_value_AST = RefASTNodeExt(currentAST.root);
		break;
	}
	case LITERAL_false:
	{
		RefASTNodeExt tmp47_AST = RefASTNodeExt(ANTLR_USE_NAMESPACE(antlr)nullAST);
		tmp47_AST = astFactory->create(LT(1));
		astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(tmp47_AST));
		match(LITERAL_false);
		const_value_AST = RefASTNodeExt(currentAST.root);
		break;
	}
	default:
	{
		throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename());
	}
	}
	returnAST = const_value_AST;
}

void DataParser::block() {
	returnAST = RefASTNodeExt(ANTLR_USE_NAMESPACE(antlr)nullAST);
	ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
	RefASTNodeExt block_AST = RefASTNodeExt(ANTLR_USE_NAMESPACE(antlr)nullAST);
	
	match(LCURLY);
	{ // ( ... )*
	for (;;) {
		if ((_tokenSet_0.member(LA(1)))) {
			statement();
			astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
		}
		else {
			goto _loop75;
		}
		
	}
	_loop75:;
	} // ( ... )*
	match(RCURLY);
	block_AST = RefASTNodeExt(currentAST.root);
#line 217 "syntax.g"
	block_AST = RefASTNodeExt(astFactory->make((new ANTLR_USE_NAMESPACE(antlr)ASTArray(2))->add(ANTLR_USE_NAMESPACE(antlr)RefAST(astFactory->create(BLOCK,"BLOCK")))->add(ANTLR_USE_NAMESPACE(antlr)RefAST(block_AST))));
#line 465 "DataParser.cpp"
	currentAST.root = block_AST;
	if ( block_AST!=RefASTNodeExt(ANTLR_USE_NAMESPACE(antlr)nullAST) &&
		block_AST->getFirstChild() != RefASTNodeExt(ANTLR_USE_NAMESPACE(antlr)nullAST) )
		  currentAST.child = block_AST->getFirstChild();
	else
		currentAST.child = block_AST;
	currentAST.advanceChildToEnd();
	block_AST = RefASTNodeExt(currentAST.root);
	returnAST = block_AST;
}

void DataParser::assign_statement() {
	returnAST = RefASTNodeExt(ANTLR_USE_NAMESPACE(antlr)nullAST);
	ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
	RefASTNodeExt assign_statement_AST = RefASTNodeExt(ANTLR_USE_NAMESPACE(antlr)nullAST);
	
	RefASTNodeExt tmp50_AST = RefASTNodeExt(ANTLR_USE_NAMESPACE(antlr)nullAST);
	tmp50_AST = astFactory->create(LT(1));
	astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(tmp50_AST));
	match(IDENT);
	RefASTNodeExt tmp51_AST = RefASTNodeExt(ANTLR_USE_NAMESPACE(antlr)nullAST);
	tmp51_AST = astFactory->create(LT(1));
	astFactory->makeASTRoot(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(tmp51_AST));
	match(ASSIGN);
	expression();
	astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
	match(SEMI);
	assign_statement_AST = RefASTNodeExt(currentAST.root);
	returnAST = assign_statement_AST;
}

void DataParser::initializeASTFactory( ANTLR_USE_NAMESPACE(antlr)ASTFactory& factory )
{
	factory.setMaxNodeType(40);
}
const char* DataParser::tokenNames[] = {
	"<0>",
	"EOF",
	"<2>",
	"NULL_TREE_LOOKAHEAD",
	"APOSTROPHE",
	"SEMI",
	"COLON",
	"ASSIGN",
	"DIGIT",
	"an integer value",
	"a hexadecimal integer value",
	"an floating point value",
	"WS",
	"an identifer",
	"BIT",
	"BITS",
	"SL_COMMENT",
	"ML_COMMENT",
	"a character literal",
	"a string literal",
	"ESC",
	"BLOCK",
	"PROGRAM",
	"DEFASSIGN",
	"COMMA",
	"\"true\"",
	"\"false\"",
	"\"bit\"",
	"\"bits\"",
	"\"uint8\"",
	"\"char\"",
	"\"string\"",
	"\"uint16\"",
	"\"int16\"",
	"\"int\"",
	"\"uint\"",
	"\"float\"",
	"\"double\"",
	"\"bool\"",
	"LCURLY",
	"RCURLY",
	0
};

const unsigned long DataParser::_tokenSet_0_data_[] = { 4160757760UL, 255UL, 0UL, 0UL };
// IDENT "bit" "bits" "uint8" "char" "string" "uint16" "int16" "int" "uint" 
// "float" "double" "bool" LCURLY 
const ANTLR_USE_NAMESPACE(antlr)BitSet DataParser::_tokenSet_0(_tokenSet_0_data_,4);