#include?
#include?
#include?
typedef?int?ValType;
typedef?enum?Symbol?{?
	ERR?=-1ENDNUMPLUSMINUSTIMESSLASHLPARENRPAREN
}?Symbol;

//二叉樹定義
typedef?struct?ASTNode?{
????Symbol?sym;
????ValType?val;
????int?id;
????struct?ASTNode?*?arg1?*arg2;
}?ASTNode?*AST;

//棧的定義
typedef?struct?Stack{
????AST?basetop;
????int?length;
}?Stack;

AST?E;
AST?Er;
AST?T;
AST?Tr;
AST?F;
char?ch;
Symbol?SYM;
int?flag?=0;
int?LastIsNum=0;
int?number;
int?clock?=?1;

//創建節點
ASTNode?*mknode（Symbol?op?ASTNode?*arg1?ASTNode?*arg2）;?//返回新創建的一個運算節點，標號是op，域arg1?和arg2?分別指向一棵子樹。
ASTNode?*mkleaf（Symbol?sym?ValType?val）;??//返回新創建的一個數節點，標號為num，域val?用于存放數的值
int?InOrderTraverse（AST?E）;??//中序遍歷
void?OutFour（AST?E）;??//輸出四元式
int?calculate（Symbol?sym?int?val1?int?val2）;??//計算二元運算

//棧的操作
int?InitStack（Stack?*S）;
void?Push（Stack?*SASTNode?p）;
int?StackEmpty（Stack?S）;
int?GetTop（Stack?SAST?p）;
void?Pop（Stack?*SAST?p）;

//輸出符號
void?outputchar（AST?E）;

//語法分析相關函數
Symbol?gettoken（）;
void?error（）;
void?expr（）;
void?exprRest（）;
void?term（）;
void?termRest（）;
void?factor（）;
void?match（Symbol）;

void?main（）
{
???printf（“請輸入無符號整形四則運算表達式:\n“）;
???SYM?=?gettoken（）;
???expr（）;
???printf（“\n語法分析結果：“）;
???if（flag?==?0?&&?SYM?==?END）
???{
??????printf（“正確!!!\n\n“）;
??????InOrderTraverse（E）;
??????printf（“四元式序列:\n\n“）;
??????OutFour（E）;
??????printf（“\n計算結果為：%d\n\n“E->val）;
???}
???else
	??printf（“錯誤!!!\n“）;
}


//?二叉樹操作
//返回新創建的一個運算節點，標號是op，域arg1?和arg2?分別指向一棵子樹
ASTNode?*mknode（Symbol?op?ASTNode?*arg1?ASTNode?*arg2）
{
	ASTNode?*NewNode?=?（AST）malloc（sizeof（ASTNode））;
	if（!NewNode）
	{
		printf（“運算符號結點創建失敗\n“）;
		exit（0）;
	}
	NewNode->sym?=?op;
	NewNode->id?=?clock++;
	NewNode->arg1?=?arg1;
	NewNode->arg2?=?arg2;
	return?NewNode;
}

//返回新創建的一個數節點，標號為num，域val?用于存放數的值
ASTNode?*mkleaf（Symbol?sym?ValType?val）
{
	ASTNode?*NewLeaf=?（AST）malloc（sizeof（ASTNode））;
	if（!NewLeaf）
	{
		printf（“數結點創建失敗\n“）;
		exit（0）;
	}
	NewLeaf->sym?=?sym;
	NewLeaf->val?=?val;
	NewLeaf->id?=?0;
	NewLeaf->arg1?=?NULL;
	NewLeaf->arg2?=?NULL;
	return?NewLeaf;
}

//中序遍歷
int?InOrderTraverse（AST?E）
{
	Stack?*S?=?（Stack?*）malloc（sizeof（Stack））;
	AST?p?=?（AST）malloc（sizeof（ASTNode））;
	InitStack（S）;
	Push（S*E）;
	printf（“抽象語法樹的中序遍歷序列:\n\n“）;
	while（!StackEmpty（*S））
	{
		while（GetTop（*Sp）&&（p->arg1!=NULL））
			Push（S*（p->arg1））;
		while（!StackEmpty（*S））
		{
			Pop（Sp）;
			outputchar（p）;
			if（p->arg2）
			{
				Push（S*（p->arg2））;
				break;
			}
		}
	}
	printf（“\n\n“）;
	return?1;
}

//輸出四元式
void?OutFour（AST?p）
{
	if（p->sym==NUM）
	{
		printf（“無四元式\n“）;
		return?;
	}
	if（p->arg1->sym==NUM&&p->arg2->sym==NUM）
	{
		p->val?=?calculate（p->symp->arg1->valp->arg2->val）;
		outputchar（p）;
		if（p->arg1->id==0）
			outputchar（p->arg1）;
		else
			printf（“%4c%d“‘T‘p->arg1->id）;
		if（p->arg2->id==0）
			outputchar（p->arg2）;
		else
			printf（“%4c%d