Files
dl_old/dl/script/dl_script.cpp
T
2024-06-28 03:55:45 +08:00

796 lines
18 KiB
C++
Raw Blame History

This file contains ambiguous Unicode characters
This file contains Unicode characters that might be confused with other characters. If you think that this is intentional, you can safely ignore this warning. Use the Escape button to reveal them.
#include "dl_script.h"
#include <cassert>
#include "io/dl_log.h"
#include "base/dl_string.h"
namespace dl
{
enum class ScriptLogType
{
E_print, // 调用打印
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_print:
log_info("script:{}", str);
break;
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;
}
}
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;
ret._name = src;
ret._varSpaceIteral._index = SCRIPT_INDEX_VS_NAG_1;
std::vector<ScriptSegment>& vec_seg = ret._allSeg;
std::size_t beg = 0;
std::size_t end = 0;
std::vector<ScriptToken> 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 = [&](ScriptToken::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<ScriptExprToken> vec_mid;
// token 转 表达式
for (ScriptToken& token : vec_token)
{
ScriptExprToken expr = MakeExprToken(ret, token);
vec_mid.push_back(expr);
}
vec_token.clear();
// 4、转为后缀表达式
// 初始化:创建一个空栈用于存放运算符,以及一个空列表或向量用于存放最终的后缀表达式。
std::vector<ScriptExprToken>& vec_out = seg._expr._allToken;
std::stack<ScriptExprToken> s;
// 遍历中缀表达式:从左到右遍历中缀表达式的每一个元素。
for (ScriptExprToken& expr : vec_mid)
{
// 如果当前元素是操作数(如数字、变量等非运算符),直接将其添加到后缀表达式的列表中。
if (expr._type != ScriptExprTokenType::ESET_operator)
{
vec_out.push_back(expr);
}
else if (s.empty())
{// 如果栈为空或者当前运算符的优先级高于栈顶运算符,将当前运算符压入栈中。
s.push(expr);
}
else
{
ScriptExprToken& expr_top = s.top();
int p_new = GetOperatorPriority(expr._str);
int p_top = GetOperatorPriority(expr_top._str);
if (p_new < p_top)
{
s.push(expr);
}
else if (p_new == p_top)
{
vec_out.push_back(expr_top);
s.pop();
s.push(expr);
}
else
{
while (true)
{
vec_out.push_back(expr_top);
s.pop();
if (s.empty())
break;
ScriptExprToken& expr_top = s.top();
p_top = GetOperatorPriority(expr_top._str);
if (p_top > p_new)
break;
}
s.push(expr);
}
}
}
// 处理剩余栈内运算符:
// 遍历结束后,如果栈中还有剩余的运算符,将它们全部弹出并追加到后缀表达式的末尾。
// 这是因为这些运算符没有遇到更低优先级的运算符,按照运算符的顺序应该在表达式的最后。
while (!s.empty())
{
vec_out.push_back(s.top());
s.pop();
}
/*注意事项:
需要定义一个函数来确定每个运算符的优先级。
空格和括号在实际处理时可能需要特殊考虑,尤其是处理括号时,遇到左括号直接入栈,遇到右括号则弹出栈顶运算符直到遇到左括号对应的符号。
对于一元运算符,如负号 - 作为负数标志或逻辑非 !,需要特别处理规则,确保正确识别其作用。*/
// 打印
script_print(ScriptLogType::E_debug, "中缀表达式为:");
for (ScriptExprToken& expr : vec_out)
{
script_print(ScriptLogType::E_debug, expr._str);
}
int x = 3;
};
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(ScriptToken::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(ScriptToken::Type::LBRACE);
++level_brace;
}
else if (ch == ')' || ch == '}' || ch == ']')
{
fn_make_word(ScriptToken::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(ScriptToken::Type::STRING);
++end;
beg = end;
state = State::NORMAL;
}
else
++end;
}
break;
default:
break;
}
if (end >= src.size())
{
fn_make_word(ScriptToken::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(str);
}
int ScriptSystem::GetOperatorPriority(std::string_view str)
{
auto iter = _allOperator.find(str);
if (iter == _allOperator.end())
return INT_MAX;
return iter->second;
}
bool ScriptSystem::IsKeyword(std::string_view str)
{
return _allKeyword.contains(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;
}
bool ScriptSystem::IsGlobalVariable(std::string_view str)
{
return str.size() > 2
&& str[0] == 'g'
&& str[1] == '_';
}
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(ScriptBlock& block, const ScriptToken& token)
{
ScriptExprToken ret;
ret._type = GetTokenType(token._str);
switch (ret._type)
{
case dl::ScriptExprTokenType::ESET_variable:
ret._str = token._str;
break;
case dl::ScriptExprTokenType::ESET_literal:
ret._str = token._str;
ret._value = MakeLiteral(block, token);
break;
case dl::ScriptExprTokenType::ESET_operator:
ret._str = token._str;
ret._value.FromOperator(String2Operator(token._str));
break;
default:
break;
}
return ret;
}
ScriptVar ScriptSystem::MakeLiteral(ScriptBlock& block, const ScriptToken& token)
{
ScriptVar ret;
if (token._type == ScriptToken::STRING)
ret = block._varSpaceIteral.AddString(token._str);
else
{// 字面量类型有限 数字、字符串、表
StringType type = String::GetType(token._str);
switch (type)
{
case StringType::NORMAL:
assert(0);
case StringType::INTGER:
ret.FromInt(std::stoi(token._str));
break;
case StringType::FLOAT:
ret.FromFloat(std::stof(token._str));
break;
default:
assert(0);
}
}
return ret;
}
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)
{
ScriptVar ret;
if (v0._type == ScriptVarType::E_int)
{
ScriptInt vv0 = v0.ToInt();
if (v1._type == ScriptVarType::E_int)
{
ScriptInt vv1 = v1.ToInt();
ret.FromInt(vv0 + vv1);
}
}
return ret;
}
void ScriptSystem::OpAssign(ScriptVar& v0, const ScriptVar& v1)
{
if (v0._type == ScriptVarType::E_null)
{
v0 = v1;
}
else if (v0._type == ScriptVarType::E_int)
{
if (v1._type == ScriptVarType::E_int)
{
ScriptInt vv1 = v1.ToInt();
v0.FromInt(vv1);
}
else if (v1._type == ScriptVarType::E_float)
{
ScriptFloat vv1 = v1.ToFloat();
v0.FromInt((ScriptInt)vv1);
}
}
else if (v0._type == ScriptVarType::E_float)
{
if (v1._type == ScriptVarType::E_int)
{
ScriptInt vv1 = v1.ToInt();
v0.FromFloat((ScriptFloat)vv1);
}
else if (v1._type == ScriptVarType::E_float)
{
ScriptFloat vv1 = v1.ToFloat();
v0.FromFloat(vv1);
}
}
}
int ex_script_print(ScriptVM& vm, ScriptParam param)
{
script_print(ScriptLogType::E_print, vm.Variable2String(param[0]));
return 0;
}
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["*"] = 10;
_allOperator["/"] = 10;
_allOperator["="] = 20;
_varSpaceGlobal._index = 0;
RegisterFunction("print", ex_script_print);
}
void ScriptVM::Execute(const ScriptBlock& block)
{
script_print(ScriptLogType::E_info, fmt::format("开始执行代码块:{}", block._name));
// 记录代码块
_block = &block;
size_t cur = 0;
while (cur < block._allSeg.size())
{
const ScriptSegment& seg = block._allSeg[cur];
ScriptVarSpace* var_space = new ScriptVarSpace;
var_space->_index = _allVarSpace.size();
_allVarSpace.push_back(var_space);
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;
}
delete _allVarSpace.back();
_allVarSpace.pop_back();
++cur;
}
// 变量空间出栈
_block = nullptr;
script_print(ScriptLogType::E_info, fmt::format("完成执行代码块:{}", block._name));
}
ScriptVM::ScriptVM()
{
g_script->CopyVariableToVm(*this);
_allVarSpace.push_back(&_varSpaceGlobal);
_param.resize(16);
}
void ScriptVM::_exec_expr(const ScriptExpr& expr)
{
_expr = &expr;
_stackVar.clear();
const std::vector<ScriptExprToken>& vec_token = _expr->_allToken;
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:
_op_assign();
break;
case ScriptOperator::E_add:
_op_add();
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
{
_stackVar.push_back((ScriptIndex)i);
}
}
// 剩余栈处理
if (_stackVar.size() == 0)
;
if (_stackVar.size() == 1)
;
else if (_stackVar.size() == 2)
{
ScriptVar& var0 = _get_stack_var(0);
ScriptVar& var1 = _get_stack_var(1);
_stack_pop(2);
ScriptFunction func = GetVariableFunction(var0);
_param[0] = var1;
func(*this, _param);
}
else
assert(0);
int a = 3;
}
const ScriptExprToken& ScriptVM::_get_stack_expr_token(size_t i)
{
if(i >= _stackVar.size())
{
script_print(ScriptLogType::E_damage, "stack越界!");
return _return;
}
if (_stackVar[i] == SCRIPT_INDEX_NAG_1)
return _return;
else
return _expr->_allToken[_stackVar[i]];
}
const ScriptExprToken& ScriptVM::_get_stack_expr_token_top(size_t i)
{
i = _stackVar.size() - i - 1;
return _get_stack_expr_token(i);
}
dl::ScriptVar& ScriptVM::_get_stack_var(size_t i)
{
return _get_variable(_get_stack_expr_token(i));
}
dl::ScriptVar& ScriptVM::_get_stack_var_top(size_t i)
{
i = _stackVar.size() - i - 1;
return _get_stack_var(i);
}
void ScriptVM::_stack_pop(size_t i)
{
i = _stackVar.size() - i;
if (i > _stackVar.size())
{
script_print(ScriptLogType::E_damage, "stack数量不足!");
return;
}
_stackVar.resize(i);
}
void ScriptVM::_op_add()
{
ScriptVar& var0 = _get_stack_var_top(1);
ScriptVar& var1 = _get_stack_var_top(0);
_stack_pop(2);
_stackVar.push_back(SCRIPT_INDEX_NAG_1);
_return._type = ScriptExprTokenType::ESET_variable;
_return._value = g_script->OpAdd(var0, var1);
_return._str = {};
}
void ScriptVM::_op_assign()
{
const ScriptExprToken& t0 = _get_stack_expr_token_top(1);
ScriptVar& var0 = _get_stack_var_top(1);
ScriptVar& var1 = _get_stack_var_top(0);
_stack_pop(2);
g_script->OpAssign(var0, var1);
_stackVar.push_back(SCRIPT_INDEX_NAG_1);
_return._type = ScriptExprTokenType::ESET_variable;
_return._value = var0;
_return._str = t0._str;
}
ScriptVar& ScriptVM::_get_variable(const ScriptExprToken& t)
{
if (t._type == ScriptExprTokenType::ESET_literal)
{// 字面量
static ScriptVar ret;
ret = t._value;
return ret;
}
// 空名变量视为返回值
if (t._str.empty())
{
return _return._value;
}
auto iter = _allVar.find(t._str);
if (iter == _allVar.end())
{
// 新建
ScriptVar& var = _allVar[t._str];
if (g_script->IsGlobalVariable(t._str))
var._indexVarSpace = 0;
else
{
assert(_allVarSpace.size() > 1);
var._indexVarSpace = _allVarSpace.size() - 1;
}
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.
// }
//}
}
dl::ScriptFunction ScriptVM::GetVariableFunction(ScriptVar var)
{
if(var._indexVarSpace == SCRIPT_INDEX_VS_NAG_1)
return _block->_varSpaceIteral._vecFunction[var._value];
if (var._indexVarSpace >= _allVarSpace.size())
{
script_print(ScriptLogType::E_damage, "变量错误!");
return {};
}
return _allVarSpace[var._indexVarSpace]->_vecFunction[var._value];
}
dl::ScriptString ScriptVM::GetVariableString(ScriptVar var)
{
if (var._indexVarSpace == SCRIPT_INDEX_VS_NAG_1)
return _block->_varSpaceIteral._vecString[var._value];
if (var._indexVarSpace >= _allVarSpace.size())
{
script_print(ScriptLogType::E_damage, "变量错误!");
return {};
}
return _allVarSpace[var._indexVarSpace]->_vecString[var._value];
}
std::string ScriptVM::Variable2String(const ScriptVar& var)
{
switch (var.GetType())
{
case ScriptVarType::E_null:
return "null";
case ScriptVarType::E_int:
return std::to_string(var.ToInt());
case ScriptVarType::E_float:
return std::to_string(var.ToFloat());
case ScriptVarType::E_string:
return GetVariableString(var);
case ScriptVarType::E_class:
case ScriptVarType::E_vector:
case ScriptVarType::E_table:
case ScriptVarType::E_function:
case ScriptVarType::E_userdata:
case ScriptVarType::E_operator:
case ScriptVarType::E_max:
default:
break;
}
assert(0);
}
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";
}
}
}