/** * @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 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_NAG_1 = (ScriptIndex)-1; // 返回值 constexpr ScriptIndexVS SCRIPT_INDEX_VS_0 = 0; // 全局空间 constexpr ScriptIndexVS SCRIPT_INDEX_VS_NAG_1 = (ScriptIndexVS)-1; // 字面量 constexpr ScriptIndexVS SCRIPT_INDEX_VS_NAG_2 = (ScriptIndexVS)-2; // 临时变量 //! 变量类型(用户层面) 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 }; //! 操作类型 enum class ScriptOperator : ScriptIndex { E_assign, // 赋值 E_add, // E_sub, E_mul, E_div, }; std::string_view to_string(ScriptOperator op); //! 变量(大小严格控制) struct ScriptVar { public: ScriptVar() { _type = ScriptVarType::E_null; } void FromInt(ScriptInt v) { _type = ScriptVarType::E_int; *(ScriptInt*)&_value = *(ScriptInt*)&v; } void FromFloat(ScriptFloat v) { _type = ScriptVarType::E_float; *(ScriptFloat*)&_value = *(ScriptFloat*)&v; } void FromOperator(ScriptOperator v) { _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; public: ScriptVarType _type; ScriptIndexVS _indexVarSpace; // 所在变量空间(基础类型需要释放,也需要标记) uint64_t _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 _str; // 字符串内容(变量使用) 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]._str; ret += ' '; } ret += expr._allToken[expr._allToken.size() - 1]._str; 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; } const ScriptString& GetString(size_t i) const { return _vecString[i]; } const ScriptFunction& GetFunction(size_t i) const { return _vecFunction[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_NAG_1, 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; // 字面量 ScriptVar _varIiteral; //-------------------------------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(); // 获取(新建)变量,新建则在当前变量空间初始化 ScriptVar& _get_variable(const ScriptExprToken& var0); // 移除变量空间后,从变量表中移除 void _delete_var_space(ScriptVarSpace* vs); //------------------------------------变量获取-------------------------------- ScriptFunction GetVariableFunction(ScriptVar var); ScriptString GetVariableString(ScriptVar var); }; //! 管理器 class ScriptSystem { public: ScriptBlock Compile(std::string_view src); //! 预处理代码(行号不变) 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; }