OctaForge
/
libcubescript
1
0
Fork 1
Code Issues 1 Pull Requests Releases Wiki Activity

unify enum style

master
Daniel Kolesa 2021-03-18 20:55:14 +01:00
parent 7023e09049
commit 704f9217f7
8 changed files with 701 additions and 699 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

36
include/cubescript/cubescript.hh
View File

@ -106,7 +106,7 @@ private:
}; };
enum class cs_value_type { enum class cs_value_type {
Null = 0, Int, Float, String, Code, Ident NONE = 0, INT, FLOAT, STRING, CODE, IDENT
}; };
struct OSTD_EXPORT cs_value { struct OSTD_EXPORT cs_value {
@ -126,7 +126,7 @@ struct OSTD_EXPORT cs_value {
void set_float(cs_float val); void set_float(cs_float val);
void set_str(ostd::string_range val); void set_str(ostd::string_range val);
void set_str(cs_strref const &val); void set_str(cs_strref const &val);
void set_null(); void set_none();
void set_code(cs_bcode *val); void set_code(cs_bcode *val);
void set_ident(cs_ident *val); void set_ident(cs_ident *val);
@ -139,7 +139,7 @@ struct OSTD_EXPORT cs_value {
bool get_bool() const; bool get_bool() const;
void force_null(); void force_none();
cs_float force_float(); cs_float force_float();
cs_int force_int(); cs_int force_int();
ostd::string_range force_str(); ostd::string_range force_str();
@ -177,7 +177,7 @@ struct cs_error;
struct cs_gen_state; struct cs_gen_state;
enum class cs_ident_type { enum class cs_ident_type {
Ivar = 0, Fvar, Svar, Command, Alias, Special IVAR = 0, FVAR, SVAR, COMMAND, ALIAS, SPECIAL
}; };
struct cs_var; struct cs_var;
@ -355,17 +355,17 @@ private:
int p_numargs; int p_numargs;
}; };
struct cs_identLink; struct cs_ident_link;
enum { enum {
CsLibMath = 1 << 0, CS_LIB_MATH = 1 << 0,
CsLibString = 1 << 1, CS_LIB_STRING = 1 << 1,
CsLibList = 1 << 2, CS_LIB_LIST = 1 << 2,
CsLibAll = 0b111 CS_LIB_ALL = 0b111
}; };
enum class CsLoopState { enum class cs_loop_state {
Normal = 0, Break, Continue NORMAL = 0, BREAK, CONTINUE
}; };
static inline void *cs_default_alloc(void *, void *p, size_t, size_t ns) { static inline void *cs_default_alloc(void *, void *p, size_t, size_t ns) {
@ -383,7 +383,7 @@ struct OSTD_EXPORT cs_state {
friend struct cs_gen_state; friend struct cs_gen_state;
cs_shared_state *p_state; cs_shared_state *p_state;
cs_identLink *p_callstack = nullptr; cs_ident_link *p_callstack = nullptr;
int identflags = 0; int identflags = 0;
@ -423,7 +423,7 @@ struct OSTD_EXPORT cs_state {
cs_vprint_cb set_var_printer(cs_vprint_cb func); cs_vprint_cb set_var_printer(cs_vprint_cb func);
cs_vprint_cb const &get_var_printer() const; cs_vprint_cb const &get_var_printer() const;
void init_libs(int libs = CsLibAll); void init_libs(int libs = CS_LIB_ALL);
void clear_override(cs_ident &id); void clear_override(cs_ident &id);
void clear_overrides(); void clear_overrides();
@ -482,8 +482,8 @@ struct OSTD_EXPORT cs_state {
void run(ostd::string_range code); void run(ostd::string_range code);
void run(cs_ident *id, cs_value_r args); void run(cs_ident *id, cs_value_r args);
CsLoopState run_loop(cs_bcode *code, cs_value &ret); cs_loop_state run_loop(cs_bcode *code, cs_value &ret);
CsLoopState run_loop(cs_bcode *code); cs_loop_state run_loop(cs_bcode *code);
bool is_in_loop() const { bool is_in_loop() const {
return p_inloop; return p_inloop;
@ -855,19 +855,19 @@ private:
) { ) {
for (size_t i = 0; i < vals.size(); ++i) { for (size_t i = 0; i < vals.size(); ++i) {
switch (vals[i].get_type()) { switch (vals[i].get_type()) {
case cs_value_type::Int: { case cs_value_type::INT: {
format_int( format_int(
std::forward<R>(writer), vals[i].get_int() std::forward<R>(writer), vals[i].get_int()
); );
break; break;
} }
case cs_value_type::Float: { case cs_value_type::FLOAT: {
format_float( format_float(
std::forward<R>(writer), vals[i].get_float() std::forward<R>(writer), vals[i].get_float()
); );
break; break;
} }
case cs_value_type::String: { case cs_value_type::STRING: {
ostd::range_put_all( ostd::range_put_all(
writer, ostd::string_range{vals[i].get_str()} writer, ostd::string_range{vals[i].get_str()}
); );

496
src/cs_gen.cc
View File

File diff suppressed because it is too large Load Diff

104
src/cs_val.cc
View File

@ -19,12 +19,12 @@ static inline T &csv_get(U &stor) {
template<typename T> template<typename T>
static inline void csv_cleanup(cs_value_type tv, T &stor) { static inline void csv_cleanup(cs_value_type tv, T &stor) {
switch (tv) { switch (tv) {
case cs_value_type::String: case cs_value_type::STRING:
reinterpret_cast<cs_strref *>(&stor)->~cs_strref(); reinterpret_cast<cs_strref *>(&stor)->~cs_strref();
break; break;
case cs_value_type::Code: { case cs_value_type::CODE: {
uint32_t *bcode = csv_get<uint32_t *>(stor); uint32_t *bcode = csv_get<uint32_t *>(stor);
if (bcode[-1] == CsCodeStart) { if (bcode[-1] == CS_CODE_START) {
delete[] &bcode[-1]; delete[] &bcode[-1];
} }
break; break;
@ -37,7 +37,7 @@ static inline void csv_cleanup(cs_value_type tv, T &stor) {
cs_value::cs_value(cs_state &st): cs_value(*st.p_state) {} cs_value::cs_value(cs_state &st): cs_value(*st.p_state) {}
cs_value::cs_value(cs_shared_state &st): cs_value::cs_value(cs_shared_state &st):
p_stor(), p_type(cs_value_type::Null) p_stor(), p_type(cs_value_type::NONE)
{ {
reinterpret_cast<stor_priv_t<void *> *>(&p_stor)->state = &st; reinterpret_cast<stor_priv_t<void *> *>(&p_stor)->state = &st;
} }
@ -52,21 +52,21 @@ cs_value::cs_value(cs_value const &v): cs_value(*v.state()) {
cs_value &cs_value::operator=(cs_value const &v) { cs_value &cs_value::operator=(cs_value const &v) {
csv_cleanup(p_type, p_stor); csv_cleanup(p_type, p_stor);
p_type = cs_value_type::Null; p_type = cs_value_type::NONE;
switch (v.get_type()) { switch (v.get_type()) {
case cs_value_type::Int: case cs_value_type::INT:
case cs_value_type::Float: case cs_value_type::FLOAT:
case cs_value_type::Ident: case cs_value_type::IDENT:
p_type = v.p_type; p_type = v.p_type;
p_stor = v.p_stor; p_stor = v.p_stor;
break; break;
case cs_value_type::String: case cs_value_type::STRING:
p_type = cs_value_type::String; p_type = cs_value_type::STRING;
new (&p_stor) cs_strref{ new (&p_stor) cs_strref{
*reinterpret_cast<cs_strref const *>(&v.p_stor) *reinterpret_cast<cs_strref const *>(&v.p_stor)
}; };
break; break;
case cs_value_type::Code: case cs_value_type::CODE:
set_code(cs_copy_code(v.get_code())); set_code(cs_copy_code(v.get_code()));
break; break;
default: default:
@ -81,64 +81,64 @@ cs_value_type cs_value::get_type() const {
void cs_value::set_int(cs_int val) { void cs_value::set_int(cs_int val) {
csv_cleanup(p_type, p_stor); csv_cleanup(p_type, p_stor);
p_type = cs_value_type::Int; p_type = cs_value_type::INT;
csv_get<cs_int>(p_stor) = val; csv_get<cs_int>(p_stor) = val;
} }
void cs_value::set_float(cs_float val) { void cs_value::set_float(cs_float val) {
csv_cleanup(p_type, p_stor); csv_cleanup(p_type, p_stor);
p_type = cs_value_type::Float; p_type = cs_value_type::FLOAT;
csv_get<cs_float>(p_stor) = val; csv_get<cs_float>(p_stor) = val;
} }
void cs_value::set_str(ostd::string_range val) { void cs_value::set_str(ostd::string_range val) {
csv_cleanup(p_type, p_stor); csv_cleanup(p_type, p_stor);
new (&p_stor) cs_strref{*state(), val}; new (&p_stor) cs_strref{*state(), val};
p_type = cs_value_type::String; p_type = cs_value_type::STRING;
} }
void cs_value::set_str(cs_strref const &val) { void cs_value::set_str(cs_strref const &val) {
csv_cleanup(p_type, p_stor); csv_cleanup(p_type, p_stor);
new (&p_stor) cs_strref{val}; new (&p_stor) cs_strref{val};
p_type = cs_value_type::String; p_type = cs_value_type::STRING;
} }
void cs_value::set_null() { void cs_value::set_none() {
csv_cleanup(p_type, p_stor); csv_cleanup(p_type, p_stor);
p_type = cs_value_type::Null; p_type = cs_value_type::NONE;
} }
void cs_value::set_code(cs_bcode *val) { void cs_value::set_code(cs_bcode *val) {
csv_cleanup(p_type, p_stor); csv_cleanup(p_type, p_stor);
p_type = cs_value_type::Code; p_type = cs_value_type::CODE;
csv_get<cs_bcode *>(p_stor) = val; csv_get<cs_bcode *>(p_stor) = val;
} }
void cs_value::set_ident(cs_ident *val) { void cs_value::set_ident(cs_ident *val) {
csv_cleanup(p_type, p_stor); csv_cleanup(p_type, p_stor);
p_type = cs_value_type::Ident; p_type = cs_value_type::IDENT;
csv_get<cs_ident *>(p_stor) = val; csv_get<cs_ident *>(p_stor) = val;
} }
void cs_value::force_null() { void cs_value::force_none() {
if (get_type() == cs_value_type::Null) { if (get_type() == cs_value_type::NONE) {
return; return;
} }
set_null(); set_none();
} }
cs_float cs_value::force_float() { cs_float cs_value::force_float() {
cs_float rf = 0.0f; cs_float rf = 0.0f;
switch (get_type()) { switch (get_type()) {
case cs_value_type::Int: case cs_value_type::INT:
rf = csv_get<cs_int>(p_stor); rf = csv_get<cs_int>(p_stor);
break; break;
case cs_value_type::String: case cs_value_type::STRING:
rf = cs_parse_float(ostd::string_range( rf = cs_parse_float(ostd::string_range(
*reinterpret_cast<cs_strref const *>(&p_stor) *reinterpret_cast<cs_strref const *>(&p_stor)
)); ));
break; break;
case cs_value_type::Float: case cs_value_type::FLOAT:
return csv_get<cs_float>(p_stor); return csv_get<cs_float>(p_stor);
default: default:
break; break;
@ -150,15 +150,15 @@ cs_float cs_value::force_float() {
cs_int cs_value::force_int() { cs_int cs_value::force_int() {
cs_int ri = 0; cs_int ri = 0;
switch (get_type()) { switch (get_type()) {
case cs_value_type::Float: case cs_value_type::FLOAT:
ri = csv_get<cs_float>(p_stor); ri = csv_get<cs_float>(p_stor);
break; break;
case cs_value_type::String: case cs_value_type::STRING:
ri = cs_parse_int(ostd::string_range( ri = cs_parse_int(ostd::string_range(
*reinterpret_cast<cs_strref const *>(&p_stor) *reinterpret_cast<cs_strref const *>(&p_stor)
)); ));
break; break;
case cs_value_type::Int: case cs_value_type::INT:
return csv_get<cs_int>(p_stor); return csv_get<cs_int>(p_stor);
default: default:
break; break;
@ -170,13 +170,13 @@ cs_int cs_value::force_int() {
ostd::string_range cs_value::force_str() { ostd::string_range cs_value::force_str() {
cs_string rs; cs_string rs;
switch (get_type()) { switch (get_type()) {
case cs_value_type::Float: case cs_value_type::FLOAT:
rs = floatstr(csv_get<cs_float>(p_stor)); rs = floatstr(csv_get<cs_float>(p_stor));
break; break;
case cs_value_type::Int: case cs_value_type::INT:
rs = intstr(csv_get<cs_int>(p_stor)); rs = intstr(csv_get<cs_int>(p_stor));
break; break;
case cs_value_type::String: case cs_value_type::STRING:
return ostd::string_range( return ostd::string_range(
*reinterpret_cast<cs_strref const *>(&p_stor) *reinterpret_cast<cs_strref const *>(&p_stor)
); );
@ -189,11 +189,11 @@ ostd::string_range cs_value::force_str() {
cs_int cs_value::get_int() const { cs_int cs_value::get_int() const {
switch (get_type()) { switch (get_type()) {
case cs_value_type::Float: case cs_value_type::FLOAT:
return cs_int(csv_get<cs_float>(p_stor)); return cs_int(csv_get<cs_float>(p_stor));
case cs_value_type::Int: case cs_value_type::INT:
return csv_get<cs_int>(p_stor); return csv_get<cs_int>(p_stor);
case cs_value_type::String: case cs_value_type::STRING:
return cs_parse_int(ostd::string_range( return cs_parse_int(ostd::string_range(
*reinterpret_cast<cs_strref const *>(&p_stor) *reinterpret_cast<cs_strref const *>(&p_stor)
)); ));
@ -205,11 +205,11 @@ cs_int cs_value::get_int() const {
cs_float cs_value::get_float() const { cs_float cs_value::get_float() const {
switch (get_type()) { switch (get_type()) {
case cs_value_type::Float: case cs_value_type::FLOAT:
return csv_get<cs_float>(p_stor); return csv_get<cs_float>(p_stor);
case cs_value_type::Int: case cs_value_type::INT:
return cs_float(csv_get<cs_int>(p_stor)); return cs_float(csv_get<cs_int>(p_stor));
case cs_value_type::String: case cs_value_type::STRING:
return cs_parse_float(ostd::string_range( return cs_parse_float(ostd::string_range(
*reinterpret_cast<cs_strref const *>(&p_stor) *reinterpret_cast<cs_strref const *>(&p_stor)
)); ));
@ -220,14 +220,14 @@ cs_float cs_value::get_float() const {
} }
cs_bcode *cs_value::get_code() const { cs_bcode *cs_value::get_code() const {
if (get_type() != cs_value_type::Code) { if (get_type() != cs_value_type::CODE) {
return nullptr; return nullptr;
} }
return csv_get<cs_bcode *>(p_stor); return csv_get<cs_bcode *>(p_stor);
} }
cs_ident *cs_value::get_ident() const { cs_ident *cs_value::get_ident() const {
if (get_type() != cs_value_type::Ident) { if (get_type() != cs_value_type::IDENT) {
return nullptr; return nullptr;
} }
return csv_get<cs_ident *>(p_stor); return csv_get<cs_ident *>(p_stor);
@ -235,11 +235,11 @@ cs_ident *cs_value::get_ident() const {
cs_strref cs_value::get_str() const { cs_strref cs_value::get_str() const {
switch (get_type()) { switch (get_type()) {
case cs_value_type::String: case cs_value_type::STRING:
return *reinterpret_cast<cs_strref const *>(&p_stor); return *reinterpret_cast<cs_strref const *>(&p_stor);
case cs_value_type::Int: case cs_value_type::INT:
return cs_strref{*state(), intstr(csv_get<cs_int>(p_stor))}; return cs_strref{*state(), intstr(csv_get<cs_int>(p_stor))};
case cs_value_type::Float: case cs_value_type::FLOAT:
return cs_strref{*state(), floatstr(csv_get<cs_float>(p_stor))}; return cs_strref{*state(), floatstr(csv_get<cs_float>(p_stor))};
default: default:
break; break;
@ -249,17 +249,17 @@ cs_strref cs_value::get_str() const {
void cs_value::get_val(cs_value &r) const { void cs_value::get_val(cs_value &r) const {
switch (get_type()) { switch (get_type()) {
case cs_value_type::String: case cs_value_type::STRING:
r = *this; r = *this;
break; break;
case cs_value_type::Int: case cs_value_type::INT:
r.set_int(csv_get<cs_int>(p_stor)); r.set_int(csv_get<cs_int>(p_stor));
break; break;
case cs_value_type::Float: case cs_value_type::FLOAT:
r.set_float(csv_get<cs_float>(p_stor)); r.set_float(csv_get<cs_float>(p_stor));
break; break;
default: default:
r.set_null(); r.set_none();
break; break;
} }
} }
@ -269,12 +269,12 @@ OSTD_EXPORT bool cs_code_is_empty(cs_bcode *code) {
return true; return true;
} }
return ( return (
*reinterpret_cast<uint32_t *>(code) & CsCodeOpMask *reinterpret_cast<uint32_t *>(code) & CS_CODE_OP_MASK
) == CsCodeExit; ) == CS_CODE_EXIT;
} }
bool cs_value::code_is_empty() const { bool cs_value::code_is_empty() const {
if (get_type() != cs_value_type::Code) { if (get_type() != cs_value_type::CODE) {
return true; return true;
} }
return cscript::cs_code_is_empty(csv_get<cs_bcode *>(p_stor)); return cscript::cs_code_is_empty(csv_get<cs_bcode *>(p_stor));
@ -299,11 +299,11 @@ static inline bool cs_get_bool(ostd::string_range s) {
bool cs_value::get_bool() const { bool cs_value::get_bool() const {
switch (get_type()) { switch (get_type()) {
case cs_value_type::Float: case cs_value_type::FLOAT:
return csv_get<cs_float>(p_stor) != 0; return csv_get<cs_float>(p_stor) != 0;
case cs_value_type::Int: case cs_value_type::INT:
return csv_get<cs_int>(p_stor) != 0; return csv_get<cs_int>(p_stor) != 0;
case cs_value_type::String: case cs_value_type::STRING:
return cs_get_bool(ostd::string_range( return cs_get_bool(ostd::string_range(
*reinterpret_cast<cs_strref const *>(&p_stor) *reinterpret_cast<cs_strref const *>(&p_stor)
)); ));

540
src/cs_vm.cc
View File

File diff suppressed because it is too large Load Diff

114
src/cs_vm.hh
View File

@ -25,9 +25,9 @@ enum {
CsIdNot, CsIdAnd, CsIdOr CsIdNot, CsIdAnd, CsIdOr
}; };
struct cs_identLink { struct cs_ident_link {
cs_ident *id; cs_ident *id;
cs_identLink *next; cs_ident_link *next;
int usedargs; int usedargs;
cs_ident_stack *argstack; cs_ident_stack *argstack;
}; };
@ -54,12 +54,14 @@ struct cs_valarray {
}; };
enum { enum {
CsValNull = 0, CsValInt, CsValFloat, CsValString, CS_VAL_NULL = 0, CS_VAL_INT, CS_VAL_FLOAT, CS_VAL_STRING,
CsValAny, CsValCode, CsValIdent, CsValWord, CsValPop, CsValCond CS_VAL_ANY, CS_VAL_CODE, CS_VAL_IDENT, CS_VAL_WORD,
CS_VAL_POP, CS_VAL_COND
}; };
static const int cs_valtypet[] = { static const int cs_valtypet[] = {
CsValNull, CsValInt, CsValFloat, CsValString, CsValCode, CsValIdent CS_VAL_NULL, CS_VAL_INT, CS_VAL_FLOAT, CS_VAL_STRING,
CS_VAL_CODE, CS_VAL_IDENT
}; };
static inline int cs_vtype_to_int(cs_value_type v) { static inline int cs_vtype_to_int(cs_value_type v) {
@ -68,48 +70,48 @@ static inline int cs_vtype_to_int(cs_value_type v) {
/* instruction: uint32 [length 24][retflag 2][opcode 6] */ /* instruction: uint32 [length 24][retflag 2][opcode 6] */
enum { enum {
CsCodeStart = 0, CS_CODE_START = 0,
CsCodeOffset, CS_CODE_OFFSET,
CsCodeNull, CsCodeTrue, CsCodeFalse, CsCodeNot, CS_CODE_NULL, CS_CODE_TRUE, CS_CODE_FALSE, CS_CODE_NOT,
CsCodePop, CS_CODE_POP,
CsCodeEnter, CsCodeEnterResult, CS_CODE_ENTER, CS_CODE_ENTER_RESULT,
CsCodeExit, CsCodeResultArg, CS_CODE_EXIT, CS_CODE_RESULT_ARG,
CsCodeVal, CsCodeValInt, CS_CODE_VAL, CS_CODE_VAL_INT,
CsCodeDup, CS_CODE_DUP,
CsCodeBool, CS_CODE_BOOL,
CsCodeBlock, CsCodeEmpty, CS_CODE_BLOCK, CS_CODE_EMPTY,
CsCodeCompile, CsCodeCond, CS_CODE_COMPILE, CS_CODE_COND,
CsCodeForce, CS_CODE_FORCE,
CsCodeResult, CS_CODE_RESULT,
CsCodeIdent, CsCodeIdentU, CsCodeIdentArg, CS_CODE_IDENT, CS_CODE_IDENT_U, CS_CODE_IDENT_ARG,
CsCodeCom, CsCodeComC, CsCodeComV, CS_CODE_COM, CS_CODE_COM_C, CS_CODE_COM_V,
CsCodeConc, CsCodeConcW, CsCodeConcM, CS_CODE_CONC, CS_CODE_CONC_W, CS_CODE_CONC_M,
CsCodeSvar, CsCodeSvar1, CS_CODE_SVAR, CS_CODE_SVAR1,
CsCodeIvar, CsCodeIvar1, CsCodeIvar2, CsCodeIvar3, CS_CODE_IVAR, CS_CODE_IVAR1, CS_CODE_IVAR2, CS_CODE_IVAR3,
CsCodeFvar, CsCodeFvar1, CS_CODE_FVAR, CS_CODE_FVAR1,
CsCodeLookup, CsCodeLookupU, CsCodeLookupArg, CS_CODE_LOOKUP, CS_CODE_LOOKUP_U, CS_CODE_LOOKUP_ARG,
CsCodeLookupM, CsCodeLookupMu, CsCodeLookupMarg, CS_CODE_LOOKUP_M, CS_CODE_LOOKUP_MU, CS_CODE_LOOKUP_MARG,
CsCodeAlias, CsCodeAliasU, CsCodeAliasArg, CS_CODE_ALIAS, CS_CODE_ALIAS_U, CS_CODE_ALIAS_ARG,
CsCodeCall, CsCodeCallU, CsCodeCallArg, CS_CODE_CALL, CS_CODE_CALL_U, CS_CODE_CALL_ARG,
CsCodePrint, CS_CODE_PRINT,
CsCodeLocal, CS_CODE_LOCAL,
CsCodeDo, CsCodeDoArgs, CS_CODE_DO, CS_CODE_DO_ARGS,
CsCodeJump, CsCodeJumpB, CsCodeJumpResult, CS_CODE_JUMP, CS_CODE_JUMP_B, CS_CODE_JUMP_RESULT,
CsCodeBreak, CS_CODE_BREAK,
CsCodeOpMask = 0x3F, CS_CODE_OP_MASK = 0x3F,
CsCodeRet = 6, CS_CODE_RET = 6,
CsCodeRetMask = 0xC0, CS_CODE_RET_MASK = 0xC0,
/* return type flags */ /* return type flags */
CsRetNull = CsValNull << CsCodeRet, CS_RET_NULL = CS_VAL_NULL << CS_CODE_RET,
CsRetString = CsValString << CsCodeRet, CS_RET_STRING = CS_VAL_STRING << CS_CODE_RET,
CsRetInt = CsValInt << CsCodeRet, CS_RET_INT = CS_VAL_INT << CS_CODE_RET,
CsRetFloat = CsValFloat << CsCodeRet, CS_RET_FLOAT = CS_VAL_FLOAT << CS_CODE_RET,
/* CsCodeJumpB, CsCodeJumpResult */ /* CS_CODE_JUMP_B, CS_CODE_JUMP_RESULT */
CsCodeFlagTrue = 1 << CsCodeRet, CS_CODE_FLAG_TRUE = 1 << CS_CODE_RET,
CsCodeFlagFalse = 0 << CsCodeRet CS_CODE_FLAG_FALSE = 0 << CS_CODE_RET
}; };
struct cs_shared_state { struct cs_shared_state {
@ -199,7 +201,7 @@ struct cs_gen_state {
void gen_str(ostd::string_range word) { void gen_str(ostd::string_range word) {
if (word.size() <= 3) { if (word.size() <= 3) {
uint32_t op = CsCodeValInt | CsRetString; uint32_t op = CS_CODE_VAL_INT | CS_RET_STRING;
for (size_t i = 0; i < word.size(); ++i) { for (size_t i = 0; i < word.size(); ++i) {
op |= uint32_t( op |= uint32_t(
static_cast<unsigned char>(word[i]) static_cast<unsigned char>(word[i])
@ -208,7 +210,7 @@ struct cs_gen_state {
code.push_back(op); code.push_back(op);
return; return;
} }
code.push_back(CsCodeVal | CsRetString | (word.size() << 8)); code.push_back(CS_CODE_VAL | CS_RET_STRING | (word.size() << 8));
auto it = reinterpret_cast<uint32_t const *>(word.data()); auto it = reinterpret_cast<uint32_t const *>(word.data());
code.insert( code.insert(
code.end(), it, it + (word.size() / sizeof(uint32_t)) code.end(), it, it + (word.size() / sizeof(uint32_t))
@ -224,23 +226,23 @@ struct cs_gen_state {
} }
void gen_str() { void gen_str() {
code.push_back(CsCodeValInt | CsRetString); code.push_back(CS_CODE_VAL_INT | CS_RET_STRING);
} }
void gen_null() { void gen_null() {
code.push_back(CsCodeValInt | CsRetNull); code.push_back(CS_CODE_VAL_INT | CS_RET_NULL);
} }
void gen_int(cs_int i = 0) { void gen_int(cs_int i = 0) {
if (i >= -0x800000 && i <= 0x7FFFFF) { if (i >= -0x800000 && i <= 0x7FFFFF) {
code.push_back(CsCodeValInt | CsRetInt | (i << 8)); code.push_back(CS_CODE_VAL_INT | CS_RET_INT | (i << 8));
} else { } else {
union { union {
cs_int i; cs_int i;
uint32_t u[CsTypeStorageSize<cs_int>]; uint32_t u[CsTypeStorageSize<cs_int>];
} c; } c;
c.i = i; c.i = i;
code.push_back(CsCodeVal | CsRetInt); code.push_back(CS_CODE_VAL | CS_RET_INT);
code.insert(code.end(), c.u, c.u + CsTypeStorageSize<cs_int>); code.insert(code.end(), c.u, c.u + CsTypeStorageSize<cs_int>);
} }
} }
@ -249,14 +251,14 @@ struct cs_gen_state {
void gen_float(cs_float f = 0.0f) { void gen_float(cs_float f = 0.0f) {
if (cs_int(f) == f && f >= -0x800000 && f <= 0x7FFFFF) { if (cs_int(f) == f && f >= -0x800000 && f <= 0x7FFFFF) {
code.push_back(CsCodeValInt | CsRetFloat | (cs_int(f) << 8)); code.push_back(CS_CODE_VAL_INT | CS_RET_FLOAT | (cs_int(f) << 8));
} else { } else {
union { union {
cs_float f; cs_float f;
uint32_t u[CsTypeStorageSize<cs_float>]; uint32_t u[CsTypeStorageSize<cs_float>];
} c; } c;
c.f = f; c.f = f;
code.push_back(CsCodeVal | CsRetFloat); code.push_back(CS_CODE_VAL | CS_RET_FLOAT);
code.insert(code.end(), c.u, c.u + CsTypeStorageSize<cs_float>); code.insert(code.end(), c.u, c.u + CsTypeStorageSize<cs_float>);
} }
} }
@ -266,8 +268,8 @@ struct cs_gen_state {
void gen_ident(cs_ident *id) { void gen_ident(cs_ident *id) {
code.push_back( code.push_back(
((id->get_index() < MaxArguments) ((id->get_index() < MaxArguments)
? CsCodeIdentArg ? CS_CODE_IDENT_ARG
: CsCodeIdent : CS_CODE_IDENT
) | (id->get_index() << 8) ) | (id->get_index() << 8)
); );
} }
@ -285,7 +287,7 @@ struct cs_gen_state {
int line = 0 int line = 0
); );
void gen_main(ostd::string_range s, int ret_type = CsValAny); void gen_main(ostd::string_range s, int ret_type = CS_VAL_ANY);
void next_char() { void next_char() {
if (source.empty()) { if (source.empty()) {
@ -436,8 +438,8 @@ static void cs_do_args(cs_state &cs, F body) {
); );
} }
} }
cs_identLink *prevstack = cs.p_callstack->next; cs_ident_link *prevstack = cs.p_callstack->next;
cs_identLink aliaslink = { cs_ident_link aliaslink = {
cs.p_callstack->id, cs.p_callstack, cs.p_callstack->id, cs.p_callstack,
prevstack ? prevstack->usedargs : ((1 << MaxArguments) - 1), prevstack ? prevstack->usedargs : ((1 << MaxArguments) - 1),
prevstack ? prevstack->argstack : nullptr prevstack ? prevstack->argstack : nullptr

88
src/cubescript.cc
View File

@ -41,67 +41,67 @@ cs_var::cs_var(cs_ident_type tp, cs_strref name, cs_var_cb f, int fl):
cs_ivar::cs_ivar( cs_ivar::cs_ivar(
cs_strref name, cs_int m, cs_int x, cs_int v, cs_var_cb f, int fl cs_strref name, cs_int m, cs_int x, cs_int v, cs_var_cb f, int fl
): ):
cs_var(cs_ident_type::Ivar, name, std::move(f), fl | ((m > x) ? CS_IDF_READONLY : 0)), cs_var(cs_ident_type::IVAR, name, std::move(f), fl | ((m > x) ? CS_IDF_READONLY : 0)),
p_storage(v), p_minval(m), p_maxval(x), p_overrideval(0) p_storage(v), p_minval(m), p_maxval(x), p_overrideval(0)
{} {}
cs_fvar::cs_fvar( cs_fvar::cs_fvar(
cs_strref name, cs_float m, cs_float x, cs_float v, cs_var_cb f, int fl cs_strref name, cs_float m, cs_float x, cs_float v, cs_var_cb f, int fl
): ):
cs_var(cs_ident_type::Fvar, name, std::move(f), fl | ((m > x) ? CS_IDF_READONLY : 0)), cs_var(cs_ident_type::FVAR, name, std::move(f), fl | ((m > x) ? CS_IDF_READONLY : 0)),
p_storage(v), p_minval(m), p_maxval(x), p_overrideval(0) p_storage(v), p_minval(m), p_maxval(x), p_overrideval(0)
{} {}
cs_svar::cs_svar(cs_strref name, cs_strref v, cs_strref ov, cs_var_cb f, int fl): cs_svar::cs_svar(cs_strref name, cs_strref v, cs_strref ov, cs_var_cb f, int fl):
cs_var(cs_ident_type::Svar, name, std::move(f), fl), cs_var(cs_ident_type::SVAR, name, std::move(f), fl),
p_storage{v}, p_overrideval{ov} p_storage{v}, p_overrideval{ov}
{} {}
cs_alias::cs_alias(cs_state &cs, cs_strref name, cs_strref a, int fl): cs_alias::cs_alias(cs_state &cs, cs_strref name, cs_strref a, int fl):
cs_ident(cs_ident_type::Alias, name, fl), cs_ident(cs_ident_type::ALIAS, name, fl),
p_acode(nullptr), p_astack(nullptr), p_val{cs} p_acode(nullptr), p_astack(nullptr), p_val{cs}
{ {
p_val.set_str(a); p_val.set_str(a);
} }
cs_alias::cs_alias(cs_state &cs, cs_strref name, ostd::string_range a, int fl): cs_alias::cs_alias(cs_state &cs, cs_strref name, ostd::string_range a, int fl):
cs_ident(cs_ident_type::Alias, name, fl), cs_ident(cs_ident_type::ALIAS, name, fl),
p_acode(nullptr), p_astack(nullptr), p_val{cs} p_acode(nullptr), p_astack(nullptr), p_val{cs}
{ {
p_val.set_str(a); p_val.set_str(a);
} }
cs_alias::cs_alias(cs_state &cs, cs_strref name, cs_int a, int fl): cs_alias::cs_alias(cs_state &cs, cs_strref name, cs_int a, int fl):
cs_ident(cs_ident_type::Alias, name, fl), cs_ident(cs_ident_type::ALIAS, name, fl),
p_acode(nullptr), p_astack(nullptr), p_val{cs} p_acode(nullptr), p_astack(nullptr), p_val{cs}
{ {
p_val.set_int(a); p_val.set_int(a);
} }
cs_alias::cs_alias(cs_state &cs, cs_strref name, cs_float a, int fl): cs_alias::cs_alias(cs_state &cs, cs_strref name, cs_float a, int fl):
cs_ident(cs_ident_type::Alias, name, fl), cs_ident(cs_ident_type::ALIAS, name, fl),
p_acode(nullptr), p_astack(nullptr), p_val{cs} p_acode(nullptr), p_astack(nullptr), p_val{cs}
{ {
p_val.set_float(a); p_val.set_float(a);
} }
cs_alias::cs_alias(cs_state &cs, cs_strref name, int fl): cs_alias::cs_alias(cs_state &cs, cs_strref name, int fl):
cs_ident(cs_ident_type::Alias, name, fl), cs_ident(cs_ident_type::ALIAS, name, fl),
p_acode(nullptr), p_astack(nullptr), p_val{cs} p_acode(nullptr), p_astack(nullptr), p_val{cs}
{ {
p_val.set_null(); p_val.set_none();
} }
/* FIXME: use cs rather than val's cs */ /* FIXME: use cs rather than val's cs */
cs_alias::cs_alias(cs_state &, cs_strref name, cs_value v, int fl): cs_alias::cs_alias(cs_state &, cs_strref name, cs_value v, int fl):
cs_ident(cs_ident_type::Alias, name, fl), cs_ident(cs_ident_type::ALIAS, name, fl),
p_acode(nullptr), p_astack(nullptr), p_val(v) p_acode(nullptr), p_astack(nullptr), p_val(v)
{} {}
cs_command::cs_command( cs_command::cs_command(
cs_strref name, cs_strref args, int nargs, cs_command_cb f cs_strref name, cs_strref args, int nargs, cs_command_cb f
): ):
cs_ident(cs_ident_type::Command, name, 0), cs_ident(cs_ident_type::COMMAND, name, 0),
p_cargs(args), p_cb_cftv(std::move(f)), p_numargs(nargs) p_cargs(args), p_cb_cftv(std::move(f)), p_numargs(nargs)
{} {}
bool cs_ident::is_alias() const { bool cs_ident::is_alias() const {
return get_type() == cs_ident_type::Alias; return get_type() == cs_ident_type::ALIAS;
} }
cs_alias *cs_ident::get_alias() { cs_alias *cs_ident::get_alias() {
@ -119,7 +119,7 @@ cs_alias const *cs_ident::get_alias() const {
} }
bool cs_ident::is_command() const { bool cs_ident::is_command() const {
return get_type() == cs_ident_type::Command; return get_type() == cs_ident_type::COMMAND;
} }
cs_command *cs_ident::get_command() { cs_command *cs_ident::get_command() {
@ -137,12 +137,12 @@ cs_command const *cs_ident::get_command() const {
} }
bool cs_ident::is_special() const { bool cs_ident::is_special() const {
return get_type() == cs_ident_type::Special; return get_type() == cs_ident_type::SPECIAL;
} }
bool cs_ident::is_var() const { bool cs_ident::is_var() const {
cs_ident_type tp = get_type(); cs_ident_type tp = get_type();
return (tp >= cs_ident_type::Ivar) && (tp <= cs_ident_type::Svar); return (tp >= cs_ident_type::IVAR) && (tp <= cs_ident_type::SVAR);
} }
cs_var *cs_ident::get_var() { cs_var *cs_ident::get_var() {
@ -160,7 +160,7 @@ cs_var const *cs_ident::get_var() const {
} }
bool cs_ident::is_ivar() const { bool cs_ident::is_ivar() const {
return get_type() == cs_ident_type::Ivar; return get_type() == cs_ident_type::IVAR;
} }
cs_ivar *cs_ident::get_ivar() { cs_ivar *cs_ident::get_ivar() {
@ -178,7 +178,7 @@ cs_ivar const *cs_ident::get_ivar() const {
} }
bool cs_ident::is_fvar() const { bool cs_ident::is_fvar() const {
return get_type() == cs_ident_type::Fvar; return get_type() == cs_ident_type::FVAR;
} }
cs_fvar *cs_ident::get_fvar() { cs_fvar *cs_ident::get_fvar() {
@ -196,7 +196,7 @@ cs_fvar const *cs_ident::get_fvar() const {
} }
bool cs_ident::is_svar() const { bool cs_ident::is_svar() const {
return get_type() == cs_ident_type::Svar; return get_type() == cs_ident_type::SVAR;
} }
cs_svar *cs_ident::get_svar() { cs_svar *cs_ident::get_svar() {
@ -387,7 +387,7 @@ OSTD_EXPORT void cs_state::destroy() {
cs_ident *i = p.second; cs_ident *i = p.second;
cs_alias *a = i->get_alias(); cs_alias *a = i->get_alias();
if (a) { if (a) {
a->get_value().force_null(); a->get_value().force_none();
cs_alias_internal::clean_code(a); cs_alias_internal::clean_code(a);
} }
p_state->destroy(i); p_state->destroy(i);
@ -437,25 +437,25 @@ OSTD_EXPORT void cs_state::clear_override(cs_ident &id) {
return; return;
} }
switch (id.get_type()) { switch (id.get_type()) {
case cs_ident_type::Alias: { case cs_ident_type::ALIAS: {
cs_alias &a = static_cast<cs_alias &>(id); cs_alias &a = static_cast<cs_alias &>(id);
cs_alias_internal::clean_code(&a); cs_alias_internal::clean_code(&a);
a.get_value().set_str(""); a.get_value().set_str("");
break; break;
} }
case cs_ident_type::Ivar: { case cs_ident_type::IVAR: {
cs_ivar &iv = static_cast<cs_ivar &>(id); cs_ivar &iv = static_cast<cs_ivar &>(id);
iv.set_value(iv.p_overrideval); iv.set_value(iv.p_overrideval);
iv.changed(*this); iv.changed(*this);
break; break;
} }
case cs_ident_type::Fvar: { case cs_ident_type::FVAR: {
cs_fvar &fv = static_cast<cs_fvar &>(id); cs_fvar &fv = static_cast<cs_fvar &>(id);
fv.set_value(fv.p_overrideval); fv.set_value(fv.p_overrideval);
fv.changed(*this); fv.changed(*this);
break; break;
} }
case cs_ident_type::Svar: { case cs_ident_type::SVAR: {
cs_svar &sv = static_cast<cs_svar &>(id); cs_svar &sv = static_cast<cs_svar &>(id);
sv.set_value(sv.p_overrideval); sv.set_value(sv.p_overrideval);
sv.changed(*this); sv.changed(*this);
@ -500,9 +500,9 @@ OSTD_EXPORT cs_ident *cs_state::new_ident(ostd::string_range name, int flags) {
OSTD_EXPORT cs_ident *cs_state::force_ident(cs_value &v) { OSTD_EXPORT cs_ident *cs_state::force_ident(cs_value &v) {
switch (v.get_type()) { switch (v.get_type()) {
case cs_value_type::Ident: case cs_value_type::IDENT:
return v.get_ident(); return v.get_ident();
case cs_value_type::String: { case cs_value_type::STRING: {
cs_ident *id = new_ident(v.get_str()); cs_ident *id = new_ident(v.get_str());
v.set_ident(id); v.set_ident(id);
return id; return id;
@ -593,7 +593,7 @@ OSTD_EXPORT void cs_state::set_alias(ostd::string_range name, cs_value v) {
cs_ident *id = get_ident(name); cs_ident *id = get_ident(name);
if (id) { if (id) {
switch (id->get_type()) { switch (id->get_type()) {
case cs_ident_type::Alias: { case cs_ident_type::ALIAS: {
cs_alias *a = static_cast<cs_alias *>(id); cs_alias *a = static_cast<cs_alias *>(id);
if (a->get_index() < MaxArguments) { if (a->get_index() < MaxArguments) {
cs_alias_internal::set_arg(a, *this, v); cs_alias_internal::set_arg(a, *this, v);
@ -602,13 +602,13 @@ OSTD_EXPORT void cs_state::set_alias(ostd::string_range name, cs_value v) {
} }
return; return;
} }
case cs_ident_type::Ivar: case cs_ident_type::IVAR:
set_var_int_checked(static_cast<cs_ivar *>(id), v.get_int()); set_var_int_checked(static_cast<cs_ivar *>(id), v.get_int());
break; break;
case cs_ident_type::Fvar: case cs_ident_type::FVAR:
set_var_float_checked(static_cast<cs_fvar *>(id), v.get_float()); set_var_float_checked(static_cast<cs_fvar *>(id), v.get_float());
break; break;
case cs_ident_type::Svar: case cs_ident_type::SVAR:
set_var_str_checked(static_cast<cs_svar *>(id), v.get_str()); set_var_str_checked(static_cast<cs_svar *>(id), v.get_str());
break; break;
default: default:
@ -632,24 +632,24 @@ OSTD_EXPORT void cs_state::print_var(cs_var const &v) const {
void cs_alias::get_cval(cs_value &v) const { void cs_alias::get_cval(cs_value &v) const {
switch (p_val.get_type()) { switch (p_val.get_type()) {
case cs_value_type::String: case cs_value_type::STRING:
v = p_val; v = p_val;
break; break;
case cs_value_type::Int: case cs_value_type::INT:
v.set_int(p_val.get_int()); v.set_int(p_val.get_int());
break; break;
case cs_value_type::Float: case cs_value_type::FLOAT:
v.set_float(p_val.get_float()); v.set_float(p_val.get_float());
break; break;
default: default:
v.set_null(); v.set_none();
break; break;
} }
} }
cs_ident_type cs_ident::get_type() const { cs_ident_type cs_ident::get_type() const {
if (p_type > CsIdAlias) { if (p_type > CsIdAlias) {
return cs_ident_type::Special; return cs_ident_type::SPECIAL;
} }
return cs_ident_type(p_type); return cs_ident_type(p_type);
} }
@ -986,7 +986,7 @@ static inline void cs_do_loop(
break; break;
} }
switch (cs.run_loop(body)) { switch (cs.run_loop(body)) {
case CsLoopState::Break: case cs_loop_state::BREAK:
goto end; goto end;
default: /* continue and normal */ default: /* continue and normal */
break; break;
@ -1010,9 +1010,9 @@ static inline void cs_loop_conc(
idv.push(); idv.push();
cs_value v{cs}; cs_value v{cs};
switch (cs.run_loop(body, v)) { switch (cs.run_loop(body, v)) {
case CsLoopState::Break: case cs_loop_state::BREAK:
goto end; goto end;
case CsLoopState::Continue: case cs_loop_state::CONTINUE:
continue; continue;
default: default:
break; break;
@ -1082,7 +1082,7 @@ void cs_init_lib_base(cs_state &gcs) {
cs_int val = args[0].get_int(); cs_int val = args[0].get_int();
for (size_t i = 1; (i + 1) < args.size(); i += 2) { for (size_t i = 1; (i + 1) < args.size(); i += 2) {
if ( if (
(args[i].get_type() == cs_value_type::Null) || (args[i].get_type() == cs_value_type::NONE) ||
(args[i].get_int() == val) (args[i].get_int() == val)
) { ) {
cs.run(args[i + 1].get_code(), res); cs.run(args[i + 1].get_code(), res);
@ -1095,7 +1095,7 @@ void cs_init_lib_base(cs_state &gcs) {
cs_float val = args[0].get_float(); cs_float val = args[0].get_float();
for (size_t i = 1; (i + 1) < args.size(); i += 2) { for (size_t i = 1; (i + 1) < args.size(); i += 2) {
if ( if (
(args[i].get_type() == cs_value_type::Null) || (args[i].get_type() == cs_value_type::NONE) ||
(args[i].get_float() == val) (args[i].get_float() == val)
) { ) {
cs.run(args[i + 1].get_code(), res); cs.run(args[i + 1].get_code(), res);
@ -1108,7 +1108,7 @@ void cs_init_lib_base(cs_state &gcs) {
cs_strref val = args[0].get_str(); cs_strref val = args[0].get_str();
for (size_t i = 1; (i + 1) < args.size(); i += 2) { for (size_t i = 1; (i + 1) < args.size(); i += 2) {
if ( if (
(args[i].get_type() == cs_value_type::Null) || (args[i].get_type() == cs_value_type::NONE) ||
(args[i].get_str() == val) (args[i].get_str() == val)
) { ) {
cs.run(args[i + 1].get_code(), res); cs.run(args[i + 1].get_code(), res);
@ -1189,7 +1189,7 @@ void cs_init_lib_base(cs_state &gcs) {
cs_bcode *cond = args[0].get_code(), *body = args[1].get_code(); cs_bcode *cond = args[0].get_code(), *body = args[1].get_code();
while (cs.run_bool(cond)) { while (cs.run_bool(cond)) {
switch (cs.run_loop(body)) { switch (cs.run_loop(body)) {
case CsLoopState::Break: case cs_loop_state::BREAK:
goto end; goto end;
default: /* continue and normal */ default: /* continue and normal */
break; break;
@ -1311,13 +1311,13 @@ void cs_init_lib_string(cs_state &cs);
void cs_init_lib_list(cs_state &cs); void cs_init_lib_list(cs_state &cs);
OSTD_EXPORT void cs_state::init_libs(int libs) { OSTD_EXPORT void cs_state::init_libs(int libs) {
if (libs & CsLibMath) { if (libs & CS_LIB_MATH) {
cs_init_lib_math(*this); cs_init_lib_math(*this);
} }
if (libs & CsLibString) { if (libs & CS_LIB_STRING) {
cs_init_lib_string(*this); cs_init_lib_string(*this);
} }
if (libs & CsLibList) { if (libs & CS_LIB_LIST) {
cs_init_lib_list(*this); cs_init_lib_list(*this);
} }
} }

14
src/lib_list.cc
View File

@ -87,9 +87,9 @@ static void cs_loop_list_conc(
} }
cs_value v{cs}; cs_value v{cs};
switch (cs.run_loop(body, v)) { switch (cs.run_loop(body, v)) {
case CsLoopState::Break: case cs_loop_state::BREAK:
goto end; goto end;
case CsLoopState::Continue: case cs_loop_state::CONTINUE:
continue; continue;
default: default:
break; break;
@ -294,7 +294,7 @@ void cs_init_lib_list(cs_state &gcs) {
idv.set_str(p.get_item()); idv.set_str(p.get_item());
idv.push(); idv.push();
switch (cs.run_loop(body)) { switch (cs.run_loop(body)) {
case CsLoopState::Break: case cs_loop_state::BREAK:
goto end; goto end;
default: /* continue and normal */ default: /* continue and normal */
break; break;
@ -322,7 +322,7 @@ end:
idv1.push(); idv1.push();
idv2.push(); idv2.push();
switch (cs.run_loop(body)) { switch (cs.run_loop(body)) {
case CsLoopState::Break: case cs_loop_state::BREAK:
goto end; goto end;
default: /* continue and normal */ default: /* continue and normal */
break; break;
@ -357,7 +357,7 @@ end:
idv2.push(); idv2.push();
idv3.push(); idv3.push();
switch (cs.run_loop(body)) { switch (cs.run_loop(body)) {
case CsLoopState::Break: case cs_loop_state::BREAK:
goto end; goto end;
default: /* continue and normal */ default: /* continue and normal */
break; break;
@ -557,8 +557,8 @@ static void cs_list_sort(
} }
cs_stacked_value xval{cs, xa}, yval{cs, ya}; cs_stacked_value xval{cs, xa}, yval{cs, ya};
xval.set_null(); xval.set_none();
yval.set_null(); yval.set_none();
xval.push(); xval.push();
yval.push(); yval.push();

8
tools/repl.cc
View File

@ -190,7 +190,7 @@ static void do_sigint(int n) {
/* an example of what var printer would look like in real usage */ /* an example of what var printer would look like in real usage */
static void repl_print_var(cs_state const &cs, cs_var const &var) { static void repl_print_var(cs_state const &cs, cs_var const &var) {
switch (var.get_type()) { switch (var.get_type()) {
case cs_ident_type::Ivar: { case cs_ident_type::IVAR: {
auto &iv = static_cast<cs_ivar const &>(var); auto &iv = static_cast<cs_ivar const &>(var);
auto val = iv.get_value(); auto val = iv.get_value();
if (!(iv.get_flags() & CS_IDF_HEX) || (val < 0)) { if (!(iv.get_flags() & CS_IDF_HEX) || (val < 0)) {
@ -205,7 +205,7 @@ static void repl_print_var(cs_state const &cs, cs_var const &var) {
} }
break; break;
} }
case cs_ident_type::Fvar: { case cs_ident_type::FVAR: {
auto &fv = static_cast<cs_fvar const &>(var); auto &fv = static_cast<cs_fvar const &>(var);
auto val = fv.get_value(); auto val = fv.get_value();
ostd::writefln( ostd::writefln(
@ -214,7 +214,7 @@ static void repl_print_var(cs_state const &cs, cs_var const &var) {
); );
break; break;
} }
case cs_ident_type::Svar: { case cs_ident_type::SVAR: {
auto &sv = static_cast<cs_svar const &>(var); auto &sv = static_cast<cs_svar const &>(var);
auto val = ostd::string_range{sv.get_value()}; auto val = ostd::string_range{sv.get_value()};
if (ostd::find(val, '"').empty()) { if (ostd::find(val, '"').empty()) {
@ -266,7 +266,7 @@ static bool do_call(cs_state &cs, ostd::string_range line, bool file = false) {
} }
signal(SIGINT, SIG_DFL); signal(SIGINT, SIG_DFL);
scs = nullptr; scs = nullptr;
if (ret.get_type() != cs_value_type::Null) { if (ret.get_type() != cs_value_type::NONE) {
ostd::writeln(ret.get_str()); ostd::writeln(ret.get_str());
} }
return false; return false;