Files
dl_old/dl/script/dl_script.cpp
T
2024-06-22 17:58:54 +08:00

609 lines
13 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();
size_t i = 0;
for (Token& token : vec_token)
{
//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.)
}
// 首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";
}
}
}