fc-compile.cpp

编译原理的一个课程设计

	switch(m_curElement)
	{
	case E_INUMBER:		//整数
		if(!TestCode())
			return FALSE;
		m_code[m_iCode].op=OP_LOADCONSTI;
		m_code[m_iCode].sd.iNumber=m_nCurNumber;
		m_iCode++;
		if(!GetElement())
			return FALSE;
		break;
	case E_DNUMBER:		//实数
		m_bDouble=TRUE;
		if(!TestCode())
			return FALSE;
		m_code[m_iCode].op=OP_LOADCONSTD;
		m_code[m_iCode].sd.dNumber=m_dCurNumber;
		m_iCode++;
		if(!GetElement())
			return FALSE;
		break;
	case E_INT:			//int -- 强制类型转换
	case E_DOUBLE:		//double -- 强制类型转换
		it=(m_curElement==E_INT?IT_INT:IT_DOUBLE);
		if(!GetElement())
			return FALSE;
		if(m_curElement!=E_LPAREN)
		{
			if(!ErrorReport(CFCErrorDlg::ET_LESSLPAREN))
				return FALSE;
		}
		//此处不填入break语句
	case E_LPAREN:		//左括号 -- (表达式)
		if(!GetElement())
			return FALSE;
		if(!DoExpression())
			return FALSE;
		if(m_curElement!=E_RPAREN)
		{
			if(!ErrorReport(CFCErrorDlg::ET_LESSRPAREN))
				return FALSE;
			//继续编译，权当此处有个右小括号
		}
		switch(it)//进行类型转换
		{
		case IT_VOID://不进行类型转换
			break;
		case IT_INT:
			if(m_bDouble)
			{
				if(!TestCode())
					return FALSE;
				m_code[m_iCode].op=OP_D2I;
				m_code[m_iCode].sd.iNumber=0;
				m_iCode++;
				m_bDouble=FALSE;
			}
			break;
		case IT_DOUBLE:
			if(!m_bDouble)
			{
				if(!TestCode())
					return FALSE;
				m_code[m_iCode].op=OP_I2D;
				m_code[m_iCode].sd.iNumber=0;
				m_iCode++;
				m_bDouble=TRUE;
			}
			break;
		}
		m_bDouble=(bDouble || m_bDouble);
		if(!GetElement())
			return FALSE;
		break;
	case E_IDENT:		//标识符 -- 变量或数组或函数调用
		index=IdentIndex(m_curIdent);
		switch(GetIdentType(m_curIdent))
		{
		case IT_NULL:
			if(!ErrorReport(CFCErrorDlg::ET_UNKNOWNIDENT))
				return FALSE;
			//继续编译，不写入导入变量这一中间代码
			if(!GetElement())
				return FALSE;
			break;
		case IT_FUNCTION:
			if(!DoCall())
				return FALSE;
			m_bDouble=(bDouble || m_bDouble);
			break;
		case IT_INT:
		case IT_INTINRANG:
			if(!TestCode())
				return FALSE;
			m_code[m_iCode].op=OP_LOADVARI;
			m_code[m_iCode].sd.iNumber=index;
			m_iCode++;
			if(!GetElement())
				return FALSE;
			break;
		case IT_DOUBLE:
		case IT_DOUBLEINRANG:
			m_bDouble=TRUE;
			if(!TestCode())
				return FALSE;
			m_code[m_iCode].op=OP_LOADVARD;
			m_code[m_iCode].sd.iNumber=index;
			m_iCode++;
			if(!GetElement())
				return FALSE;
			break;
		case IT_INTARRAY:
		case IT_IARRAYINRANG:
			if(!GetElement())//获取左方括号
				return FALSE;
			if(!DoSubscript())
				return FALSE;
			m_bDouble=FALSE;//整数数组
			if(!TestCode())
				return FALSE;
			m_code[m_iCode].op=OP_LOADARRAYI;
			m_code[m_iCode].sd.iNumber=index;
			m_iCode++;
			if(!GetElement())
				return FALSE;
			break;
		case IT_DOUBLEARRAY:
		case IT_DARRAYINRANG:
			if(!GetElement())//获取左方括号
				return FALSE;
			if(!DoSubscript())
				return FALSE;
			m_bDouble=TRUE;//实数数组
			if(!TestCode())
				return FALSE;
			m_code[m_iCode].op=OP_LOADARRAYD;
			m_code[m_iCode].sd.iNumber=index;
			m_iCode++;
			if(!GetElement())
				return FALSE;
			break;
		//不需要default语句 -- GetIdentType(m_curIdent,m_iFunction)只返回所列举的几个值
		}//end inner switch
		break;
	default:
		if(!ErrorReport(CFCErrorDlg::ET_UNKNOWNERROR))
			return FALSE;
		if(!GetElement())
			return FALSE;
		break;
	}//end outer switch
	m_bDouble=(m_bDouble || bDouble);
	return TRUE;
}

BOOL CFCDlg::DoCall(void)
{
	m_bDouble=FALSE;
	int i,index=FunctionIndex(m_curIdent);
	if(!GetElement())//获取左小括号
		return FALSE;
	if(m_curElement!=E_LPAREN)
	{
		if(!ErrorReport(CFCErrorDlg::ET_LESSLPAREN))
			return FALSE;
		//继续编译，权当此处有一个左小括号
	}
	if(!GetElement())//获取函数第一个实参（表达式）的第一个 ZElement 或右小括号
		return FALSE;
	if(m_curElement!=E_RPAREN)//不是右小括号，函数有参数
	{
		for(i=0;;i++)//参数处理循环
		{
			m_bDouble=FALSE;
			if(!DoExpression())
				return FALSE;
			if(m_bDouble && m_function[index].param[i].type!=IT_DOUBLE)//应为整数参数，却为实数
			{
				if(!ErrorReport(CFCErrorDlg::ET_WRONGPARAMTYPE))
					return FALSE;
			}
			if(m_curElement==E_RPAREN)//右小括号，参数部分结束
			{
				i++;
				break;
			}
			if(m_curElement!=E_COMMA)//不是右小括号也不是逗号，错误
			{
				if(!ErrorReport(CFCErrorDlg::ET_LESSCOMMA))
					return FALSE;
			}
			if(!GetElement())
				return FALSE;
		}
	}
	else i=0;
	if(i!=m_function[index].iParam)//参数数目错误
	{
		if(!ErrorReport(CFCErrorDlg::ET_WRONGPARAMNUM))
			return FALSE;
	}
	m_bDouble=(m_function[index].ReturnType==IT_DOUBLE);
	if(!TestCode())
		return FALSE;
	m_code[m_iCode].op=OP_CALL;
	m_code[m_iCode].sd.iNumber=SearchFunction(index);
	m_iCode++;
	if(!GetElement())
		return FALSE;
	return TRUE;
}

BOOL CFCDlg::DoDefine(void)
{
	ZIdentType type=(m_curElement==E_INT?IT_INT:IT_DOUBLE);
	for(int i=m_function[m_iFunction].iIdent;;i++)//循环处理变量定义
	{
		if(!GetElement())//获取变量标识符
			return FALSE;
		if(m_curElement!=E_IDENT)//不是标识符
		{
			if(!ErrorReport(CFCErrorDlg::ET_LESSIDENT))
				return FALSE;
		}
		else
		{
			switch(GetIdentType(m_curIdent))
			{
			case IT_FUNCTION:
			case IT_INT:
			case IT_DOUBLE:
			case IT_INTARRAY:
			case IT_DOUBLEARRAY:
				if(!ErrorReport(CFCErrorDlg::ET_DEFINEDIDENT))
					return FALSE;
				break;
			}
		}
		strcpy(m_function[m_iFunction].ident[i].name,m_curIdent);//登记变量名
		m_function[m_iFunction].ident[i].level=m_function[m_iFunction].level;//登记嵌套层次
		if(!GetElement())//获取逗号或分号或等号
			return FALSE;
		if(m_curElement==E_LSUB)//数组定义
		{
			m_function[m_iFunction].ident[i].type= //登记数组类型
				(type==IT_INT?IT_INTARRAY:IT_DOUBLEARRAY);
			if(!DoSubscript())
				return FALSE;
			if(!TestCode())
				return FALSE;
			//申请数组
			m_code[m_iCode].op=(type==IT_INT?OP_NEWARRAYI:OP_NEWARRAYD);
			m_code[m_iCode].sd.iNumber=i+m_function[m_iFunction].iParam;
			m_iCode++;
			if(!GetElement())//获取逗号或分号
				return FALSE;
		}
		else//变量定义
		{
			m_function[m_iFunction].ident[i].type=type;//登记变量类型
			if(m_curElement==E_BECOMES)//标识符后有等号
			{
				if(!GetElement())//获取表达式的第一个 ZElement
					return FALSE;
				m_bDouble=FALSE;//准备类型检查
				if(!DoExpression())//处理表达式
					return FALSE;
				if(m_bDouble && type==IT_INT)//把实数赋予整数，错误
				{
					if(!ErrorReport(CFCErrorDlg::ET_DOUBLE2INT))
						return FALSE;
				}
				if(!m_bDouble && type==IT_DOUBLE)//把整数赋予实数，进行类型转换
				{
					if(!TestCode())
						return FALSE;
					m_code[m_iCode].op=OP_I2D;
					m_code[m_iCode].sd.iNumber=0;//栈顶第一个数
					m_iCode++;
				}
				if(!TestCode())
					return FALSE;
				m_code[m_iCode].op=(type==IT_INT?OP_SAVEI:OP_SAVED);
				m_code[m_iCode].sd.iNumber=i+m_function[m_iFunction].iParam;
				m_iCode++;
			}
			else//标识符没有赋予初值，设置初值为0
			{
				m_iCode++;//预先加一，因为下边需要2单元的ZCode
				if(!TestCode())
					return FALSE;
				if(type==IT_INT)//变量为整型
				{
					m_code[m_iCode-1].op=OP_LOADCONSTI;
					m_code[m_iCode-1].sd.iNumber=0;
					m_code[m_iCode].op=OP_SAVEI;
					m_code[m_iCode].sd.iNumber=i+m_function[m_iFunction].iParam;
				}
				else//变量为实型
				{
					m_code[m_iCode-1].op=OP_LOADCONSTD;
					m_code[m_iCode-1].sd.dNumber=0;
					m_code[m_iCode].op=OP_SAVED;
					m_code[m_iCode].sd.iNumber=i+m_function[m_iFunction].iParam;
				}
				m_iCode++;
			}
		}
		if(m_curElement==E_SEMICOLON)//标识符后是分号，变量定义结束
		{
			m_function[m_iFunction].iIdent=i+1;
			break;
		}
		else if(m_curElement!=E_COMMA)//标识符后不是等号也不是逗号，错误
		{
			if(!ErrorReport(CFCErrorDlg::ET_LESSCOMMA))
				return FALSE;
		}
		m_function[m_iFunction].iIdent=i+1;
	}//end for
	if(!GetElement())
		return FALSE;
	return TRUE;
}

BOOL CFCDlg::DoBecomes(void)
{
	ZIdentType type=GetIdentType(m_curIdent);
	int index=IdentIndex(m_curIdent);
	BOOL bVar=TRUE;
	if(!GetElement())//获取赋值号或左方括号
		return FALSE;
	if(m_curElement==E_LSUB)//左方括号，处理数组
	{
		bVar=FALSE;
		if(!DoSubscript())
			return FALSE;
		if(!GetElement())//获取赋值号
			return FALSE;
	}
	if(m_curElement!=E_BECOMES)//不是等号，错误
	{
		if(!ErrorReport(CFCErrorDlg::ET_LESSBECOMES))
			return FALSE;
	}
	if(!GetElement())//获取表达式的第一个 ZElement
		return FALSE;
	m_bDouble=FALSE;//准备类型检查
	if(!DoExpression())
		return FALSE;
	if(m_bDouble &&
		 (type==IT_INT || type==IT_INTARRAY ||
		  type==IT_INTINRANG || type==IT_IARRAYINRANG))//把实数赋予整数，错误
	{
		if(!ErrorReport(CFCErrorDlg::ET_DOUBLE2INT))
			return FALSE;
	}
	if(!m_bDouble &&
		 (type==IT_DOUBLE || type==IT_DOUBLEARRAY ||
		  type==IT_DOUBLEINRANG || type==IT_DARRAYINRANG))//把整数赋予实数，进行类型转换
	{
		if(!TestCode())
			return FALSE;
		m_code[m_iCode].op=OP_I2D;
		m_code[m_iCode].sd.iNumber=0;//栈顶第一个数
		m_iCode++;
	}
	if(!TestCode())
		return FALSE;
	if(bVar)
		m_code[m_iCode].op=((type==IT_INT || type==IT_INTINRANG)?OP_SAVEI:OP_SAVED);
	else
		m_code[m_iCode].op=((type==IT_INTARRAY || type==IT_IARRAYINRANG)?OP_SAVEARRAYI:OP_SAVEARRAYD);
	m_code[m_iCode].sd.iNumber=index;
	m_iCode++;
	if(!GetElement())
		return FALSE;
	return TRUE;
}

BOOL CFCDlg::DoInput(void)
{
	ZIdentType type;
	int index;
	BOOL bVar;
	while(1)//输入处理循环
	{
		if(!GetElement())//获取标识符
			return FALSE;
		if(m_curElement!=E_IDENT)//要输入的不是标识符
		{
			if(!ErrorReport(CFCErrorDlg::ET_WRONGINPUTOB))
				return FALSE;
		}
		else
		{
			type=GetIdentType(m_curIdent);
			switch(type)
			{
			case IT_INT:
			case IT_DOUBLE:
			case IT_INTINRANG:
			case IT_DOUBLEINRANG:
				bVar=TRUE;
				index=IdentIndex(m_curIdent);
				break;
			case IT_INTARRAY:
			case IT_DOUBLEARRAY:
			case IT_IARRAYINRANG:
			case IT_DARRAYINRANG:
				bVar=FALSE;
				index=IdentIndex(m_curIdent);
				if(!GetElement())//获取左方括号
					return FALSE;
				if(!DoSubscript())
					return FALSE;
				break;
			default://要输入的不是变量、参数、数组
				if(!ErrorReport(CFCErrorDlg::ET_WRONGINPUTOB))
					return FALSE;
				break;
			}
		}
		if(!TestCode())
			return FALSE;
		if(bVar)
			m_code[m_iCode].op=((type==IT_INT || type==IT_INTINRANG)?
				OP_INPUTI:OP_INPUTD);
		else 
			m_code[m_iCode].op=((type==IT_INTARRAY || type==IT_IARRAYINRANG)?
				OP_INPUTARRAYI:OP_INPUTARRAYD);
		m_code[m_iCode].sd.iNumber=index;
		m_iCode++;
		if(!GetElement())//获取逗号或分号
			return FALSE;
		if(m_curElement==E_SEMICOLON)//分号，输入语句结束
			break;
		if(m_curElement!=E_COMMA)//不是分号也不是逗号，错误
		{
			if(!ErrorReport(CFCErrorDlg::ET_LESSCOMMA))
				return FALSE;
		}
	}//end for
	if(!GetElement())
		return FALSE;
	return TRUE;
}

BOOL CFCDlg::DoSpecial(void)
{
	switch(m_curElement)
	{
	case E_RETURN:
		if(m_function[m_iFunction].ReturnType==IT_VOID)//无返回值
		{
			if(!GetElement())//获取分号
				return FALSE;
			if(m_curElement!=E_SEMICOLON)//不是分号，错误
			{
				if(!ErrorReport(CFCErrorDlg::ET_LESSSEMICOLON))
					return FALSE;
			}
			if(!TestCode())
				return FALSE;
			m_code[m_iCode].op=OP_RETURN;
			m_code[m_iCode].sd.iNumber=m_function[m_iFunction].iParam;
			m_iCode++;
		}
		else//有返回值
		{
			if(!GetElement())//获取表达式的第一个 ZElement
				return FALSE;
			m_bDouble=FALSE;//准备类型检查
			if(!DoExpression())
				return FALSE;
			if(m_function[m_iFunction].ReturnType==IT_INT && m_bDouble)//int函数返回double值，错误
			{
				if(!ErrorReport(CFCErrorDlg::ET_DOUBLE2INT))
					return FALSE;
			}
			if(m_function[m_iFunction].ReturnType==IT_DOUBLE && !m_bDouble)//double函数返回int值，进行类型转换
			{
				if(!TestCode())
					return FALSE;
				m_code[m_iCode].op=OP_I2D;
				m_code[m_iCode].sd.iNumber=0;
				m_iCode++;
			}
			if(!TestCode())
				return FALSE;
			m_code[m_iCode].op=(m_function[m_iFunction].ReturnType==IT_INT?OP_RETURNI:OP_RETURND);
			m_code[m_iCode].sd.iNumber=m_function[m_iFunction].iParam;
			m_iCode++;
		}
		m_code[m_iCode].sd.iNumber=m_function[m_iFunction].iParam;
		break;
	case E_BREAK:
		if(m_iBreak==-1)//不在while语句中，错误
		{
			if(!ErrorReport(CFCErrorDlg::ET_WRONGBREAK))
				return FALSE;
		}
		m_code[m_iCode].op=OP_JUMP;
		m_code[m_iCode].sd.iNumber=m_iBreak;
		m_iCode++;
		if(!GetElement())//获取分号
			return FALSE;
		if(m_curElement!=E_SEMICOLON)//不是分号，错误
		{
			if(!ErrorReport(CFCErrorDlg::ET_LESSSEMICOLON))
				return FALSE;
		}
		break;
	case E_CONTINUE:
		if(m_iContinue==-1)//不在while语句中，错误
		{
			if(!ErrorReport(CFCErrorDlg::ET_WRONGCONTINUE))
				return FALSE;
		}
		m_code[m_iCode].op=OP_JUMP;
		m_code[m_iCode].sd.iNumber=m_iContinue;
		m_iCode++;
		if(!GetElement())//获取分号
			return FALSE;
		if(m_curElement!=E_SEMICOLON)//不是分号，错误
		{
			if(!ErrorReport(CFCErrorDlg::ET_LESSSEMICOLON))
				return FALSE;
		}