/** * @file dl_script.h * @brief dl脚本语言 * * * @version 1.0 * @author lveyou * @date 24-05-30 * * @note 尽量不依赖dl的其他文件 */ #pragma once #include #include #include #include #include #include #include #include #include #include namespace dl { using ScriptIndex = uint32_t; using ScriptInt = int64_t; using ScriptFloat = double; using ScriptString = std::string; using ScriptIndexVS = uint8_t; // 变量空间下标 struct ScriptVar; class ScriptVM; using ScriptVector = std::vector; using ScriptTable = std::unordered_map; using ScriptParam = ScriptVector; using ScriptFunction = std::function; constexpr ScriptIndex SCRIPT_INDEX_RETURN = (ScriptIndex)-1; // 返回值 constexpr ScriptIndexVS SCRIPT_INDEX_VS_0 = 0; // 全局空间 constexpr ScriptIndexVS SCRIPT_INDEX_VS_ITERAL = (ScriptIndexVS)-3; // 字面量 constexpr ScriptIndexVS SCRIPT_INDEX_VS_TEMP = (ScriptIndexVS)-2; // 临时变量 constexpr ScriptIndexVS SCRIPT_INDEX_VS_ERROR = (ScriptIndexVS)-1; // 初始变量 //! 变量类型(用户层面) enum class ScriptVarType : ScriptIndex { E_null, // 空 E_int, // 整数 E_float, // 浮点 E_string, // 字符串 E_class, // 类 E_vector, // 数组 E_table, // 表 E_function, // 函数 E_userdata, // 指针 E_operator, // 操作符 E_max }; //! 是基础类型 inline bool IsBaseType(ScriptVarType type) { return type == ScriptVarType::E_null || type == ScriptVarType::E_int || type == ScriptVarType::E_float || type == ScriptVarType::E_userdata || type == ScriptVarType::E_operator; } //! 操作类型 enum class ScriptOperator : ScriptIndex { E_assign, // 赋值 E_add, // E_sub, E_mul, E_div, E_comma, // 逗号,视为 push_back E_equal, // == E_error }; std::string_view to_string(ScriptOperator op); //! 变量(大小严格控制) struct ScriptVar { friend class ScriptVarSpace; friend bool operator==(const ScriptVar& a, const ScriptVar& b); public: ScriptVar() { _type = ScriptVarType::E_null; _indexVarSpace = SCRIPT_INDEX_VS_ERROR; _value = 0; } void FromInt(ScriptInt v) { assert(_indexVarSpace != SCRIPT_INDEX_VS_ITERAL); _type = ScriptVarType::E_int; *(ScriptInt*)&_value = *(ScriptInt*)&v; } void FromFloat(ScriptFloat v) { assert(_indexVarSpace != SCRIPT_INDEX_VS_ITERAL); _type = ScriptVarType::E_float; *(ScriptFloat*)&_value = *(ScriptFloat*)&v; } void FromOperator(ScriptOperator v) { assert(_indexVarSpace != SCRIPT_INDEX_VS_ITERAL); _type = ScriptVarType::E_operator; *(ScriptOperator*)&_value = *(ScriptOperator*)&v; } ScriptInt ToInt() const { assert(_type == ScriptVarType::E_int); return (ScriptInt)_value; } ScriptFloat ToFloat() const { assert(_type == ScriptVarType::E_float); return (ScriptFloat)_value; } ScriptOperator ToOperator() const { assert(_type == ScriptVarType::E_operator); return (ScriptOperator)_value; } ScriptVarType GetType() const { return _type; } std::string_view GetTypeString() const; uint64_t GetValue() const { assert(IsBaseType(_type)); return _value; } uint64_t GetIndex() const { assert(!IsBaseType(_type)); return _value; } ScriptIndexVS GetSpaceIndex() const { return _indexVarSpace; } void SetValue(uint64_t v) { assert(IsBaseType(_type)); assert(_indexVarSpace != SCRIPT_INDEX_VS_ITERAL); _value = v; } void SetType(ScriptVarType type) { assert(_type == ScriptVarType::E_null); _type = type; } void _set_space_index(ScriptIndexVS index) { _indexVarSpace = index; } private: ScriptVarType _type; ScriptIndexVS _indexVarSpace; // 所在变量空间(基础类型需要释放,也需要标记) uint64_t _value; // 基础类型直接存储(或变量下标) }; inline bool operator==(const ScriptVar& a, const ScriptVar& b) { return a._type == b._type && a._indexVarSpace == b._indexVarSpace && a._value == b._value; } // 初步token(文本解析) struct ScriptToken { enum Type { NORMAL, STRING, OPERATOR,// 操作符 }; ScriptToken() : _type{ Type::NORMAL } {} ScriptToken(Type type, std::string_view str) : _type{ type }, _str{ std::string{str} } {} Type _type; std::string _str; }; std::string_view to_string(ScriptToken::Type type); //! 表达式token类型 enum class ScriptExprTokenType { ESET_variable, // 变量 ESET_literal, // 字面量 ESET_operator, // }; //! 表达式token(指向真实变量) struct ScriptExprToken { ScriptExprTokenType _type; // 类别 std::string _name; // 字符串内容(变量使用) ScriptVar _value; // 值(表达式用、字面量) std::string GetTypeString() const { return "expr_token"; } }; //! 后缀表达式 struct ScriptExpr { std::vector _allToken; size_t _lineNumber; // 行号(0开始) std::string _strRaw;// 源代码,调试用 }; inline std::string to_string(const ScriptExpr& expr) { if (expr._allToken.empty()) return {}; std::string ret; for (size_t i = 0; i < expr._allToken.size() - 1; ++i) { ret += expr._allToken[i]._name; ret += ' '; } ret += expr._allToken[expr._allToken.size() - 1]._name; return ret; } //! 变量空间 class ScriptVarSpace { public: ScriptVarSpace(ScriptIndexVS index, size_t level) : _index{ index }, _level{ level } {} ScriptIndexVS GetIndex() const { return _index; } size_t GetLevel() const { return _level; } ScriptVar AddString(std::string_view v) { ScriptVar ret; ret._type = ScriptVarType::E_string; ret._indexVarSpace = _index; ret._value = _vecString.size(); _vecString.push_back(std::string{ v }); return ret; } ScriptVar AddFunction(ScriptFunction v) { ScriptVar ret; ret._type = ScriptVarType::E_function; ret._indexVarSpace = _index; ret._value = _vecFunction.size(); _vecFunction.push_back(v); return ret; } ScriptVar AddVector() { ScriptVar ret; ret._type = ScriptVarType::E_vector; ret._indexVarSpace = _index; ret._value = _vecVector.size(); _vecVector.push_back({}); return ret; } void SetString(size_t i, const ScriptString& str) { _vecString[i] = str; } void SetVector(size_t i, const ScriptVector& vec) { _vecVector[i] = vec; } const ScriptString& GetString(size_t i) const { return _vecString[i]; } const ScriptFunction& GetFunction(size_t i) const { return _vecFunction[i]; } ScriptVector& GetVetorRef(size_t i) { return _vecVector[i]; } private: ScriptIndexVS _index; // 自己下标 0全局变量 size_t _level; std::vector _vecString; std::vector _vecClass; std::vector _vecVector; std::vector _vecTable; std::vector _vecFunction; std::vector _vecExpr; }; enum class ScriptSegmentType : ScriptIndex { E_expr, E_if, E_ifelse, E_else, E_while, E_for, E_vector, E_table, }; //! 代码段(包含单独作用域) struct ScriptSegment { ScriptSegmentType _type; size_t _level; // 层级(作用域) std::vector _allExpr; }; //! 代码块 struct ScriptBlock { ScriptBlock() : _varSpaceIteral{ SCRIPT_INDEX_VS_ITERAL, 0 } {} std::vector _allSeg; // 字面量是编译器固定的,不可修改,全局可见,所以单独处理 ScriptVarSpace _varSpaceIteral; std::vector _vecSource;// 不包含换行 std::string GetSource(bool line_number = true, bool header = true, bool footer = true) const; }; //! 控制语句 struct ScriptControlIf { ScriptExpr _cond; ScriptSegment _seg; }; struct ScriptControlIfElse { ScriptExpr _cond; ScriptSegment _seg; }; struct ScriptControlElse { ScriptExpr _cond; ScriptSegment _seg; }; struct ScriptControlFor { std::array _cond; ScriptSegment _seg; }; struct ScriptControlWhile { ScriptExpr _cond; ScriptSegment _seg; }; //! 代码段运行时 struct ScriptSegmentRT { //std:: }; //! 虚拟机 class ScriptVM { friend class ScriptSystem; public: void Execute(const ScriptBlock& block); // 变量转字符串 std::string Variable2String(const ScriptVar& var); // 变量转bool bool Variable2Bool(const ScriptVar& var); // 中断执行(内部调用) void Throw() { _bThrow = true; } ScriptVM(); private: // 当前执行代码块 const ScriptBlock* _block; // 名字 -> 变量(变量) std::unordered_map _allVar; // 全局变量空间 ScriptVarSpace _varSpaceGlobal; // 变量空间 std::vector _allVarSpace; // 函数参数 ScriptParam _param; //-------------------------------expr------------------------------ // 返回值(可变) ScriptExprToken _return; // 操作堆栈 std::vector _stackVar; // 当前表达式 const ScriptExpr* _expr; // 临时变量空间 ScriptVarSpace _varSpaceTemp; //todo清理 // 出现异常 bool _bThrow; void _exec_expr(const ScriptExpr& expr); void _clear_expr(); // 从 操作堆栈 访问 const ScriptExprToken& _get_stack_expr_token(size_t i); const ScriptExprToken& _get_stack_expr_token_top(size_t i); ScriptVar& _get_stack_var(size_t i); ScriptVar& _get_stack_var_top(size_t i); void _stack_pop(size_t i); void _op_arithmetic(ScriptOperator op); void _op_assign(); void _op_comma(); void _op_equal(); // 获取(新建)变量,新建则在当前变量空间初始化 ScriptVar& _get_variable(const ScriptExprToken& var0); // 移除变量空间后,从变量表中移除 void _delete_var_space(ScriptVarSpace* vs); // 返回变量所在空间 ScriptVarSpace* GetVariableSpaceRef(ScriptIndexVS index); const ScriptVarSpace* GetVariableSpace(ScriptIndexVS index); ScriptVarSpace* GetVariableSpaceRef(ScriptVar var) { return GetVariableSpaceRef(var.GetSpaceIndex()); } const ScriptVarSpace* GetVariableSpace(ScriptVar var) { return GetVariableSpace(var.GetSpaceIndex()); } //------------------------------------变量创建(默认值)-------------- ScriptVar AddVariable(ScriptIndexVS index, ScriptVarType type); //------------------------------------变量获取(必须已存在)-------------- ScriptFunction GetVariableFunction(ScriptVar var); ScriptString GetVariableString(ScriptVar var); ScriptVector& GetVariableVector(ScriptVar var); //------------------------------------变量设置(必须已存在)-------------- void SetVariableString(ScriptVar var, ScriptString str); void SetVariableVector(ScriptVar var, const ScriptVector& vec); }; //! 管理器 class ScriptSystem { public: ScriptBlock Compile(std::string_view src); // 中缀 -> 后缀(逆波兰表达式) std::vector ConvertMid(const std::vector& vec); //! 预处理代码(行号不变) std::string Preprocess(std::string_view src); void PreprocessLineNumber(ScriptBlock& block, std::string_view src); //! 是否操作符 bool IsOperator(std::string_view str); //! 是否可能为操作符内容(变量名不可能出现) bool IsMaybeOperator(char ch); //! 返回操作符优先级,越大越优先 int GetOperatorPriority(std::string_view str); //! 是否关键字 bool IsKeyword(std::string_view str); //! 是否变量名 bool IsVariable(std::string_view str); //! 是否全局变量名 bool IsGlobalVariable(std::string_view str); //! 返回token类型 ScriptExprTokenType GetTokenType(std::string_view str); //! 生成表达式token(字面量是编译器信息,需要生成到block) ScriptExprToken MakeExprToken(ScriptBlock& block, const ScriptToken& token); //! 生成字面量 ScriptVar MakeLiteral(ScriptBlock& block, const ScriptToken& token); //! 注册函数 void RegisterFunction(std::string_view name, ScriptFunction func) { ScriptVar var = _varSpaceGlobal.AddFunction(func); _allVar[std::string{ name }] = var; } void CopyVariableToVm(ScriptVM& vm) { vm._allVar = _allVar; vm._varSpaceGlobal = _varSpaceGlobal; } bool CheckToken(ScriptExprTokenType type); //! 字符串转操作符变量 ScriptOperator String2Operator(std::string_view str); //------------------------------------基础运算(不考虑变量)----------------------- ScriptVar OpArithmetic(ScriptVM& vm, ScriptOperator op, const ScriptVar& v0, const ScriptVar& v1); void OpAssign(ScriptVM& vm, ScriptVar& v0, const ScriptVar& v1); ScriptSystem(); private: // 关键字 std::unordered_map _allKeyword; // 操作符、优先级(越大越优先) std::unordered_map _allOperator; // 变量空间池 std::list _listVarSpaceFree; // 内置变量(例print) std::unordered_map _allVar; // 内置变量空间(全局) ScriptVarSpace _varSpaceGlobal; }; extern ScriptSystem* g_script; }