dl
dl_script.h
浏览该文件的文档.
1
12#pragma once
13
14#include <vector>
15#include <list>
16#include <unordered_map>
17#include <functional>
18#include <string>
19#include <cassert>
20#include <stack>
21#include <variant>
22#include <array>
23
24namespace dl
25{
26 using ScriptIndex = uint32_t;
27 using ScriptInt = int64_t;
28 using ScriptFloat = double;
29 using ScriptString = std::string;
30 using ScriptIndexVS = uint8_t; // 变量空间下标
31
32 struct ScriptVar;
33 class ScriptVM;
34
35 using ScriptVector = std::vector<ScriptVar>;
36 using ScriptTable = std::unordered_map<std::string, ScriptVar>;
38 using ScriptFunction = std::function<int(ScriptVM&, const ScriptParam&)>;
39
40 constexpr ScriptIndex SCRIPT_INDEX_NAG_1 = (ScriptIndex)-1; // 返回值
41 constexpr ScriptIndexVS SCRIPT_INDEX_VS_0 = 0; // 全局空间
43 constexpr ScriptIndexVS SCRIPT_INDEX_VS_NAG_2 = (ScriptIndexVS)-2; // 临时变量
44
47 {
48 E_null, // 空
49 E_int, // 整数
50 E_float, // 浮点
51 E_string, // 字符串
52 E_class, // 类
53 E_vector, // 数组
54 E_table, // 表
55 E_function, // 函数
56 E_userdata, // 指针
57 E_operator, // 操作符
59 };
60
63 {
64 E_assign, // 赋值
69 };
70 std::string_view to_string(ScriptOperator op);
71
73 struct ScriptVar
74 {
75 public:
81 {
83 *(ScriptInt*)&_value = *(ScriptInt*)&v;
84 }
95
96
98 {
99 assert(_type == ScriptVarType::E_int);
100 return *(ScriptInt*)&_value;
101 }
103 {
104 assert(_type == ScriptVarType::E_float);
105 return *(ScriptFloat*)&_value;
106 }
108 {
110 return *(ScriptOperator*)&_value;
111 }
112
113 ScriptVarType GetType() const { return _type; }
114 std::string_view GetTypeString() const;
115 public:
117 ScriptIndexVS _indexVarSpace; // 所在变量空间(基础类型需要释放,也需要标记)
118 uint64_t _value; // 基础类型直接存储(或变量下标)
119 };
120
121 // 初步token(文本解析)
123 {
124 enum Type
125 {
128 OPERATOR,// 操作符
129 };
131 _type{ Type::NORMAL }
132 {}
133 ScriptToken(Type type, std::string_view str) :
134 _type{ type },
135 _str{ std::string{str} }
136 {}
137
139 std::string _str;
140 };
141
142 std::string_view to_string(ScriptToken::Type type);
143
146 {
147 ESET_variable, // 变量
148 ESET_literal, // 字面量
150 };
151
154 {
156 std::string _str; // 字符串内容(变量使用)
157 ScriptVar _value; // 值(表达式用、字面量)
158
159 std::string GetTypeString() const
160 {
161 return "expr_token";
162 }
163 };
164
167 {
168 std::vector<ScriptExprToken> _allToken;
169 size_t _lineNumber; // 行号(0开始)
170 std::string _strRaw;// 源代码,调试用
171 };
172
173 inline std::string to_string(const ScriptExpr& expr)
174 {
175 if (expr._allToken.empty())
176 return {};
177 std::string ret;
178 for (size_t i = 0; i < expr._allToken.size() - 1; ++i)
179 {
180 ret += expr._allToken[i]._str;
181 ret += ' ';
182 }
183 ret += expr._allToken[expr._allToken.size() - 1]._str;
184 return ret;
185 }
186
189 {
190 public:
191 ScriptVarSpace(ScriptIndexVS index, size_t level) :
192 _index{ index },
193 _level{ level }
194 {}
195 ScriptIndexVS GetIndex() const { return _index; }
196 size_t GetLevel() const { return _level; }
197
198 ScriptVar AddString(std::string_view v)
199 {
200 ScriptVar ret;
202 ret._indexVarSpace = _index;
203 ret._value = _vecString.size();
204 _vecString.push_back(std::string{ v });
205 return ret;
206 }
208 {
209 ScriptVar ret;
211 ret._indexVarSpace = _index;
212 ret._value = _vecFunction.size();
213 _vecFunction.push_back(v);
214 return ret;
215 }
216
217 const ScriptString& GetString(size_t i) const
218 {
219 return _vecString[i];
220 }
221 const ScriptFunction& GetFunction(size_t i) const
222 {
223 return _vecFunction[i];
224 }
225 private:
226 ScriptIndexVS _index; // 自己下标 0全局变量
227 size_t _level;
228 std::vector<ScriptString> _vecString;
229 std::vector<ScriptTable> _vecClass;
230 std::vector<ScriptVector> _vecVector;
231 std::vector<ScriptTable> _vecTable;
232 std::vector<ScriptFunction> _vecFunction;
233 std::vector<ScriptExpr> _vecExpr;
234 };
235
236
248
251 {
253 size_t _level; // 层级(作用域)
254 std::vector<ScriptExpr> _allExpr;
255 };
256
258 {
262
263 std::vector<ScriptSegment> _allSeg;
264 // 字面量是编译器固定的,不可修改,全局可见,所以单独处理
266 std::vector<std::string> _vecSource;// 不包含换行
267
268 std::string GetSource(bool line_number = true, bool header = true, bool footer = true) const;
269 };
270
271
289 {
290 std::array<ScriptExpr, 3> _cond;
292 };
298
301 {
302 //std::
303 };
304
307 {
308 friend class ScriptSystem;
309 public:
310 void Execute(const ScriptBlock& block);
311
312 // 变量转字符串
313 std::string Variable2String(const ScriptVar& var);
314 // 变量转bool
315 bool Variable2Bool(const ScriptVar& var);
316
317 // 中断执行(内部调用)
318 void Throw() { _bThrow = true; }
319
321 private:
322 // 当前执行代码块
323 const ScriptBlock* _block;
324 // 名字 -> 变量(变量)
325 std::unordered_map<std::string, ScriptVar> _allVar;
326 // 全局变量空间(包含字面量,字面量没有名字)
327 ScriptVarSpace _varSpaceGlobal;
328 // 变量空间
329 std::vector<ScriptVarSpace*> _allVarSpace;
330 // 函数参数
331 ScriptParam _param;
332 // 字面量
333 ScriptVar _varIiteral;
334
335 //-------------------------------expr------------------------------
336 // 返回值(可变)
337 ScriptExprToken _return;
338 // 操作堆栈
339 std::vector<ScriptIndex> _stackVar;
340 // 当前表达式
341 const ScriptExpr* _expr;
342 // 临时变量空间
343 ScriptVarSpace _varSpaceTemp; //todo清理
344 // 出现异常
345 bool _bThrow;
346
347 void _exec_expr(const ScriptExpr& expr);
348 void _clear_expr();
349
350 // 从 操作堆栈 访问
351 const ScriptExprToken& _get_stack_expr_token(size_t i);
352 const ScriptExprToken& _get_stack_expr_token_top(size_t i);
353 ScriptVar& _get_stack_var(size_t i);
354 ScriptVar& _get_stack_var_top(size_t i);
355
356 void _stack_pop(size_t i);
357
358 void _op_arithmetic(ScriptOperator op);
359 void _op_assign();
360
361 // 获取(新建)变量,新建则在当前变量空间初始化
362 ScriptVar& _get_variable(const ScriptExprToken& var0);
363 // 移除变量空间后,从变量表中移除
364 void _delete_var_space(ScriptVarSpace* vs);
365
366 //------------------------------------变量获取--------------------------------
367 ScriptFunction GetVariableFunction(ScriptVar var);
368 ScriptString GetVariableString(ScriptVar var);
369
370 };
371
374 {
375 public:
376 ScriptBlock Compile(std::string_view src);
377
379 std::string Preprocess(std::string_view src);
380 void PreprocessLineNumber(ScriptBlock& block, std::string_view src);
381
383 bool IsOperator(std::string_view str);
385 bool IsMaybeOperator(char ch);
386
388 int GetOperatorPriority(std::string_view str);
389
391 bool IsKeyword(std::string_view str);
393 bool IsVariable(std::string_view str);
395 bool IsGlobalVariable(std::string_view str);
396
398 ScriptExprTokenType GetTokenType(std::string_view str);
399
402
405
407 void RegisterFunction(std::string_view name, ScriptFunction func)
408 {
409 ScriptVar var = _varSpaceGlobal.AddFunction(func);
410 _allVar[std::string{ name }] = var;
411 }
413 {
414 vm._allVar = _allVar;
415 vm._varSpaceGlobal = _varSpaceGlobal;
416 }
417
419
421 ScriptOperator String2Operator(std::string_view str);
422
423 //------------------------------------基础运算(不考虑变量)-----------------------
425 void OpAssign(ScriptVM& vm, ScriptVar& v0, const ScriptVar& v1);
426
428 private:
429 // 关键字
430 std::unordered_map<std::string_view, int> _allKeyword;
431 // 操作符、优先级(越小越优先)
432 std::unordered_map<std::string_view, int> _allOperator;
433 // 变量空间池
434 std::list<ScriptVarSpace*> _listVarSpaceFree;
435 // 内置变量(例print)
436 std::unordered_map<std::string, ScriptVar> _allVar;
437 // 内置变量空间(全局)
438 ScriptVarSpace _varSpaceGlobal;
439 };
440
441 extern ScriptSystem* g_script;
442}
bool IsVariable(std::string_view str)
是否变量名
std::string Preprocess(std::string_view src)
预处理代码(行号不变)
ScriptBlock Compile(std::string_view src)
int GetOperatorPriority(std::string_view str)
返回操作符优先级,越大越优先
bool IsOperator(std::string_view str)
是否操作符
bool IsKeyword(std::string_view str)
是否关键字
bool CheckToken(ScriptExprTokenType type)
bool IsGlobalVariable(std::string_view str)
是否全局变量名
void PreprocessLineNumber(ScriptBlock &block, std::string_view src)
void RegisterFunction(std::string_view name, ScriptFunction func)
注册函数
void CopyVariableToVm(ScriptVM &vm)
ScriptVar OpArithmetic(ScriptVM &vm, ScriptOperator op, const ScriptVar &v0, const ScriptVar &v1)
ScriptVar MakeLiteral(ScriptBlock &block, const ScriptToken &token)
生成字面量
void OpAssign(ScriptVM &vm, ScriptVar &v0, const ScriptVar &v1)
ScriptExprToken MakeExprToken(ScriptBlock &block, const ScriptToken &token)
生成表达式token(字面量是编译器信息,需要生成到block)
bool IsMaybeOperator(char ch)
是否可能为操作符内容(变量名不可能出现)
ScriptExprTokenType GetTokenType(std::string_view str)
返回token类型
ScriptOperator String2Operator(std::string_view str)
字符串转操作符变量
std::string Variable2String(const ScriptVar &var)
bool Variable2Bool(const ScriptVar &var)
void Execute(const ScriptBlock &block)
friend class ScriptSystem
const ScriptString & GetString(size_t i) const
ScriptVar AddFunction(ScriptFunction v)
const ScriptFunction & GetFunction(size_t i) const
ScriptVar AddString(std::string_view v)
ScriptIndexVS GetIndex() const
ScriptVarSpace(ScriptIndexVS index, size_t level)
size_t GetLevel() const
ScriptSystem * g_script
std::unordered_map< std::string, ScriptVar > ScriptTable
constexpr ScriptIndexVS SCRIPT_INDEX_VS_0
std::function< int(ScriptVM &, const ScriptParam &)> ScriptFunction
ScriptExprTokenType
表达式token类型
constexpr ScriptIndexVS SCRIPT_INDEX_VS_NAG_1
constexpr ScriptIndex SCRIPT_INDEX_NAG_1
ScriptSegmentType
uint32_t ScriptIndex
std::string to_string(T v)
to_string包装
std::vector< ScriptVar > ScriptVector
ScriptVarType
变量类型(用户层面)
std::string ScriptString
ScriptVector ScriptParam
ScriptOperator
操作类型
constexpr ScriptIndexVS SCRIPT_INDEX_VS_NAG_2
int64_t ScriptInt
double ScriptFloat
uint8_t ScriptIndexVS
std::vector< std::string > _vecSource
ScriptVarSpace _varSpaceIteral
std::vector< ScriptSegment > _allSeg
std::string GetSource(bool line_number=true, bool header=true, bool footer=true) const
std::array< ScriptExpr, 3 > _cond
后缀表达式
std::vector< ScriptExprToken > _allToken
std::string _strRaw
表达式token(指向真实变量)
ScriptExprTokenType _type
std::string GetTypeString() const
代码段(包含单独作用域)
std::vector< ScriptExpr > _allExpr
ScriptSegmentType _type
代码段运行时
ScriptToken(Type type, std::string_view str)
变量(大小严格控制)
std::string_view GetTypeString() const
ScriptVarType GetType() const
ScriptFloat ToFloat() const
void FromInt(ScriptInt v)
void FromFloat(ScriptFloat v)
ScriptOperator ToOperator() const
ScriptInt ToInt() const
ScriptIndexVS _indexVarSpace
void FromOperator(ScriptOperator v)
ScriptVarType _type