grammar.cpp

第一次写的

// Grammar.cpp: implementation of the Grammar class.
//
//////////////////////////////////////////////////////////////////////
#include <iostream>
#include <string>
#include <fstream>
#include <stdlib.h>
#include "Word.h"
#include "Table.h"
#include "pcode.h"
#include "Grammar.h"

//////////////////////////////////////////////////////////////////////
// Construction/Destruction
//////////////////////////////////////////////////////////////////////

#define $program 1
#define $const 2
#define $var 3
#define $procedure 4
#define $begin 5
#define $if 6
#define $while 7
#define $call 8
#define $read 9
#define $write 10
#define $end 11
#define $then 12
#define $else 13
#define $do 14
#define $odd 15
#define $lop 16          //<lop> → =|<>|<|<=|>|>=
#define $aop 17          //<aop> → +|-
#define $mop 18          //<mop> → *|/
#define $id 19           //<id> → l{l|d}
#define $integer 20      //<integer> → d{d}
#define $ 21             // ;
#define $equal 22        // :=
#define $and 23          // ,
#define $leftbrack 24    //(
#define $rightbrack 25   //)

//using namespace std;

Grammar::Grammar(Simpsc *p)
{
	pl=p;
}

bool Grammar::Analysis(Word *Token)
{	
	lev=-1;
	i=0;
	if(!ProceProg(Token))
	{
		cout<<"出现语法错误，分析中断，请检查程序"<<endl;
		return false;
	}
	else
		cout<<"分析成功，该程序无语法错误"<<endl;
	return true;
}

char *Grammar::ReturnName(Word *Token)
{
//	char name[30];
//	strcpy(name,this->Token[i].ReturnCont());
//	return name;
	return Token[i].ReturnCont();
}

void Grammar::ConstVar(Word *Token)
{
	Table *tb=pl->ChaTable;
	tb->Enter(constant,Token);
}

void Grammar::ConstDecla(Word *Token)
{
	char con[16];
	int num;
	Table *tb=pl->ChaTable;
	strcpy(con,Token[i].ReturnCont());
	num=atoi(con);
	tb->GetVal(num);
}

void Grammar::VarDecla(Word *Token)
{
	Table *tb=pl->ChaTable;
	tb->Enter(variable,Token);
	dx[lev]++;
}

bool Grammar::ProceFactor(Word *Token)              //<factor>→<id>|<integer>|(<exp>)
{
	int p,num;
	char con[16];
	Table *tb=pl->ChaTable;
	pcode *cd=pl->CodeList;

	if(Token[i].ReturnWType()==$id)
	{
		p=tb->Position(Token[i].ReturnCont());
		if(p==0)
		{
			Token[i].ReturnXY(bx,ex,y);
			cout<<"未申明的标识符！！第"<<y<<"行"<<endl;
			return false;
		}
		else
		{
			switch(tb->table[p].kind)
			{
			case constant:
				cd->Gen(LIT,0,tb->table[p].val);
				break;
			case variable:
				cd->Gen(LOD,lev-tb->table[p].level,tb->table[p].adr);
				break;
			case procedure:
				Token[i].ReturnXY(bx,ex,y);
				cout<<"错误的标识符，函数名不可用于表达式:第"<<y<<"行"<<endl;
				return false;
				break;
			}
		}
		i++;
	}
	else if(Token[i].ReturnWType()==$integer)
	{
		strcpy(con,Token[i].ReturnCont());
		num=atoi(con);
		cd->Gen(LIT,0,num);
		i++;
	}
	else if(Token[i].ReturnWType()==$leftbrack)
	{
		i++;
		if(!ProceExp(Token))
			return false;
		if(Token[i].ReturnWType()==$rightbrack)
			i++;
		else
		{
			Token[i].ReturnXY(bx,ex,y);
			cout<<"左右括号不匹配:第"<<y<<"行"<<endl;
			return false;
		}
	}
	else
	{
		Token[i].ReturnXY(bx,ex,y);
		cout<<"缺少常量或标识符:第"<<y<<"行"<<endl;
		return false;
	}
	return true;
}

bool Grammar::ProceTerm(Word *Token)        //<term> → <factor>{<mop><factor>}
{
	char op[2];
	pcode *cd=pl->CodeList;
	if(!ProceFactor(Token))
		return false;
	while(Token[i].ReturnWType()==$mop)
	{
		strcpy(op,Token[i].ReturnCont());
		i++;
		if(!ProceFactor(Token))
			return false;
		else
		{
			if(op[0]=='*')
				cd->Gen(OPR,0,4);
			else
				cd->Gen(OPR,0,5);
		}
	}
	return true;
}

bool Grammar::ProceExp(Word *Token)             //<exp> → [+|-]<term>{<aop><term>}
{
	char op[2];
	Table *tb=pl->ChaTable;
	pcode *cd=pl->CodeList;
	if(!strcmp(Token[i].ReturnCont(),"+") || !strcmp(Token[i].ReturnCont(),"-"))
	{
		strcpy(op,Token[i].ReturnCont());
		i++;
	}
	if(!ProceTerm(Token))
		return false;
	else
	{
		if(op[0]=='-')
			cd->Gen(OPR,0,1);
	}
	while(Token[i].ReturnWType()==$aop)
	{
		strcpy(op,Token[i].ReturnCont());
		i++;
		if(!ProceTerm(Token))
			return false;
		if(op[0]=='+')
			cd->Gen(OPR,0,2);
		else
			cd->Gen(OPR,0,3);
	}
	return true;
}

bool Grammar::ProceLexp(Word *Token)            //<lexp> → <exp> <lop> <exp>|odd <exp>
{
	Table *tb=pl->ChaTable;
	pcode *cd=pl->CodeList;
	char lop[3];
	if(Token[i].ReturnWType()==$odd)
	{
		i++;
		if(!ProceExp(Token))
			return false;
		else
			cd->Gen(OPR,0,6);
	}
	else if(ProceExp(Token))
	{
		if(Token[i].ReturnWType()==$lop)
		{
			strcpy(lop,Token[i].ReturnCont());
			i++;
		}
		else
		{
			Token[i].ReturnXY(bx,ex,y);
			cout<<"缺少关系运算符:第"<<y<<"行"<<endl;
			return false;
		}
		if(!ProceExp(Token))
			return false;
		else
		{
			if(!strcmp(lop,"="))
				cd->Gen(OPR,0,8);
			else if(!strcmp(lop,"<>"))
				cd->Gen(OPR,0,9);
			else if(!strcmp(lop,"<"))
				cd->Gen(OPR,0,10);
			else if(!strcmp(lop,">="))
				cd->Gen(OPR,0,11);
			else if(!strcmp(lop,">"))
				cd->Gen(OPR,0,12);
			else if(!strcmp(lop,"<="))
				cd->Gen(OPR,0,13);
		}
	}
	else
		return false;
	return true;
}

bool Grammar::ProceState(Word *Token)                   //<statement> → 
{
	int cx1,cx2,p;
	Table *tb=pl->ChaTable;
	pcode *cd=pl->CodeList;
	if(Token[i].ReturnWType()==$id)                   //<id> := <exp>
	{
		p=tb->Position(Token[i].ReturnCont());
		if(p==0)
		{
			Token[i].ReturnXY(bx,ex,y);
			cout<<"未申明的标识符！！第"<<y<<"行"<<endl;
			return false;
		}
		else if(tb->table[p].kind!=variable)
		{
			Token[i].ReturnXY(bx,ex,y);
			cout<<"赋值号左部标识符属性应是变量!!第"<<y<<"行"<<endl;
			return false;
		}
		i++;	
		if(Token[i].ReturnWType()==$equal)
		{
			i++;
			if(!ProceExp(Token))
				return false;
		}
		else
		{
			Token[i].ReturnXY(bx,ex,y);
			cout<<"应输入\":=\":第"<<y<<"行"<<endl;
			return false;
		}
		if(p>0)
			cd->Gen(STO,lev-tb->table[p].level,tb->table[p].adr);
	}
	else if(Token[i].ReturnWType()==$if)               //if <lexp> then <statement>[else <statement>]
	{
		i++;
		if(!ProceLexp(Token))
			return false;
		if(Token[i].ReturnWType()==$then)
		{
			i++;
			cx1=cd->cx;
			cd->Gen(JPC,0,0);
		}
		else
			return false;
		if(!ProceState(Token))
			return false;
		if(Token[i].ReturnWType()==$else)
		{
			i++;
			cx2=cd->cx;
			cd->Gen(JMP,0,0);
			if(!ProceState(Token))
				return false;
			else
			{
				cd->code[cx1].a=cx2+1;
				cd->code[cx2].a=cd->cx;
			}
		}
		else
			cd->code[cx1].a=cd->cx;
	}
	else if(Token[i].ReturnWType()==$while)            //while <lexp> do <statement>
	{
		cx1=cd->cx;
		i++;
		if(!ProceLexp(Token))
			return false;
		else
		{
			cx2=cd->cx;
			cd->Gen(JPC,0,0);
		}
		if(Token[i].ReturnWType()==$do)
			i++;
		else
		{
			Token[i].ReturnXY(bx,ex,y);
			cout<<"缺少\"do\":第"<<y<<"行"<<endl;
			return false;
		}
		if(!ProceState(Token))
			return false;
		else
		{
			cd->Gen(JMP,0,cx1);
			cd->code[cx2].a=cd->cx;
		}
	}
	else if(Token[i].ReturnWType()==$call)             //call <id>[（<exp>{,<exp>}）]
	{
		i++;
		if(Token[i].ReturnWType()==$id)
		{
			p=tb->Position(Token[i].ReturnCont());
			if(p==0)
			{
				Token[i].ReturnXY(bx,ex,y);
				cout<<"未定义的函数!!第"<<y<<"行"<<endl;
				return false;
			}
			else if(tb->table[p].kind!=procedure)
			{
				Token[i].ReturnXY(bx,ex,y);
				cout<<"错误的函数名!!第"<<y<<"行"<<endl;
				return false;
			}
			else
				cd->Gen(CAL,lev-tb->table[p].level,tb->table[p].adr);
			i++;
		}
		else
		{
			Token[i].ReturnXY(bx,ex,y);
			cout<<"缺少标识符:第"<<y<<"行"<<endl;
			return false;
		}
	}
	else if(ProceBody(Token));                       //<body>
	else if(Token[i].ReturnWType()==$read)             //read (<id>{，<id>})
	{
		i++;
		if(Token[i].ReturnWType()==$leftbrack)
			i++;
		else
		{
			Token[i].ReturnXY(bx,ex,y);
			cout<<"缺少\"(\":第"<<y<<"行"<<endl;
			return false;
		}
		if(Token[i].ReturnWType()==$id)
		{
			p=tb->Position(Token[i].ReturnCont());
			i++;		
			if(p==0)
			{
				Token[i].ReturnXY(bx,ex,y);
				cout<<"未申明的标识符！！第"<<y<<"行"<<endl;
				return false;
			}
			else
			{
				cd->Gen(RED,lev-tb->table[p].level,tb->table[p].adr);
			}
		}
		else
		{
			Token[i].ReturnXY(bx,ex,y);
			cout<<"此处输入的应是变量!!第"<<y<<"行"<<endl;
			return false;
		}
		while(Token[i].ReturnWType()==$and)
		{
			i++;
			if(Token[i].ReturnWType()==$id)
			{
				p=tb->Position(Token[i].ReturnCont());
				i++;
				
				if(p==0)
				{
					Token[i].ReturnXY(bx,ex,y);
					cout<<"未申明的标识符！！第"<<y<<"行"<<endl;
					return false;
				}
				else
				{
					cd->Gen(RED,lev-tb->table[p].level,tb->table[p].adr);
				}
			}
			else
			{
				Token[i].ReturnXY(bx,ex,y);
				cout<<"此处输入的应是变量!!第"<<y<<"行"<<endl;
				return false;
			}
		}
		if(Token[i].ReturnWType()==$rightbrack)
			i++;
		else
		{
			Token[i].ReturnXY(bx,ex,y);
			cout<<"左右括号不匹配:第"<<y<<"行"<<endl;
			return false;
		}
	}
	else if(Token[i].ReturnWType()==$write)           //write (<exp>{,<exp>})
	{
		i++;
		if(Token[i].ReturnWType()==$leftbrack)
			i++;
		else
		{
			Token[i].ReturnXY(bx,ex,y);
			cout<<"缺少\"(\":第"<<y<<"行"<<endl;
			return false;
		}
		if(!ProceExp(Token))
			return false;
		else	
			cd->Gen(WRT,0,0);
		while(Token[i].ReturnWType()==$and)
		{
			i++;
			if(!ProceExp(Token))
				return false;
			else	
				cd->Gen(WRT,0,0);
		}
		if(Token[i].ReturnWType()==$rightbrack)
			i++;
		else
		{
			Token[i].ReturnXY(bx,ex,y);
			cout<<"左右括号不匹配:第"<<y<<"行"<<endl;
			return false;
		}
		cd->Gen(OPR,0,15);
	}
	else
	{
		Token[i].ReturnXY(bx,ex,y);
		cout<<"错误的语句:第"<<y<<"行"<<endl;
		return false;
	}
	return true;
}

bool Grammar::ProceBody(Word *Token)           //<body> → begin <statement>{;<statement>}end
{
	if(Token[i].ReturnWType()==$begin)
	{
		i++;
		if(!ProceState(Token))
			return false;
		while(Token[i].ReturnWType()==$)
		{
			i++;
			if(!ProceState(Token))
				return false;
		}
	}
	else
		return false;
	if(Token[i].ReturnWType()==$end)
		i++;
	else
	{
		Token[i].ReturnXY(bx,ex,y);
		cout<<"此处应输入\"end\":第"<<y<<"行"<<endl;
		return false;
	}
	return true;
}

bool Grammar::ProceConst(Word *Token)                //<const> → <id>:=<integer>
{
	if(Token[i].ReturnWType()==$id)
	{
		this->ConstVar(Token);
		i++;		
		if(Token[i].ReturnWType()==$equal)
		{
			i++;
			if(Token[i].ReturnWType()==$integer)
			{
				this->ConstDecla(Token);
				i++;				
				return true;
			}
		}
		else
		{
			Token[i].ReturnXY(bx,ex,y);
			cout<<"此处应输入\":=\":第"<<y<<"行"<<endl;
			return false;
		}
	}
	return false;
}

bool Grammar::ProceCondecl(Word *Token)               //<condecl> → const <const>{,<const>}
{
	if(Token[i].ReturnWType()==$const)
	{
		i++;
		if(!ProceConst(Token))
			return false;
		while(Token[i].ReturnWType()==$and)
		{
			i++;
			if(!ProceConst(Token))
			{
				Token[i].ReturnXY(bx,ex,y);
				cout<<"常量定义出错:第"<<y<<"行"<<endl;
				return false;
				return false;
			}
		}
	}
	return true;
}

bool Grammar::ProceVardecl(Word *Token)                //<vardecl> → var <id>{,<id>}
{
	if(Token[i].ReturnWType()==$var)
	{
		i++;
		if(Token[i].ReturnWType()==$id)
		{
			this->VarDecla(Token);
			i++;			
			while(Token[i].ReturnWType()==$and)
			{
				i++;
				if(Token[i].ReturnWType()==$id)
				{
					this->VarDecla(Token);
					i++;					
				}
				else
				{
					i++;
					Token[i].ReturnXY(bx,ex,y);
					cout<<"\",\"后应当输入变量名:第"<<y<<"行"<<endl;
					return false;
				}
			}
		}
		else
		{
			Token[i].ReturnXY(bx,ex,y);
			cout<<"缺少标识符:第"<<y<<"行"<<endl;
			return false;
		}
	}
	return true;
}

bool Grammar::ProceProc(Word *Token)                         //<proc> → procedure <id>（<id>{,<id>}）;<block>{;<proc>}
{
	int tx0;
	Table *tb=pl->ChaTable;
	pcode *cd=pl->CodeList;
	
	if(Token[i].ReturnWType()==$procedure)
	{
		i++;
//		lev++;
//		dx[lev]=3;
		tb=pl->ChaTable;
		tx0=tb->ReturnIndex();
		if(Token[i].ReturnWType()==$id)
		{
			tb->Enter(procedure,Token);
			i++;
			if(Token[i].ReturnWType()==$)
			{
				i++;
				if(!ProceBlock(Token))
					return false;
				while(Token[i].ReturnWType()==$)
				{
					i++;
					if(!ProceProc(Token))
						return false;
				}
			}
			else
			{
				Token[i].ReturnXY(bx,ex,y);
				cout<<"缺少\";\":第"<<y<<"行"<<endl;
				return false;
			}
		}
		else
		{
			Token[i].ReturnXY(bx,ex,y);
			cout<<"缺少标识符:第"<<y<<"行"<<endl;
			return false;
		}
	}
	return true;
}

bool Grammar::ProceBlock(Word *Token)                   //<block> → [<condecl>][<vardecl>][<proc>]<body>
{
	Table *tb=pl->ChaTable;
	pcode *cd=pl->CodeList;
	int cx0,tx0;
	lev++;
	dx[lev]=3;
	tx0=tb->ReturnIndex();
	tb->table[tx0].adr=cd->cx;
	cd->Gen(JMP,0,0);
	if(lev>MAX_LEV)
	{
		cout<<"超出最高允许嵌套次数！"<<endl;
		return false;
	}
	if(!ProceCondecl(Token))
		return false;
	if(!ProceVardecl(Token))
		return false;
	if(!ProceProc(Token))
		return false;
	else
	{
		cd->code[tb->table[tx0].adr].a=cd->cx;
		tb->table[tx0].adr=cd->cx;
		tb->table[tx0].size=dx[lev];
		cx0=cd->cx;
		cd->Gen(INT,0,dx[lev]);
	}
	if(!ProceBody(Token))
		return false;
	else
	{
		cd->Gen(OPR,0,0);
		lev--;
	}
	return true;
}

bool Grammar::ProceProg(Word *Token)                    //<prog> → program <id>；<block>
{
	if(Token[i].ReturnWType()==$program)
	{
		i++;
		if(Token[i].ReturnWType()==$id)
		{
			i++;

		}
		else
		{
			Token[i].ReturnXY(bx,ex,y);
			cout<<"第"<<y<<"行第"<<bx<<"个字符处错误，应输入标识符;"<<endl;
			return false;
		}
		if(Token[i].ReturnWType()==$)
		{
			i++;
			if(!ProceBlock(Token))
				return false;
		}
		else
		{
			Token[i].ReturnXY(bx,ex,y);
			cout<<"第"<<y<<"行第"<<bx<<"个字符处错误，应输入;"<<endl;
			return false;
		}
	}
	else
	{
		Token[i].ReturnXY(bx,ex,y);
		cout<<"第"<<y<<"行第"<<bx<<"个字符处错误，应输入program"<<endl;
		return false;
	}
	return true;
}