dl_script.h

浏览该文件的文档.

#pragma once
 
#include <vector>
#include <list>
#include <unordered_map>
#include <functional>
#include <string>
#include <cassert>
#include <stack>
#include <variant>
#include <array>
 
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<ScriptVar>;
    using ScriptTable = std::unordered_map<std::string, ScriptVar>;
    using ScriptParam = ScriptVector;
    using ScriptFunction = std::function<int(ScriptVM&, const ScriptParam&)>;
 
    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);

    enum class ScriptExprTokenType
    {
        ESET_variable, // 变量
        ESET_literal,   // 字面量
        ESET_operator, // 
    };

    struct ScriptExprToken
    {
        ScriptExprTokenType _type;  // 类别
        std::string _name;         // 字符串内容（变量使用）
        ScriptVar _value;            // 值（表达式用、字面量）
 
        std::string GetTypeString() const
        {
            return "expr_token";
        }
    };

    struct ScriptExpr
    {
        std::vector<ScriptExprToken> _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<ScriptString> _vecString;
        std::vector<ScriptTable> _vecClass;
        std::vector<ScriptVector> _vecVector;
        std::vector<ScriptTable> _vecTable;
        std::vector<ScriptFunction> _vecFunction;
        std::vector<ScriptExpr> _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<ScriptExpr> _allExpr;
    };

    struct ScriptBlock
    {
        ScriptBlock() :
            _varSpaceIteral{ SCRIPT_INDEX_VS_ITERAL, 0 }
        {}
 
        std::vector<ScriptSegment> _allSeg;
        // 字面量是编译器固定的，不可修改，全局可见，所以单独处理
        ScriptVarSpace _varSpaceIteral;
        std::vector<std::string> _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<ScriptExpr, 3> _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<std::string, ScriptVar> _allVar;
        // 全局变量空间
        ScriptVarSpace _varSpaceGlobal;
        // 变量空间
        std::vector<ScriptVarSpace*> _allVarSpace;
        // 函数参数
        ScriptParam _param;
 
        //-------------------------------expr------------------------------
        // 返回值（可变）
        ScriptExprToken _return;
        // 操作堆栈
        std::vector<ScriptIndex> _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<ScriptExprToken> ConvertMid(const std::vector<ScriptExprToken>& 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);

        ScriptExprTokenType GetTokenType(std::string_view str);

        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<std::string_view, int> _allKeyword;
        // 操作符、优先级（越大越优先）
        std::unordered_map<std::string_view, int> _allOperator;
        // 变量空间池
        std::list<ScriptVarSpace*> _listVarSpaceFree;
        // 内置变量（例print）
        std::unordered_map<std::string, ScriptVar> _allVar;
        // 内置变量空间（全局）
        ScriptVarSpace _varSpaceGlobal;
    };
 
    extern ScriptSystem* g_script;
}