编程实战：类C语法的编译型脚本解释器（六）表达式

已于 2024-03-11 09:17:13 修改
阅读量1.2k 收藏 20
点赞数 34
分类专栏： C语法的预编译脚本解释器 文章标签： c语言 C++ 编程语言 脚本解释器
于 2023-12-04 14:40:52 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/2301_77171572/article/details/134781329
版权

初级代码游戏的专栏介绍与文章目录-CSDN博客

系列入口：

编程实战：类C语法的编译型脚本解释器（系列）-CSDN博客

        脚本的结构与C语言类似，由语句和表达式构成，后来增加了子函数，子函数当作独立的脚本。

        本文介绍表达式。从本文开始前面介绍过的东西和后面要介绍的东西会纠缠在一起，互相递归。

目录

 一、表达式概览

二、表达式类型

三、成员变量

四、计算结果类型

五、编译时检查

六、执行

 一、表达式概览

		//表达式，单目算符有两个操作数则为后缀(第一个不使用)，函数参数个数不限
		//VARIABLE:pVariable 包含常量
		//PLUGIN:pPlugin(operands)
		//OPERATION:op operands
		struct Expression
		{
			enum types { NULLEXPRESSION, CONSTANT, DEFINE, VARIABLE, FUNCTION, PLUGIN, OPERATION };
			types type;
			Variable::types result_type;//编译用的结果类型，执行时实际上并不需要这个
			size_t source_start;//起始位置
			size_t source_end;//结束位置

			//变量
			string VariableName;
			Variable m_variable;//用于常量或运行时创建变量

			//函数
			CScript * pFunction;//函数索引

			//插件
			CPluginMap::HANDLE pPlugin;

			//插件或函数的参数
			vector<Expression > ParamList;

			//操作
			string op;
			vector<Expression > Operands;//操作数

			//函数和属性
			void* user_p;//用户自行使用的指针，编译时可设置，执行时不可修改（指向的内容由用户决定）

			Expression() :type(NULLEXPRESSION), result_type(Variable::NULLVARIABLE), source_start(0), source_end(0), pFunction(NULL), user_p(NULL) {}
			Expression* pLeftOperand() { return (Operands.size() >= 1 && Operands[0].type != NULLEXPRESSION ? &Operands[0] : NULL); }//左操作数
			Expression const* pLeftOperand()const { return (Operands.size() >= 1 && Operands[0].type != NULLEXPRESSION ? &Operands[0] : NULL); }//左操作数
			Expression* pRightOperand() { return (Operands.size() >= 2 && Operands[1].type != NULLEXPRESSION ? &Operands[1] : NULL); }//右操作数
			Expression const* pRightOperand()const { return (Operands.size() >= 2 && Operands[1].type != NULLEXPRESSION ? &Operands[1] : NULL); }//右操作数
			bool AddLeftOperand(Expression const& exp)
			{
				if (NULL != pLeftOperand())return false;
				if (Operands.size() < 1)Operands.resize(1);
				Operands[0] = exp;
				return true;
			}
			bool AddRightOperand(Expression const& exp)
			{
				if (NULL != pRightOperand())return false;
				if (Operands.size() < 2)Operands.resize(2);
				Operands[1] = exp;
				return true;
			}

			Variable::types GetResultType(string& source, T_VARIABLE_S& vars);
			//setpp记录已经做过的++ --
			bool CheckExpression(string& source, T_VARIABLE_S& vars, long level, set<string >& setpp);
			bool ExecExpression(CScript const& script, T_VARIABLE_S& vars, Variable& ret, void* pe)const;
			string ToString(string const& source, T_VARIABLE_S const& vars, long level = 0)const
			{
				STATIC_C const char typestr[][TOKEN_BUF_LEN] = { "NULLEXPRESSION","DEFINE","CONSTANT","VARIABLE","FUNCTION","PLUGIN","OPERATION" };//必须与types对应
				char buf[256];
				string ret;
				size_t i;
				string prefix;
				prefix.assign(level * 4, ' ');

				ret = prefix.c_str();
				sprintf(buf, "%03ld %03ld 表达式类型 %-12s 结果类型 %-12s: ", source_start, source_end - 1, typestr[type], Variable::TypeStr(result_type));
				ret += buf;
				ret += source.substr(source_start, source_end - source_start);
				ret += "\r\n";
				switch (type)
				{
				case DEFINE:
					ret += VariableName + " " + m_variable.ToString(level + 1);
					ret += "\r\n";
					break;
				case CONSTANT:
					ret += m_variable.ToString(level + 1);
					ret += "\r\n";
					break;
				case VARIABLE:
					if (NULL == vars.FindVariable(VariableName))
					{
						ret += VariableName;
					}
					else ret += vars.FindVariable(VariableName)->ToString(level + 1);
					ret += "\r\n";
					break;
				case FUNCTION:
					ret += prefix + "函数名： " + pFunction->script_name;
					if (ParamList.size() != 0)
					{
						ret += prefix + "参数：\r\n";
						for (i = 0; i < ParamList.size(); ++i)
						{
							ret += ParamList[i].ToString(source, vars, level + 1);
						}
					}
					else
					{
						ret += "\r\n";
					}
					break;
				case PLUGIN:
					ret += prefix + "插件名： " + CPluginMap::GetPlugin(pPlugin)->plugin_name;
					if (ParamList.size() != 0)
					{
						ret += prefix + "参数：\r\n";
						for (i = 0; i < ParamList.size(); ++i)
						{
							ret += ParamList[i].ToString(source, vars, level + 1);
						}
					}
					else
					{
						ret += "\r\n";
					}
					break;
				case OPERATION:
					if (NULL != pLeftOperand())
					{
						ret += pLeftOperand()->ToString(source, vars, level + 1);
					}
					ret += prefix + "    " + op;
					ret += "\r\n";
					if (NULL != pRightOperand())
					{
						ret += pRightOperand()->ToString(source, vars, level + 1);
					}
					break;
				default:
					break;
				}
				return ret;
			}
		};

        表达式就是用运算符穿起来的一组变量，总是可以拆解为“左操作数+运算符+右操作数”的形式（三元运算符没打算支持），比如“a+b+c”就可以拆解为：

  ----a+表达式

  --------b+c

        表达式总是有个值的，除非是函数调用，返回值为“void”。

二、表达式类型

			enum types { NULLEXPRESSION, CONSTANT, DEFINE, VARIABLE, FUNCTION, PLUGIN, OPERATION };

        这个枚举定义了表达式类型，包括：

  • 无类型 空的表达式，只是表达式结构的初始状态
  • 常量
  • 定义 定义变量
  • 变量
  • 函数 脚本里面定义的子函数
  • 插件 外部实现的自定义函数（包括内置函数）
  • 运算

        实际上这是一个递归的表达方式，一个运算最终会被拆解到变量、常量和函数，函数又会被拆解到插件和参数（每个参数是一个表达式）。

三、成员变量

        表达式具有如下几个通用成员变量：

类型名称用途
typestype类型
Variable::typesresult_type结果类型，仅在编译时使用
size_tsource_start在脚本中的起始位置
size_tsource_end在脚本中的结束位置

        其余参数视类型不同而分别使用。比如变量使用VariableName和m_variable，操作则使用op和Operands。函数和插件都要用到ParamList。

        user_p并没有实际使用。

四、计算结果类型

			Variable::types GetResultType(string& source, T_VARIABLE_S& vars)
			{
				Variable::types _resulttype = Variable::NULLVARIABLE;
				bool eva;
				switch (type)
				{
				case NULLEXPRESSION:
					_resulttype = Variable::NULLVARIABLE;
					break;
				case DEFINE:
					_resulttype = m_variable.type;
					break;
				case CONSTANT:
					_resulttype = m_variable.type;
					break;
				case VARIABLE:
					if (0 == VariableName.size())CException::Throw(__FILE__, __LINE__, source, source_start, "未声明的变量");
					if (NULL == vars.FindVariable(VariableName))
					{
						cout << VariableName << endl << vars.ToString() << endl;
						CException::Throw(__FILE__, __LINE__, source, source_start, "未声明的变量");
					}
					_resulttype = vars.FindVariable(VariableName)->type;
					break;
				case FUNCTION:
					if (NULL== pFunction)CException::Throw(__FILE__, __LINE__, source, source_start, "未声明的函数");
					_resulttype = pFunction->return_type;
					break;
				case PLUGIN:
					if (pPlugin.isNULL())CException::Throw(__FILE__, __LINE__, source, source_start, "未声明的插件");
					_resulttype = CPluginMap::GetPlugin(pPlugin)->plugin_return_type;
					break;
				case OPERATION:
					if (NULL == pLeftOperand() && NULL != pRightOperand())_resulttype = pRightOperand()->GetResultType(source, vars);
					else if (NULL != pLeftOperand() && NULL == pRightOperand())_resulttype = pLeftOperand()->GetResultType(source, vars);
					else if (NULL != pLeftOperand() && NULL != pRightOperand())
					{
						if ("=" == op || "+=" == op || "-=" == op || "*=" == op || "/=" == op || "%=" == op)eva = true;
						else eva = false;
						_resulttype = Variable::typeUpgrade(pLeftOperand()->GetResultType(source, vars), pRightOperand()->GetResultType(source, vars), eva);
						if (">" == op || "<" == op || ">=" == op || "<=" == op || "==" == op || "!=" == op || "||" == op || "&&" == op)
						{
							if (Variable::NULLVARIABLE != _resulttype)_resulttype = Variable::LONG;
						}
						if ("," == op)_resulttype = pRightOperand()->GetResultType(source, vars);
					}
					else CException::Throw(__FILE__, __LINE__, source, source_start, "左右操作数不能都没有");
					break;
				default:
					CException::Throw(__FILE__, __LINE__, source, source_start, "未知的表达式类型");
					break;
				}
				return _resulttype;
			}

        计算结果类型根据表达式类型不同而有不同的方法，左右操作数根据运算符得到结果类型。

五、编译时检查

			//setpp记录已经做过的++ --
			bool CheckExpression(string& source, T_VARIABLE_S& vars, long level, set<string >& setpp)
			{
				size_t i;
				string msg;
				Variable var;
				vector<Variable > _paramvars;//函数调用的参数

				if (DEFINE == type)
				{
					if (!vars.AddVariable(VariableName, m_variable))CException::Throw(__FILE__, __LINE__, source, source_start, "添加变量失败");
					//cout <<"添加变量 "<< VariableName << endl << vars.ToString() << endl;
				}

				result_type = GetResultType(source, vars);
				switch (type)
				{
				case NULLEXPRESSION:
					break;
				case DEFINE:
					if (0 == VariableName.size())CException::Throw(__FILE__, __LINE__, source, source_start, "未声明的变量");
					if (Variable::NULLVARIABLE == m_variable.type)CZException::Throw(__FILE__, __LINE__, source, source_start, "变量类型不能为NULLVARIABLE");
					if (Operands.size() > 1)CException::Throw(__FILE__, __LINE__, source, source_start, "变量定义最多有一个操作数");
					break;
				case CONSTANT:
					if (0 != VariableName.size())CException::Throw(__FILE__, __LINE__, source, source_start, "常量不应该有名字");
					if (Variable::NULLVARIABLE == m_variable.type)CException::Throw(__FILE__, __LINE__, source, source_start, "常量类型不能为NULLVARIABLE");
					break;
				case VARIABLE:
					if (0 == VariableName.size())CException::Throw(__FILE__, __LINE__, source, source_start, "未声明的变量");
					break;
				case FUNCTION:
					if (NULL==pFunction)CException::Throw(__FILE__, __LINE__, source, source_start, "未声明的函数");
					if (!pFunction->IsCompiled())CException::Throw(__FILE__, __LINE__, source, source_start, "子函数未能成功编译");
					if (pFunction->m_EnvVariables.size() != ParamList.size())CException::Throw(__FILE__, __LINE__, source, source_start, "函数参数个数错误");
					for (i = 0; i < ParamList.size(); ++i)
					{
						ParamList[i].CheckExpression(source, vars, 0, setpp);
					}
					break;
				case PLUGIN:
					if (pPlugin.isNULL())CException::Throw(__FILE__, __LINE__, source, source_start, "未声明的插件");
					_paramvars.reserve(ParamList.size());
					for (i = 0; i < ParamList.size(); ++i)
					{
						ParamList[i].CheckExpression(source, vars, 0, setpp);
						if (Expression::VARIABLE == ParamList[i].type && vars.FindVariable(ParamList[i].VariableName)->isconst)
						{
							_paramvars.push_back(*vars.FindVariable(ParamList[i].VariableName));
						}
						else
						{
							var.type = ParamList[i].result_type;
							_paramvars.push_back(var);
						}
					}
					if (!CPluginMap::GetPlugin(pPlugin)->CheckPlugin(_paramvars, user_p, msg))CException::Throw(__FILE__, __LINE__, source, source_start, msg.c_str());
					break;
				case OPERATION:
					//先检查左右表达式
					if (NULL != pLeftOperand())
					{
						pLeftOperand()->CheckExpression(source, vars, level + 1, setpp);
					}
					if (NULL != pRightOperand())
					{
						pRightOperand()->CheckExpression(source, vars, level + 1, setpp);
					}
					//检查操作是否合理
					if (NULL == pRightOperand())
					{//后缀
						if ("++" == op || "--" == op)
						{
							if (result_type != Variable::LONG)CException::Throw(__FILE__, __LINE__, source, source_start, "后缀++ --操作只能用于整数");
							if (Expression::VARIABLE != pLeftOperand()->type || vars.FindVariable(pLeftOperand()->VariableName)->isconst)CException::Throw(__FILE__, __LINE__, source, source_start, "后缀++ --操作只能用于变量");
							if (0 != level)CException::Throw(__FILE__, __LINE__, source, source_start, "后缀++ --操作只能作为独立语句使用，如'i++;'或'for(...;...;i++)'，不能用于赋值或组合运算");
						}
						else
						{
							CException::Throw(__FILE__, __LINE__, source, source_start, "不支持的后缀操作");
						}
					}
					else if (NULL == pLeftOperand())
					{//前缀
						if ("-" == op || "+" == op)
						{
							if (result_type != Variable::DOUBLE && result_type != Variable::LONG)CException::Throw(__FILE__, __LINE__, source, source_start, "前缀+-操作只能用于数值");
						}
						else if ("!" == op)
						{
							if (result_type != Variable::LONG)CException::Throw(__FILE__, __LINE__, source, source_start, "前缀!操作只能用于整数");
						}
						else if ("++" == op || "--" == op)
						{
							if (result_type != Variable::LONG)CException::Throw(__FILE__, __LINE__, source, source_start, "前缀++ --操作只能用于整数");
							if (Expression::VARIABLE != pRightOperand()->type || vars.FindVariable(pRightOperand()->VariableName)->isconst)CException::Throw(__FILE__, __LINE__, source, source_start, "前缀++ --操作只能用于变量");
							if (setpp.find(pRightOperand()->VariableName) != setpp.end())
								CException::Throw(__FILE__, __LINE__, source, source_start, "前缀++ --操作每个语句对每个变量仅限使用一次（不区分++ --）");
							setpp.insert(pRightOperand()->VariableName);
						}
						else
						{
							CException::Throw(__FILE__, __LINE__, source, source_start, "不支持的前缀操作");
						}
					}
					else
					{//二元
						if ("+" == op || ">" == op || "<" == op || ">=" == op || "<=" == op || "==" == op || "!=" == op || "," == op)
						{
						}
						else if ("-" == op || "*" == op || "/" == op)
						{
							if (Variable::STRING == result_type)CException::Throw(__FILE__, __LINE__, source, source_start, "不能对字符串做-*/");
						}
						else if ("-=" == op || "*=" == op || "/=" == op)
						{
							if (Variable::STRING == result_type)CException::Throw(__FILE__, __LINE__, source, source_start, "不能对字符串做-*/");
							if (pLeftOperand()->type != Expression::VARIABLE || vars.FindVariable(pLeftOperand()->VariableName)->isconst)CException::Throw(__FILE__, __LINE__, source, source_start, "不能对常量赋值");
						}
						else if ("&&" == op || "||" == op)
						{
							if (Variable::STRING == result_type)CException::Throw(__FILE__, __LINE__, source, source_start, "不能对字符串做&& ||");
						}
						else if ("%" == op)
						{
							if (Variable::LONG != result_type)CException::Throw(__FILE__, __LINE__, source, source_start, "只能对整数做%");
						}
						else if ("%=" == op)
						{
							if (Variable::LONG != result_type)CException::Throw(__FILE__, __LINE__, source, source_start, "只能对整数做%");
							if (pLeftOperand()->type != Expression::VARIABLE || vars.FindVariable(pLeftOperand()->VariableName)->isconst)CException::Throw(__FILE__, __LINE__, source, source_start, "不能对常量赋值");
						}
						else if ("=" == op || "+=" == op)
						{
							if (pLeftOperand()->type != Expression::VARIABLE || vars.FindVariable(pLeftOperand()->VariableName)->isconst)CException::Throw(__FILE__, __LINE__, source, source_start, "不能对常量赋值");
						}
						else
						{
							CException::Throw(__FILE__, __LINE__, source, source_start, (op + " 不支持的操作").c_str());
						}

						if ("," != op)
						{
							if (Variable::NULLVARIABLE == result_type)CException::Throw(__FILE__, __LINE__, source, source_start, "操作符两边类型不匹配，不允许数值和字符串的自动转换");
						}
					}
					break;
				}
				return true;
			}

        这个函数在编译后检查是否存在语法问题。如果检查成功，起码在语法上是没有问题的。

六、执行

			bool ExecExpression(CZBScript const& script, T_VARIABLE_S& vars, Variable& ret, void* pe)const
			{
				size_t i;
				string msg;
				vector<Variable > _paramvars;//插件调用的参数
				Variable ret_left;
				Variable ret_right;
				ret.type = result_type;
				switch (type)
				{
				case NULLEXPRESSION:
					ret.type = Variable::NULLVARIABLE;
					break;
				case DEFINE:
					ret.type = Variable::NULLVARIABLE;
					vars.AddVariable(VariableName, m_variable);
					if (NULL != pLeftOperand())
					{
						pLeftOperand()->ExecExpression(script, vars, ret_left, pe);
						if (ret_left.isNull())script.Throw(__FILE__, __LINE__, "左操作数计算出错");
						ret = *(vars.FindVariable(VariableName)) = ret_left;
					}
					break;
				case CONSTANT:
					ret = m_variable;
					break;
				case VARIABLE:
					ret = *vars.FindVariable(VariableName);
					break;
				case FUNCTION:
					{
						T_VARIABLE_BLOCK tmpparams;
						tmpparams = pFunction->m_EnvVariables;
						if(tmpparams.size()!= ParamList.size())script.Throw(__FILE__, __LINE__, "函数参数个数错误");
						for (i = 0; i < ParamList.size(); ++i)
						{
							ParamList[i].ExecExpression(script, vars, ret, pe);
							tmpparams[i].second = ret;
						}
						
						T_VARIABLE_S tmpvars;
						tmpvars.FromParentVars(vars, pFunction->count_global_variable, &tmpparams);
						
						ret.type = result_type;
						if (!pFunction->ExeSentences(tmpvars, ret, pe))script.Throw(__FILE__, __LINE__, "函数执行出错");
					}
					break;
				case PLUGIN:
					_paramvars.reserve(ParamList.size());
					for (i = 0; i < ParamList.size(); ++i)
					{
						ParamList[i].ExecExpression(script, vars, ret, pe);
						_paramvars.push_back(ret);
					}
					ret.type = result_type;
					if (!CPluginMap::GetPlugin(pPlugin)->ExecFunction(_paramvars, user_p, ret, msg, pe))script.Throw(__FILE__, __LINE__, "插件执行出错");
					break;
				case OPERATION:
					//计算
					if (NULL == pRightOperand())
					{
						if ("++" == op)
						{
							ret = *vars.FindVariable(pLeftOperand()->VariableName);
							++vars.FindVariable(pLeftOperand()->VariableName)->lValue;
						}
						else if ("--" == op)
						{
							ret = *vars.FindVariable(pLeftOperand()->VariableName);
							--vars.FindVariable(pLeftOperand()->VariableName)->lValue;
						}
						else
						{
							script.Throw(__FILE__, __LINE__, "不支持的前缀操作");
						}
					}
					else if (NULL == pLeftOperand())
					{//前缀
						pRightOperand()->ExecExpression(script, vars, ret_right, pe);
						if (ret_right.isNull())script.Throw(__FILE__, __LINE__, "右操作数计算出错");
						if ("-" == op)
						{
							ret = -ret_right;
						}
						else if ("+" == op)
						{
							ret = ret_right;
						}
						else if ("++" == op)
						{
							++vars.FindVariable(pRightOperand()->VariableName)->lValue;
							ret = *vars.FindVariable(pRightOperand()->VariableName);
						}
						else if ("--" == op)
						{
							--vars.FindVariable(pRightOperand()->VariableName)->lValue;
							ret = *vars.FindVariable(pRightOperand()->VariableName);
						}
						else if ("!" == op)
						{
							ret = ret_right;
							ret.lValue = (0 == ret.lValue ? 1 : 0);
						}
						else
						{
							script.Throw(__FILE__, __LINE__, "不支持的前缀操作");
						}
					}
					else
					{//二元
						if ("||" == op)
						{//若前面为真则不计算后面
							pLeftOperand()->ExecExpression(script, vars, ret_left, pe);
							if (ret_left.isNull())script.Throw(__FILE__, __LINE__, "左操作数计算出错");
							if (ret_left.GetBool())ret = ret_left;
							else
							{
								pRightOperand()->ExecExpression(script, vars, ret_right, pe);
								if (ret_right.isNull())script.Throw(__FILE__, __LINE__, "右操作数计算出错");
								ret = ret_right;
							}
						}
						else
						{
							{
								//先计算左右表达式
								pLeftOperand()->ExecExpression(script, vars, ret_left, pe);
								if (ret_left.isNull())script.Throw(__FILE__, __LINE__, "左操作数计算出错");
								pRightOperand()->ExecExpression(script, vars, ret_right, pe);
								if (ret_right.isNull())script.Throw(__FILE__, __LINE__, "右操作数计算出错");
								else if ("+" == op)ret = ret_left + ret_right;
								else if ("-" == op)ret = ret_left - ret_right;
								else if ("*" == op)ret = ret_left * ret_right;
								else if ("/" == op)ret = ret_left / ret_right;
								else if ("%" == op)ret = ret_left % ret_right;
								else if (">" == op)ret = ret_left > ret_right;
								else if ("<" == op)ret = ret_left < ret_right;
								else if (">=" == op)ret = ret_left >= ret_right;
								else if ("<=" == op)ret = ret_left <= ret_right;
								else if ("==" == op)ret = ret_left == ret_right;
								else if ("!=" == op)ret = ret_left != ret_right;
								else if ("&&" == op)ret = ret_left && ret_right;
								else if ("=" == op)ret = *(vars.FindVariable(pLeftOperand()->VariableName)) = ret_right;
								else if ("+=" == op)ret = *(vars.FindVariable(pLeftOperand()->VariableName)) = ret_left + ret_right;
								else if ("-=" == op)ret = *(vars.FindVariable(pLeftOperand()->VariableName)) = ret_left - ret_right;
								else if ("*=" == op)ret = *(vars.FindVariable(pLeftOperand()->VariableName)) = ret_left * ret_right;
								else if ("/=" == op)ret = *(vars.FindVariable(pLeftOperand()->VariableName)) = ret_left / ret_right;
								else if ("%=" == op)ret = *(vars.FindVariable(pLeftOperand()->VariableName)) = ret_left % ret_right;
								else if ("," == op)
								{
									ret = ret_right;
								}
								else
								{
									script.Throw(__FILE__, __LINE__, "不支持的操作");
								}
							}
						}
						if (Variable::NULLVARIABLE == ret.type)script.Throw(__FILE__, __LINE__, "操作符两边类型不匹配");
					}
					break;
				}
				return true;
			}

        执行时仍然可能出错。

（这里是结束，但不是整个系列的结束）

初级代码游戏
关注
专栏目录
脚本语言：也称解释型语言，指运行时可以直接执行代码的语言。例如：JavaScript、PHP等。
AI天才研究院
07-29 1492
1995年，由美国计算机科学家Brendan Eich所提出的脚本语言概念被提出来。脚本语言的主要特点是能够让程序员在文本编辑器中创作脚本代码，然后由编译器或解释器运行，不需要编译成可执行文件。脚本语言带来的便利之处很多，例如可以自动化地处理大量数据，也可以用脚本语言开发游戏。但同时，脚本语言也存在一些弱点，例如易读性差、语法复杂、性能低下等。20多年过去了，随着互联网的飞速发展，脚本语言逐渐走向衰落。至今还有很多企业仍在继续使用脚本语言作为编程语言。因此，本文将讨论当前主流的脚本语言有哪些？
解释器c语言
04-14
解释器，c语言编写
C语言解释器的实现--表达式解析(四)
weixin_34055910的博客
12-28 503
1. BNF定义 2.表达式解析 3. 后缀表达式 4.后缀表达式到中间代码 5.中间代码的表示 1. BNF定义 虽然不想多提理论知识，但是有些东西还是避免不了。在解析表达式的时候，我们必须知道它的BNF定义，这样解析起来就非常方便了。所谓的BNF定义，相信大家看一眼就知道了： exp_additive -> exp_multiplicative ...
编程实战：类C语法的编译型脚本解释器（系列）
最新发布
编程之道在明明德在亲民在止于至善
12-02 1185
编程实战：类C语法的编译型脚本解释器（系列）
C++ 脚本解释器cint
热门推荐
feiren127的专栏
05-15 1万+
Cint(C/C++ interpreter, C-int)是一个C++解释器，顾名思义，和GCC、VC等编译器不同，它是解释执行C++代码的。它具有的能力有：•支持 K&R-C, ANSI-C, ANSI-C++ Cint 覆盖了80-90%的K&R-C、ANSI-C和C++语言特性。包括多继承、虚函数重载、操作符重载、默认参数、模板（这个猛）等等。 Cint的目标不是成为100%兼容ANSI/
只有140行代码的C语言解释器,C语言解释器Parser剖析器——笔记与心得
weixin_42361622的博客
05-21 587
THE LITTLE C INTERPRETER表达式剖析器(THE EXPRESSION PARSER)读取和分析表达式的这部分代码叫做表达式剖析器。毫无疑问，表达式剖析器是C解释器中单一的最重要的部分。因为C语言定义表达式的方式比其他语言更加粗鄙，所以用大量的代码组成的C源文件来实现表达式剖析器。有几种不同的方式来设计C的表达式剖析器。许多商业的编译器用一种由parser-generator创...
类C语法脚本解释器
09-28
类C语法脚本解释器是一种程序，它能够读取并执行使用类似C语言语法的脚本。这样的解释器使得程序员可以使用他们熟悉的C语言结构来编写动态执行的脚本，而无需每次都进行编译和链接步骤。这在快速原型开发、自动化...
delphi编写的小型解释器
09-18
在IT领域，编程语言的解释器是至关重要的工具，它能读取并执行特定语言编写的脚本。本文将深入探讨使用Delphi编程环境构建小型解释器的过程，以及相关的关键技术点。 首先，我们要理解“解释器模式”。这是一种设计...
yufa.rar.rar_C语 言语 法分析器_Parser_c parser_c语言 语法分析器_语法分析器
09-24
总的来说，这个项目提供了一个学习和实践编译原理的好机会，通过构建C语言的语法分析器，可以加深对编程语言结构的理解，同时提升编程和问题解决能力。对于想要深入理解和开发编译器或解释器的程序员来说，这是一个...
update-script-interpreter:使用yacc和lex的更新程序脚本解释器的简单C语言
05-22
1. Yacc：Yacc是贝尔实验室开发的语法分析器生成器，它根据巴科斯范式（Bison，Yacc的开源版本）定义的语法规则生成C代码，这些C代码可以解析输入的源代码，并将其转化为抽象语法树（AST），为后续的编译或解释过程...
类C语言的脚本解析执行(使用C语言编写)
02-19
本组建主要用于在程序中解析预先编写的类C脚本，并依据脚本执行，可通过调用外部指针函数读入输入变量执行计算，最终得出计算结果写入输出变量中；用户可通过读取输出变量获取最终的结果。 脚本中可调用函数，函数分为系统函数和自定义函数两种；系统函数可直接调用；自定义函数需在脚本中自行定义
c语言写脚本6,C语言解释器的实现(6)--让脚本跑起来
weixin_39646107的博客
05-20 630
目录：在前面的文章中，我主要讲解了语言的解析部分，最终我们生产了脚本的中间代码。接下来，将是一个最困难的时刻，怎么解析执行中间代码！执行代码其实是经过一定处理后的中间代码的另外一种表示。正如前面提到的，我们的中间代码是三元组的形式，比如：c = a + b * c; 可以表示成 @1 = b * c; @2 = a + @1; @3 = c = @2;但是，这种中间代码还得经过一定的转换才能更方便...
只有140行代码的C语言解释器
zerokkqq的专栏
02-24 3612
【 以下文字转载自 CProgramming 讨论区 】 发信人: wax (ooo), 信区: CProgramming 标  题: 只有140行代码的C语言解释器 发信站: 水木社区 (Thu Feb 26 14:57:59 2015), 站内   https://github.com/xu4wang/recruit 里面有五道面试题。   源码的初始作者是： http://en.wikipe...
c语言解释器的实现,C语言解释器的实现-顺序（零）
weixin_42384735的博客
05-20 798
在编写CuteC文本编辑器时，为了使其具有脚本执行功能. 特意实现了一个简单的C语言解释器. 所谓的解释器是它解析并执行脚本文件c嵌入脚本解释器，并且不生成可执行的目标代码. 它几乎具有C语言的所有语法. 随着时间的推移，我计划将其开发为一个独立的项目. 在此过程中，我还学到了很多知识c嵌入脚本解释器，因此我打算与所有人分享. 尽管编写这些东西是重复发明轮子的问题，但这不是浪费生命. 好吧，程序员...
[脚本之间]C语言解析Python字典
二货磁铁
04-03 1805
这里我们简单说一些背景，就是突然想写一点用C去写Python库的东西，下面的这些方法和用法大部分参考官方介绍 Python中字典 从参数中获取 从参数中获取的情况一般有两种，一般是我们如果明确了传入类型就是字典，并且需要知道需要解析的key，那么可以采用如下的方式进行解析： static PyObject *my_func(PyObject* self, PyObject* a...
C语言解释器，用C语言脚本程序
weixin_34268579的博客
06-12 270
站点：http://www.softintegration.com/ 能用在哪些地方呢？ 转载于:https://www.cnblogs.com/qtchina/archive/2010/06/12/1757061.html
C语言程序解析
weixin_45743799的博客
02-17 3824
首先我们要有一段完整的代码。 #include <stdio.h> int main() { puts("Hello World"); return 0; } 下面我们对以上程序进行解析 函数的概念 先来看第 4 行代码，这行代码会在显示器上输出“Hello World”。前面我们已经讲过，puts 后面要带( )，字符串也要放在( )中。 在C语言中，有的语句使用时...
脚本、C语言笔记
cherylzy的博客
01-25 713
1.基本数据类型 整型int 整数，在目前绝大多数机器上占4个字节。TC环境中是2个字节 单精度实型float 单精度浮点数，一般是4个字节长 双精度实型double 双精度浮点数，一般是8个字节长 字符型char 字符，一般是1个字节长 用来表示256个ASCII字符，或者0~255的整数 枚举型enum 2.const，volatile修饰变量的时候表示什么意
JSP编程深度解析：生命周期、脚本元素与表达式语言
重点讲解了JSP脚本元素，包括使用`<%...%>`语法编写的Java代码块，以及输出表达式、注释和声明变量的用法。输出表达式允许动态生成文本，而注释则帮助开发者组织和解释代码。声明变量在页面范围内有效，且可能影响...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

初级代码游戏

知识究竟是有价还是无价

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值