plxcompiler.cpp

pl/x的编译器

	
	}
	else //出错了
	{
		error(14);
	}
	if(m_sym==EQL || m_sym==GTR || m_sym==GEQ || m_sym==LSS || m_sym==LEQ || m_sym==NEQ)
	{
		op=m_sym;
		getSym();
	}
	else
	{
		error(15);
	}
	this->ArithmeticExpression(level,fsys);
	switch(op)
	{
	case EQL:
		gen(OPR,0,9);
		break;
	case GTR:
		gen(OPR,0,13);
		break;
	case GEQ:
		gen(OPR,0,14);
		break;
	case LSS:
		gen(OPR,0,11);
		break;
	case LEQ:
		gen(OPR,0,12);
		break;
	case NEQ:
		gen(OPR,0,10);
		break;
	default:
		;
	}
}

//处理ae非终结符
void PLXCompiler::ArithmeticExpression(int level,symset fsys)
{
	symset tmp,tmp1;
	symbol minusOp=NUL;
	tmp=fsys;
	tmp.insert(PLUS);
	tmp.insert(MINUS);
	if(m_sym==MINUS)
	{
		getSym();
		minusOp=m_sym;
	}
	this->ArithmeticTerm(level,tmp);
	if(minusOp==MINUS)
	{
		gen(OPR,0,1);//取负
	}
	tmp1=this->m_firstaf;
	tmp1.insert(MINUS);
	tmp1.insert(PLUS);
	tmp1.insert(NUL);
	while(tmp1.find(m_sym)!=tmp1.end())
	{
		if(m_sym==MINUS || m_sym==PLUS)
		{
			minusOp=m_sym;
			getSym();
		}
		else if(m_sym==NUL)
		{
			error(38);
			getSym();
		}
		else
		{
			error(38);
		}
		this->ArithmeticTerm(level,tmp);
		if(minusOp==MINUS)
		{
			gen(OPR,0,3);//减
		}
		if(minusOp==PLUS)
		{
			gen(OPR,0,2);//加
		}
	}
}

//处理at非终结符
void PLXCompiler::ArithmeticTerm(int level,symset fsys)
{
	symset tmp,tmp1;
	symbol op=NUL;
	tmp=fsys;
	tmp.insert(TIMES);
	tmp.insert(SLASH);
	this->ArithmeticFactor(level,tmp);
	while(m_sym==TIMES || m_sym==SLASH)
	{
		op=m_sym;
		getSym();
		this->ArithmeticFactor(level,tmp);
		if(op==TIMES)
		{
			gen(OPR,0,4);
		}
		if(op==SLASH)
		{
			gen(OPR,0,5);
		}
	}
}

//处理af非终结符
void PLXCompiler::ArithmeticFactor(int level,symset fsys)
{
	symset tmp;
	test(this->m_firstaf,fsys,32);
	if(m_sym==IDENT)
	{
		//查找符号表
		vector<item>::iterator iter=this->position(m_id);
		if(NULL==iter)
		{
			error(1); //变量为定义
		}
		else
		{
			if(iter->kind!=aident)
			{
				error(2);//此处变量需为整型
			}
			else
			{
				gen(LOD,level-iter->level,iter->adr);
			}
		}
		getSym();
	}

	else if(m_sym==NUMBER)
	{
		gen(LIT,0,this->m_num);
		getSym();
	}
	else if(m_sym==LPAREN)
	{
		getSym();
		tmp.clear();
		tmp=fsys;
		tmp.insert(RPAREN);
		this->ArithmeticExpression(level,tmp);
		if(m_sym!=RPAREN)
		{
			error(3);//缺了')'
		}
		else
			getSym();
	}
	else
	{
		error(4);//
	}
}

//处理非终结符be
void PLXCompiler::BoolExpression(int level,symset fsys)
{
	symset tmp=fsys;
	symbol op=NUL;
	tmp.insert(ORSYM);
	this->BoolTerm(level,tmp);
	while(m_sym==ORSYM)
	{
		op=m_sym;
		getSym();
		this->BoolTerm(level,tmp);
		if(op==ORSYM)
		{
			gen(OPR,0,6);//OR
		}
	}
	tmp.clear();
	tmp.insert(THENSYM);
	tmp.insert(DOSYM);
	test(fsys,tmp,34);
}

//处理非终结符bt
void PLXCompiler::BoolTerm(int level,symset fsys)
{
	symset tmp=fsys;
	symbol op;
	tmp.insert(ANDSYM);
	this->BoolFactor(level,tmp);
	while(m_sym==ANDSYM)
	{
		op=m_sym;
		getSym();
		this->BoolFactor(level,tmp);
		if(op==ANDSYM)
		{
			gen(OPR,0,7);//AND
		}
	}
}

//处理非终结符bf
void PLXCompiler::BoolFactor(int level,symset fsys)
{
	symset tmp;
	symbol op;
	test(this->m_firstbf,fsys,6);
	if(m_sym==IDENT)
	{
		//查找符号表
		vector<item>::iterator iter=this->position(m_id);
		if(NULL==iter)
		{
			error(1); //变量为定义
			getSym();
		}
		else
		{
			if(iter->kind==bident)
			{
				gen(LOD,level-iter->level,iter->adr);
				getSym();
			}
			else if(iter->kind==aident)
			{
				tmp.clear();
				tmp=fsys;
				this->RelationExpression(level,fsys);
			}
			else
			{
				error(5);//非法的变量
				getSym();
			}
		}
	}
	else if(m_sym==TRUESYM || m_sym==FALSESYM)
	{
		if(m_sym==TRUESYM)
		{
			gen(LIT,0,1);
		}
		else
		{
			gen(LIT,0,0);
		}
		getSym();
	}
	else if(m_sym==NOTSYM)
	{
		op=m_sym;
		getSym();
		tmp.clear();
		tmp=fsys;
		this->BoolFactor(level,tmp);
		if(op==NOTSYM)
		{
			gen(OPR,0,8);//NOT
		}
	}
	else if(m_sym==LPAREN)
	{
		getSym();
		tmp.clear();
		tmp=fsys;
		tmp.insert(RPAREN);
		this->BoolExpression(level,tmp);
		if(m_sym!=RPAREN)
		{
			error(3);//缺少')'
		}
		else
			getSym();
	}
	else if(m_sym==NUMBER)
	{
	    tmp.clear();
		tmp=fsys;
		this->RelationExpression(level,tmp);
	}
	else
	{
		error(6);
	}
//	tmp.clear();
//	tmp.insert(DOSYM);
	//tmp.insert(THENSYM);
//	tmp.insert(ENDSYM);
	//test(fsys,tmp,34);
}

//
void PLXCompiler::ProcedureSque(int level,symset fsys)
{
	symset tmp;
	while(m_sym==PROSYM)
	{
		this->Procedure(level,fsys);
	}
	tmp.clear();
	tmp=this->m_firsts;
	tmp.insert(ENDSYM);
	test(fsys,tmp,35);
}
//处理非终结符proc
void PLXCompiler::Procedure(int level,symset fsys)
{
	symset tmp,stop;
	alfa   name;//保存函数名
	vector<item>::iterator iter=NULL;
	int k=0;

	vector<item>::iterator pt;
	int dx=3,tx=m_tx,cx=m_cx;
	

	if(m_sym==PROSYM)
	{
		gen(JMP,0,0);

		getSym();
		if(m_sym==IDENT)
		{
			//在符号表中登记函数名
			enter(pident,level);
			strcpy(name,m_id);
		}
		else
		{
			error(7); //非法的变量名
		}
		getSym();
		if(m_sym!=LPAREN)
		{
			error(33);//缺了'('
		}
		else
			getSym();
		if(m_sym==INTESYM)
		{
			getSym();
			k++;
			if(m_sym==IDENT)
			{
				enter(aident,dx,level+1);
			}
			else
			{
				error(9);//非法的参数名
			}
			getSym();
			while(m_sym==COMMA || m_sym==IDENT)
			{
				if(m_sym==COMMA)
					getSym();
				else
					error(19);
				if(m_sym==IDENT)
				{
					enter(aident,dx,level+1);
					k++;
				}
				else
				{
					error(9);//非法的参数名
					k++;
				}
				getSym();
			}
			
		}
		if(m_sym!=RPAREN)
		{
			error(3);//缺了')'
		}
		else
			getSym();
		
		//
		this->DefinitionSque(level+1,dx,fsys);
		if(m_sym!=BEGINSYM)
		{
			error(10);//缺了begin
		}
		else
			getSym();

		this->Procedure(level+1,fsys);
		tmp.clear();
		tmp=fsys;
		tmp.insert(ENDSYM);

        //修改参数信息,函数的局部变量所需空间大小，函数地址
		pt=m_table.begin()+tx;
		if(pt!=NULL)
		{
			(*((m_code.begin()+cx))).a=m_cx;
			pt->num=k;
			pt->adr=m_cx;
			pt->size=dx;
		}
		
        gen(INT,0,dx);

		this->SentenceSque(level+1,tmp);
		gen(OPR,0,0);

		if(m_sym!=ENDSYM)
		{
			error(11);//缺了end
		}
		else
			getSym();
		tmp=fsys;
		tmp.insert(PROSYM);
		stop.clear();
		stop=this->m_firsts;
		stop.insert(ENDSYM);
		test(tmp,stop,35);
	}
}

//处理非终结符S
void PLXCompiler::Sentence(int level,symset fsys)
{
	int k=0,num=0; //用来记录函数的参数个数
	vector<item>::iterator pfunction,pParameter;
	
	item _item;//
	int cx1,cx2,cx3;

	symset tmp;
	test(this->m_firsts,fsys,30);
	if(m_sym==IDENT)
	{
		//查找符号表
		vector<item>::iterator iter=this->position(m_id);
		if(NULL==iter)
		{
			error(1); //变量未定义
			getSym();
			//若变量没定义则当作整型变量
			if(m_sym!=BECOMES)
				error(22); //此处应为":="
			else
				getSym();
			tmp.clear();
			set_union(fsys.begin(),fsys.end(),m_followae.begin(),m_followae.end(),insert_iterator<symset>(tmp,tmp.begin()));
			this->ArithmeticExpression(level,tmp);
		}
		else if(iter->kind==aident)
		{
			getSym();
			if(m_sym!=BECOMES)
				error(22); //此处应为":="
			else
				getSym();
			tmp.clear();
			set_union(fsys.begin(),fsys.end(),m_followae.begin(),m_followae.end(),insert_iterator<symset>(tmp,tmp.begin()));
			this->ArithmeticExpression(level,tmp);
			//产生一条赋值语句
			gen(STO,level-iter->level,iter->adr);
		}
		else if(iter->kind==bident)
		{
			getSym();
			if(m_sym!=BECOMES)
				error(22); //此处应为":="
			getSym();
			tmp.clear();
			set_union(fsys.begin(),fsys.end(),m_followbe.begin(),m_followbe.end(),insert_iterator<symset>(tmp,tmp.begin()));
			this->BoolExpression(level,tmp);
			//产生一条赋值语句
			gen(STO,level-iter->level,iter->adr);
		}
		else
		{
			error(23);//此处不能为函数名
			getSym();
		}
	}
	else if(m_sym==IFSYM)
	{
		getSym();
		tmp.clear();
		set_union(fsys.begin(),fsys.end(),m_followbe.begin(),m_followbe.end(),insert_iterator<symset>(tmp,tmp.begin()));
		this->BoolExpression(level,tmp);
		if(m_sym!=THENSYM)
			error(24); //缺了then
		else
			getSym();
		tmp.clear();
		set_union(fsys.begin(),fsys.end(),m_followss.begin(),m_followss.end(),insert_iterator<symset>(tmp,tmp.begin()));
		
		cx1=this->m_cx;
		gen(JPC,0,0);
		this->SentenceSque(level,tmp);
		cx2=this->m_cx;
		if(m_sym==ELSESYM)
		{
			gen(JMP,0,0);
			getSym();
			this->SentenceSque(level,tmp);
			(*(m_code.begin()+cx2)).a=m_cx;
			(*(m_code.begin()+cx1)).a=cx2+1;
		}
		else
			(*(m_code.begin()+cx1)).a=cx2;

		if(m_sym!=ENDSYM)
			error(11);//缺了end
		else
			getSym();
	}
	else if(m_sym==WHILESYM)
	{
		cx1=m_cx;

		getSym();
		tmp.clear();
		set_union(fsys.begin(),fsys.end(),m_followbe.begin(),m_followbe.end(),insert_iterator<symset>(tmp,tmp.begin()));
		this->BoolExpression(level,tmp);

		cx2=m_cx;
		gen(JPC,0,0);

		if(m_sym!=DOSYM)
			error(26);//缺了do
		else
			getSym();
		tmp.clear();
		set_union(fsys.begin(),fsys.end(),m_followss.begin(),m_followss.end(),insert_iterator<symset>(tmp,tmp.begin()));
		this->SentenceSque(level,tmp);

		gen(JMP,0,cx1);
		(*(m_code.begin()+cx2)).a=m_cx;

		if(m_sym!=ENDSYM)
			error(11);//缺了end
		getSym();
	}
	else if(m_sym==REPEATSYM)
	{
		cx1=m_cx;
		getSym();
		tmp.clear();
		set_union(fsys.begin(),fsys.end(),m_followss.begin(),m_followss.end(),insert_iterator<symset>(tmp,tmp.begin()));
		this->SentenceSque(level,tmp);
		if(m_sym!=UNTILSYM)
			error(27);
		else
			getSym();
		tmp.clear();
		set_union(fsys.begin(),fsys.end(),m_followbe.begin(),m_followbe.end(),insert_iterator<symset>(tmp,tmp.begin()));
		this->BoolExpression(level,tmp);
		gen(OPR,0,8);
		cx2=m_cx;
		gen(JPC,0,0);
		gen(JMP,0,cx1);
		(*(m_code.begin()+cx2)).a=m_cx;
	}
	else if(m_sym==WRITESYM)
	{
		getSym();
		tmp.clear();
		set_union(fsys.begin(),fsys.end(),m_followae.begin(),m_followae.end(),insert_iterator<symset>(tmp,tmp.begin()));
		this->ArithmeticExpression(level,tmp);
		gen(OPR,0,15);
	}
	else if(m_sym==READSYM)
	{
		getSym();
		if(m_sym==IDENT)
		{
			//查找符号表
			vector<item>::iterator iter=this->position(m_id);
			if(NULL==iter)
			{
				error(1); //变量为定义
				//getSym();
			}
			else
			{
				if(iter->kind!=aident)
					error(13);
				else
				{
					gen(OPR,0,16);
					gen(STO,level-iter->level,iter->adr);
				}
				//getSym();
			}
		}
		else
		{
			error(13);//此处为一个整型变量名
		
		}
		getSym();
	}
	else if(m_sym==FORSYM)
	{
		getSym();
		if(m_sym==IDENT)
		{
			//查找符号表
			vector<item>::iterator iter=this->position(m_id);
			if(NULL==iter)
			{
				error(1); //变量为定义
			}
			else
			{
				if(iter->kind!=aident)
				{
					error(13);
				}
				else
				{
					cx1=m_cx;
					_item.adr=iter->adr;
					_item.level=iter->level;
					gen(LOD,level-iter->level,iter->adr);
				}
			}
		}
		else
		{
			error(13);//此处为一个整型变量名
		}
		getSym();
		if(m_sym!=FROMSYM)
		{
			error(25);//缺了from
		}
		else
			getSym();
		if(m_sym==IDENT)
		{
			//查找符号表