fenxi.cpp

计算机科学与技术专业课程编译原理的课程实验代码

 
#include "stdafx.h"
#include "fenxi.h"



/*================================================================ 
* 函数名：    CiFaFenXi
* 功能描述:   词法分析 (public)
* 返回值：    void
================================================================*/
void CFenXi::CiFaFenXi()
{
	BOOL flag=false;
	char token[20];
	int k,v;
	
	init();

	for (int i=0;i<m_n;i++)  //当第2次调用该函数时，就要释放前1次的资源
	{
		delete m_cifa[i];
	}
	
	int n=0;		//用于指示当前的字符
	m_n=0;			//词法结果单词的个数
	
	while (m_str[n])
	{
		if (flag)
		{
			while (!((m_str[n]=='*')&&(m_str[n+1]=='/')))
			{
				if (m_str[n]) 
					n++;
				else 
					break;
			}
			
			if (m_str[n])
			{
				n++;
				n++;
				flag=false;
			}
		}
		while (1)
		{
			while ((m_str[n]==32) || (m_str[n]==9))
				n++;
			
			if (!((m_str[n]==13) && (m_str[n+1]==10)))
				break;
			
			n++;
			n++;
		}

		
		if (isalpha(m_str[n]))		//字母
		{
			k=0;
			while (1)
			{
				if (k<19)				//标志符的长度为20
					token[k++]=m_str[n++];
				else 
					n++;
				
				if (!isalnum(m_str[n])) //如果不是数字或字母就退出
					break;
			}
			
			token[k]=0;
			v=FinKW(token);		//查找关键词表
			if (v)	//如果是关键词
			{
				m_cifa[m_n]=new CIFA;
				m_cifa[m_n]->nValue=0;
				m_cifa[m_n]->nType=v;
				strcpy(m_cifa[m_n]->szText,token);
				strcpy(m_cifa[m_n]->szDesc, "关键字");
				m_cifa[m_n]->nAddr=n-k;
				m_n++;
			}
			else   //普通标志符
			{
				m_cifa[m_n]=new CIFA;
				
			    /*----------在词法分析结果中查找-----------*/
				int vv=1;
				for (int i=0;i<m_n;i++)
				{
					if (m_cifa[i]->nType==1)
					{
						vv++;
						if (!::stricmp(m_cifa[i]->szText,token))
							m_cifa[m_n]->nValue= m_cifa[i]->nValue;
					}
				}
				m_cifa[m_n]->nValue=vv;
			    /*---------------------------------------*/

				m_cifa[m_n]->nType=1;
				strcpy(m_cifa[m_n]->szText,token);
				strcpy(m_cifa[m_n]->szDesc, "标志符");
				m_cifa[m_n]->nAddr=n-k;
				m_n++;
			}
		}
		else if (isdigit(m_str[n]))	//数字
		{
			k=0;
			BOOL error=false;
			while (1)
			{
				if (k<=8) 
					token[k++]=m_str[n++];
				else
				{
					error=true;
					n++;
				}
				if (!isdigit(m_str[n])) 
					break;
			}
			token[k]=0;
			v=::strtol(token,NULL,10);
			if (error)
			{
				m_cifa[m_n]=new CIFA;
				m_cifa[m_n]->nValue=1;
				m_cifa[m_n]->nType=0;
				strcpy(m_cifa[m_n]->szText,token);
				strcpy(m_cifa[m_n]->szDesc,"");
				m_cifa[m_n]->nAddr=n-k;
				m_n++;
			}
			else
			{
				m_cifa[m_n]=new CIFA;
				m_cifa[m_n]->nValue=v;
				m_cifa[m_n]->nType=2;
				strcpy(m_cifa[m_n]->szText,token);
				strcpy(m_cifa[m_n]->szDesc,"数字");
				m_cifa[m_n]->nAddr=n-k;
				m_n++;
			}
		}
		else
			switch (m_str[n])	//其他符号
			{
			case '+':
			case '-':
			case '*':
			case '~':
			case '&':
			case '|':
			case '=':
			case ';':
			case '.':
			case ',':
			case '(':
			case ')':
				token[0]=m_str[n];
				token[1]=0;
				v=FinKW(token);

				m_cifa[m_n]=new CIFA;
				m_cifa[m_n]->nValue=0;
				m_cifa[m_n]->nType=v;
				strcpy(m_cifa[m_n]->szText,token);
				strcpy(m_cifa[m_n]->szDesc,"其他符号");
				m_cifa[m_n]->nAddr=n;

				m_n++;
				n++;
				break;

			case '\0':
				break;

			case '/':
				switch (m_str[n+1])
				{
				case '*':
					n++;
					n++;
					flag=true;
					break;
				default:
					token[0]=m_str[n];
					token[1]=0;
					v=FinKW(token);
					m_cifa[m_n]=new CIFA;
					m_cifa[m_n]->nValue=0;
					m_cifa[m_n]->nType=v;
					strcpy(m_cifa[m_n]->szText,token);
					strcpy(m_cifa[m_n]->szDesc,"___");
					m_cifa[m_n]->nAddr=n;
					m_n++;
					n++;
				}
				break;

				case '<':
					switch (m_str[n+1])
					{
					case '=':
						token[0]=m_str[n];
						token[1]=m_str[n+1];
						token[2]=0;
						v=FinKW(token);
						m_cifa[m_n]=new CIFA;
						m_cifa[m_n]->nValue=0;
						m_cifa[m_n]->nType=v;
						strcpy(m_cifa[m_n]->szText,token);
						strcpy(m_cifa[m_n]->szDesc,"小于等于");
						m_cifa[m_n]->nAddr=n;
						m_n++;
						n++;
						n++;
						break;
					case '>':
						token[0]=m_str[n];
						token[1]=m_str[n+1];
						token[2]=0;
						v=FinKW(token);
						m_cifa[m_n]=new CIFA;
						m_cifa[m_n]->nValue=0;
						m_cifa[m_n]->nType=v;
						strcpy(m_cifa[m_n]->szText,token);
						strcpy(m_cifa[m_n]->szDesc,"不等于");
						m_cifa[m_n]->nAddr=n;
						m_n++;
						n++;
						n++;
						break;

					default:
						token[0]=m_str[n];
						token[1]=0;
						v=FinKW(token);
						m_cifa[m_n]=new CIFA;
						m_cifa[m_n]->nValue=0;
						m_cifa[m_n]->nType=v;
						strcpy(m_cifa[m_n]->szText,token);
						strcpy(m_cifa[m_n]->szDesc,"小于");
						m_cifa[m_n]->nAddr=n;
						m_n++;
						n++;
					}
					break;

					case '>':
						switch (m_str[n+1])
						{
						case '=':
							token[0]=m_str[n];
							token[1]=m_str[n+1];
							token[2]=0;
							v=FinKW(token);
							m_cifa[m_n]=new CIFA;
							m_cifa[m_n]->nValue=0;
							m_cifa[m_n]->nType=v;
							strcpy(m_cifa[m_n]->szText,token);
							strcpy(m_cifa[m_n]->szDesc,"大于等于");
							m_cifa[m_n]->nAddr=n;
							m_n++;
							n++;
							n++;
							break;

						default:
							token[0]=m_str[n];
							token[1]=0;
							v=FinKW(token);
							m_cifa[m_n]=new CIFA;
							m_cifa[m_n]->nValue=0;
							m_cifa[m_n]->nType=v;
							strcpy(m_cifa[m_n]->szText,token);
							strcpy(m_cifa[m_n]->szDesc,"大于");
							m_cifa[m_n]->nAddr=n;
							m_n++;
							n++;
						}
						break;

						case ':':
							switch (m_str[n+1])
							{
							case '=':
								token[0]=m_str[n];
								token[1]=m_str[n+1];
								token[2]=0;
								v=FinKW(token);
								m_cifa[m_n]=new CIFA;
								m_cifa[m_n]->nValue=0;
								m_cifa[m_n]->nType=v;
								strcpy(m_cifa[m_n]->szText,token);
								strcpy(m_cifa[m_n]->szDesc,"赋值运算符");
								m_cifa[m_n]->nAddr=n;
								m_n++;
								n++;
								n++;
								break;

							default:
								token[0]=m_str[n];
								token[1]=0;
								v=FinKW(token);
								m_cifa[m_n]=new CIFA;
								m_cifa[m_n]->nValue=0;
								m_cifa[m_n]->nType=v;
								strcpy(m_cifa[m_n]->szText,token);
								strcpy(m_cifa[m_n]->szDesc,"类型说明符号");
								m_cifa[m_n]->nAddr=n;
								m_n++;
								n++;
							}
							break;

							default:
								token[0]=m_str[n];
								token[1]=0;
								m_cifa[m_n]=new CIFA;
								m_cifa[m_n]->nValue=2;
								m_cifa[m_n]->nType=0;
								strcpy(m_cifa[m_n]->szText,token);
								strcpy(m_cifa[m_n]->szDesc,"ddd");
								m_cifa[m_n]->nAddr=n;
								m_n++;
								n++;
			} 

		if (m_n==10000-2)	//词法分析的结果的个数规定为10000
		{
			m_cifa[m_n]=new CIFA;
			m_cifa[m_n]->nValue=99;
			m_cifa[m_n]->nType=0;
			strcpy(m_cifa[m_n]->szText,"");
			strcpy(m_cifa[m_n]->szDesc,"错误");
			m_cifa[m_n]->nAddr=n-1;
			m_n++;
			break;
		}
	} 

	m_cifa[m_n]=new CIFA;
	m_cifa[m_n]->nValue=0;
	m_cifa[m_n]->nType=-1;	//结束符
	strcpy(m_cifa[m_n]->szText,"");
	strcpy(m_cifa[m_n]->szDesc,"程序结束");
	m_cifa[m_n]->nAddr=0;
	m_n++;

	return;
}




/*================================================================ 
* 函数名：    FinKW(char * a)
* 功能描述:   在关键字表中查找  (protected)
* 返回值：    int (如果找到返回在表中的位置，否则返回0)
================================================================*/
int CFenXi::FinKW(char * a)
{
	for (int i=0;i<50;i++)
		if (!::stricmp(m_kw[i],a))   //找到
			return i;

		return 0; //未找到
}



/*================================================================ 
* 函数名：    YuFaFenXi
* 功能描述:   语法分析 (public)
* 返回值：    void
================================================================*/
void CFenXi::YuFaFenXi()
{

	if (m_n==0) 
		return;		//尚未进行词法分析
	
	m_nCur=0;		//m_nCur用语指示词法分析结果表中单词的位置

	Program();		//从 程序 开始
 
	return;
}


/*================================================================ 
* 函数名：    Program
* 功能描述:   分析整个程序 (protected)
* 返回值：    bool
* 示例：
			Program abc;
				这里是程序体	
			.
================================================================*/
bool CFenXi::Program()			//程序
{
 
	if(m_cifa[m_nCur]->nType !=3) 
	{
		m_nErrNo=3;		//缺少关键字 program 
		m_nErrAddr=m_nCur;
		return false;
	}

	m_nCur++;			//分析下一个单词

	if(m_cifa[m_nCur]->nType !=1) //标志符
	{
		m_nErrNo=4;		//program 后缺少标识符！
		m_nErrAddr=m_nCur;
		return false;
	}

	m_nCur++;

	if( m_cifa[m_nCur]->nType !=30) //;
	{
		m_nErrNo=5;		//缺少 ;
		m_nErrAddr=m_nCur;
		return false;
	}

	m_nCur++;

	if (!ProgramTi())  //分析程序体
		return false;

	if(m_cifa[m_nCur]->nType !=31)  	//. (程序的最后一个符号)
	{
		m_nErrNo=6;		//缺少程序结束符.
		m_nErrAddr=m_nCur;
		return false;
	}

	m_nCur++;

	if( m_cifa[m_nCur]->nType !=-1)  
	{
		m_nErrNo=96;	//源程序结束符. 后还有多余的内容！
		m_nErrAddr=m_nCur;
		return false;
	}

	m_nErrNo=0;		//语法分析成功
	m_nErrAddr=m_nCur;
	return true;
}


/*================================================================ 
* 函数名：    ProgramTi
* 功能描述:   分析程序体 (protected)
* 返回值：    bool
* 示例：
		  Integer x,y,z;   
		  Real a,b;        //变量声明

		  Procedure ab(Var m,n:Integer; t:Real);  //过程声明
		  Begin
			  t:=n+m;
			  If m>n then n:=m else t:=m;
			  While n<m do
				Begin
				  n:=n+1
				End
		  End;

		  Begin
			这里是语句串
		  End
================================================================*/
bool CFenXi::ProgramTi()
{
	switch (m_cifa[m_nCur]->nType)
	{
	case 5:			//procedure		
	case 14:		//booleger
	case 15:		//real
 
		if (!ShengMingChuan())   //声明串(用;隔开的多个变量或过程声明)
			return false;

		if(m_cifa[m_nCur]->nType  !=30 ) //;
		{
			m_nErrNo=5;	//缺少;！"
			m_nErrAddr=m_nCur;
			return false;
		}
		m_nCur++;
		break;

		case 6:		//begin
			break;

		default:
			m_nErrNo=7;		//缺少程序体，应为 begin,integer,real,procedure 
			m_nErrAddr=m_nCur;
			return false;
	}

	if(m_cifa[m_nCur]->nType !=6)  //begin
	{
		m_nErrNo=8;		//缺少保留字“ begin ”！
		m_nErrAddr=m_nCur;
		return false;
	}

	m_nCur++;

	if (!SentenceChuan())  //语句串
		return false;

	if( m_cifa[m_nCur]->nType !=7)  //end
	{
		m_nErrNo=10;	//缺少保留字“ end ”！
		m_nErrAddr=m_nCur;
		return false;
	}

	m_nCur++;

	return true;
}


/*================================================================ 
* 函数名：    ShengMingChuan
* 功能描述:   声明串 用;隔开的多个声明(protected)
* 返回值：    void
================================================================*/
bool CFenXi::ShengMingChuan()
{
	if (!ShengMing()) 		
		return false;

	while (m_cifa[m_nCur]->nType==30 && m_cifa[m_nCur+1]->nType!=6)	//是; 不是begin
	{
		m_nCur++;
		if (!ShengMing()) //递归调用
			return false;
	}
	return true;
}

/*================================================================ 
* 函数名：    ShengMing
* 功能描述:   声明 (protected)
* 返回值：    void
================================================================*/
bool CFenXi::ShengMing()
{
	switch (m_cifa[m_nCur]->nType)
	{
	case 14:		//booleger
	case 15:		//real
		if (!BianliangShengMing())	//变量声明
			return false;
		break;

	case 5:			//procedure
		if (!GuoChengShengMing()) //过程声明
			return false;
		break;

	default:
		m_nErrNo=11;		//缺少声明(integer,real,procedure)
		m_nErrAddr=m_nCur;
		return false;
	}
	return true;
}


/*================================================================ 
* 函数名：    BianliangShengMing
* 功能描述:   变量声明	(protected)
* 返回值：    void
* 示例：	 Integer x,y,z;
================================================================*/
bool CFenXi::BianliangShengMing()
{

	switch (m_cifa[m_nCur]->nType)
	{
	case 14:	//booleger
	case 15:	//real
		break;

	default:
		m_nErrNo=12;	//缺少变量类型 integer 或 real！
		m_nErrAddr=m_nCur;
		return false;
	}

	m_nCur++;

	if( m_cifa[m_nCur]->nType !=1)
	{
		m_nErrNo=14;	//变量声明后缺少标识符！
		m_nErrAddr=m_nCur;
		return false;
	}

	m_nCur++;

	while (m_cifa[m_nCur]->nType==32)  //32 , 分析用逗号隔开的连续声明的几个变量
	{
		m_nCur++;

		if( m_cifa[m_nCur]->nType !=1) //id
		{
			m_nErrNo=14;  	//变量声明后缺少标识符
			m_nErrAddr=m_nCur;
			return false;
		}
		m_nCur++;
	}
	return true;
}

/*================================================================ 
* 函数名：    GuoChengShengMing
* 功能描述:   过程声明 (protected)
* 返回值：    void
* 示例:
			  Procedure ab(形参);
					这里是程序体
			
================================================================*/
bool CFenXi::GuoChengShengMing()
{
	if( m_cifa[m_nCur]->nType !=5) //procedure
	{
		m_nErrNo=15;		//缺少保留字“ procedure ”！
		m_nErrAddr=m_nCur;
		return false;

	}

	m_nCur++;

	if(m_cifa[m_nCur]->nType !=1) //id
	{
		m_nErrNo=13;		//procedure 后缺少标识符！
		m_nErrAddr=m_nCur;
		return false;
	}

	m_nCur++;

	if( m_cifa[m_nCur]->nType !=33) //(
	{
		m_nErrNo=16;		//缺少 “ ( ”符号！"
		m_nErrAddr=m_nCur;
		return false;
	}

	m_nCur++;

	if (!XingCan())
		return false;

	while (m_cifa[m_nCur]->nType==30)	//;
	{
		m_nCur++;