main.cpp

编译器很好用

#include<iostream.h>
#include<fstream.h>
#include"scanner.h"
#include"function&struct.h"
#include"stack.h"
///////////////////////////////////////////////////////////////////////////////////////////
//全局变量定义
int flag=1;					//判断程序是否出错，开始时置1为正确
extern int lineno;			//行号，于Scanner.h中定义
char token[11];				//字符缓冲区
table* t_first,*t_last;		//总程序数据区的首指针,末指针
quad* q_first,*q_last;		//四元式链的首，末指针
char label_temp[10][11];	//标识符的临时数组，只是在IDT中用到,默认只能存十个
stack<int> Stack;
int temp_vary=2001;			//生成四元式时用到的临时变量序号
int numoflabel;				//标识符缓冲区
int lev;
///////////////////////////////////////////////////////////////////////////////////////////


//语义函数定义
int BLK(ifstream&,int);
int constant(ifstream&,int,table*& tp0,int& dp);
int vary(ifstream&,int,table*& tp0,int& dp);
int funcpro(ifstream&,int,table*& tp0,int& dp);
int CS(ifstream&,int,int&,table*,int& dp);
int IDT(ifstream&,int);
int sentence(ifstream&,int,int&,table*,int& dp);
int ET(ifstream&,int,table*,int& dp);
int CE(ifstream&,int,int&,int&,table*,int& dp);
int E(ifstream&,int,table*,int& dp);
int T(ifstream&,int,table*,int& dp);
int F(ifstream&,int,table*,int& dp);
//出错函数
void error(int);
///////////////////////////////////////////////////////////////////////////////////////////

void main( )
{
	int a;
	lev=0;
	
	ifstream sf("c:\\file.txt");
	if(sf.fail())
	{
		cerr<<"error opening file file.txt\n";
		return;
	}
	a=scanner(sf);

	if(a==13)		a=scanner(sf);
	if(a==21)		a=scanner(sf);
	if(a!=24)		
		error(13);
	else
		a=scanner(sf);

	a=BLK(sf,a);


	if(a!=26)	
	error(14);

	cout<<"this syntax has been completed!"<<endl;
	if(flag)
		cout<<"this grammar of source program is regular."<<endl;
	else
		cout<<"this grammar of source program is wrong!"<<endl;
	
	sf.close();

	quad* p=q_first;
	while(p!=NULL)
	{
		cout<<p->num<<"( "<<p->OP<<","<<p->arg1<<","<<p->arg2<<","<<p->result<<")"<<endl;
		p=p->next;
	}
}
///////////////////////////////////////////////////////////////////////////////////////////

void error(int err)
{
	cout<<lineno<<" line! :";
	switch(err)
	{
	case 0: cout<<" expected'('"<<endl;		break;
	case 1: cout<<" expected'因子'"<<endl;	break;
	case 2: cout<<" expected':='"<<endl;	break;
	case 3: cout<<" expected'then'"<<endl;	break;
	case 4: cout<<" expected'do'"<<endl;	break;
	case 5: cout<<" expected')'"<<endl;		break;
	case 6: cout<<" expected'begin'"<<endl;	break;
	case 7: cout<<" expected'end'"<<endl;	break;
	case 8: cout<<" expected'标识符'"<<endl;break;
	case 9: cout<<" expected'常量'"<<endl;	break;
	case 10: cout<<" expected'='"<<endl;	break;
	case 11: cout<<" expected':'"<<endl;	break;
	case 12: cout<<" 缺interger说明"<<endl;	break;
	case 13: cout<<" expected';'"<<endl;	break;
	case 14: cout<<" expected'.'"<<endl;	break;
	case 15: cout<<" 不认识字符"<<endl;		break;
	case 16: cout<<" 标识符重定义"<<endl;	break;
	case 17: cout<<" 整数越界"<<endl;		break;
	case 18: cout<<" 标识符未定义"<<endl;	break;
	default: cout<<"其他"<<endl;			break;
	}
	flag=0;                       //出错同时置出错标志flag=0
}


///////////////////////////////////////////////////////////////////////////////////////////
int BLK(ifstream& sf,int a)
{
	int S_CHAIN,cp0;
	int dp=5;					//局部变量的起始地址
	table* tp0=NULL;
	 
	if(q_last==NULL)
		 cp0=1;
	 else
		 cp0=q_last->num+1;

	Gen("j",0,-1,-1);
	
	if(a==27)							//过程定义
	{
		a=scanner(sf);					
		//缺处理形参
		if(a!=28)						//存在形参的处理
		{
			a=IDT(sf,a);
			if(a!=25)					//缺:
				error(11);
			else
				a=scanner(sf);

			if(a!=9)					//缺interger
				error(12);
			else
			{
				int temp=0;
				while(temp<numoflabel)
					fill(label_temp[temp++],0,lev,tp0,dp);	//此处需填表
				a=scanner(sf);
			}
		}

		if(a!=28)					//缺 )
			error(5);	
		else
			a=scanner(sf);

		if(a!=25)					//缺:
			error(11);
		else
			a=scanner(sf);

	if(a!=9)						//缺interger
		error(12);
	else
		a=scanner(sf);
	
	if(a!=24)						//缺;
		error(13);
	else
		a=scanner(sf);
	}
	
	if(a==2)			//常量定义
	{
		a=scanner(sf);
		a=constant(sf,a,tp0,dp);
	}
	
	if(a==18)   	//变量说明
	{
		a=scanner(sf);
		a=vary(sf,a,tp0,dp);		
	}
	if(a==7)		//函数说明
	{
		a=scanner(sf);
		a=funcpro(sf,a,tp0,dp);	
	}
	while(a==7)
	{
		a=scanner(sf);
		a=funcpro(sf,a,tp0,dp);
	}

	backpatch(cp0,q_last->num+1);
	Gen("prt",dp,-1,-1);			

	if(a!=1)							//复合语句
		error(6);
	else
	{
		a=scanner(sf);
		a=CS(sf,a,S_CHAIN,tp0,dp);
	}

	
	if(a!=24&&a!=26)					//缺';'或者'.'
	{
		error(13);
	}
	
	backpatch(S_CHAIN,q_last->num+1);
	Gen("ret",0,-1,-1);

	return a;
}

///////////////////////////////////////////////////////////////////////////////////////////
int constant(ifstream& sf,int a,table*& tp0,int& dp)
{
	if(a==21)	a=scanner(sf);
	if(a==38)   a=scanner(sf);
	if(a==22)
	{
		fill(token,1,lev,tp0,dp);//填表
		a=scanner(sf);
	}
	
	while(a==23)
	{
		a=scanner(sf);
		if(a==21)	a=scanner(sf);
		if(a==38)   a=scanner(sf);
		if(a==22)		
		{
			fill(token,1,lev,tp0,dp);//填表
			a=scanner(sf);
		}
	}

	if(a==24)
		a=scanner(sf);
	else
		error(13);

	return a;
}

///////////////////////////////////////////////////////////////////////////////////////////
int vary(ifstream& sf,int a,table*& tp0,int& dp)	
{	
	int temp=0;
	a=IDT(sf,a);
	
	if(a==25)	a=scanner(sf);

	if(a==9)	
	{
		while(temp<numoflabel)
			fill(label_temp[temp++],0,lev,tp0,dp);	//此处需填表
			
		a=scanner(sf);
	}
	if(a==24)	
		a=scanner(sf);
	else
		error(13);

	return a;
}
///////////////////////////////////////////////////////////////////////////////////////////
int funcpro(ifstream& sf,int a,table*& tp0,int& dp)
{

	if(a==21)	
	{
		fill(token,2,lev,tp0,dp);
		a=scanner(sf);
	}
	lev++;
	a=BLK(sf,a);

	if(a!=24)
		error(13);
	else
		a=scanner(sf);

	lev-=1;
	return a;
}

///////////////////////////////////////////////////////////////////////////////////////////
int CS(ifstream& sf,int a,int& C_CHAIN,table* tp0,int& dp)
{
	a=sentence(sf,a,C_CHAIN,tp0,dp);
	
	while(a==24)
	{
		int NXQ=q_last->num+1;
		a=scanner(sf);
		backpatch(C_CHAIN,NXQ);
		a=sentence(sf,a,C_CHAIN,tp0,dp);
	}
	
	if(a!=6)
		error(7);
	else
		a=scanner(sf);

	return a;
}

///////////////////////////////////////////////////////////////////////////////////////////
int IDT(ifstream& sf,int a)
{
	numoflabel=0;
	if(a==21)
	{	
		strcpy(label_temp[numoflabel++],token);	
		a=scanner(sf);
	}

	while(a==23)
	{
		a=scanner(sf);
		if(a==21)
		{	
			strcpy(label_temp[numoflabel++],token);	
			a=scanner(sf);
		}
	}

	return a;
}

///////////////////////////////////////////////////////////////////////////////////////////
int sentence(ifstream& sf,int a,int& S_CHAIN,table* tp0,int& dp)
{
	int temp=0;
	int E_TC,E_FC,S1_CHAIN,S2_CHAIN,W_QUAD;
	table* p;
	switch(a)
	{
	case 21:
				p=entry(token,lev,tp0);
				a=scanner(sf);
				if(a==44)				//赋值语句及函数返回
				{
					if(p->cat==0&&p->level<=lev)
					{
						if(p->level==lev)			//访问同层的变量
						{
							Stack.Push(p->addr);
						}else{						//访问上层的变量
							int i,j=0;
							for( i=lev;i>=p->level;i--)
							{
								j=j*10+i;
							}

							j=j*10+p->addr;
							Stack.Push(j);
							}
					
						a=scanner(sf);					
						a=E(sf,a,tp0,dp);
					Gen(":=",Stack.Pop(),Stack.Pop(),-1);
						S_CHAIN=0;
					}else{
						if(p->cat==2)
						{
							a=scanner(sf);					
							a=E(sf,a,tp0,dp);
							Gen(":=",0,Stack.Pop(),-1);
								S_CHAIN=0;
						}
					}
				}
				break;
	case 1:		a=scanner(sf);
				a=CS(sf,a,S1_CHAIN,tp0,dp);					//复合语句
				S_CHAIN=0;
				break;
	case 8:				
				a=scanner(sf);
				a=CE(sf,a,E_TC,E_FC,tp0,dp);					//if语句
				
				if(a!=16)	
					error(3);
				else{
					backpatch(E_TC,q_last->num+1);
					a=scanner(sf);
				}

				a=sentence(sf,a,S1_CHAIN,tp0,dp);

				if(a==5)
				{
					int NXQ=q_last->num+1;
					a=scanner(sf);
					Gen("j",0,-1,-1);
					backpatch(E_FC,q_last->num+1);
					S1_CHAIN=merg(S1_CHAIN,NXQ);
					a=sentence(sf,a,S2_CHAIN,tp0,dp);
					
					S_CHAIN=merg(S1_CHAIN,S2_CHAIN);
					
					return a;
				}
				
				S_CHAIN=merg(E_FC,S1_CHAIN);
				break;
	case 19:	W_QUAD=q_last->num+1;
				a=scanner(sf);
				a=CE(sf,a,E_TC,E_FC,tp0,dp);					//while语句
				
				if(a==4)
				{
					a=scanner(sf);
					backpatch(E_TC,q_last->num+1);
					a=sentence(sf,a,S1_CHAIN,tp0,dp);
					backpatch(S1_CHAIN,W_QUAD);
					Gen("j",W_QUAD,-1,-1);
					S_CHAIN=E_FC;
				}
				else
					error(4);
				break;
	case 14:	a=scanner(sf);
				if(a==27)					//read语句
					a=scanner(sf);
				else
					error(0);

				a=IDT(sf,a);

				if(a==28)
				{
					table* p;
					while(temp<numoflabel)
					{
						p=entry(label_temp[temp++],lev,tp0);
						if(p->cat==0)						//常量不能read
							Gen("in",p->addr,-1,-1);
					}
					a=scanner(sf);
				}
				else
					error(5);
				S_CHAIN=0;
				break;

	case 20:	a=scanner(sf);
				if(a==27)					//write语句
					a=scanner(sf);
				else
					error(0);

				a=ET(sf,a,tp0,dp);

				if(a==28)
				{
					stack<int> tempstack;	//建立一个临时栈，完成Stack栈的倒栈
					while(!Stack.IsEmpty())
						tempstack.Push(Stack.Pop());//
					while(!tempstack.IsEmpty())
						Gen("out",tempstack.Pop(),-1,-1);
					a=scanner(sf);
				}
				else
					error(5);
				S_CHAIN=0;
				break;
	default:	
				S_CHAIN=0;
				break;
	}

	return a;
}

///////////////////////////////////////////////////////////////////////////////////////////
int ET(ifstream& sf,int a,table* tp0,int& dp)
{
	a=E(sf,a,tp0,dp);
	while(a==23)
	{
		a=scanner(sf);
		a=E(sf,a,tp0,dp);
	}

	return a;
}

///////////////////////////////////////////////////////////////////////////////////////////
int CE(ifstream& sf,int a,int& E_TC,int& E_FC,table* tp0,int& dp)
{	
	a=E(sf,a,tp0,dp);
	
	while(a>=38&&a<=43)
	{
		int temp=a;
		a=scanner(sf);
		a=E(sf,a,tp0,dp);
		switch(temp)
		{
		case 38:	E_TC=q_last->num+1;
					E_FC=q_last->num+2;
					Gen("jeq",0,Stack.Pop(),Stack.Pop());
					Gen("j",0,-1,-1);
					break;
		case 39:	E_TC=q_last->num+1;
					E_FC=q_last->num+2;
					Gen("jl",0,Stack.Pop(),Stack.Pop());
					Gen("j",0,-1,-1);
					break;
		case 40:	E_TC=q_last->num+1;
					E_FC=q_last->num+2;
					Gen("jg",0,Stack.Pop(),Stack.Pop());
					Gen("j",0,-1,-1);
					break;
		case 41:	E_TC=q_last->num+1;
					E_FC=q_last->num+2;
					Gen("jne",0,Stack.Pop(),Stack.Pop());
					Gen("j",0,-1,-1);
					break;
		case 42:	E_TC=q_last->num+1;
					E_FC=q_last->num+2;
					Gen("jle",0,Stack.Pop(),Stack.Pop());
					Gen("j",0,-1,-1);
					break;
		case 43:	E_TC=q_last->num+1;
					E_FC=q_last->num+2;
					Gen("jge",0,Stack.Pop(),Stack.Pop());
					Gen("j",0,-1,-1);
					break;
		}

	}

	return a;
}


///////////////////////////////////////////////////////////////////////////////////////////
int E(ifstream& sf,int a,table* tp0,int& dp)			//没有处理单目运算符
{
	a=T(sf,a,tp0,dp);

	while(a==34||a==35)
	{
		int temp=a;
		a=scanner(sf);
		a=T(sf,a,tp0,dp);
		switch(temp)
		{
		case 34:	Gen("+",temp_vary,Stack.Pop(),Stack.Pop());
						Stack.Push(temp_vary++);
								break;
		case 35:	Gen("-",temp_vary,Stack.Pop(),Stack.Pop());
						Stack.Push(temp_vary++);
								break;
		}
	}

	return a;
}

///////////////////////////////////////////////////////////////////////////////////////////
int T(ifstream& sf,int a,table* tp0,int& dp)
{
	a=F(sf,a,tp0,dp);

	while(a==3||a==36||a==37)
	{
		int temp=a;
		a=scanner(sf);
		a=F(sf,a,tp0,dp);
		switch(temp)
		{
		case 3:		Gen("div",temp_vary,Stack.Pop(),Stack.Pop());
						Stack.Push(temp_vary++);
								break;
		case 36:	Gen("*",temp_vary,Stack.Pop(),Stack.Pop());
						Stack.Push(temp_vary++);
								break;
		case 37:	Gen("/",temp_vary,Stack.Pop(),Stack.Pop());
						Stack.Push(temp_vary++);
								break;
		}		
	}

	return a;
}

///////////////////////////////////////////////////////////////////////////////////////////
int F(ifstream& sf,int a,table* tp0,int& dp)				//因子文法没有改写
{
	table* p;
	switch(a)
	{
	case 21:	p=entry(token,lev,tp0);
				
				if(p->cat==0)
				{				
					if(p->cat==0&&p->level<=lev)	
					{
						if(p->level==lev)		//访问同层的变量
						{
							Stack.Push(p->addr);
						}else{					//访问上层的变量
							int i,j=0;
							for( i=lev;i>=p->level;i--)
							{
								j=j*10+i;
							}

							j=j*10+p->addr;
							Stack.Push(j);
							}
					}
					a=scanner(sf);
				}else{
					if(p->cat==1)
					{
						Stack.Push(1000+p->val);
						a=scanner(sf);
					}else{						//函数调用

						int i,temp;
						stack<int> ss;
						a=scanner(sf);
						if(a==27)				//存在实参
						{
							a=scanner(sf);
							temp=1;
							a=E(sf,a,tp0,dp);
							while(a==23)
							{
								a=scanner(sf);
								temp++;
								a=E(sf,a,tp0,dp);
							}
					
							if(a==28)	a=scanner(sf);

							for( i=0;i<temp;i++)
								ss.Push(Stack.Pop());
							for(i=0;i<temp;i++)
								Gen(":=",dp+5+i,ss.Pop(),-1);
							}
						temp=lev-p->level;
						Gen("jsr",p->addr,-1,temp);
						Gen(":=",temp_vary,dp,-1);
						Stack.Push(temp_vary++);
					}
				}
								//调用结束

				if(a==27)
				{
					a=scanner(sf);
					a=ET(sf,a,tp0,dp);
					
					if(a!=28)
						error(5);
					else
						a=scanner(sf);
				}
					break;
	case 27:	a=scanner(sf);
				a=E(sf,a,tp0,dp);
					
				if(a!=28)
					error(5);
				else
					a=scanner(sf);

				break;
	case 22:	Stack.Push(getconst());
				a=scanner(sf);
				break;
	}

	return a;
}