编译原理之语义分析

#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