Files
dl_old/dl/script/dl_script.cpp
T
2024-06-25 19:02:10 +08:00

641 lines
14 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_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<ScriptSegment>& vec_seg = ret._allSeg;
std::size_t beg = 0;
std::size_t end = 0;
std::vector<Token> 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<ScriptExprToken> 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<ScriptExprToken> 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 = &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<ScriptExprToken>& vec_token = expr._allToken;
std::stack<ScriptIndex> 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<ScriptExprToken>& vec_token, std::stack<ScriptIndex>& 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<ScriptExprToken>& vec_token, std::stack<ScriptIndex>& 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";
}
}
}