⭐ 欢迎来到虫虫下载站！ | 📦 资源下载 📁 资源专辑 ℹ️ 关于我们
⭐ 虫虫下载站
📤 上传资源

📄 fc-compile.cpp

📁 编译原理的一个课程设计
💻 CPP
📖 第 1 页 / 共 4 页
字号:
🔍
1234 
		break;
	case E_EXIT:
		if(!TestCode())
			return FALSE;
		m_code[m_iCode].op=OP_EXIT;
		m_iCode++;
		if(!GetElement())//获取分号
			return FALSE;
		if(m_curElement!=E_SEMICOLON)//不是分号，错误
		{
			if(!ErrorReport(CFCErrorDlg::ET_LESSSEMICOLON))
				return FALSE;
		}
		break;
	}
	if(!GetElement())
		return FALSE;
	return TRUE;
}

BOOL CFCDlg::DoCondition(void)
{
	if(!DoAndCondition())
		return FALSE;
	while(m_curElement==E_OR)
	{
		if(!GetElement())
			return FALSE;
		if(!DoAndCondition())
			return FALSE;
		if(!TestCode())
			return FALSE;
		m_code[m_iCode].op=OP_OR;
		m_iCode++;
	}
	return TRUE;
}

BOOL CFCDlg::DoAndCondition(void)
{
	if(!DoSubCondition())
		return FALSE;
	while(m_curElement==E_AND)//条件子项处理循环
	{
		if(!GetElement())
			return FALSE;
		if(!DoSubCondition())
			return FALSE;
		if(!TestCode())
			return FALSE;
		m_code[m_iCode].op=OP_AND;
		m_iCode++;
	}
	return TRUE;
}

BOOL CFCDlg::DoSubCondition(void)
{
	BOOL bNot=FALSE;
	if(m_curElement==E_NOT)//前置为“!”
	{
		bNot=TRUE;
		if(!GetElement())//获取左小括号
			return FALSE;
	}
	if(bNot || m_curElement==E_LPAREN)//前置有“!”或由左小括号开始
	{
		if(m_curElement!=E_LPAREN)//不是左小括号，错误
		{
			if(!ErrorReport(CFCErrorDlg::ET_LESSLPAREN))
				return FALSE;
		}
		if(!GetElement())//获取条件的第一个 ZElement
			return FALSE;
		if(!DoCondition())
			return FALSE;
		if(!TestCode())
			return FALSE;
		m_code[m_iCode].op=OP_NOT;
		m_iCode++;
		if(m_curElement!=E_RPAREN)//不是右小括号，错误
		{
			if(!ErrorReport(CFCErrorDlg::ET_LESSRPAREN))
				return FALSE;
		}
		if(!GetElement())
			return FALSE;
	}
	else//表达式 rop 表达式
	{
		BOOL bDouble;
		ZElement el;
		m_bDouble=FALSE;//准备类型检查
		if(!DoExpression())
			return FALSE;
		bDouble=m_bDouble;
		switch(m_curElement)
		{
		case E_EQUAL:
		case E_NOTEQUAL:
		case E_GREAT:
		case E_GREATEQUAL:
		case E_LESS:
		case E_LESSEQUAL:
			el=m_curElement;
			break;
		default://不是比较运算符，错误
			if(!ErrorReport(CFCErrorDlg::ET_LESSROP))
				return FALSE;
			break;
		}
		m_bDouble=FALSE;//准备类型检查
		if(!GetElement())//获取右表达式的第一个 ZElement
			return FALSE;
		if(!DoExpression())
			return FALSE;
		if(bDouble && !m_bDouble)//第一表达式为实型，第二整型
		{
			if(!TestCode())
				return FALSE;
			m_code[m_iCode].op=OP_I2D;
			m_code[m_iCode].sd.iNumber=0;//栈顶第一个数
			m_iCode++;
		}
		if(!bDouble && m_bDouble)//第一表达式为整型，第二实型
		{
			if(!TestCode())
				return FALSE;
			m_code[m_iCode].op=OP_I2D;
			m_code[m_iCode].sd.iNumber= -1;//栈顶第二个数
			m_iCode++;
		}
		m_bDouble=(m_bDouble || bDouble);
		if(!TestCode())
			return FALSE;
		switch(el)
		{
		case E_EQUAL:
			m_code[m_iCode].op=m_bDouble?OP_EQUALD:OP_EQUALI;
			break;
		case E_NOTEQUAL:
			m_code[m_iCode].op=m_bDouble?OP_NOTEQUALD:OP_NOTEQUALI;
			break;
		case E_GREAT:
			m_code[m_iCode].op=m_bDouble?OP_GREATD:OP_GREATI;
			break;
		case E_GREATEQUAL:
			m_code[m_iCode].op=m_bDouble?OP_GREATEQUALD:OP_GREATEQUALI;
			break;
		case E_LESS:
			m_code[m_iCode].op=m_bDouble?OP_LESSD:OP_LESSI;
			break;
		case E_LESSEQUAL:
			m_code[m_iCode].op=m_bDouble?OP_LESSEQUALD:OP_LESSEQUALI;
			break;
		}
		m_iCode++;
	}
	return TRUE;
}

BOOL CFCDlg::DoIf(void)
{
	int head,mid;
	if(!GetElement())//获取左小括号
		return FALSE;
	if(m_curElement!=E_LPAREN)//不是左小括号，错误
	{
		if(!ErrorReport(CFCErrorDlg::ET_LESSLPAREN))
			return FALSE;
	}
	if(!GetElement())//获取条件的第一个 ZElement
		return FALSE;
	if(!DoCondition())
		return FALSE;
	if(!TestCode())
		return FALSE;
	m_code[m_iCode].op=OP_JUMPC;
	m_code[m_iCode].sd.iNumber=m_iCode+2;
	m_iCode++;
	if(!TestCode())
		return FALSE;
	m_code[m_iCode].op=OP_JUMP;
	head=m_iCode;
	m_iCode++;
	m_function[m_iFunction].level++;//嵌套层次加一
	if(!GetElement())//获取if后语句的第一个 ZElement
		return FALSE;
	if(!DoStatement())//处理if后的语句
		return FALSE;
	m_function[m_iFunction].level--;//嵌套层次减一
	if(!RecycleMemory())//回收内存
		return FALSE;
	if(m_curElement!=E_ELSE)//if无else语句
		m_code[head].sd.iNumber=m_iCode;
	else//if-else语句
	{
		m_code[m_iCode].op=OP_JUMP;
		mid=m_iCode;
		m_iCode++;
		m_code[head].sd.iNumber=m_iCode;//回填前边if头的跳转地址
		m_function[m_iFunction].level++;//嵌套层次加一
		if(!GetElement())//获取else后的语句的第一个 ZElement
			return FALSE;
		if(!DoStatement())
			return FALSE;
		m_function[m_iFunction].level--;//嵌套层次减一
		if(!RecycleMemory())//回收内存
			return FALSE;
		m_code[mid].sd.iNumber=m_iCode;//回填前边else的跳转地址
	}
	return TRUE;
}

BOOL CFCDlg::DoWhile(void)
{
	int oldHead=m_iContinue;	//保存上一级while的continue跳转地址
	int oldEnd=m_iBreak;		//保存上一级while的break跳转地址
	m_iContinue=m_iCode;//设置continue跳转位置
	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)//右小括号，条件恒为真循环
	{
		if(!TestCode())
			return FALSE;
		m_code[m_iCode].op=OP_LOADCONSTI;
		m_code[m_iCode].sd.iNumber=1;
		m_iCode++;
	}
	else//右小括号，变条件循环
	{
		if(!DoCondition())
			return FALSE;
		if(m_curElement!=E_RPAREN)//不是右小括号，错误
		{
			if(!ErrorReport(CFCErrorDlg::ET_LESSRPAREN))
				return FALSE;
		}
	}
	if(!TestCode())
		return FALSE;
	m_code[m_iCode].op=OP_JUMPC;
	m_code[m_iCode].sd.iNumber=m_iCode+2;
	m_iCode++;
	if(!TestCode())
		return FALSE;
	m_code[m_iCode].op=OP_JUMP;
	m_iBreak=m_iCode;//设置break语句的跳转位置
	m_iCode++;
	m_function[m_iFunction].level++;//嵌套层次加一
	if(!GetElement())//获取while后语句的第一个 ZElement
		return FALSE;
	if(!DoStatement())
		return FALSE;
	m_function[m_iFunction].level--;//嵌套层次减一
	if(!RecycleMemory())
		return FALSE;
	if(!TestCode())
		return FALSE;
	m_code[m_iCode].op=OP_JUMP;
	m_code[m_iCode].sd.iNumber=m_iContinue;
	m_iCode++;
	m_code[m_iBreak].sd.iNumber=m_iCode;//回填while的结束跳转
	m_iContinue=oldHead;	//恢复上一级while的continue跳转地址
	m_iBreak=oldEnd;		//恢复上一级while的break跳转地址
	return TRUE;
}

BOOL CFCDlg::DoDoWhile(void)
{
	int oldHead=m_iContinue;	//保存上一级while的continue跳转地址
	int oldEnd=m_iBreak;		//保存上一级while的break跳转地址
	if(!TestCode())
		return FALSE;
	m_code[m_iCode].op=OP_JUMP;
	m_code[m_iCode].sd.iNumber=m_iCode+2;
	m_iCode++;
	if(!TestCode())
		return FALSE;
	m_code[m_iCode].op=OP_JUMP;
	m_iBreak=m_iCode;//设置break跳转位置
	m_iCode++;
	m_iContinue=m_iCode;//设置continue跳转位置
	m_function[m_iFunction].level++;
	if(!GetElement())//获取do语句后的第一个ZElement
		return FALSE;
	if(!DoStatement())
		return FALSE;
	m_function[m_iFunction].level--;
	if(!RecycleMemory())
		return FALSE;
	if(m_curElement!=E_WHILE)//不是while，错误
	{
		if(!ErrorReport(CFCErrorDlg::ET_DONOWHILE))
			return FALSE;
	}
	if(!GetElement())//获取while后的左小括号
		return FALSE;
	if(m_curElement!=E_LPAREN)//不是左小括号，错误
	{
		if(!ErrorReport(CFCErrorDlg::ET_LESSLPAREN))
			return FALSE;
	}
	if(!GetElement())//获取条件的第一个ZElement
		return FALSE;
	if(!DoCondition())
		return FALSE;
	if(m_curElement!=E_RPAREN)//不是右小括号，错误
	{
		if(!ErrorReport(CFCErrorDlg::ET_LESSRPAREN))
			return FALSE;
	}
	if(!GetElement())//获取分号
		return FALSE;
	if(m_curElement!=E_SEMICOLON)//不是分号
	{
		if(!ErrorReport(CFCErrorDlg::ET_LESSSEMICOLON))
			return FALSE;
	}
	if(!GetElement())//获取do-while语句后的第一个ZElement
		return FALSE;
	if(!TestCode())
		return FALSE;
	m_code[m_iCode].op=OP_JUMPC;
	m_code[m_iCode].sd.iNumber=m_iContinue;
	m_iCode++;
	m_code[m_iBreak].sd.iNumber=m_iCode;//回填break跳转位置
	m_iContinue=oldHead;	//恢复上一级while的continue跳转地址
	m_iBreak=oldEnd;		//恢复上一级while的break跳转地址
	return TRUE;
}

BOOL CFCDlg::DoSwitch(void)
{
	int oldBreak=m_iBreak;//保存旧的break跳转位置
	int oldCase=m_iCase;	//保存外层switch语句的case跳转位置
	if(!TestCode())
		return FALSE;
	m_code[m_iCode].op=OP_JUMP;
	m_code[m_iCode].sd.iNumber=m_iCode+2;
	m_iCode++;
	if(!TestCode())
		return FALSE;
	m_code[m_iCode].op=OP_JUMP;
	m_iBreak=m_iCode;//设置break跳转位置
	m_iCode++;
	if(!GetElement())//获取switch后的左小括号
		return FALSE;
	if(m_curElement!=E_LPAREN)//不是左小括号，错误
	{
		if(!ErrorReport(CFCErrorDlg::ET_LESSLPAREN))
			return FALSE;
	}
	if(!GetElement())//获取switch后条件的第一个ZElement
		return FALSE;
	m_bDouble=FALSE;//准备类型检查
	if(!DoExpression())
		return FALSE;
	if(m_bDouble)
	{
		if(!ErrorReport(CFCErrorDlg::ET_DOUBLESWITCH))
			return FALSE;
	}
	if(m_curElement!=E_RPAREN)//不是右小括号，错误
	{
		if(!ErrorReport(CFCErrorDlg::ET_LESSRPAREN))
			return FALSE;
	}
	if(!GetElement())//获取左花括号
		return FALSE;
	if(m_curElement!=E_BEGIN)//不是左花括号，错误
	{
		if(!ErrorReport(CFCErrorDlg::ET_LESSLPAREN))
			return FALSE;
	}
	if(!GetElement())//获取case关键字
		return FALSE;
	m_iCase=0;
	while(m_curElement==E_CASE)
	{
		if(!DoCase())
			return FALSE;
	}
	if(!TestCode())
		return FALSE;
	m_code[m_iCode].op=OP_DELETE;
	m_iCode++;
	if(m_curElement==E_DEFAULT)
	{
		if(!DoDefault())
			return FALSE;
	}
	if(m_curElement!=E_END)//不是右花括号，错误
	{
		if(!ErrorReport(CFCErrorDlg::ET_LESSRPAREN))
			return FALSE;
	}
	if(!GetElement())//获取下一语句的第一个ZElement
		return FALSE;
	m_code[m_iBreak].sd.iNumber=m_iCode;//回填break的跳转地址
	m_iBreak=oldBreak;//恢复旧的break跳转地址
	m_iCase =oldCase;	//恢复旧的case跳转地址
	return TRUE;
}

BOOL CFCDlg::DoCase(void)
{
	int iCase;
	BOOL bBreak=FALSE;//标记此case语句中是否有break语句
	if(!GetElement())//获取case后的整常数
		return FALSE;
	if(m_curElement!=E_INUMBER)//不是整常数，错误
	{
		if(!ErrorReport(CFCErrorDlg::ET_CASENOCONSTINT))
			return FALSE;
	}
	if(!GetElement())//获取整常数后的冒号
		return FALSE;
	if(m_curElement!=E_COLON)//不是冒号，错误
	{
		if(!ErrorReport(CFCErrorDlg::ET_LESSCOLON))
			return FALSE;
	}
	if(!TestCode())
		return FALSE;
	m_code[m_iCode].op=OP_COPYI;//复制栈顶数值
	m_iCode++;
	if(!TestCode())
		return FALSE;
	m_code[m_iCode].op=OP_LOADCONSTI;//导入case后的数值
	m_code[m_iCode].sd.iNumber=m_nCurNumber;
	m_iCode++;
	if(!TestCode())
		return FALSE;
	m_code[m_iCode].op=OP_NOTEQUALI;//栈顶两数值不等比较
	m_iCode++;
	if(!TestCode())
		return FALSE;
	m_code[m_iCode].op=OP_JUMPC;//条件跳转
	iCase=m_iCode;//保留case跳转地址
	m_iCode++;//此处暂不填入跳转地址，留后回填
	if(m_iCase!=0)
		m_code[m_iCase].sd.iNumber=m_iCode;//回填case继续跳转地址
	m_function[m_iFunction].level++;
	if(!GetElement())//获取冒号后语句的第一个ZElement
		return FALSE;
	while(m_curElement!=E_CASE && m_curElement!=E_DEFAULT && m_curElement!=E_END)
	{
		if(m_curElement==E_BREAK)
			bBreak=TRUE;
		if(!DoStatement())
			return FALSE;
	}
	m_function[m_iFunction].level--;
	if(!RecycleMemory())
		return FALSE;
	if(!bBreak)//case语句中没有break语句，继续执行下一个case或default的内容
	{
		if(!TestCode())
			return FALSE;
		m_code[m_iCode].op=OP_JUMP;
		m_iCase=m_iCode;//保存case继续跳转起点，留后回填
		m_iCode++;
	}
	else m_iCase=0;
	m_code[iCase].sd.iNumber=m_iCode;//回填case跳转地址
	return TRUE;
}

BOOL CFCDlg::DoDefault(void)
{
	if(!GetElement())//获取default后的冒号
		return FALSE;
	if(m_curElement!=E_COLON)//不是冒号，错误
	{
		if(!ErrorReport(CFCErrorDlg::ET_LESSCOLON))
			return FALSE;
	}
	if(m_iCase!=0)
		m_code[m_iCase].sd.iNumber=m_iCode;//回填case继续跳转地址
	if(!GetElement())//获取冒号后语句的第一个ZElement
		return FALSE;
	m_function[m_iFunction].level++;
	while(m_curElement!=E_END)
	{
		if(!DoStatement())
			return FALSE;
	}
	m_function[m_iFunction].level--;
	if(!RecycleMemory())
		return FALSE;
	return TRUE;
}

BOOL CFCDlg::DoSubscript()
{
	if(m_curElement!=E_LSUB)//不是左方括号，错误
	{
		if(!ErrorReport(CFCErrorDlg::ET_LESSLSUB))
			return FALSE;
	}
	if(!GetElement())//获取数组下标表达式的第一个 ZElement
		return FALSE;
	m_bDouble=FALSE;//准备类型检查
	if(!DoExpression())
		return FALSE;
	if(m_bDouble)//实数作为数组下标，错误
	{
		if(!ErrorReport(CFCErrorDlg::ET_DOUBLESUB))
			return FALSE;
	}
	if(m_curElement!=E_RSUB)//不是右方括号，错误
	{
		if(!ErrorReport(CFCErrorDlg::ET_LESSRSUB))
			return FALSE;
	}
	return TRUE;
}
1234

⌨️ 快捷键说明

复制代码 Ctrl + C
搜索代码 Ctrl + F
全屏模式 F11
切换主题 Ctrl + Shift + D
显示快捷键 ?
增大字号 Ctrl + =
减小字号 Ctrl + -