run.cpp

c语言写的VB编译器

////////////////////////////////////////////
//                                        //
//    Run.cpp                             //
//    运行模块                            //
//    处理运行程序的全部情况              //
//    最后更新时间：2004年4月23日11:34    //
//                                        //
////////////////////////////////////////////



#include <string.h>
#include <conio.h>
#include <stdio.h>
#include <stdlib.h>
#include <dos.h>

#include "Run.h"

int RunLine(const int LineNo)
{
	// 执行指定行程序

	if (LineNo > EndLine)
	{
		// 当前行已经大于最后一行，程序结束。
		// 在没有END语句的程序中起作用

		Finished = true;
		return -1;
	}

	// 存储当前执行行语句
	char Line[MaxY];
	strcpy(Line, Text[LineNo]->Line);

	// 清除前后空格
	ClearHeadBlank(Line);
	ClearTailBlank(Line);

	// 隐藏光标
	_setcursortype(_NOCURSOR);

	// 取第一个单词，用于判断语句类型
	char Cmd[MaxY];
	GetPart(Line, 1, ' ', Cmd);

	// 根据语句类型分别执行相应函数
	if (strcmp(Cmd, "CLS") == 0)
	{
		// 清屏语句

		CallCls();
		return RunLineNo + 1;
	}
	else if (strcmp(Cmd, "DIM") == 0)
	{
		// 变量定义语句

		CallDim(Line);
		return RunLineNo + 1;
	}
	else if (strcmp(Cmd, "INPUT") == 0)
	{
		// 键盘输入语句

		// 取变量
		GetBack(Line, 1, ' ', Cmd);
		ClearBlankInside(Cmd);

		CallInput(Cmd);
		return RunLineNo + 1;
	}
	else if (strcmp(Cmd, "PRINT") == 0)
	{
		// 输出语句

		// 取打印列表
		GetBack(Line, 1, ' ', Cmd);

		CallPrint(Cmd);
		return RunLineNo + 1;
	}
	else if (strcmp(Cmd, "LOCATE") == 0)
	{
		// 光标定位语句

		// 取坐标字符串
		char Coordinates[MaxY];
		GetBack(Line, 1, ' ', Coordinates);
		ClearBlankInside(Coordinates);

		CallLocate(Coordinates);
		return RunLineNo + 1;
	}
	else if (strcmp(Cmd, "FOR") == 0)
	{
		// 循环语句

		CallFor(Line);
		return RunLineNo + 1;
	}
	else if (strcmp(Cmd, "NEXT") == 0)
	{
		// 循环结束语句

		CallNext();
		return RunLineNo;
	}
	else if (strcmp(Cmd, "DELAY") == 0)
	{
		// 延时语句

		// 取延时值表达式字符串
		char DelayTime[MaxY];
		GetBack(Line, 1, ' ', DelayTime);

		CallDelay(DelayTime);
		return RunLineNo + 1;
	}
	else if (strcmp(Cmd, "IF") == 0)
	{
		// 条件语句

		CallIf(Line);
		return RunLineNo;
	}
	else if (strcmp(Cmd, "ELSE") == 0)
	{
		// 条件否则语句

		CallElse();
		return RunLineNo;
	}
	else if (strcmp(Cmd, "CONTINUE") == 0)
	{
		// 跳到NEXT语句

		CallContinue();
		return RunLineNo;
	}
	else if (strcmp(Cmd, "BREAK") == 0)
	{
		// 跳出循环语句

		CallBreak();
		return RunLineNo;
	}
	else if (strcmp(Cmd, "GOSUB") == 0)
	{
		// 调用过程语句

		// 取过程名
		GetPart(Line, 2, ' ', Cmd);

		CallGosub(Cmd);
		return RunLineNo;
	}
	else if (strcmp(Cmd, "DELETE") == 0)
	{
		// 删除变量语句

		// 取变量列表
		GetBack(Line, 1, ' ', Cmd);

		CallDelete(Cmd);
		return RunLineNo + 1;
	}
	else if (strcmp(Cmd, "SUB") == 0)
	{
		// 过程定义语句

		// 取过程名
		GetPart(Line, 2, ' ', Cmd);

		// 跳过此过程
		for (int i = 0; i < TotSubInProg; i++)
		{
			if (strcmp(Sub[i].Name, Cmd) == 0)
			{
				// 找到该过程的结束行
				RunLineNo = Sub[i].End + 1;
				break;
			}
		}

		return RunLineNo;
	}
	else if (strcmp(Cmd, "RETURN") == 0)
	{
		// 结束当前过程

		CallEndSub();
	}
	else if (strcmp(Cmd, "END") == 0)
	{
		// 程序结束，或条件结束，或过程结束

		// 取第二个单词
		GetPart(Line, 2, ' ', Cmd);
		if (strcmp(Cmd, "IF") == 0)
		{
			// 条件结束语句

			CallEndIf();
			return RunLineNo + 1;
		}
		else if (strcmp(Cmd, "SUB") == 0)
		{
			// 过程结束语句

			CallEndSub();
			return RunLineNo;
		}
		else if (Cmd[0] == '\0')
		{
			// 程序结束语句

			Finished = true;
			return RunLineNo;
		}
	}
	else if (strstr(Line, " = "))
	{
		// 赋值语句

		CallGiveValue(Line);
		return RunLineNo + 1;
	}
	else
	{
		// 无法识别的语句

		ShowError(ErrorSyntax, RunLineNo);
		return -1;
	}
}

void JoinVar
	(
	VarAllType *pNew,				// 新变量的指针
	const char Name[MaxLenOfVar],	// 新变量名
	const VarType TypeCode			// 新变量的类型
	)
{
	// 将变量加入变量类型检索链表，并加入相应类型的变量链表

	// 将变量加入变量类型检索链表
	strcpy(pNew->Name, Name);
	pNew->Type = TypeCode;
	pNew->NextVar = NULL;
	if (HeadAll == NULL)
	{
		HeadAll = TailAll = pNew;
	}
	else
	{
		TailAll->NextVar = pNew;
		TailAll = pNew;
	}

	// 根据类型，加入相应变量链表
	switch(TypeCode)
	{
	case Integer:
		// 整型变量

		pNewInt = new VarIntType;
		if (pNewInt == NULL)
		{
			ShowError(ErrorNoFreeMemoryInRun);
			return;
		}

		// 加入整型变量链表
		strcpy(pNewInt->Name, Name);
		pNewInt->Value = 0;
		pNewInt->NextVar = NULL;
		if (HeadInt == NULL)
		{
			HeadInt = TailInt = pNewInt;
		}
		else
		{
			TailInt->NextVar = pNewInt;
			TailInt = pNewInt;
		}

		break;
	case Real:
		// 实型变量

		pNewReal = new VarRealType;
		if (pNewReal == NULL)
		{
			ShowError(ErrorNoFreeMemoryInRun);
			return;
		}

		// 加入实型变量链表
		strcpy(pNewReal->Name, Name);
		pNewReal->Value = 0;
		pNewReal->NextVar = NULL;
		if (HeadReal == NULL)
		{
			HeadReal = TailReal = pNewReal;
		}
		else
		{
			TailReal->NextVar = pNewReal;
			TailReal = pNewReal;
		}

		break;
	case Array:
		// 数组变量

		// 加入数组变量链表
		if (HeadArray == NULL)
		{
			HeadArray = TailArray = pNewArrayHead;
		}
		else
		{
			TailArray->NextArray = pNewArrayHead;
			TailArray = pNewArrayHead;
		}

		break;
	}
}

void ClearAll()
{
	// 运行前初始化

	Finished	= false;
	Error		= NoError;

	NowIf	= -1;
	NowFor	= -1;
	NowSub	= -1;

	ClearVar();
}

void ClearVar()
{
	// 清空全部变量链表

	// 清空变量类型检索链表
	VarAllType *pAll = HeadAll, *pAllBefore;
	while (pAll != NULL)
	{
		pAllBefore = pAll;
		pAll = pAll->NextVar;
		delete pAllBefore;
	}
	HeadAll = NULL;

	// 清空整数变量链表
	VarIntType *pInt = HeadInt, *pIntBefore;
	while (pInt != NULL)
	{
		pIntBefore = pInt;
		pInt = pInt->NextVar;
		delete pIntBefore;
	}
	HeadInt = NULL;

	// 清空实型变量链表
	VarRealType *pReal = HeadReal, *pRealBefore;
	while (pReal != NULL)
	{
		pRealBefore = pReal;
		pReal = pReal->NextVar;
		delete pRealBefore;
	}
	HeadReal = NULL;

	// 清空数组变量链表
	VarArrayHeadType *pArrayHead = HeadArray, *pArrayHeadBefore;
	VarArrayElemType *pArrayElem, *pArrayElemBefore;
	while (pArrayHead != NULL)
	{
		pArrayElem = pArrayHead->HeadElem;
		while (pArrayElem != NULL)
		{
			pArrayElemBefore = pArrayElem;
			pArrayElem = pArrayElem->NextElem;
			delete pArrayElemBefore;
		}
		pArrayHeadBefore = pArrayHead;
		pArrayHead = pArrayHead->NextArray;
		delete pArrayHeadBefore;
	}
	HeadArray = NULL;
}

void PutValue(const char Name[MaxLenOfVar], const int Exp)
{
	// 给整型变量赋值

	VarIntType *pInt = HeadInt;
	while (pInt != NULL)
	{
		if (strcmp(pInt->Name, Name) == 0)
		{
			pInt->Value = Exp;
			return;
		}
		pInt = pInt->NextVar;
	}
}

void PutValue(const char Name[MaxLenOfVar], const double Exp)
{
	// 给实型变量赋值

	VarRealType *pReal = HeadReal;
	while (pReal != NULL)
	{
		if (strcmp(pReal->Name, Name) == 0)
		{
			pReal->Value = Exp;
			return;
		}
		pReal = pReal->NextVar;
	}
}

void PutValue
	(
	const VarArrayHeadType *pArrayHead,		// 数组变量头指针
	const int Position,						// 元素的位置
	const int Exp							// 欲赋给的变量值
	)
{
	// 给数组变量赋值

	// 寻找指定位置
	VarArrayElemType *pArrayElem = pArrayHead->HeadElem;
	for (int i = 0; i < Position; i++)
	{
		pArrayElem = pArrayElem->NextElem;
	}

	// 赋值
	pArrayElem->Value = Exp;
}

int GetValue(const VarArrayHeadType *pArrayHead, const int Position)
{
	// 取数组指定位置元素的值

	// 寻找指定位置
	VarArrayElemType *pArrayElem = pArrayHead->HeadElem;
	for (int i = 0; i < Position; i++)
	{
		pArrayElem = pArrayElem->NextElem;
	}

	// 返回元素值
	return pArrayElem->Value;
}

bool LoopFinished()
{
	// 判断循环结束条件是否满足

	if (For[NestFor[NowFor]].Step > 0)
	{
		// 步长值大于0

		return For[NestFor[NowFor]].VarValue >= For[NestFor[NowFor]].End;
	}
	else
	{
		// 步长值小于0

		return For[NestFor[NowFor]].VarValue <= For[NestFor[NowFor]].End;
	}
}

void CallCls()
{
	// 清屏

	SetColor(WHITE,BLACK);
	clrscr();
	OutX = 1;
	OutY = 1;
}

void CallDim(const char Command[MaxY])
{
	// 定义变量

	// 取变量名
	char VarName[MaxLenOfVar];
	GetPart(Command, 2, ' ', VarName);

	// 取类型
	char Type[MaxLenOfType];
	GetPart(Command, 4, ' ', Type);

	switch (Type[0])
	{
	case 'I':
		// 整型

		pNewAll = new VarAllType;
		if (pNewAll != NULL)
		{
			// 加入新变量

			JoinVar(pNewAll, VarName, Integer);
		}
		else
		{
			// 无剩余内存

			ShowError(ErrorNoFreeMemoryInRun);
		}

		break;
	case 'R':
		// 实型

		pNewAll = new VarAllType;
		if (pNewAll != NULL)
		{
			// 加入新变量

			JoinVar(pNewAll, VarName, Real);
		}
		else
		{
			// 无剩余内存

			ShowError(ErrorNoFreeMemoryInRun);
		}

		break;
	case 'A':
		// 数组型

		pNewArrayHead = new VarArrayHeadType;
		if (pNewArrayHead == NULL)
		{
			// 无剩余内存

			ShowError(ErrorNoFreeMemoryInRun);
			return;
		}

		// 加入新的数组变量头
		strcpy(pNewArrayHead->Name, VarName);
		pNewArrayHead->HeadElem = NULL;
		pNewArrayHead->TailElem = NULL;

		// 取下标字符串
		char Tail[MaxY];
		GetBack(Command, 4, ' ', Tail);
		ClearBlankInside(Tail);

		// 取各维的下标
		int Range[MaxDim];
		int Tot;
		Para(Tail, Range, Tot);

		// 存储维数
		pNewArrayHead->TotDim = Tot;

		// 计算元素总数
		int Total = 1;
		for (int i = 0; i < Tot; i++)
		{
			Total *= Range[i];
			pNewArrayHead->Dim[i] = Range[i];
		}

		// 申请全部元素
		for (i = 0; i < Total; i++ )
		{
			pNewArrayElem = new VarArrayElemType;
			if (pNewArrayElem == NULL)
			{
				// 无剩余内存

				ShowError(ErrorNoFreeMemoryInRun);
				return;
			}

			// 初始化当前元素
			pNewArrayElem->Value = 0;
			pNewArrayElem->NextElem = NULL;

			if (pNewArrayHead->TailElem == NULL)
			{
				pNewArrayHead->HeadElem 
					= pNewArrayHead->TailElem 
					= pNewArrayElem;
			}
			else
			{
				pNewArrayHead->TailElem->NextElem = pNewArrayElem;
				pNewArrayHead->TailElem = pNewArrayElem;
			}
		}

		// 计算累计因子
		int Coe = 1;
		for (i = pNewArrayHead->TotDim - 1; i >= 0; i-- )
		{
			pNewArrayHead->Coefficient[i] = Coe;
			Coe *= pNewArrayHead->Dim[i];
		}

		// 加入变量类型检索表
		pNewAll = new VarAllType;
		JoinVar(pNewAll, VarName, Array);

		break;
	}
}

void CallGiveValue(const char Command[MaxY])
{
	// 赋值语句

	// 取变量部分
	char strTemp[MaxY];
	GetPart(Command, 1, '=', strTemp);
	ClearTailBlank(strTemp);

	// 存储真正的变量名
	char strVar[MaxY];

	if (strchr(strTemp, '('))
	{
		// 数组变量

		GetPart(strTemp, 1, '(', strVar);
	}
	else
	{
		strcpy(strVar, strTemp);
	}

	// 取表达式部分
	char strExp[MaxY];
	GetBack(Command, 1, '=', strExp);
	ClearBlankInside(strExp);

	// 计算表达式的值
	int Seat = 0;
	double Exp = Expression(strExp, Seat);
	if (Error)
	{
		ShowError(Error, RunLineNo);
		return;
	}

	// 取变量类型
	VarType Type = GetType(strVar);
	switch (Type)
	{
	case Integer:
		// 整型

		PutValue(strVar, (int)Exp);
		break;
	case Real:
		// 实型

		PutValue(strVar, Exp);
		break;
	case Array:
		// 数组型

		// 取该数组的头指针
		VarArrayHeadType *pThis = GetArrayDim(strVar);

		// 取下标部分字符串
		char strPara[MaxY];
		int i;
		GetParaStr(strTemp, strlen(strVar), strPara, i);
		ClearBlankInside(strPara);

		// 取各下标
		int Range[MaxDim];
		int Tot;
		Para(strPara, Range, Tot);

		if (Tot != pThis->TotDim)
		{
			// 维数不匹配

			ShowError(ErrorDim, RunLineNo, strVar);
			return;
		}

		// 计算元素实际存放位置
		int Position = CalcPosition(pThis, Range);
		if (Error)
		{
			return;
		}

		PutValue(pThis, Position, Exp);

		break;
	default:
		// 未定义的变量

		ShowError(ErrorUndefined, RunLineNo, strVar);
		break;
	}
}

void CallInput(const char Var[MaxY])
{
	// 键盘输入

	// 存储变量名
	char strVar[MaxY];

	if (strchr(Var, '('))
	{
		// 是数组变量，取数组名

		GetPart(Var, 1, '(', strVar);
	}
	else
	{
		// 简单变量

		strcpy(strVar, Var);
	}

	// 现实光标
	_setcursortype(_NORMALCURSOR);

	// 存储用户的输入
	char Input[MaxInput];

	// 存储实型值
	double Value;

	// 根据变量类型，读入数据
	switch (GetType(strVar))
	{
	case Integer:
		// 整型

		// 读入用户输入
		scanf("%s", Input);

		if (IsNumber(Input, Value))
		{
			// 输入正确，赋值

			PutValue(strVar, (int)Value);
		}
		else
		{
			// 输入非法

			ShowError(ErrorInput, RunLineNo);
		}

		break;

	case Real:
		// 实型

		// 读入用户输入
		scanf("%s", Input);

		if (IsNumber(Input, Value))
		{
			// 输入正确，赋值

			PutValue(strVar, Value);
		}
		else
		{
			// 输入非法

			ShowError(ErrorInput, RunLineNo);
		}

		break;

	case Array:
		// 数组型

		// 取该数组的头指针
		VarArrayHeadType *pThis = GetArrayDim(strVar);

		// 存储数组的下标字符串
		char strPara[MaxY];

		// 取数组下标字符串
		int i;
		GetParaStr(Var, strlen(strVar), strPara, i);
		ClearBlankInside(strPara);

		// 计算数组各下标
		int Range[MaxDim];
		int Tot;
		Para(strPara, Range, Tot);

		if (Tot != pThis->TotDim)
		{
			// 数组维数不匹配

			ShowError(ErrorDim, RunLineNo, strVar);
			return;
		}

		// 取元素的位置
		int Position = CalcPosition(pThis, Range);
		if (Error)
		{
			return;
		}

		// 读入用户输入
		scanf("%s", Input);

		if (IsNumber(Input, Value))
		{
			// 输入正确，赋值

			PutValue(pThis, Position, Value);
		}
		else
		{
			ShowError(ErrorInput, RunLineNo);
		}

		break;

	default:
		// 变量未定义

		ShowError(ErrorUndefined, RunLineNo, strVar);
		break;
	}

	// 隐藏光标
	_setcursortype(_NOCURSOR);

	// 取光标的位置
	OutX = wherex();
	OutY = wherey();
}

void CallPrint(const char PrintList[MaxY])
{
	// 屏幕输出语句

	// 存储打印单元
	char Part[MaxY] = "";

	int i = 0;
	while (i <= strlen(PrintList))
	{
		if (PrintList[i] == ';' || i ==strlen(PrintList))
		{
			// 当前是分隔符或打印列表遍历完成

			if (Part[0] != '\0')
			{
				// 处理当前表达式

				// 计算表达式的值
				int Seat = 0;
				double Exp = Expression(Part, Seat);

				if (Error)