fc-compile.cpp

编译原理的一个课程设计

{
	int i,cnt=0,m=2*n+1;
	for(i=1;i<m_iCode && cnt<m;i++)
		if(m_code[i].op==OP_NULL)
			cnt++;
	return i-1;
}

int CFCDlg::IdentIndex(char ident[IDENTLENGTH])
{
	int i;
	if(m_iFunction>=0)
	{
		for(i=m_function[m_iFunction].iIdent;i>=0;i--)//查找变量列表
			if(strcmp(ident,m_function[m_iFunction].ident[i].name)==0 && //标识符名相同
				 m_function[m_iFunction].ident[i].level>=0 )//变量在其作用域内
				return i+m_function[m_iFunction].iParam;
		for(i=m_function[m_iFunction].iParam;i>=0;i--)//查找参数列表
			if(strcmp(ident,m_function[m_iFunction].param[i].name)==0)
				return i;
	}
	return -1;
}

int CFCDlg::FunctionIndex(char ident[IDENTLENGTH])
{
	for(int i=m_iFunction;i>=0;i--)
		if(strcmp(ident,m_function[i].name)==0)
			break;
	return i;
}

BOOL CFCDlg::RecycleMemory(void)
{
	if(m_function[m_iFunction].iIdent>m_function[m_iFunction].iMaxIdent)
		m_function[m_iFunction].iMaxIdent=m_function[m_iFunction].iIdent;
	for(int i=m_function[m_iFunction].iIdent-1;i>=0;i--)
		if(m_function[m_iFunction].ident[i].level>m_function[m_iFunction].level)
		{
			switch(m_function[m_iFunction].ident[i].type)
			{
			case IT_INTARRAY:
				if(!TestCode())
					return FALSE;
				m_code[m_iCode].op=OP_DELARRAYI;
				m_code[m_iCode].sd.iNumber=i+m_function[m_iFunction].iParam;
				m_iCode++;
				break;
			case IT_DOUBLEARRAY:
				if(!TestCode())
					return FALSE;
				m_code[m_iCode].op=OP_DELARRAYD;
				m_code[m_iCode].sd.iNumber=i+m_function[m_iFunction].iParam;
				m_iCode++;
				break;
			}
			m_function[m_iFunction].ident[i].level=-1;
			m_function[m_iFunction].iIdent--;
		}
	return TRUE;
}
// CFCDlg 编译函数
BOOL CFCDlg::Compile(void)
{
	m_strEdit="编译中...\r\n";
	UpdateData(FALSE);	//刷新输出信息
	m_nCurNumber=0;		//当前整数
	m_dCurNumber=0.0;	//当前实数
	m_curElement=E_NULL;//当前ZElement
	m_iFunction=-1;		//函数数目计数
	m_iCount=0;			//源代码字符计数
	m_iLine=0;			//源代码行计数
	m_iCode=1;			//中间代码计数 -- 赋值 1 是为了在 0 处填入jump to main代码
	m_iErrorCount=0;	//源代码错误计数
	m_iContinue=-1;
	m_iBreak=-1;

	if(!GetElement())//获取第一个函数的返回类型
		return FALSE;
	while(1)//循环处理函数
	{
		if(m_curElement==E_FILEEND)
			break;
		if(!DoFunction())
			return FALSE;
	}
	m_iFunction++;
	if(!SearchMain())
		return FALSE;
	return TRUE;
}

BOOL CFCDlg::DoFunction(void)
{
	if(m_iFunction==nFUNCTION)//函数数超过上限
	{
		ErrorReport(CFCErrorDlg::ET_MANYFUNCTION);
		return FALSE;
	}
	if(!TestCode())
		return FALSE;
	int head=m_iCode;
	m_code[head].op=OP_NULL;//函数开始标志
	m_iCode++;//预留空格以填入函数参数和变量所需的内存大小
	switch(m_curElement)//登记函数的返回类型
	{
	case E_DOUBLE:
		m_function[m_iFunction+1].ReturnType=IT_DOUBLE;
		break;
	case E_INT:
		m_function[m_iFunction+1].ReturnType=IT_INT;
		break;
	case E_VOID:
		m_function[m_iFunction+1].ReturnType=IT_VOID;
		break;
	default://错误的函数返回类型
		ErrorReport(CFCErrorDlg::ET_UNKNOWNTYPE);
		return FALSE;
	}
	if(!GetElement())//获取函数名
		return FALSE;
	if(m_curElement!=E_IDENT)//不是标识符
	{
		if(!ErrorReport(CFCErrorDlg::ET_LESSIDENT))
			return FALSE;
	}
	if(IT_FUNCTION==GetIdentType(m_curIdent))//已经定义的函数？
	{
		if(!ErrorReport(CFCErrorDlg::ET_DEFINEDIDENT))
			return FALSE;
		//继续编译，权当此处函数名没有重名
	}
	m_iFunction++;
	strcpy(m_function[m_iFunction].name,m_curIdent);//登记函数名
	if(!GetElement())//获取函数参数前的左括号
		return FALSE;
	if(m_curElement!=E_LPAREN)//不是左小括号？
	{
		if(!ErrorReport(CFCErrorDlg::ET_LESSLPAREN))
			return FALSE;
		//继续编译，权当此处有一个左小括号
	}
	if(!GetElement())//获取函数的第一个参数的类型或右小括号
		return FALSE;
	if(m_curElement==E_RPAREN)//右括号，即此函数时无参函数
		m_function[m_iFunction].iParam=0;
	else//处理函数参数
	{
		int iParam=0;
		m_function[m_iFunction].iParam=0;
		while(1)
		{
			if(iParam==nPARAM)//检查参数数目
			{
				ErrorReport(CFCErrorDlg::ET_MANYPARAM);
				return FALSE;
			}
			switch(m_curElement)//登记参数类型
			{
			case E_INT:
				m_function[m_iFunction].param[iParam].type=IT_INT;
				break;
			case E_DOUBLE:
				m_function[m_iFunction].param[iParam].type=IT_DOUBLE;
				break;
			default:
				ErrorReport(CFCErrorDlg::ET_UNKNOWNTYPE);
				return FALSE;
			}
			if(!GetElement())//获取参数名称
				return FALSE;
			if(m_curElement!=E_IDENT)//不是标识符
			{
				if(!ErrorReport(CFCErrorDlg::ET_LESSIDENT))
					return FALSE;
			}
			if(GetIdentType(m_curIdent)!=IT_NULL)//参数重名
			{
				if(!ErrorReport(CFCErrorDlg::ET_DEFINEDIDENT))
					return FALSE;
				//继续编译，权当此处参数没有重名
			}
			strcpy(m_function[m_iFunction].param[iParam].name,m_curIdent);//登记参数名称
			if(!GetElement())//获取逗号或右小括号
				return FALSE;
			iParam++;
			m_function[m_iFunction].iParam++;//参数数目加一
			if(m_curElement!=E_COMMA)//不是逗号，结束参数
				break;
			if(!GetElement())//获取下一个参数类型
				return FALSE;
		}
		if(m_curElement!=E_RPAREN)
		{
			if(!ErrorReport(CFCErrorDlg::ET_LESSRPAREN))
				return FALSE;
			//继续编译，权当此处有一个右小括号
		}
		for(iParam=0;iParam<m_function[m_iFunction].iParam;iParam++)//处理参数传递
		{
			if(!TestCode())
				return FALSE;
			m_code[m_iCode].op=(m_function[m_iFunction].param[iParam].type==IT_INT?
				OP_PARAMTRANSI:OP_PARAMTRANSD);
			m_code[m_iCode].sd.iNumber=iParam;
			m_code[m_iCode].sd.nParam=m_function[m_iFunction].iParam;
			m_iCode++;
		}
	}
	if(!GetElement())//获取函数头部的左花括号
		return FALSE;
	if(m_curElement!=E_BEGIN)
	{
		if(!ErrorReport(CFCErrorDlg::ET_LESSBEGIN))
			return FALSE;
		//继续编译，权当此处有一个左花括号
	}
	m_function[m_iFunction].level=0;//初始嵌套层次为0
	m_function[m_iFunction].iIdent=0;
	if(!GetElement())//获取语句的第一个 ZElement
		return FALSE;
	while(m_curElement!=E_END)//循环处理函数内的语句
	{
		if(!DoStatement())
			return FALSE;
	}
	m_function[m_iFunction].level=-1;//函数已经结束，回收所有变量占用的内存
	if(!RecycleMemory())
		return FALSE;
	if(!GetElement())//获取下一个函数的类型或源代码结束符
		return FALSE;
	switch(m_function[m_iFunction].ReturnType)//处理函数默认返回
	{
	case IT_INT:
		if(!TestCode())
			return FALSE;
		m_code[m_iCode].op=OP_LOADCONSTI;
		m_code[m_iCode].sd.iNumber=0;
		m_iCode++;
		break;
	case IT_DOUBLE:
		if(!TestCode())
			return FALSE;
		m_code[m_iCode].op=OP_LOADCONSTD;
		m_code[m_iCode].sd.dNumber=0.0;
		m_iCode++;
		break;
	}
	if(!TestCode())
		return FALSE;
	m_code[m_iCode].op=OP_NULL;		//函数结束标志
	m_code[m_iCode].sd.iNumber=m_function[m_iFunction].iParam;
	m_iCode++;
	m_code[head].sd.iNumber=			//填入函数参数和变量所需的内存大小
		m_function[m_iFunction].iMaxIdent+m_function[m_iFunction].iParam;
//	m_iFunction++;
	return TRUE;
}

BOOL CFCDlg::DoStatement(void)
{
	m_bDouble=FALSE;
	switch(m_curElement)
	{
	case E_FILEEND:							//源代码结束
		ErrorReport(CFCErrorDlg::ET_SOURCENOEND);
		return FALSE;
	case E_OUTPUT:							//输出语句
		return DoOutput();
	case E_BEGIN:								//复合语句
		m_function[m_iFunction].level++;
		if(!GetElement())
			return FALSE;
		while(1)
		{
			if(m_curElement==E_END || m_curElement==E_FILEEND)
				break;
			if(!DoStatement())
				return FALSE;
		}
		m_function[m_iFunction].level--;
		if(!RecycleMemory())
			return FALSE;
		if(!GetElement())//获取下一语句开始的 ZElement
			return FALSE;
		break;
	case E_INT:case E_DOUBLE:		//定义语句
		return DoDefine();
	case E_IDENT:
		switch(GetIdentType(m_curIdent))
		{
		case IT_NULL:							//未知标识符
			if(!ErrorReport(CFCErrorDlg::ET_UNKNOWNIDENT))
				return FALSE;
			if(!GetElement())
				return FALSE;
			break;
		case IT_INT:							//赋值语句
		case IT_DOUBLE:
		case IT_INTARRAY:
		case IT_DOUBLEARRAY:
		case IT_INTINRANG:
		case IT_DOUBLEINRANG:
		case IT_IARRAYINRANG:
		case IT_DARRAYINRANG:
			if(!DoBecomes())
				return FALSE;
			break;
		case IT_FUNCTION:					//函数调用
			ZIdentType it=m_function[FunctionIndex(m_curIdent)].ReturnType;
			if(!DoCall())
				return FALSE;
			if(m_curElement!=E_SEMICOLON)//缺少分号
			{
				if(!ErrorReport(CFCErrorDlg::ET_LESSSEMICOLON))
					return FALSE;
			}
			if(it!=IT_VOID)
			{
				if(!TestCode())
					return FALSE;
				m_code[m_iCode].op=OP_DELETE;
				m_iCode++;
			}
			if(!GetElement())
				return FALSE;
			break;
		}
		break;
	case E_INPUT:								//输入语句
		return DoInput();
	case E_CONTINUE:case E_BREAK:case E_EXIT:case E_RETURN://特殊语句
		return DoSpecial();
	case E_IF:									//判断语句
		return DoIf();
	case E_WHILE:								//循环语句
		return DoWhile();
	case E_DO:									//重复语句
		return DoDoWhile();
	case E_SWITCH:							//选择语句
		return DoSwitch();
	default:
		if(!ErrorReport(CFCErrorDlg::ET_WRONGSTATEMENT))
			return FALSE;
		if(!GetElement())
			return FALSE;
		break;
	}
	return TRUE;
}

BOOL CFCDlg::DoOutput(void)
{
	do
	{
		if(!GetElement())
			return FALSE;
		if(m_curElement==E_STRING)//输出字符串
		{
			char *string=new char[m_curString.GetLength()+1];
			strcpy(string,m_curString);
			if(!TestCode())
				return FALSE;
			m_code[m_iCode].op=OP_OUTPUTS;
			m_code[m_iCode].sd.string=string;
			m_iCode++;
			if(!GetElement())
				return FALSE;
		}
		else//输出表达式
		{
			m_bDouble=FALSE;
			if(!DoExpression())
				return FALSE;
			if(!TestCode())
				return FALSE;
			if(m_bDouble)
				m_code[m_iCode].op=OP_OUTPUTD;
			else
				m_code[m_iCode].op=OP_OUTPUTI;
			m_iCode++;
		}
	}
	while(m_curElement==E_COMMA);
	if(m_curElement!=E_SEMICOLON)
	{
		if(!ErrorReport(CFCErrorDlg::ET_LESSSEMICOLON))
			return FALSE;
		//继续编译，权当此处有一个分号
	}
	if(!GetElement())
		return FALSE;
	return TRUE;
}

BOOL CFCDlg::DoExpression(void)
{
	BOOL bDouble=FALSE;
	BOOL bMinus=FALSE;
	if(m_curElement==E_MINUS || m_curElement==E_PLUS)//处理表达式前的加减号
	{
		if(m_curElement==E_MINUS)
			bMinus=TRUE;
		if(!GetElement())
			return FALSE;
		if(!DoTerm())
			return FALSE;
		if(bMinus)
		{
			if(!TestCode())
				return FALSE;
			if(m_bDouble)m_code[m_iCode].op=OP_CHANGESIGNALD;
			else m_code[m_iCode].op=OP_CHANGESIGNALI;
			m_iCode++;
		}
	}
	else//表达式前没有加减号
	{
		if(!DoTerm())
			return FALSE;
	}
	while(m_curElement==E_MINUS || m_curElement==E_PLUS)//循环处理项
	{
		bMinus=(m_curElement==E_MINUS);
		if(!GetElement())
			return FALSE;
		bDouble=m_bDouble;
		m_bDouble=FALSE;
		if(!DoTerm())
			return FALSE;
		if(!bDouble && m_bDouble)//原来不是double现在是
		{//作整数变实数
			if(!TestCode())
				return FALSE;
			m_code[m_iCode].op=OP_I2D;
			m_code[m_iCode].sd.iNumber=-1;//栈顶第二个数
			m_iCode++;
		}
		if(bDouble && !m_bDouble)//原来是double现在不是
		{//作整数变实数
			if(!TestCode())
				return FALSE;
			m_code[m_iCode].op=OP_I2D;
			m_code[m_iCode].sd.iNumber=0;//栈顶第一个数
			m_iCode++;
		}
		m_bDouble=(m_bDouble || bDouble);
		if(!TestCode())
			return FALSE;
		if(bMinus)
		{
			if(m_bDouble)m_code[m_iCode].op=OP_MINUSD;
			else m_code[m_iCode].op=OP_MINUSI;
		}
		else
		{
			if(m_bDouble)m_code[m_iCode].op=OP_PLUSD;
			else m_code[m_iCode].op=OP_PLUSI;
		}
		m_iCode++;
	}
	return TRUE;
}

BOOL CFCDlg::DoTerm(void)
{
	BOOL bDouble=FALSE;
	ZElement el;
	if(!DoFactor())
		return FALSE;
	while(m_curElement==E_TIMES || m_curElement==E_SLASH || m_curElement==E_MOD)//循环处理因子
	{
		el=m_curElement;
		if(!GetElement())
			return FALSE;
		bDouble=m_bDouble;
		m_bDouble=FALSE;
		if(!DoFactor())
			return FALSE;
		if(!bDouble && m_bDouble)//原来不是double现在是
		{//作整数变实数
			if(!TestCode())
				return FALSE;
			m_code[m_iCode].op=OP_I2D;
			m_code[m_iCode].sd.iNumber=-1;//栈顶第二个数
			m_iCode++;
		}
		if(bDouble && !m_bDouble)//原来是double现在不是
		{//作整数变实数
			if(!TestCode())
				return FALSE;
			m_code[m_iCode].op=OP_I2D;
			m_code[m_iCode].sd.iNumber=0;//栈顶第一个数
			m_iCode++;
		}
		m_bDouble=(bDouble || m_bDouble);
		if(!TestCode())
			return FALSE;
		switch(el)
		{
		case E_TIMES:
			if(m_bDouble)m_code[m_iCode].op=OP_TIMESD;
			else m_code[m_iCode].op=OP_TIMESI;
			break;
		case E_SLASH:
			if(m_bDouble)m_code[m_iCode].op=OP_SLASHD;
			else m_code[m_iCode].op=OP_SLASHI;
			break;
		case E_MOD:
			if(m_bDouble)
			{
				if(!ErrorReport(CFCErrorDlg::ET_DOUBLEMOD))
					return FALSE;
				//继续编译，权当此处不是浮点数参加余运算
			}
			m_code[m_iCode].op=OP_MOD;
			break;
		}//end switch
		m_iCode++;
	}
	return TRUE;
}

BOOL CFCDlg::DoFactor(void)
{
	BOOL bDouble=FALSE;
	m_bDouble=FALSE;
	ZIdentType it=IT_VOID;//强制类型转换标志
	int index;