#include "dl_script.h" #include #include "io/dl_log.h" #include "base/dl_string.h" namespace dl { enum class ScriptLogType { E_debug, E_info, E_err, // 用户错误 E_damage, // 引擎bug E_compile, }; void script_print(ScriptLogType type, std::string_view str) { switch (type) { case ScriptLogType::E_debug: log_msg("script:【调试】 {}", str); break; case ScriptLogType::E_info: log_msg("script:【提示】 {}", str); break; case ScriptLogType::E_err: log_warn("script:【错误】 {}", str); break; case ScriptLogType::E_damage: log_err("script:【严重错误】 {}", str); break; case ScriptLogType::E_compile: log_err("script:【编译错误】 {}", str); break; default: assert(0); break; } } struct Token { enum Type { NORMAL, STRING, LBRACE, // 括号类 RBRACE, }; Token() : _type{ Type::NORMAL } {} Token(Type type, std::string_view str) : _type{ type }, _str{ std::string{str} } {} Type _type; std::string _str; }; ScriptBlock ScriptSystem::Compile(std::string_view src) { script_print(ScriptLogType::E_debug, fmt::format("{:=^32}", "开始编译脚本")); script_print(ScriptLogType::E_debug, fmt::format("源:\n{}", src)); ScriptBlock ret; std::vector& vec_seg = ret._allSeg; std::size_t beg = 0; std::size_t end = 0; std::vector vec_token; // 括号层级 size_t level_brace = 0; enum class State { FREE,// 空闲 NORMAL,// 单词匹配 STRING,// 字符串 }; State state = State::FREE; // 构造当前 auto fn_string = [&]() { #if DL_PLATFORM == DL_PLATFORM_WIN32 return std::string_view{ src.begin() + beg, src.begin() + end }; #else return std::string_view{ str.begin(), end - beg }; #endif }; // 构造word auto fn_make_word = [&](Token::Type type) { std::string_view word = fn_string(); if (!word.empty()) { script_print(ScriptLogType::E_debug, fmt::format("匹配到token{}:[{}]", (int)type, word)); vec_token.push_back({ type, word }); } }; // 一段完成 auto fn_segment = [&]() { script_print(ScriptLogType::E_debug, fmt::format("代码段完成,词数量 {}", vec_token.size())); if (vec_token.empty()) { log_warn("空代码段!"); return; } vec_seg.push_back({}); ScriptSegment& seg = vec_seg.back(); // 例:print a + b // 1、函数视为变量 // 2、若变量后不是操作符,则添加 call 视为函数调用 // 3、检查是否合法中缀表达式 size_t i = 0; std::vector vec_mid; for (Token& token : vec_token) { ScriptExprToken expr = MakeExprToken(token._str, ret); vec_mid.push_back(expr); //script_print(ScriptLogType::E_debug, fmt::format("{}: {}", (int)token._type, token._str)); //if (i == 0) //{ // if (token._str == "if") // { // } // else // {// 变量 // } //} //seg._expr._allVar.push_back(token.) } vec_token.clear(); // 4、转为后缀表达式 std::stack s; for (ScriptExprToken& expr : vec_mid) { // 从左到右扫描中缀表达式的每个字符。如果遇到操作数(如数字),则直接将其输出。 if (expr._type != ScriptExprTokenType::ESET_operator) { s.push(expr); } else { /*如果遇到操作符,根据其优先级进行处理: 如果栈为空或该操作符的优先级高于栈顶的操作符,直接将其压入栈中。 如果该操作符的优先级低于栈顶的操作符,则将栈顶的操作符弹出并输出,直到栈顶的操作符优先级小于或等于当前操作符。 然后将当前操作符压入栈中。*/ //if (s.empty() || s.top(). } } // 首token //std::string_view t0 = vec_token[0]._str; //size_t num_token = vec_token.size(); //if (t0.empty()) //{ // script_print(ScriptLogType::E_compile, fmt::format("首字为空!")); // return; //} //bool is_keyword = g_script->IsKeyword(t0); //if (is_keyword) //{ //} //else //{ // if (num_token > 2) // { // std::string_view t1 = vec_token[1]._str; // std::string_view t2 = vec_token[2]._str; // seg._type = ScriptSegmentType::E_expr; // seg._expr._allToken.resize(3); // seg._expr._allToken[0] = MakeExprToken(t0, ret); // seg._expr._allToken[1] = MakeExprToken(t2, ret); // //if(g_script->IsVariable(t0)) // seg._expr._allToken[2] = MakeExprToken(t1, ret); // } //} // //vec_token.clear(); }; while (true) { char ch = src[end]; switch (state) { case State::FREE: {// 空闲状态,跳过空白字符 if (ch == ' ' || ch == '\t' || ch == '\n') { ++beg; ++end; } else { state = State::NORMAL; ++end; } } break; case State::NORMAL: {// 普通字符则继续, if (ch == ' ' || ch == '\t' || ch == '\n') { fn_make_word(Token::Type::NORMAL); if (ch == '\n' && level_brace == 0) { fn_segment(); // 解析代码段 } ++end; beg = end; } else if (ch == '\'' || ch == '\"') { state = State::STRING; ++beg; ++end; } else if (ch == '(' || ch == '{' || ch == '[') { fn_make_word(Token::Type::LBRACE); ++level_brace; } else if (ch == ')' || ch == '}' || ch == ']') { fn_make_word(Token::Type::RBRACE); if (level_brace == 0) { script_print(ScriptLogType::E_compile, fmt::format("括号数量不匹配,右括号数量过多!")); return {}; } else if (level_brace == 1) { fn_segment(); ++end; beg = end; } else ++end; --level_brace; } else ++end; } break; case State::STRING: { if (ch == '\'' || ch == '\"') { fn_make_word(Token::Type::STRING); ++end; beg = end; state = State::NORMAL; } else ++end; } break; default: break; } if (end >= src.size()) { fn_make_word(Token::Type::NORMAL); if(!vec_token.empty()) fn_segment(); break; } } script_print(ScriptLogType::E_debug, fmt::format("{:=^32}", "词法分析完成")); return ret; } bool ScriptSystem::IsOperator(std::string_view str) { return _allOperator.contains(std::string{ str }); } bool ScriptSystem::IsKeyword(std::string_view str) { return _allKeyword.contains(std::string{ str }); } bool ScriptSystem::IsVariable(std::string_view str) { /*变量名称只能使用字母、数字和下划线。 第一个字符必须是字母或下划线,因为C++不允许数字作为变量名的首字符。 区分大小写,即变量name和Name是不同的。 避免使用C++的关键字和保留字作为变量名。*/ assert(!str.empty()); if (!std::isalpha(str[0]) && str[0] != '_') return false; for (auto& iter : str) { if (iter != '_' && !std::isalpha(iter) && !std::isdigit(iter)) return false; } return true; } dl::ScriptExprTokenType ScriptSystem::GetTokenType(std::string_view str) { if (IsOperator(str)) return ScriptExprTokenType::ESET_operator; else if (IsVariable(str)) return ScriptExprTokenType::ESET_variable; else return ScriptExprTokenType::ESET_literal; } dl::ScriptExprToken ScriptSystem::MakeExprToken(std::string_view str, ScriptBlock& block) { ScriptExprToken ret; ret._type = GetTokenType(str); switch (ret._type) { case dl::ScriptExprTokenType::ESET_variable: ret._str = str; break; case dl::ScriptExprTokenType::ESET_literal: ret._str = str; ret._value = {};//block String2Literal(str); break; case dl::ScriptExprTokenType::ESET_operator: ret._str = str; ret._value = String2Operator(str); break; default: break; } return ret; } dl::ScriptVar ScriptSystem::MakeLiteral(std::string_view str) { return {}; } dl::ScriptOperator ScriptSystem::String2Operator(std::string_view str) { if (str == "=") return ScriptOperator::E_assign; if (str == "+") return ScriptOperator::E_add; if (str == "-") return ScriptOperator::E_sub; if (str == "*") return ScriptOperator::E_mul; if (str == "/") return ScriptOperator::E_div; return {}; } dl::ScriptVar ScriptSystem::OpAdd(const ScriptVar& v0, const ScriptVar& v1) { if (v0._type == ScriptVarType::E_int) { ScriptInt vv0 = v0.ToInt(); if (v1._type == ScriptVarType::E_int) { ScriptInt vv1 = v1.ToInt(); return vv0 + vv1; } } } ScriptSystem::ScriptSystem() { _allKeyword["function"] = 0; _allKeyword["param"] = 0; _allKeyword["typeof"] = 0; _allKeyword["is_null"] = 0; _allKeyword["operator"] = 0; _allKeyword["return"] = 0; _allKeyword["new"] = 0; _allKeyword["if"] = 0; _allKeyword["elseif"] = 0; _allKeyword["else"] = 0; _allKeyword["while"] = 0; _allKeyword["for"] = 0; _allKeyword["goto"] = 0; _allOperator["+"] = 0; _allOperator["-"] = 0; _allOperator["*"] = 0; _allOperator["/"] = 0; _allOperator["="] = 0; } void ScriptVM::Execute(const ScriptBlock& block) { script_print(ScriptLogType::E_info, fmt::format("开始执行代码块:{}", block._name)); _block = █ size_t cur = 0; while (cur < block._allSeg.size()) { const ScriptSegment& seg = block._allSeg[cur]; switch (seg._type) { case ScriptSegmentType::E_expr: _exec_expr(seg._expr); break; case ScriptSegmentType::E_if: break; case ScriptSegmentType::E_ifelse: break; case ScriptSegmentType::E_else: break; case ScriptSegmentType::E_while: break; case ScriptSegmentType::E_for: break; default: script_print(ScriptLogType::E_damage, fmt::format("未知代码段类型:{}行,{}", seg._lineNumber, (int)seg._type)); return; } ++cur; } _block = nullptr; script_print(ScriptLogType::E_info, fmt::format("完成执行代码块:{}", block._name)); } /*switch (seg._expr._op) { case ScriptExprOperator::E_add: break; case ScriptExprOperator::E_sub: break; case ScriptExprOperator::E_mul: break; case ScriptExprOperator::E_div: break; default: script_print(ScriptLogType::E_compile, fmt::format("未知操作符:{}", block._name)); break; }*/ void ScriptVM::_exec_expr(const ScriptExpr& expr) { const std::vector& vec_token = expr._allToken; std::stack stack_var; ScriptVar var_ret; for (size_t i = 0; i < vec_token.size(); ++i) { const ScriptExprToken& token = vec_token[i]; if (token._type == ScriptExprTokenType::ESET_operator) { ScriptOperator op = token._value.ToOperator(); switch (op) { case ScriptOperator::E_assign: var_ret = _op_assign(vec_token, stack_var); break; case ScriptOperator::E_add: var_ret = _op_add(vec_token, stack_var); break; case ScriptOperator::E_sub: //break; case ScriptOperator::E_mul: //break; case ScriptOperator::E_div: //break; default: script_print(ScriptLogType::E_damage, fmt::format("未知操作符:{}", (int)op)); break; } } else { stack_var.push((ScriptIndex)i); } } } ScriptVar ScriptVM::_op_add(const std::vector& vec_token, std::stack& stack_var) { if (stack_var.size() < 2) { script_print(ScriptLogType::E_damage, fmt::format("操作数量不匹配:add,{}", 2)); return {}; } ScriptIndex v0 = stack_var.top(); stack_var.pop(); ScriptIndex v1 = stack_var.top(); stack_var.pop(); const ScriptExprToken& var0 = vec_token[v0]; const ScriptExprToken& var1 = vec_token[v1]; if(var0._type == ScriptExprTokenType::ESET_literal) { if (var1._type == ScriptExprTokenType::ESET_literal) { stack_var.push(SCRIPT_INDEX_NAG_1); return g_script->OpAdd(var0._value, var1._value); } else if(var1._type == ScriptExprTokenType::ESET_variable) { stack_var.push(SCRIPT_INDEX_NAG_1); return g_script->OpAdd(var0._value, var1._value); } else { script_print(ScriptLogType::E_damage, fmt::format("右操作数不是变量或字面量:add,{}", var1._str)); return {}; } } else { goto error; } error: script_print(ScriptLogType::E_damage, fmt::format("不能执行操作:add,{}, {}", var0.GetTypeString(), var1.GetTypeString())); return {}; } dl::ScriptVar ScriptVM::_op_assign(const std::vector& vec_token, std::stack& stack_var) { if (stack_var.size() < 2) { script_print(ScriptLogType::E_damage, fmt::format("操作数量不匹配:assign,{}", 2)); return {}; } ScriptIndex v1 = stack_var.top(); stack_var.pop(); ScriptIndex v0 = stack_var.top(); stack_var.pop(); const ScriptExprToken& t0 = vec_token[v0]; const ScriptExprToken& t1 = vec_token[v1]; if (t0._type != ScriptExprTokenType::ESET_variable) { goto error; } { ScriptVar var0 = _get_variable(t0); ScriptVar var1 = _get_variable(t1); var0 = var1; return var0; } error: script_print(ScriptLogType::E_damage, fmt::format("不能执行操作:assign,{}, {}", t0.GetTypeString(), t1.GetTypeString())); return {}; } dl::ScriptVar ScriptVM::_get_variable(const ScriptExprToken& t) { if (t._type == ScriptExprTokenType::ESET_literal) {// 字面量 return t._value; } auto iter = _allVar.find(t._str); if (iter == _allVar.end()) { // 新建 ScriptVar& var = _allVar[t._str]; return var; } return _allVar[t._str]; //if (var0._type == ScriptExprTokenType::ESET_literal) //{ // // // return {}; //} //else if (var0._type == ScriptExprTokenType::ESET_variable) //{ // if (var0._str.size() > 2 // && var0._str[0] == 'g' && var0._str[1] == '_') // { // var0. // } //} } std::string_view ScriptVar::GetTypeString() const { switch (_type) { case dl::ScriptVarType::E_null: return "null"; case dl::ScriptVarType::E_int: return "int"; case dl::ScriptVarType::E_float: return "float"; case dl::ScriptVarType::E_string: return "string"; case dl::ScriptVarType::E_class: return "class"; case dl::ScriptVarType::E_vector: return "vector"; case dl::ScriptVarType::E_table: return "table"; case dl::ScriptVarType::E_function: return "function"; case dl::ScriptVarType::E_userdata: return "userdata"; case dl::ScriptVarType::E_operator: return "operator"; case dl::ScriptVarType::E_max: default: script_print(ScriptLogType::E_damage, fmt::format("错误的变量类型:{}", (int)_type)); return "error"; } } }