{
				// 變量錯誤

				return Error;
			}

			// 檢查賦值號右側表達式
			char Exp[MaxY];
			GetMid(strLine, Pos + 2, strlen(strLine) - 1, Exp);
			ClearBlankInside(Exp);

			if (!ExpressionOK(Exp))
			{
				// 表達式錯誤

				return ErrorExpression;
			}
		}
		else
		{
			// 未知語句類型

			return ErrorSyntax;
		}
	}

	// 返回無錯誤
	return NoError;
}

bool VarOK(const char Var[MaxY])
{
	// 檢查變量名

	if (strchr(Var, '('))
	{
		// 當前字符串是數組

		// 取數組名
		char VarMain[MaxY];
		GetPart(Var, 1, '(', VarMain);

		if (!VarOK(VarMain))
		{
			// 數組名非法

			Error = ErrorVar;
			return false;
		}

		// 取數組下標
		GetPart(Var, 2, '(', VarMain);
		VarMain[strlen(VarMain) - 1] = '\0';

		if (VarMain[strlen(VarMain) - 1] == ',')
		{
			// 有多余的逗號

			Error = ErrorUnwantedComma;
			return false;
		}

		// 存儲各下標字符串
		char Range[MaxY];

		// 取第一個下標字符串
		int i = 1;
		GetPart(VarMain, i, ',', Range);
		ClearBlankInside(Range);

		while (Range[0] != '\0')
		{
			if (!ExpressionOK(Range))
			{
				// 下標表達式出錯

				Error = ErrorExpression;
				return false;
			}

			// 取下一個下標
			i++;
			GetPart(VarMain, i, ',', Range);
			ClearBlankInside(Range);
		}

		if (i == 1)
		{
			// 缺少下標

			Error = ErrorMissingRange;
			return false;
		}

		return true;
	}

	if (Var[0] == '\0')
	{
		// 變量為空

		Error = ErrorMissingVar;
		return false;
	}
	else if (strlen(Var) <= MaxLenOfVar)
	{
		// 長度小于最大允許長度

		if (isalpha(Var[0]))
		{
			for(int i = 1; i < strlen(Var); i++)
			{
				if (!isdigit(Var[i]) && !isalpha(Var[i]) && Var[i] != '_')
				{
					// 非字母，非數字，非下劃線

					Error = ErrorVar;
					return false;
				}
			}

			// 正確
			return true;
		}
		else
		{
			// 首字符必須是字母

			Error = ErrorVar;
			return false;
		}
	}
	else
	{
		// 超過允許長度

		Error = ErrorVar;
		return false;
	}
}

bool BooleanOK(const char Exp[MaxY])
{
	// 檢查布爾表達式是否正確，供外部調用

	int Seat = 0;
	bool Result = BoolOK(Exp, Seat);
	return Result && Seat >= strlen(Exp);
}

bool BoolOK(const char Exp[MaxY], int &Seat)
{
	// 檢查布爾表達式是否正確，內部使用

	// 測試OR表達式
	if (!OROK(Exp, Seat))
	{
		// 第一個OR表達式出錯，返回

		return false;
	}

	while (Exp[Seat] == '|')
	{
		// 繼續檢查后面的

		Seat++;
		if (!OROK(Exp, Seat))
		{
			// 表達式錯誤，返回

			return false;
		}
	}

	// 正確，返回
	return true;
}

bool OROK(const char Exp[MaxY], int &Seat)
{
	// 檢查OR表達式是否正確

	// 檢查第一個AND表達式
	if (!ANDOK(Exp, Seat))
	{
		// 表達式錯誤，返回

		return false;
	}

	while (Exp[Seat] == '&')
	{
		// 繼續檢查后面的

		Seat++;
		if (!ANDOK(Exp, Seat))
		{
			return false;
		}
	}

	// 正確，返回
	return true;
}

bool ANDOK(const char Exp[MaxY], int &Seat)
{
	// 檢查AND表達式是否正確

	if (Exp[Seat] == '(')
	{
		// 一個新的布爾表達式開始

		Seat++;

		if (!BoolOK(Exp, Seat))
		{
			// 表達式錯誤

			return false;
		}

		if (Exp[Seat] != ')')
		{
			// 缺少括號匹配

			return false;
		}

		// 正確，返回
		return true;
	}
	else if (Exp[Seat] == '~')
	{
		// 檢查非表達式

		Seat++;

		if (!ANDOK(Exp, Seat))
		{
			// 表達式錯誤，返回

			return false;
		}

		// 正確，返回
		return true;
	}
	else
	{
		// 檢查元表達式

		// 取左側表達式
		char Word[MaxY] = "";
		while (!strchr("<>!=&|", Exp[Seat]))
		{
			strcat(Word, " ");
			Word[strlen(Word) - 1] = Exp[Seat];
			Seat++;
		}

		if (!ExpressionOK(Word))
		{
			// 左側表達式錯誤

			return false;
		}

		// 取邏輯運算符
		char Operation[3] = "";
		while (Seat < strlen(Exp) && strchr("<>!=", Exp[Seat]))
		{
			strcat(Operation, " ");
			Operation[strlen(Operation) - 1] = Exp[Seat];
			Seat++;
		}

		if (Operation[0] == '\0')
		{
			// 無運算符，正確返回

			return true;
		}

		// 取右側表達式
		Word[0] = '\0';
		while (!strchr("<>!=&|", Exp[Seat]))
		{
			strcat(Word, " ");
			Word[strlen(Word) - 1] = Exp[Seat];
			Seat++;
		}

		if (!ExpressionOK(Word))
		{
			// 右側表達式錯誤

			return false;
		}

		if (strcmp(Operation, ">") != 0 &&
			strcmp(Operation, "<") != 0 &&
			strcmp(Operation, "=") != 0 &&
			strcmp(Operation, ">=") != 0 &&
			strcmp(Operation, "<=") != 0 &&
			strcmp(Operation, "<>") != 0)
		{
			// 操作符錯誤

			return false;
		}

		// 正確，返回
		return true;
	}
}

bool FactorOK(const char strExp[MaxY], int &Seat)
{
	// 計算因式的值

	if (strExp[Seat] == '(')
	{
		// 因式中含有括號，開始表達式處理

		// 越過左括號位
		Seat++;

		// 返回表達式的值
		if (!ExpressOK(strExp, Seat))
		{
			return false;
		}

		if (Seat >= strlen(strExp) || strExp[Seat] != ')')
		{
			return false;
		}

		// 越過右括號位
		Seat++;

		// 返回因式的值
		return true;
	}
	else if (strExp[Seat] == '+' || strExp[Seat] == '-')
	{
		// 是負號

		if (Seat > 0 && (strchr("+-", strExp[Seat - 1])))
		{
			return false;
		}

		// 越過負號位
		Seat++;

		// 返回因式的相反數
		bool OK = FactorOK(strExp, Seat);

		return OK;
	}
	else
	{
		// 處理普通因式

		int i = Seat;
		char Chr = strExp[i];

		while (i < strlen(strExp) && (isalpha(Chr) || isdigit(Chr) || Chr == '.'))
		{
			// 是字母、數字或小數點

			i++;

			Chr = strExp[i];
		}

		// 取變量或數字
		char strTemp[MaxY] = "";
		GetMid(strExp, Seat, i - 1, strTemp);

		Seat = i;

		if (strTemp[0] == '\0')
		{
			// 表達式錯誤

			return false;
		}

		double Temp;

		if (strcmp(strTemp, "RND") == 0 ||
			strcmp(strTemp, "INT") == 0 ||
			strcmp(strTemp, "SQR") == 0)
		{
			// 是RND、INT或SQR

			// 取參數
			char strPara[MaxY];
			int End;
			if (!GetParaStr(strExp, Seat, strPara, End))
			{
				// 缺少參數

				return false;
			}

			Seat = End;

			// 檢查參數表達式
			ClearBlankInside(strPara);

			return ExpressionOK(strPara);
		}
		else if (strcmp(strTemp, "PI") == 0)
		{
			// 正確，返回

			return true;
		}
		else if (IsNumber(strTemp, Temp))
		{
			// 正確，返回

			return true;
		}
		else if (strExp[Seat] != '(')
		{
			// 簡單變量

			return VarOK(strTemp);
		}
		else if (strExp[Seat] == '(')
		{
			// 數組變量

			// 取下標字符串
			char strPara[MaxY];
			int New;
			if (!GetParaStr(strExp, Seat, strPara, New))
			{
				// 下標字符串錯誤

				return false;
			}
			Seat = New;

			if (strPara[strlen(strPara) - 1] == ',')
			{
				// 多余逗號

				return false;
			}

			// 末尾添加逗號，方便分離各下標
			strcat(strPara, ",");

			// 存儲各下標表達式
			char strExp[MaxY];

			// 取第一個下標
			int i = 1;
			GetPart(strPara, 1, ',', strExp);
			ClearBlankInside(strExp);

			while (strExp[0] != '\0')
			{
				if (!ExpressionOK(strExp))
				{
					// 下標表達式錯誤

					return false;
				}

				// 取下一個下標
				i++;
				GetPart(strPara, i, ',', strExp);
				ClearBlankInside(strExp);
			}

			// 正確，返回
			return true;
		}
	}

	return true;
}

bool TermOK(const char strExp[MaxY], int &Seat)
{
	// 計算項的值

	if (!FactorOK(strExp, Seat))
	{
		// 有錯誤，返回

		return false;
	}

	bool OK;

	while (Seat < strlen(strExp) &&
			(strExp[Seat] == '*' || strExp[Seat] == '/' || strExp[Seat] == '%'))
	{
		// 還有因式需要計算

		Seat++;
		switch (strExp[Seat - 1])
		{
		case '*':
		case '/':
		case '%':
			// 符號正確

			OK = FactorOK(strExp, Seat);
			break;
		default:
			return false;
		}

		if (!OK)
		{
			return false;
		}
	}

	// 返回項的值
	return true;
}

bool ExpressOK(const char strExp[MaxY], int &Seat)
{
	// 計算表達式的值

	if (!TermOK(strExp, Seat))
	{
		// 有錯誤，返回
		return false;
	}

	bool OK;

	while (Seat < strlen(strExp) &&
			(strExp[Seat] == '+' || strExp[Seat] == '-'))
	{
		// 還有項需要計算

		Seat++;
		switch (strExp[Seat - 1])
		{
		case '+':
		case '-':
			// 減號

			OK = TermOK(strExp, Seat);
			break;
		default:
			return false;
		}

		if (!OK)
		{
			return false;
		}
	}

	// 返回表達式的值
	return true;
}

bool ExpressionOK(const char strExp[MaxY])
{
	// 檢查表達式是否正確，外部調用

	int SeatOut = 0;
	bool OK = ExpressOK(strExp, SeatOut);
	return OK && SeatOut >= strlen(strExp);
}