run.cpp

c语言写的VB编译器

				{
					ShowError(Error, RunLineNo);
					return;
				}

				if ((int)Exp == Exp)
				{
					// 结果是整数

					printf("%d", (int)Exp);
				}
				else
				{
					// 结果是浮点型

					printf("%g", Exp);
				}

				// 清空表达式
				Part[0] = '\0';
			}
		}
		else if (PrintList[i] == '"')
		{
			// 发现字符串

			// 输出该字符串
			do
			{
				i++;
				printf("%c", PrintList[i]);
			} while (PrintList[i + 1] != '"');

			i++;
		}
		else if (PrintList[i] != ' ')
		{
			// 添加表达式

			strcat(Part, " ");
			Part[strlen(Part) - 1] = PrintList[i];
		}

		// 后移一位
		i++;
	}

	if (PrintList[strlen(PrintList) - 1] != ';')
	{
		// 最后一位不是分号，则换行

		printf("\n");
	}

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

void CallLocate(const char Coordinates[MaxY])
{
	// 光标定位语句

	// 取坐标值
	int XY[2];
	int Tot;
	Para(Coordinates, XY, Tot);

	if (Error)
	{
		return;
	}

	if (Tot != 2)
	{
		// 参数个数不正确

		ShowError(ErrorLocatePara, RunLineNo);
		return;
	}

	if (XY[0] < 1 || XY[0] > 25 || XY[1] < 1 || XY[1] > 80)
	{
		// 坐标值不合法

		ShowError(ErrorCoordinate, RunLineNo);
		return;
	}

	// 定位光标
	gotoxy(XY[1], XY[0]);

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

void CallFor(char Line[MaxY])
{
	// 开始循环

	// 寻找当前行循环在循环表中的位置
	for (int i = 0; i < TotForInProg; i++)
	{
		if (RunLineNo == For[i].StartNo)
		{
			// 找到当前循环

			// 循环入栈
			NowFor++;
			NestFor[NowFor] = i;

			break;
		}
	}

	// 检查当前循环的变量
	VarType Type = GetType(For[NestFor[NowFor]].Var);
	if (Type == NoType)
	{
		// 变量未定义

		ShowError(ErrorUndefined, RunLineNo, For[NestFor[NowFor]].Var);
		return;
	}
	else if (Type != Integer)
	{
		// 变量非整型

		ShowError(ErrorMustInteger, RunLineNo, For[NestFor[NowFor]].Var);
		return;
	}

	// 准备取各参数
	int Len = strlen(Line);
	int ptr1 = Len - strlen(strstr(Line, " = "));
	int ptr2 = Len - strlen(strstr(Line, " TO "));
	int ptr3 = Len - strlen(strstr(Line, " STEP "));
	if (ptr3 == Len)
	{
		ptr3 = Len + 1;
	}

	// 取循环起始表达式
	char strTemp[MaxY];
	GetMid(Line, ptr1 + 3, ptr2 - 1, strTemp);
	ClearBlankInside(strTemp);

	// 计算循环起始值
	int Seat = 0;
	int Start = Expression(strTemp, Seat);

	if (Error)
	{
		ShowError(Error, RunLineNo);
	}

	// 取循环终值表达式
	GetMid(Line, ptr2 + 4, ptr3 - 1, strTemp);
	ClearBlankInside(strTemp);

	// 计算循环终值
	Seat = 0;
	int End = Expression(strTemp, Seat);

	if (Error)
	{
		ShowError(Error, RunLineNo);
	}

	// 计算循环步长值
	int Step;
	if (ptr3 > Len)
	{
		// 缺省值

		Step = 1;
	}
	else
	{
		// 取步长表达式
		GetMid(Line, ptr3 + 6, Len, strTemp);
		ClearBlankInside(strTemp);

		// 计算步长值
		Seat = 0;
		Step = Expression(strTemp, Seat);

		if (Error)
		{
			ShowError(Error, RunLineNo);
		}
	}

	// 存储当前循环各参数
	For[NestFor[NowFor]].VarValue	= Start;
	For[NestFor[NowFor]].End		= End;
	For[NestFor[NowFor]].Step		= Step;
	PutValue(For[NestFor[NowFor]].Var, For[NestFor[NowFor]].VarValue);
}

void CallNext()
{
	// 循环结束语句

	if (LoopFinished())
	{
		// 当前循环结束

		// 循环出栈
		NowFor--;

		// 设定下一条该执行的语句行行号
		RunLineNo = RunLineNo + 1;
	}
	else
	{
		// 继续当前循环

		// 设定下一条该执行的语句行行号
		RunLineNo = For[NestFor[NowFor]].StartNo + 1;

		// 修改循环变量值
		For[NestFor[NowFor]].VarValue += For[NestFor[NowFor]].Step;
		PutValue(For[NestFor[NowFor]].Var, For[NestFor[NowFor]].VarValue);
	}
}

void CallDelay(const char strPara[MaxY])
{
	// 延迟语句

	// 计算时间表达式
	int Seat = 0;
	int Time = Expression(strPara, Seat);

	if (Error)
	{
		ShowError(Error, RunLineNo);
	}
	else if (Time < 0 || Time > MaxDelayTime)
	{
		// 时间值非法

		ShowError(ErrorDelayTime, RunLineNo);
	}
	else
	{
		delay(Time);
	}
}

void CallIf(const char strLine[MaxY])
{
	// 条件语句

	// 在条件语句表中寻找序号
	for (int i = 0; i < TotIfInProg; i++)
	{
		if (If[i].Start == RunLineNo)
		{
			// 当前条件语句入栈

			NowIf++;
			NestIf[NowIf] = i;
			break;
		}
	}

	// 取布尔表达式字符串
	char *ptr = strstr(strLine, " THEN ");
	char strTemp[MaxY];
	GetMid(strLine, 3, strlen(strLine) - strlen(ptr) - 6, strTemp);

	// 转换布尔表达式
	char Test[MaxY];
	BoolChange(strTemp, Test);

	int Seat = 0;
	if (Boolean(Test, Seat))
	{
		// 表达式为真

		RunLineNo = RunLineNo + 1;
	}
	else if (If[NestIf[NowIf]].Else >= 0)
	{
		// 有ELSE语句，跳到此执行

		RunLineNo = If[NestIf[NowIf]].Else + 1;
	}
	else
	{
		// 跳过当前IF继续执行

		RunLineNo = If[NestIf[NowIf]].End + 1;
		NowIf--;
	}
}

void CallElse()
{
	// 跳出当前IF

	RunLineNo = If[NestIf[NowIf]].End + 1;
	NowIf--;
}

void CallEndIf()
{
	// 当前IF出栈

	NowIf--;
}

void CallEndSub()
{
	// 过程结束

	RunLineNo = NestSub[NowSub].Return;
	NowSub--;
}

void CallContinue()
{
	// 跳到NEXT语句

	RunLineNo=For[NestFor[NowFor]].End;
}

void CallBreak()
{
	// 跳出当前循环

	RunLineNo = For[NestFor[NowFor]].End + 1;
	NowFor--;
}

void CallGosub(const char SubName[MaxLenOfVar])
{
	// 调用过程

	// 在SUB表中搜索当前过程
	for (int i = 0; i <= TotSubInProg; i++)
	{
		if (strcmp(Sub[i].Name, SubName) == 0)
		{
			// 找到当前过程

			// 过程入栈
			NowSub++;
			NestSub[NowSub].No = i;
			NestSub[NowSub].Return = NextLine(RunLineNo + 1);
			RunLineNo = Sub[i].Start + 1;
			return;
		}
	}

	ShowError(ErrorNoSuchSub,RunLineNo,SubName);
}

void CallDelete(const char Source[MaxY])
{
	// 删除变量

	// 存储变量列表
	char VarList[MaxY];

	// 取变量列表字符串
	strcpy(VarList, Source);

	// 末尾添加逗号，方便分离变量
	strcat(VarList, ",");

	ClearBlankInside(VarList);

	int i = 1;

	// 存储变量字符串
	char Var[MaxLenOfVar];

	// 取变量字符串
	GetPart(VarList, 1, ',', Var);

	while (Var[0] != '\0')
	{
		// 还有变量需要删除

		// 取变量类型
		switch(GetType(Var))
		{
		case Integer:
			// 整型变量

			// 在整型变量表中查找该变量并删除
			VarIntType *pInt = HeadInt;
			VarIntType *pIntBefore = NULL;
			while (pInt != NULL)
			{
				if (strcmp(pInt->Name, Var) == 0)
				{
					// 找到该变量

					if (pInt == HeadInt)
					{
						// 是第一个变量，修改头指针

						HeadInt = HeadInt->NextVar;
					}
					else
					{
						// 直接删除

						pIntBefore->NextVar = pInt->NextVar;
					}

					if (pInt == TailInt)
					{
						// 删除的是尾变量，修改尾指针

						if (pIntBefore == NULL)
						{
							// 只剩一个变量

							TailInt = HeadInt;
						}
						else
						{
							// 尾指针提前

							TailInt = pIntBefore;
						}
					}

					// 删除当前变量
					delete pInt;

					break;
				}

				// 记录前一个变量
				pIntBefore = pInt;

				// 下一个变量
				pInt = pInt->NextVar;
			}

			break;

		case Real:
			// 实型变量

			// 在实型变量中查找该变量并删除
			VarRealType *pReal = HeadReal;
			VarRealType *pRealBefore = NULL;
			while (pReal != NULL)
			{
				if (strcmp(pReal->Name, Var) == 0)
				{
					// 找到该变量

					if (pReal == HeadReal)
					{
						// 是第一个变量，修改头指针

						HeadReal = HeadReal->NextVar;
					}
					else
					{
						// 直接

						pRealBefore->NextVar = pReal->NextVar;
					}

					if (pReal == TailReal)
					{
						// 是最后一个变量

						if (pRealBefore == NULL)
						{
							// 只剩一个变量

							TailReal = HeadReal;
						}
						else
						{
							// 尾指针提前

							TailReal = pRealBefore;
						}
					}

					// 删除当前变量
					delete pReal;

					break;
				}

				// 记录前一个变量
				pRealBefore = pReal;

				// 下一个变量
				pReal = pReal->NextVar;
			}

			break;

		case Array:
			// 数组变量

			// 在数组变量中查找该变量并删除
			VarArrayHeadType *pArrayHead = HeadArray;
			VarArrayHeadType *pArrayHeadBefore = NULL;
			while (pArrayHead != NULL)
			{
				if (strcmp(pArrayHead->Name, Var) == 0)
				{
					// 找到该变量

					if (pArrayHead == HeadArray)
					{
						// 是第一个变量，修改头指针

						HeadArray = HeadArray->NextArray;
					}
					else
					{
						// 直接删除

						pArrayHeadBefore->NextArray = pArrayHead->NextArray;
					}

					if (pArrayHead == TailArray)
					{
						// 是最后一个变量

						if (pArrayHeadBefore == NULL)
						{
							// 只剩一个变量

							TailArray = HeadArray;
						}
						else
						{
							// 尾指针提前

							TailArray = pArrayHeadBefore;
						}
					}

					// 删除此数组的所有元素
					VarArrayElemType *pArrayElem = pArrayHead->HeadElem;
					VarArrayElemType *pArrayElemBefore;
					while (pArrayElem != NULL)
					{
						pArrayElemBefore = pArrayElem;
						pArrayElem = pArrayElem->NextElem;
						delete pArrayElemBefore;
					}

					// 删除当前变量
					delete pArrayHead;

					break;
				}

				// 记录前一个变量
				pArrayHeadBefore = pArrayHead;

				// 下一个变量
				pArrayHead = pArrayHead->NextArray;
			}

			break;

		default:
			// 变量未定义

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

		// 在变量类型检索表中删除记录
		VarAllType *pAll = HeadAll;
		VarAllType *pAllBefore = NULL;
		while (pAll != NULL)
		{
			if (strcmp(pAll->Name, Var) == 0)
			{
				// 找到该变量记录

				if (pAll == HeadAll)
				{
					// 是第一个变量，修改头指针

					HeadAll = HeadAll->NextVar;
				}
				else
				{
					// 直接删除

					pAllBefore->NextVar = pAll->NextVar;
				}

				if (pAll == TailAll)
				{
					// 是最后一个变量

					if (pAllBefore == NULL)
					{
						// 只剩一个变量

						TailAll = HeadAll;
					}
					else
					{
						// 尾指针前移

						TailAll = pAllBefore;
					}
				}

				// 删除当前变量
				delete pAll;

				break;
			}

			// 记录前一个变量
			pAllBefore = pAll;

			// 下一个变量
			pAll = pAll->NextVar;
		}

		// 取下一个变量字符串
		i++;
		GetPart(VarList, i, ',', Var);
	}
}

void CreateTable()
{
	// 建立IF、FOR、SUB表

	// IF栈顶指针
	int NowIf	= -1;

	// FOR栈顶指针
	int NowFor	= -1;

	// 当前行处于SUB中的标志
	bool InSub = false;

	// 程序中的IF语句数量
	TotIfInProg = -1;

	// 程序中的FOR语句数量
	TotForInProg = -1;

	// 程序中的SUB语句数量
	TotSubInProg = -1;

	// 存储关键字
	char KeyWord[MaxY];

	for (int i = 0; i <= EndLine; i++)
	{
		// 取当前行的关键字
		GetPart(Text[i]->Line, 1, ' ', KeyWord);

		if (strcmp(KeyWord, "IF") == 0)
		{
			// 是IF语句

			TotIfInProg++;
			if (TotIfInProg >= MaxIf)
			{
				// IF语句过多

				ShowError(ErrorMoreIf);
				return;
			}

			// 当前IF入栈
			NowIf++;
			if (NowIf >= MaxNestIf)
			{
				// IF栈溢出

				ShowError(ErrorMoreNestIf);
				return;
			}

			// 设置栈顶元素
			NestIf[NowIf] = TotIfInProg;
			If[NestIf[NowIf]].Start = i;
			If[NestIf[NowIf]].Else	= -1;
		}
		else if (strcmp(KeyWord, "ELSE") == 0)
		{
			// 是ELSE语句

			if (NowIf < 0 || If[NestIf[NowIf]].Else >= 0)
			{
				// 当前ELSE多余

				ShowError(ErrorUnwantedELSE, i);
				return;
			}
			
			// 设置栈顶IF语句的ELSE语句位置
			If[NestIf[NowIf]].Else = i;
		}
		else if (strcmp(KeyWord, "END") == 0)
		{
			// 开头是END

			// 取第二个单词
			GetPart(Text[i]->Line, 2, ' ', KeyWord);

			if (strcmp(KeyWord, "IF") == 0)
			{
				// 是IF结束语句

				if (NowIf < 0)
				{
					// 多余的ENDIF语句

					ShowError(ErrorUnwantedENDIF, i);
					return;
				}

				// 记录栈顶IF语句的结束位置
				If[NestIf[NowIf]].End = i;

				// IF栈顶元素出栈
				NowIf--;
			}
			else if (strcmp(KeyWord, "SUB") == 0)
			{
				// 是SUB的结束语句

				if (!InSub)
				{
					// 多余的ENDSUB语句

					ShowError(ErrorUnwantedENDSUB);
					return;
				}

				// 记录当前SUB的结束位置
				Sub[TotSubInProg].End = i;

				// 设置标志
				InSub = false;
			}
		}
		else if (strcmp(KeyWord, "FOR") == 0)
		{
			// 是FOR语句

			TotForInProg++;
			if (TotForInProg >= MaxFor)
			{
				// 循环过多

				ShowError(ErrorMoreFor);
				return;
			}

			// FOR语句入栈
			NowFor++;
			if (NowFor >= MaxNestFor)
			{
				// FOR栈溢出

				ShowError(ErrorMoreNestFor);
				return;
			}

			// 设置FOR栈顶元素
			NestFor[NowFor] = TotForInProg;
			For[NestFor[NowFor]].StartNo = i;
			GetPart(Text[i]->Line, 2, ' ', KeyWord);
			strcpy(For[NestFor[NowFor]].Var, KeyWord);
		}
		else if (strcmp(KeyWord, "NEXT") == 0)
		{
			// 是NEXT语句

			if (NowFor < 0)
			{
				// 多余的NEXT语句

				ShowError(ErrorUnwantedNEXT, i);
				return;
			}

			// 检查循环变量是否匹配
			GetPart(Text[i]->Line, 2, ' ', KeyWord);
			if (KeyWord[0] != '\0' && strcmp(KeyWord, For[NestFor[NowFor]].Var) != 0)
			{
				// 循环变量不匹配

				ShowError(ErrorUnmatchForVar, i);
				return;
			}

			// 设置FOR栈顶元素的结束行号
			For[NestFor[NowFor]].EndNo = i;

			// FOR栈顶元素出栈
			NowFor--;
		}
		else if (strcmp(KeyWord, "SUB") == 0)
		{
			// 是SUB语句

			if (InSub)
			{
				// 当前已经在过程中，出错

				ShowError(ErrorSubPosition);
				return;
			}

			TotSubInProg++;
			if (TotSubInProg >= MaxSub)
			{
				// 过程过多

				ShowError(ErrorMoreSub);
				return;
			}

			// 修改标志
			InSub = true;

			// 设置当前过程的参数
			Sub[TotSubInProg].Start = i;
			GetPart(Text[i]->Line, 2, ' ', KeyWord);
			strcpy(Sub[TotSubInProg].Name, KeyWord);
		}
		else if (strcmp(KeyWord, "RETURN") == 0)
		{
			if (!InSub)
			{
				// 多余的RETURN语句

				ShowError(ErrorUnwantedRETURN, i);
				return;
			}
		}
	}

	if (NowIf >= 0)
	{
		// 缺少ENDIF

		ShowError(ErrorMissingENDIF);
		return;
	}
	else if (NowFor >= 0)
	{
		// 缺少NEXT

		ShowError(ErrorMissingNEXT);
		return;
	}
	else if (InSub)
	{
		// 缺少ENDSUB

		ShowError(ErrorMissingENDSUB);
		return;
	}

	TotIfInProg++;
	TotForInProg++;
	TotSubInProg++;
}