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 {
Null = 0, Int, Float, String, Code, Ident
NONE = 0, INT, FLOAT, STRING, CODE, IDENT
};
struct OSTD_EXPORT cs_value {
@ -126,7 +126,7 @@ struct OSTD_EXPORT cs_value {
void set_float(cs_float val);
void set_str(ostd::string_range val);
void set_str(cs_strref const &val);
void set_null();
void set_none();
void set_code(cs_bcode *val);
void set_ident(cs_ident *val);
@ -139,7 +139,7 @@ struct OSTD_EXPORT cs_value {
bool get_bool() const;
void force_null();
void force_none();
cs_float force_float();
cs_int force_int();
ostd::string_range force_str();
@ -177,7 +177,7 @@ struct cs_error;
struct cs_gen_state;
enum class cs_ident_type {
Ivar = 0, Fvar, Svar, Command, Alias, Special
IVAR = 0, FVAR, SVAR, COMMAND, ALIAS, SPECIAL
};
struct cs_var;
@ -355,17 +355,17 @@ private:
int p_numargs;
};
struct cs_identLink;
struct cs_ident_link;
enum {
CsLibMath = 1 << 0,
CsLibString = 1 << 1,
CsLibList = 1 << 2,
CsLibAll = 0b111
CS_LIB_MATH = 1 << 0,
CS_LIB_STRING = 1 << 1,
CS_LIB_LIST = 1 << 2,
CS_LIB_ALL = 0b111
};
enum class CsLoopState {
Normal = 0, Break, Continue
enum class cs_loop_state {
NORMAL = 0, BREAK, CONTINUE
};
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;
cs_shared_state *p_state;
cs_identLink *p_callstack = nullptr;
cs_ident_link *p_callstack = nullptr;
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 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_overrides();
@ -482,8 +482,8 @@ struct OSTD_EXPORT cs_state {
void run(ostd::string_range code);
void run(cs_ident *id, cs_value_r args);
CsLoopState run_loop(cs_bcode *code, cs_value &ret);
CsLoopState run_loop(cs_bcode *code);
cs_loop_state run_loop(cs_bcode *code, cs_value &ret);
cs_loop_state run_loop(cs_bcode *code);
bool is_in_loop() const {
return p_inloop;
@ -855,19 +855,19 @@ private:
) {
for (size_t i = 0; i < vals.size(); ++i) {
switch (vals[i].get_type()) {
case cs_value_type::Int: {
case cs_value_type::INT: {
format_int(
std::forward<R>(writer), vals[i].get_int()
);
break;
}
case cs_value_type::Float: {
case cs_value_type::FLOAT: {
format_float(
std::forward<R>(writer), vals[i].get_float()
);
break;
}
case cs_value_type::String: {
case cs_value_type::STRING: {
ostd::range_put_all(
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>
static inline void csv_cleanup(cs_value_type tv, T &stor) {
switch (tv) {
case cs_value_type::String:
case cs_value_type::STRING:
reinterpret_cast<cs_strref *>(&stor)->~cs_strref();
break;
case cs_value_type::Code: {
case cs_value_type::CODE: {
uint32_t *bcode = csv_get<uint32_t *>(stor);
if (bcode[-1] == CsCodeStart) {
if (bcode[-1] == CS_CODE_START) {
delete[] &bcode[-1];
}
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_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;
}
@ -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) {
csv_cleanup(p_type, p_stor);
p_type = cs_value_type::Null;
p_type = cs_value_type::NONE;
switch (v.get_type()) {
case cs_value_type::Int:
case cs_value_type::Float:
case cs_value_type::Ident:
case cs_value_type::INT:
case cs_value_type::FLOAT:
case cs_value_type::IDENT:
p_type = v.p_type;
p_stor = v.p_stor;
break;
case cs_value_type::String:
p_type = cs_value_type::String;
case cs_value_type::STRING:
p_type = cs_value_type::STRING;
new (&p_stor) cs_strref{
*reinterpret_cast<cs_strref const *>(&v.p_stor)
};
break;
case cs_value_type::Code:
case cs_value_type::CODE:
set_code(cs_copy_code(v.get_code()));
break;
default:
@ -81,64 +81,64 @@ cs_value_type cs_value::get_type() const {
void cs_value::set_int(cs_int val) {
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;
}
void cs_value::set_float(cs_float val) {
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;
}
void cs_value::set_str(ostd::string_range val) {
csv_cleanup(p_type, p_stor);
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) {
csv_cleanup(p_type, p_stor);
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);
p_type = cs_value_type::Null;
p_type = cs_value_type::NONE;
}
void cs_value::set_code(cs_bcode *val) {
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;
}
void cs_value::set_ident(cs_ident *val) {
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;
}
void cs_value::force_null() {
if (get_type() == cs_value_type::Null) {
void cs_value::force_none() {
if (get_type() == cs_value_type::NONE) {
return;
}
set_null();
set_none();
}
cs_float cs_value::force_float() {
cs_float rf = 0.0f;
switch (get_type()) {
case cs_value_type::Int:
case cs_value_type::INT:
rf = csv_get<cs_int>(p_stor);
break;
case cs_value_type::String:
case cs_value_type::STRING:
rf = cs_parse_float(ostd::string_range(
*reinterpret_cast<cs_strref const *>(&p_stor)
));
break;
case cs_value_type::Float:
case cs_value_type::FLOAT:
return csv_get<cs_float>(p_stor);
default:
break;
@ -150,15 +150,15 @@ cs_float cs_value::force_float() {
cs_int cs_value::force_int() {
cs_int ri = 0;
switch (get_type()) {
case cs_value_type::Float:
case cs_value_type::FLOAT:
ri = csv_get<cs_float>(p_stor);
break;
case cs_value_type::String:
case cs_value_type::STRING:
ri = cs_parse_int(ostd::string_range(
*reinterpret_cast<cs_strref const *>(&p_stor)
));
break;
case cs_value_type::Int:
case cs_value_type::INT:
return csv_get<cs_int>(p_stor);
default:
break;
@ -170,13 +170,13 @@ cs_int cs_value::force_int() {
ostd::string_range cs_value::force_str() {
cs_string rs;
switch (get_type()) {
case cs_value_type::Float:
case cs_value_type::FLOAT:
rs = floatstr(csv_get<cs_float>(p_stor));
break;
case cs_value_type::Int:
case cs_value_type::INT:
rs = intstr(csv_get<cs_int>(p_stor));
break;
case cs_value_type::String:
case cs_value_type::STRING:
return ostd::string_range(
*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 {
switch (get_type()) {
case cs_value_type::Float:
case cs_value_type::FLOAT:
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);
case cs_value_type::String:
case cs_value_type::STRING:
return cs_parse_int(ostd::string_range(
*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 {
switch (get_type()) {
case cs_value_type::Float:
case cs_value_type::FLOAT:
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));
case cs_value_type::String:
case cs_value_type::STRING:
return cs_parse_float(ostd::string_range(
*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 {
if (get_type() != cs_value_type::Code) {
if (get_type() != cs_value_type::CODE) {
return nullptr;
}
return csv_get<cs_bcode *>(p_stor);
}
cs_ident *cs_value::get_ident() const {
if (get_type() != cs_value_type::Ident) {
if (get_type() != cs_value_type::IDENT) {
return nullptr;
}
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 {
switch (get_type()) {
case cs_value_type::String:
case cs_value_type::STRING:
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))};
case cs_value_type::Float:
case cs_value_type::FLOAT:
return cs_strref{*state(), floatstr(csv_get<cs_float>(p_stor))};
default:
break;
@ -249,17 +249,17 @@ cs_strref cs_value::get_str() const {
void cs_value::get_val(cs_value &r) const {
switch (get_type()) {
case cs_value_type::String:
case cs_value_type::STRING:
r = *this;
break;
case cs_value_type::Int:
case cs_value_type::INT:
r.set_int(csv_get<cs_int>(p_stor));
break;
case cs_value_type::Float:
case cs_value_type::FLOAT:
r.set_float(csv_get<cs_float>(p_stor));
break;
default:
r.set_null();
r.set_none();
break;
}
}
@ -269,12 +269,12 @@ OSTD_EXPORT bool cs_code_is_empty(cs_bcode *code) {
return true;
}
return (
*reinterpret_cast<uint32_t *>(code) & CsCodeOpMask
) == CsCodeExit;
*reinterpret_cast<uint32_t *>(code) & CS_CODE_OP_MASK
) == CS_CODE_EXIT;
}
bool cs_value::code_is_empty() const {
if (get_type() != cs_value_type::Code) {
if (get_type() != cs_value_type::CODE) {
return true;
}
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 {
switch (get_type()) {
case cs_value_type::Float:
case cs_value_type::FLOAT:
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;
case cs_value_type::String:
case cs_value_type::STRING:
return cs_get_bool(ostd::string_range(
*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
};
struct cs_identLink {
struct cs_ident_link {
cs_ident *id;
cs_identLink *next;
cs_ident_link *next;
int usedargs;
cs_ident_stack *argstack;
};
@ -54,12 +54,14 @@ struct cs_valarray {
};
enum {
CsValNull = 0, CsValInt, CsValFloat, CsValString,
CsValAny, CsValCode, CsValIdent, CsValWord, CsValPop, CsValCond
CS_VAL_NULL = 0, CS_VAL_INT, CS_VAL_FLOAT, CS_VAL_STRING,
CS_VAL_ANY, CS_VAL_CODE, CS_VAL_IDENT, CS_VAL_WORD,
CS_VAL_POP, CS_VAL_COND
};
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) {
@ -68,48 +70,48 @@ static inline int cs_vtype_to_int(cs_value_type v) {
/* instruction: uint32 [length 24][retflag 2][opcode 6] */
enum {
CsCodeStart = 0,
CsCodeOffset,
CsCodeNull, CsCodeTrue, CsCodeFalse, CsCodeNot,
CsCodePop,
CsCodeEnter, CsCodeEnterResult,
CsCodeExit, CsCodeResultArg,
CsCodeVal, CsCodeValInt,
CsCodeDup,
CsCodeBool,
CsCodeBlock, CsCodeEmpty,
CsCodeCompile, CsCodeCond,
CsCodeForce,
CsCodeResult,
CsCodeIdent, CsCodeIdentU, CsCodeIdentArg,
CsCodeCom, CsCodeComC, CsCodeComV,
CsCodeConc, CsCodeConcW, CsCodeConcM,
CsCodeSvar, CsCodeSvar1,
CsCodeIvar, CsCodeIvar1, CsCodeIvar2, CsCodeIvar3,
CsCodeFvar, CsCodeFvar1,
CsCodeLookup, CsCodeLookupU, CsCodeLookupArg,
CsCodeLookupM, CsCodeLookupMu, CsCodeLookupMarg,
CsCodeAlias, CsCodeAliasU, CsCodeAliasArg,
CsCodeCall, CsCodeCallU, CsCodeCallArg,
CsCodePrint,
CsCodeLocal,
CsCodeDo, CsCodeDoArgs,
CsCodeJump, CsCodeJumpB, CsCodeJumpResult,
CsCodeBreak,
CS_CODE_START = 0,
CS_CODE_OFFSET,
CS_CODE_NULL, CS_CODE_TRUE, CS_CODE_FALSE, CS_CODE_NOT,
CS_CODE_POP,
CS_CODE_ENTER, CS_CODE_ENTER_RESULT,
CS_CODE_EXIT, CS_CODE_RESULT_ARG,
CS_CODE_VAL, CS_CODE_VAL_INT,
CS_CODE_DUP,
CS_CODE_BOOL,
CS_CODE_BLOCK, CS_CODE_EMPTY,
CS_CODE_COMPILE, CS_CODE_COND,
CS_CODE_FORCE,
CS_CODE_RESULT,
CS_CODE_IDENT, CS_CODE_IDENT_U, CS_CODE_IDENT_ARG,
CS_CODE_COM, CS_CODE_COM_C, CS_CODE_COM_V,
CS_CODE_CONC, CS_CODE_CONC_W, CS_CODE_CONC_M,
CS_CODE_SVAR, CS_CODE_SVAR1,
CS_CODE_IVAR, CS_CODE_IVAR1, CS_CODE_IVAR2, CS_CODE_IVAR3,
CS_CODE_FVAR, CS_CODE_FVAR1,
CS_CODE_LOOKUP, CS_CODE_LOOKUP_U, CS_CODE_LOOKUP_ARG,
CS_CODE_LOOKUP_M, CS_CODE_LOOKUP_MU, CS_CODE_LOOKUP_MARG,
CS_CODE_ALIAS, CS_CODE_ALIAS_U, CS_CODE_ALIAS_ARG,
CS_CODE_CALL, CS_CODE_CALL_U, CS_CODE_CALL_ARG,
CS_CODE_PRINT,
CS_CODE_LOCAL,
CS_CODE_DO, CS_CODE_DO_ARGS,
CS_CODE_JUMP, CS_CODE_JUMP_B, CS_CODE_JUMP_RESULT,
CS_CODE_BREAK,
CsCodeOpMask = 0x3F,
CsCodeRet = 6,
CsCodeRetMask = 0xC0,
CS_CODE_OP_MASK = 0x3F,
CS_CODE_RET = 6,
CS_CODE_RET_MASK = 0xC0,
/* return type flags */
CsRetNull = CsValNull << CsCodeRet,
CsRetString = CsValString << CsCodeRet,
CsRetInt = CsValInt << CsCodeRet,
CsRetFloat = CsValFloat << CsCodeRet,
CS_RET_NULL = CS_VAL_NULL << CS_CODE_RET,
CS_RET_STRING = CS_VAL_STRING << CS_CODE_RET,
CS_RET_INT = CS_VAL_INT << CS_CODE_RET,
CS_RET_FLOAT = CS_VAL_FLOAT << CS_CODE_RET,
/* CsCodeJumpB, CsCodeJumpResult */
CsCodeFlagTrue = 1 << CsCodeRet,
CsCodeFlagFalse = 0 << CsCodeRet
/* CS_CODE_JUMP_B, CS_CODE_JUMP_RESULT */
CS_CODE_FLAG_TRUE = 1 << CS_CODE_RET,
CS_CODE_FLAG_FALSE = 0 << CS_CODE_RET
};
struct cs_shared_state {
@ -199,7 +201,7 @@ struct cs_gen_state {
void gen_str(ostd::string_range word) {
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) {
op |= uint32_t(
static_cast<unsigned char>(word[i])
@ -208,7 +210,7 @@ struct cs_gen_state {
code.push_back(op);
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());
code.insert(
code.end(), it, it + (word.size() / sizeof(uint32_t))
@ -224,23 +226,23 @@ struct cs_gen_state {
}
void gen_str() {
code.push_back(CsCodeValInt | CsRetString);
code.push_back(CS_CODE_VAL_INT | CS_RET_STRING);
}
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) {
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 {
union {
cs_int i;
uint32_t u[CsTypeStorageSize<cs_int>];
} c;
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>);
}
}
@ -249,14 +251,14 @@ struct cs_gen_state {
void gen_float(cs_float f = 0.0f) {
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 {
union {
cs_float f;
uint32_t u[CsTypeStorageSize<cs_float>];
} c;
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>);
}
}
@ -266,8 +268,8 @@ struct cs_gen_state {
void gen_ident(cs_ident *id) {
code.push_back(
((id->get_index() < MaxArguments)
? CsCodeIdentArg
: CsCodeIdent
? CS_CODE_IDENT_ARG
: CS_CODE_IDENT
) | (id->get_index() << 8)
);
}
@ -285,7 +287,7 @@ struct cs_gen_state {
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() {
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_identLink aliaslink = {
cs_ident_link *prevstack = cs.p_callstack->next;
cs_ident_link aliaslink = {
cs.p_callstack->id, cs.p_callstack,
prevstack ? prevstack->usedargs : ((1 << MaxArguments) - 1),
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_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)
{}
cs_fvar::cs_fvar(
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)
{}
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}
{}
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_val.set_str(a);
}
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_val.set_str(a);
}
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_val.set_int(a);
}
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_val.set_float(a);
}
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_val.set_null();
p_val.set_none();
}
/* FIXME: use cs rather than val's cs */
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)
{}
cs_command::cs_command(
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)
{}
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() {
@ -119,7 +119,7 @@ cs_alias const *cs_ident::get_alias() 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() {
@ -137,12 +137,12 @@ cs_command const *cs_ident::get_command() 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 {
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() {
@ -160,7 +160,7 @@ cs_var const *cs_ident::get_var() 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() {
@ -178,7 +178,7 @@ cs_ivar const *cs_ident::get_ivar() 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() {
@ -196,7 +196,7 @@ cs_fvar const *cs_ident::get_fvar() 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() {
@ -387,7 +387,7 @@ OSTD_EXPORT void cs_state::destroy() {
cs_ident *i = p.second;
cs_alias *a = i->get_alias();
if (a) {
a->get_value().force_null();
a->get_value().force_none();
cs_alias_internal::clean_code(a);
}
p_state->destroy(i);
@ -437,25 +437,25 @@ OSTD_EXPORT void cs_state::clear_override(cs_ident &id) {
return;
}
switch (id.get_type()) {
case cs_ident_type::Alias: {
case cs_ident_type::ALIAS: {
cs_alias &a = static_cast<cs_alias &>(id);
cs_alias_internal::clean_code(&a);
a.get_value().set_str("");
break;
}
case cs_ident_type::Ivar: {
case cs_ident_type::IVAR: {
cs_ivar &iv = static_cast<cs_ivar &>(id);
iv.set_value(iv.p_overrideval);
iv.changed(*this);
break;
}
case cs_ident_type::Fvar: {
case cs_ident_type::FVAR: {
cs_fvar &fv = static_cast<cs_fvar &>(id);
fv.set_value(fv.p_overrideval);
fv.changed(*this);
break;
}
case cs_ident_type::Svar: {
case cs_ident_type::SVAR: {
cs_svar &sv = static_cast<cs_svar &>(id);
sv.set_value(sv.p_overrideval);
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) {
switch (v.get_type()) {
case cs_value_type::Ident:
case cs_value_type::IDENT:
return v.get_ident();
case cs_value_type::String: {
case cs_value_type::STRING: {
cs_ident *id = new_ident(v.get_str());
v.set_ident(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);
if (id) {
switch (id->get_type()) {
case cs_ident_type::Alias: {
case cs_ident_type::ALIAS: {
cs_alias *a = static_cast<cs_alias *>(id);
if (a->get_index() < MaxArguments) {
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;
}
case cs_ident_type::Ivar:
case cs_ident_type::IVAR:
set_var_int_checked(static_cast<cs_ivar *>(id), v.get_int());
break;
case cs_ident_type::Fvar:
case cs_ident_type::FVAR:
set_var_float_checked(static_cast<cs_fvar *>(id), v.get_float());
break;
case cs_ident_type::Svar:
case cs_ident_type::SVAR:
set_var_str_checked(static_cast<cs_svar *>(id), v.get_str());
break;
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 {
switch (p_val.get_type()) {
case cs_value_type::String:
case cs_value_type::STRING:
v = p_val;
break;
case cs_value_type::Int:
case cs_value_type::INT:
v.set_int(p_val.get_int());
break;
case cs_value_type::Float:
case cs_value_type::FLOAT:
v.set_float(p_val.get_float());
break;
default:
v.set_null();
v.set_none();
break;
}
}
cs_ident_type cs_ident::get_type() const {
if (p_type > CsIdAlias) {
return cs_ident_type::Special;
return cs_ident_type::SPECIAL;
}
return cs_ident_type(p_type);
}
@ -986,7 +986,7 @@ static inline void cs_do_loop(
break;
}
switch (cs.run_loop(body)) {
case CsLoopState::Break:
case cs_loop_state::BREAK:
goto end;
default: /* continue and normal */
break;
@ -1010,9 +1010,9 @@ static inline void cs_loop_conc(
idv.push();
cs_value v{cs};
switch (cs.run_loop(body, v)) {
case CsLoopState::Break:
case cs_loop_state::BREAK:
goto end;
case CsLoopState::Continue:
case cs_loop_state::CONTINUE:
continue;
default:
break;
@ -1082,7 +1082,7 @@ void cs_init_lib_base(cs_state &gcs) {
cs_int val = args[0].get_int();
for (size_t i = 1; (i + 1) < args.size(); i += 2) {
if (
(args[i].get_type() == cs_value_type::Null) ||
(args[i].get_type() == cs_value_type::NONE) ||
(args[i].get_int() == val)
) {
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();
for (size_t i = 1; (i + 1) < args.size(); i += 2) {
if (
(args[i].get_type() == cs_value_type::Null) ||
(args[i].get_type() == cs_value_type::NONE) ||
(args[i].get_float() == val)
) {
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();
for (size_t i = 1; (i + 1) < args.size(); i += 2) {
if (
(args[i].get_type() == cs_value_type::Null) ||
(args[i].get_type() == cs_value_type::NONE) ||
(args[i].get_str() == val)
) {
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();
while (cs.run_bool(cond)) {
switch (cs.run_loop(body)) {
case CsLoopState::Break:
case cs_loop_state::BREAK:
goto end;
default: /* continue and normal */
break;
@ -1311,13 +1311,13 @@ void cs_init_lib_string(cs_state &cs);
void cs_init_lib_list(cs_state &cs);
OSTD_EXPORT void cs_state::init_libs(int libs) {
if (libs & CsLibMath) {
if (libs & CS_LIB_MATH) {
cs_init_lib_math(*this);
}
if (libs & CsLibString) {
if (libs & CS_LIB_STRING) {
cs_init_lib_string(*this);
}
if (libs & CsLibList) {
if (libs & CS_LIB_LIST) {
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};
switch (cs.run_loop(body, v)) {
case CsLoopState::Break:
case cs_loop_state::BREAK:
goto end;
case CsLoopState::Continue:
case cs_loop_state::CONTINUE:
continue;
default:
break;
@ -294,7 +294,7 @@ void cs_init_lib_list(cs_state &gcs) {
idv.set_str(p.get_item());
idv.push();
switch (cs.run_loop(body)) {
case CsLoopState::Break:
case cs_loop_state::BREAK:
goto end;
default: /* continue and normal */
break;
@ -322,7 +322,7 @@ end:
idv1.push();
idv2.push();
switch (cs.run_loop(body)) {
case CsLoopState::Break:
case cs_loop_state::BREAK:
goto end;
default: /* continue and normal */
break;
@ -357,7 +357,7 @@ end:
idv2.push();
idv3.push();
switch (cs.run_loop(body)) {
case CsLoopState::Break:
case cs_loop_state::BREAK:
goto end;
default: /* continue and normal */
break;
@ -557,8 +557,8 @@ static void cs_list_sort(
}
cs_stacked_value xval{cs, xa}, yval{cs, ya};
xval.set_null();
yval.set_null();
xval.set_none();
yval.set_none();
xval.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 */
static void repl_print_var(cs_state const &cs, cs_var const &var) {
switch (var.get_type()) {
case cs_ident_type::Ivar: {
case cs_ident_type::IVAR: {
auto &iv = static_cast<cs_ivar const &>(var);
auto val = iv.get_value();
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;
}
case cs_ident_type::Fvar: {
case cs_ident_type::FVAR: {
auto &fv = static_cast<cs_fvar const &>(var);
auto val = fv.get_value();
ostd::writefln(
@ -214,7 +214,7 @@ static void repl_print_var(cs_state const &cs, cs_var const &var) {
);
break;
}
case cs_ident_type::Svar: {
case cs_ident_type::SVAR: {
auto &sv = static_cast<cs_svar const &>(var);
auto val = ostd::string_range{sv.get_value()};
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);
scs = nullptr;
if (ret.get_type() != cs_value_type::Null) {
if (ret.get_type() != cs_value_type::NONE) {
ostd::writeln(ret.get_str());
}
return false;