test.cpp

1.1 引言 1.1.1 设计目的 本次课程设计是在完成一个学期的编译原理课程之后

	char temp;
	int bufpoint,textpoint;
	isTrue=true;
	perrfile=fopen("error.txt","r");
	for(textpoint=0;textpoint<19;textpoint++){
		bufpoint=0;
		temp=fgetc(perrfile);
		while(temp!='\n'){							//和文件存储有关
			errtext[textpoint][bufpoint]=temp;
			bufpoint++;
			temp=fgetc(perrfile);
		}
		errtext[textpoint][bufpoint]='\0';
	}
	fclose(perrfile);
	level=0;										
	counter=1;
	linenum=1;
	VariableTable.first=0;
	VariableTable.last=49;
	ProcTable.pointer=-1;							//便于后续处理
	errflag_prog=false;
	ProcStack.base=ProcStack.top=(stack_item*)malloc(sizeof(stack_item));	//初始化栈
	ProcStack.base->index=0;
	ProcStack.base->next=NULL;
}

//////////////////////////////////////////////////////////////////////////////////////////////
//入栈函数
void push(){
	ProcStack.top->next=(stack_item*)malloc(sizeof(stack_item));
	ProcStack.top=ProcStack.top->next;
	ProcStack.top->index=ProcTable.pointer;
	ProcStack.top->next=NULL;
}

//////////////////////////////////////////////////////////////////////////////////////////////
//出栈函数
void pop(){
	stack_item* p=ProcStack.base;
	if(p!=ProcStack.top){
		while(p->next!=ProcStack.top)
			p=p->next;
		p->next=NULL;
		free(ProcStack.top);
		ProcStack.top=p;
	}
}

//////////////////////////////////////////////////////////////////////////////////////////////
//此函数跳过一些单词，直到读入指定的单词
//参数为索引值，按索引值跳到相应的单词
void skip(int index){
	switch(index){
	case 1:									//jump to begin
		while(WORD.index!=4){
			getWord();
			if(WORD.index==0)
				break;
		}
		break;
	case 2:									//jump to procedure or begin
		while(WORD.index!=3 && WORD.index!=4){
			getWord();
			if(WORD.index==0)
				break;
		}
		break;
	case 3:									//jump to var or procedure or begin
		while(WORD.index!=2 && WORD.index!=3 && WORD.index!=4){
			getWord();
			if(WORD.index==0)
				break;
		}
		break;
	}
}

//////////////////////////////////////////////////////////////////////////////////////////////
//此函数错误处理函数
//参数为索引值,表示正常执行第几条错误处理
void error_handle(int index){
	printf("Error:第%d行,%s\n",linenum,errtext[index]);
	isTrue=false;
}
	
//////////////////////////////////////////////////////////////////////////////////////////////
//此函数填写变量名表
//参数为0表示正常填入,为1标识倒填
void enterVTable(int flag){
	int tempointer;
	int i;
	tempointer=VariableTable.first;
	switch(flag){
	case 0:					//正常顺序填入
		if(VariableTable.first>VariableTable.last){
			error_handle(17);			//越界处理
			return;
		}
		else{
			if(counter==1)			//若是本过程第一个变量则填过程名表第一个变量所在位置first值
				ProcTable.table[ProcTable.pointer].firstinvtable=VariableTable.first;
			else{					//若不是本过程第一个变量则查本过程内是否有同名变量
				for(i=ProcTable.table[ProcTable.pointer].firstinvtable;i<tempointer;i++)
					if(strcmp(VariableTable.table[i].vname,WORD.value)==0){
						error_handle(13);
						return;
					}
			}
			VariableTable.table[tempointer].vname=(char*)malloc((strlen(WORD.value)+1)*sizeof(char));
			strcpy(VariableTable.table[tempointer].vname,WORD.value);	//填变量名
			free(WORD.value);
			VariableTable.table[tempointer].plevel=level;				//填嵌套深度
			VariableTable.table[tempointer].relposition=counter;			//填相对个数
			counter++;	
			VariableTable.first++;			
			break;
		}
	case 1:					//倒填
		if(VariableTable.last<VariableTable.first){
			error_handle(17);			//越界处理
			break;
		}
		else{
			VariableTable.table[VariableTable.last].vname=(char*)malloc((strlen(WORD.value)+1)*sizeof(char));
			strcpy(VariableTable.table[tempointer].vname,WORD.value);	//填变量名
			free(WORD.value);
			VariableTable.last--;			
			break;
		}
	}
}

//////////////////////////////////////////////////////////////////////////////////////////////
//此函数在执行语句中遇到变量去查变量名表看是否已定义
//参数变量名,返回置为-1表示没查到,查到则返回在变量名表中的下标
int searchVTable(char *v){
	int currentproc;
	int firstvar;
	int sumvar;
	int i;
	currentproc=ProcStack.top->index;
	while(currentproc!=-1){
		firstvar=ProcTable.table[currentproc].firstinvtable;
		sumvar=ProcTable.table[currentproc].variablenum;
		for(i=firstvar;i<firstvar+sumvar;i++)
			if(strcmp(VariableTable.table[i].vname,v)==0)
				return i;
		currentproc=ProcTable.table[currentproc].outposition;
	}
	for(i=49;i>VariableTable.last;i--)
		if(strcmp(VariableTable.table[i].vname,v)==0)
			return i;
	error_handle(15);
	return -1;
}

//////////////////////////////////////////////////////////////////////////////////////////////
//此函数在填过程名表前去查过程名表看是否已定义
//参数变量名,返回置为-1表示没查到,查到则返回在过程名表中的下标
int searchPTable(char* name){
	int i;
	for(i=ProcTable.pointer;i>=0;i--){
		if(strcmp(ProcTable.table[i].pname,name)==0){
			error_handle(14);
			return i;
		}
	}
	return -1;
}

//////////////////////////////////////////////////////////////////////////////////////////////
//此函数填写过程名表
void enterPTable(){
	int templevel;
	int tempindex;
	if(searchPTable(WORD.value)==-1){			//过程名不重名
		ProcTable.pointer=ProcTable.pointer+1;
		ProcTable.table[ProcTable.pointer].pname=(char*)malloc((strlen(WORD.value)+1)*sizeof(char));
		strcpy(ProcTable.table[ProcTable.pointer].pname,WORD.value);		//填过程名
		free(WORD.value);
		ProcTable.table[ProcTable.pointer].plevel=level;			//填嵌套深度
		ProcTable.table[ProcTable.pointer].paranum=0;				//参数个数初始为0,后续可能修改
		ProcTable.table[ProcTable.pointer].variablenum=0;			//变量总数初始为0,后续可能修改
		if(ProcTable.pointer==0)									//填外过程位置
			ProcTable.table[ProcTable.pointer].outposition=-1;		//主程序外过程规定为-1
		else{
			if(level==ProcTable.table[ProcTable.pointer-1].plevel)
				ProcTable.table[ProcTable.pointer].outposition=ProcTable.table[ProcTable.pointer-1].outposition;
			else if(level>ProcTable.table[ProcTable.pointer-1].plevel)
				ProcTable.table[ProcTable.pointer].outposition=ProcTable.pointer-1;
			else{
				templevel=ProcTable.table[ProcTable.pointer-1].plevel;
				tempindex=ProcTable.pointer-1;
				while(level!=templevel){
					tempindex=ProcTable.table[tempindex].outposition;
					templevel=ProcTable.table[tempindex].plevel;
				}
				ProcTable.table[ProcTable.pointer].outposition=ProcTable.table[tempindex].outposition;
			}
		}
	}
}

//////////////////////////////////////////////////////////////////////////////////////////////
//PL(执行语句分析)
//void PL(){;}
void recurPRP();
//////////////////////////////////////////////////////////////////////////////////////////////
//PARL(参数说明)的递归下降分析子程序
void recurPARL(){
	if(WORD.index==30)				//"("
		getWord();
	
	if(WORD.index==17){			//variable
		enterVTable(0);			//填变量表
		getWord();
	}
	else{
		error_handle(11);		//error:非法变量名
		skip(3);				//jump to var or procedure or begin
	}

	while(WORD.index==32){				//","
		if(WORD.index==32)				
			getWord();
		if(WORD.index==17){			//variable
			enterVTable(0);			//填变量表
			getWord();
		}
		else{
			error_handle(11);		//error
			skip(3);				//jump to var or procedure or begin
		}
	}
	
	if(WORD.index==31){				//")"
		getWord();
		ProcTable.table[ProcTable.pointer].paranum=counter-1;//填该过程的参数个数
	}
	else{
		error_handle(7);			//error:缺少)
		skip(3);					//jump to var or procedure or begin
	}
}

//////////////////////////////////////////////////////////////////////////////////////////////
//IDP(变量说明)的递归下降分析子程序
void recurIDP(){
	if(WORD.index==2)			//"var"
		getWord();

	if(WORD.index==17){			//variable
		enterVTable(0);			//填变量表
		getWord();
	}
	else{
		error_handle(11);		//error:非法变量名
		skip(2);				//jump to procedure or begin
	}
	
	while(WORD.index==32){				//","
		if(WORD.index==32)				
			getWord();
		if(WORD.index==17){			//variable
			enterVTable(0);			//填变量表
			getWord();
		}
		else{
			error_handle(11);		//error:非法变量名
			skip(2);				//jump to procedure or begin
		}
	}
	
	if(WORD.index==33){					//";"
		getWord();
		ProcTable.table[ProcTable.pointer].variablenum=counter-1;
	}
	else{
		error_handle(5);		//error:缺少;
		skip(2);				//jump to procedure or begin
	}
}

//////////////////////////////////////////////////////////////////////////////////////////////
//PP(过程)的递归下降分析子程序
void recurPP(){
	int i;
	Operand op1;
	Operand op2;
	Operand op3;
	if(WORD.index==2)				//"var"
		recurIDP();
	if(WORD.index!=3 && WORD.index!=4){
		error_handle(3);			//error:缺少var
		skip(2);					//jump to procedure or begin
	}

	while(WORD.index==3)			//"procedure"
		recurPRP();
	if(WORD.index!=4){
		error_handle(4);			//error:缺少procedure
		skip(1);					//jump to begin
	}

	if(WORD.index==4){				//"begin"
		ProcTable.table[ProcTable.pointer].variablenum=counter-1;
		i=ProcStack.top->index;		//生成开辟数据区的四元式
		op1.type=-1;
		op2.type=-1;
		op3.type=1;
		op3.offset=ProcTable.table[i].variablenum;
		GEN(8,op1,op2,op3);
		ProcTable.table[i].quaterposition=PC-1;	//填当前过程第一条四元式的位置
		getWord();
	}
	else
		error_handle(1);			//error:缺少begin
	
	LRAnalyser();		//执行语句处理
	
	if(WORD.index==5){				//"end"
		op1.type=-1;				//生成返回四元式
		op2.type=-1;
		op3.type=-1;
		GEN(7,op1,op2,op3);
		getWord();
		level--;					//嵌套深度减1
		pop();						//一过程结束,栈顶弹出

	}
	else{
		error_handle(2);			//error:缺少end
		skip(2);
	}
}


//////////////////////////////////////////////////////////////////////////////////////////////
//PRP(子程序)的递归下降分析子程序
void recurPRP(){
	if(WORD.index==3){				//"procedure"
		getWord();
		level++;
		counter=1;
	}

	if(WORD.index==17){				//variable
		enterPTable();				//填过程名表
		push();
		getWord();
	}
	else{
		if(WORD.index==30 || WORD.index==33){
			error_handle(18);		//error:缺少过程名
			skip(3);
		}
		else{
			error_handle(12);		//error:非法过程名
			skip(3);
		}
	}

	if(WORD.index==30)				//"("
		recurPARL();
	if(WORD.index!=33){
		error_handle(6);			//error:缺少(
		skip(3);
	}

	if(WORD.index==33)				//";"
		getWord();
	else{
		error_handle(5);			//error:缺少;
		skip(3);					//jump to var or procedure or begin
	}

	recurPP();
	
	if(WORD.index==33)				//";"
		getWord();
	else{
		error_handle(3);			//error:缺少;
		skip(2);					//jump to procedure or begin
	}
}

//////////////////////////////////////////////////////////////////////////////////////////////
//PROG(程序)的递归下降分析子程序
void recurPROG(){
	Operand op1;
	Operand op2;
	Operand op3;
	if(WORD.index==1)				//"program"
		getWord();
	else{
		error_handle(0);			//error:缺少program
		errflag_prog=true;
		skip(3);					//jump to var or procedure or begin
	}
	
	if(WORD.index==17){				//variable
		enterPTable();				//填过程名表
		getWord();
	}
	else{
		if(errflag_prog==false){
			error_handle(10);		//error:非法主程序名
			errflag_prog=true;
			skip(3);				//jump to var or procedure or begin
		}
	}

	if(WORD.index==33)				//";"
		getWord();
	else{
		if(errflag_prog==false){
			error_handle(5);		//error:缺少;
			errflag_prog=true;
			skip(3);				//jump to var or procedure or begin
		}
	}

	recurPP();						//过程
	
	if(WORD.index==34){				//"."
		op1.type=-1;				//生成停机四元式
		op2.type=-1;
		op3.type=-1;
		GEN(9,op1,op2,op3);	
		op1.type=-1;				//生成停机四元式
		op2.type=-1;
		op3.type=1;
		op3.offset=ProcTable.table[0].quaterposition;
		GEN(22,op1,op2,op3);
		getWord();
		if(WORD.index!=0){
			error_handle(16);		//error:程序结束,无效语句
			while(WORD.index!=0)	//释放剩余二元式链表空间
				getWord();
		}
	}
	else{
		if(WORD.index==0)
			error_handle(9);		//error:缺少.
		else{
			error_handle(16);		//error:程序结束,无效语句
			while(WORD.index !=0)	//释放剩余二元式链表空间
				getWord();
		}
	}
}

//////////////////////////////////////////////////////////////////////////////////////////////
//显示变量名表函数
void printVTable(){
	int i;
	printf("vname\tplevel\trelposition\n");
	for(i=0;i<VariableTable.first;i++){
		printf("%s\t",VariableTable.table[i].vname);
		printf("%d\t",VariableTable.table[i].plevel);
		printf("%d\n",VariableTable.table[i].relposition);
	}
}

//////////////////////////////////////////////////////////////////////////////////////////////
//显示过程名表函数
void printPTable(){
	int i;
	printf("pname\tparanum\tvsum\tfirinvt\tplevel\toutp\tfirinqu\n");
	for(i=0;i<=ProcTable.pointer;i++){
		printf("%s\t",ProcTable.table[i].pname);
		printf("%d\t",ProcTable.table[i].paranum);
		printf("%d\t",ProcTable.table[i].variablenum);
		printf("%d\t",ProcTable.table[i].firstinvtable);
		printf("%d\t",ProcTable.table[i].plevel);
		printf("%d\t",ProcTable.table[i].outposition);
		printf("%d\n",ProcTable.table[i].quaterposition);

	}
}