fcr.cpp

我开发了一个基于ＭＦＣ的语言翻译软件

#include "FCR.h"
#include <iostream.h>
#include <fstream.h>
#include <string.h>
#include <stdlib.h>
#include <time.h>

#ifndef TRUE
#define TRUE 1
#endif

#ifndef FALSE
#define FALSE 0
#endif

#ifndef BOOL
#define BOOL int
#endif

#define nMEMORY		2048
#define nCODE		2048

ZCode code[nCODE];
int nCode;

BOOL GetCode(int argc,char* argv[]);
BOOL Run();

int main(int argc,char* argv[])
{
	if(GetCode(argc,argv))
		Run();
	cout.flush();
	system("pause");
	return 0;
}

BOOL GetCode(int argc,char* argv[])
{
	cout<<"FCR 2.2\n";
	cout<<"copyright: ZKF 2003.05\n";
	cout<<"\n";
	char FileName[64];
	if(argc<2)
	{
		cout<<"请输入FCR可执行代码文件名：";
		cin.getline(FileName,64);
	}
	else
		strcpy(FileName,argv[1]);
	ifstream fin(FileName,ios::in|ios::nocreate|ios::binary);
	if(!fin)
	{
		cout<<"无法打开 "<<FileName<<" !\n";
		return FALSE;
	}
	char buf[5];
	fin.read(buf,4);
	if(buf[0]!='F' || buf[1]!='C' || buf[2]!='R')
	{
		cout<<"错误的FC中间代码文件！\n";
		return FALSE;
	}
	else
	{
		if(buf[3]<20)
		{
			cout<<"未知的 FCR 中间代码文件版本！\n";
			return FALSE;
		}
		else if(buf[3]<22)
		{
			cout<<"不兼容的 FCR 中间代码文件版本！\n";
			return FALSE;
		}
		else if(buf[3]>22)
		{
			cout<<"无法打开 "<<FileName<<" !\n";
			cout<<"请使用高版本的 FCR 解释器解释执行 "<<FileName<<" .\n";
			return FALSE;
		}
	}
	fin.read((char*)(&nCode),4);
	int i,t;
	char ch;
	for(i=0;i<nCode;i++)
	{
		fin.read(&ch,sizeof(char));
		code[i].op=(ZOperator)ch;
		switch(code[i].op)
		{
		case OP_OUTPUTS://不定长字符串
			fin.read((char*)(&t),4);
			code[i].sd.string=new char[t+1];
			fin.read(code[i].sd.string,t);
			code[i].sd.string[t]='\0';
			break;
		case OP_LOADCONSTD://8字节*1
			fin.read((char*)(&code[i].sd.dNumber),sizeof(double));
			break;
		case OP_PARAMTRANSD:case OP_PARAMTRANSI://8字节*2
			fin.read((char*)(&code[i].sd.iNumber),sizeof(int));
			fin.read((char*)(&code[i].sd.nParam),sizeof(int));
			break;
		case OP_JUMPC:case OP_JUMP:case OP_LOADCONSTI:
		case OP_LOADVARI:case OP_LOADVARD:case OP_SAVEI:
		case OP_SAVED:case OP_INPUTI:case OP_INPUTD:
		case OP_RETURNI:case OP_RETURND:case OP_RETURN:
		case OP_NULL:case OP_I2D:case OP_D2I:
		case OP_CALL:case OP_NEWARRAYI:case OP_NEWARRAYD:
		case OP_SAVEARRAYI:case OP_SAVEARRAYD:
		case OP_LOADARRAYI:case OP_LOADARRAYD:
		case OP_DELARRAYI:case OP_DELARRAYD:
		case OP_INPUTARRAYI:case OP_INPUTARRAYD://4字节*26
			fin.read((char*)(&code[i].sd.iNumber),sizeof(int));
			break;
		}
	}
	fin.close();
	return TRUE;
}

BOOL TestAddress(int iAddress);
BOOL ZeroSlashMod(int i);
BOOL ZeroSlashMod(double d);
BOOL ArraySubscript(int index,int length);
int InputInt(void);
double InputDouble(void);
void Output(int i);
void Output(double d);
void Output(char string[]);

BOOL Run()
{
	int i,n,iTemp;
	double dTemp;

	register int iBase=0;			//函数基地址
	register int iCode=0;			//代码指针
	register int iAddress=0;	//地址指针
	ZMemory memory[nMEMORY];	//虚内存

	register int iOp;					//指令条数计数
	BOOL bWarning=TRUE;				//是否对可能的死循环进行警告

	clock_t tStart,tElapse=0;
	tStart=clock();

	for(iOp=0;;iOp++)
	{
/*
		if(iOp==17333 && bWarning)//17333只是表示173班33号，无其他意义
		{
			tElapse+=clock()-tStart;
			switch(MessageBox("\
程序可能进入死循环，要中止解释执行吗？\n\
按“是”中止解释执行，按“否”继续解释执行\n\
按“取消”继续解释执行并不再显示此消息框",
				"FC 2.2",MB_YESNOCANCEL|MB_ICONQUESTION))
			{
			case IDYES:
				tStart=clock();
				goto EndInterpret;
				//此处无需break语句
			case IDCANCEL:
				bWarning=FALSE;
				//此处不填入break语句
			case IDNO:
				tStart=clock();
				iOp=0;
				break;
			}
		}//*/
		switch(code[iCode].op)
		{
		case OP_INPUTARRAYI:		//输入整数数组
			iTemp=iBase+3+code[iCode].sd.iNumber;//数组头位置
			i=memory[iAddress].iNumber;//数组下标
			if(!ArraySubscript(i,memory[iTemp].length))//下标检查
				return FALSE;
			tElapse+=clock()-tStart;
			memory[iTemp].iArray[i]=InputInt();
			tStart=clock();
			iAddress--;
			iCode++;
			break;
		case OP_INPUTARRAYD:		//输入实数数组
			iTemp=iBase+3+code[iCode].sd.iNumber;//数组头位置
			i=memory[iAddress].iNumber;//数组下标
			if(!ArraySubscript(i,memory[iTemp].length))//下标检查
				return FALSE;
			tElapse+=clock()-tStart;
			memory[iTemp].dArray[i]=InputDouble();
			tStart=clock();
			iAddress--;
			iCode++;
			break;
		case OP_LOADARRAYI:			//导入整数数组
			iTemp=iBase+3+code[iCode].sd.iNumber;//数组头位置
			i=memory[iAddress].iNumber;//数组下标
			if(!ArraySubscript(i,memory[iTemp].length))//下标检查
				return FALSE;
			memory[iAddress].iNumber=memory[iTemp].iArray[i];
			iCode++;
			break;
		case OP_LOADARRAYD:			//导入实数数组
			iTemp=iBase+3+code[iCode].sd.iNumber;//数组头位置
			i=memory[iAddress].iNumber;//数组下标
			if(!ArraySubscript(i,memory[iTemp].length))//下标检查
				return FALSE;
			memory[iAddress].dNumber=memory[iTemp].dArray[i];
			iCode++;
			break;
		case OP_SAVEARRAYI:			//存储整数数组
			iTemp=iBase+3+code[iCode].sd.iNumber;//数组头位置
			i=memory[iAddress-1].iNumber;//数组下标
			if(!ArraySubscript(i,memory[iTemp].length))//下标检查
				return FALSE;
			memory[iTemp].iArray[i]=memory[iAddress].iNumber;
			iAddress-=2;
			iCode++;
			break;
		case OP_SAVEARRAYD:			//存储实数数组
			iTemp=iBase+3+code[iCode].sd.iNumber;//数组头位置
			i=memory[iAddress-1].iNumber;//数组下标
			if(!ArraySubscript(i,memory[iTemp].length))//下标检查
				return FALSE;
			memory[iTemp].dArray[i]=memory[iAddress].dNumber;
			iAddress-=2;
			iCode++;
			break;
		case OP_DELARRAYI:			//删除整型数组
			delete memory[iBase+3+code[iCode].sd.iNumber].iArray;
			iCode++;
			break;
		case OP_DELARRAYD:			//删除实数数组
			delete memory[iBase+3+code[iCode].sd.iNumber].dArray;
			iCode++;
			break;
		case OP_NEWARRAYI:			//申请整型数组
			iTemp=memory[iAddress].iNumber;
			if(!ArraySubscript(iTemp,-1))
				return FALSE;
			n=iBase+3+code[iCode].sd.iNumber;
			memory[n].iArray=new int[iTemp];
			memory[n].length=iTemp;
			for(i=0;i<iTemp;i++)//数组赋初值
				memory[n].iArray[i]=0;
			iCode++;
			iAddress--;
			break;
		case OP_NEWARRAYD:			//申请实型数组
			iTemp=memory[iAddress].iNumber;
			if(!ArraySubscript(iTemp,-1))
				return FALSE;
			n=iBase+3+code[iCode].sd.iNumber;
			memory[n].dArray=new double[iTemp];
			memory[n].length=iTemp;
			for(i=0;i<iTemp;i++)//数组赋初值
				memory[n].dArray[i]=0.0;
			iCode++;
			iAddress--;
			break;
		case OP_D2I:						//实数变整数
			memory[iAddress+code[iCode].sd.iNumber].iNumber=
				(int)memory[iAddress+code[iCode].sd.iNumber].dNumber;
			iCode++;
			break;
		case OP_DELETE:					//删除栈顶数
			iAddress--;
			iCode++;
			break;
		case OP_COPYI:					//复制栈顶整数
			iAddress++;
			if(!TestAddress(iAddress))
				return FALSE;
			memory[iAddress].iNumber=memory[iAddress-1].iNumber;
			iCode++;
			break;
		case OP_COPYD:					//复制栈顶实数
			iAddress++;
			if(!TestAddress(iAddress))
				return FALSE;
			memory[iAddress].dNumber=memory[iAddress-1].dNumber;
			iCode++;
			break;
		case OP_NULL:						//函数结束标志，返回
			iCode		=memory[iBase+2].iNumber+1;		//恢复中间代码指针
			iAddress=memory[iBase+1].iNumber;			//恢复栈顶指针
			iBase		=memory[iBase  ].iNumber;			//恢复原基地址
			if(iBase==0)
				goto EndInterpret;
			break;
		case OP_RETURN:					//函数返回
			iAddress=memory[iBase+1].iNumber+1	//恢复中间代码指针
				-code[iCode].sd.iNumber;		//回收参数传递时参数占用的虚内存
			iCode		=memory[iBase+2].iNumber+1;	//恢复栈顶指针
			iBase		=memory[iBase].iNumber;			//恢复原基地址
			if(iBase==0)
				goto EndInterpret;
			break;
		case OP_I2D:						//整数变实数
			memory[iAddress+code[iCode].sd.iNumber].dNumber=
				(double)memory[iAddress+code[iCode].sd.iNumber].iNumber;
			iCode++;
			break;
		case OP_EXIT:						//程序结束标志
			goto EndInterpret;
		case OP_CALL:						//调用函数
			if(!TestAddress(iAddress+3))// +3 是因为下边需要3单元虚内存
				return FALSE;
			memory[iAddress+1].iNumber=iBase;			//保留原基地址
			memory[iAddress+2].iNumber=iAddress;	//保留原栈顶指针
			memory[iAddress+3].iNumber=iCode;			//保留原中间代码指针
			iBase=iAddress+1;
			iCode=code[iCode].sd.iNumber;
			iAddress+=code[iCode].sd.iNumber+3;
			iCode++;
			break;
		case OP_JUMPC:					//条件跳转
			if(memory[iAddress].iNumber!=0)
				iCode=code[iCode].sd.iNumber;
			else iCode++;
			iAddress--;
			break;
		case OP_JUMP:						//无条件跳转
			iCode=code[iCode].sd.iNumber;
			break;
		case OP_AND:						//逻辑与
			if(memory[iAddress-1].iNumber!=0 && memory[iAddress].iNumber!=0)
				memory[iAddress-1].iNumber=1;
			else memory[iAddress-1].iNumber=0;
			iAddress--;
			iCode++;
			break;
		case OP_OR:							//逻辑或
			if(memory[iAddress-1].iNumber!=0 || memory[iAddress].iNumber!=0)
				memory[iAddress-1].iNumber=1;
			else memory[iAddress-1].iNumber=0;
			iAddress--;
			iCode++;
			break;
		case OP_NOT:						//逻辑非
			if(memory[iAddress].iNumber!=0)
				memory[iAddress].iNumber=0;
			else memory[iAddress].iNumber=1;
			iCode++;
			break;
		case OP_EQUALI:					//整数相等
			if(memory[iAddress-1].iNumber == memory[iAddress].iNumber)
				memory[iAddress-1].iNumber=1;
			else memory[iAddress-1].iNumber=0;
			iAddress--;
			iCode++;
			break;
		case OP_EQUALD:					//实数相等