diff --git a/include/cubescript/cubescript.hh b/include/cubescript/cubescript.hh index ac3dea3..dbf0ce9 100644 --- a/include/cubescript/cubescript.hh +++ b/include/cubescript/cubescript.hh @@ -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(writer), vals[i].get_int() ); break; } - case cs_value_type::Float: { + case cs_value_type::FLOAT: { format_float( std::forward(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()} ); diff --git a/src/cs_gen.cc b/src/cs_gen.cc index 0b06566..17dcc4e 100644 --- a/src/cs_gen.cc +++ b/src/cs_gen.cc @@ -99,10 +99,10 @@ ostd::string_range cs_gen_state::get_word() { } static inline int cs_ret_code(int type, int def = 0) { - if (type >= CsValAny) { - return (type == CsValString) ? CsRetString : def; + if (type >= CS_VAL_ANY) { + return (type == CS_VAL_STRING) ? CS_RET_STRING : def; } - return type << CsCodeRet; + return type << CS_CODE_RET; } static void compilestatements( @@ -110,7 +110,7 @@ static void compilestatements( ); static inline std::pair compileblock( cs_gen_state &gs, ostd::string_range p, size_t line, - int rettype = CsRetNull, int brak = '\0' + int rettype = CS_RET_NULL, int brak = '\0' ); void cs_gen_state::gen_int(ostd::string_range word) { @@ -123,33 +123,33 @@ void cs_gen_state::gen_float(ostd::string_range word) { void cs_gen_state::gen_value(int wordtype, ostd::string_range word, int line) { switch (wordtype) { - case CsValAny: + case CS_VAL_ANY: if (!word.empty()) { gen_str(word); } else { gen_null(); } break; - case CsValString: + case CS_VAL_STRING: gen_str(word); break; - case CsValFloat: + case CS_VAL_FLOAT: gen_float(word); break; - case CsValInt: + case CS_VAL_INT: gen_int(word); break; - case CsValCond: + case CS_VAL_COND: if (!word.empty()) { compileblock(*this, word, line); } else { gen_null(); } break; - case CsValCode: + case CS_VAL_CODE: compileblock(*this, word, line); break; - case CsValIdent: + case CS_VAL_IDENT: gen_ident(word); break; default: @@ -158,40 +158,40 @@ void cs_gen_state::gen_value(int wordtype, ostd::string_range word, int line) { } static inline void compileblock(cs_gen_state &gs) { - gs.code.push_back(CsCodeEmpty); + gs.code.push_back(CS_CODE_EMPTY); } static inline std::pair compileblock( cs_gen_state &gs, ostd::string_range p, size_t line, int rettype, int brak ) { size_t start = gs.code.size(); - gs.code.push_back(CsCodeBlock); - gs.code.push_back(CsCodeOffset | ((start + 2) << 8)); + gs.code.push_back(CS_CODE_BLOCK); + gs.code.push_back(CS_CODE_OFFSET | ((start + 2) << 8)); size_t retline = line; if (p) { ostd::string_range op = gs.source; size_t oldline = gs.current_line; gs.source = p; gs.current_line = line; - compilestatements(gs, CsValAny, brak); + compilestatements(gs, CS_VAL_ANY, brak); p = gs.source; retline = gs.current_line; gs.source = op; gs.current_line = oldline; } if (gs.code.size() > start + 2) { - gs.code.push_back(CsCodeExit | rettype); + gs.code.push_back(CS_CODE_EXIT | rettype); gs.code[start] |= uint32_t(gs.code.size() - (start + 1)) << 8; } else { gs.code.resize(start); - gs.code.push_back(CsCodeEmpty | rettype); + gs.code.push_back(CS_CODE_EMPTY | rettype); } return std::make_pair(p, retline); } static inline void compileunescapestr(cs_gen_state &gs) { auto str = gs.get_str(); - gs.code.push_back(CsCodeVal | CsRetString); + gs.code.push_back(CS_CODE_VAL | CS_RET_STRING); gs.code.reserve( gs.code.size() + str.size() / sizeof(uint32_t) + 1 ); @@ -217,12 +217,12 @@ static void compilelookup(cs_gen_state &gs, int ltype, int prevargs = MaxResults switch (gs.current()) { case '(': case '[': - if (!compilearg(gs, CsValString, prevargs)) { + if (!compilearg(gs, CS_VAL_STRING, prevargs)) { goto invalid; } break; case '$': - compilelookup(gs, CsValString, prevargs); + compilelookup(gs, CS_VAL_STRING, prevargs); break; case '\"': lookup = gs.get_str_dup(); @@ -234,88 +234,88 @@ lookupid: cs_ident *id = gs.cs.new_ident(lookup); if (id) { switch (id->get_type()) { - case cs_ident_type::Ivar: + case cs_ident_type::IVAR: gs.code.push_back( - CsCodeIvar | cs_ret_code(ltype, CsRetInt) | + CS_CODE_IVAR | cs_ret_code(ltype, CS_RET_INT) | (id->get_index() << 8) ); switch (ltype) { - case CsValPop: + case CS_VAL_POP: gs.code.pop_back(); break; - case CsValCode: - gs.code.push_back(CsCodeCompile); + case CS_VAL_CODE: + gs.code.push_back(CS_CODE_COMPILE); break; - case CsValIdent: - gs.code.push_back(CsCodeIdentU); + case CS_VAL_IDENT: + gs.code.push_back(CS_CODE_IDENT_U); break; } return; - case cs_ident_type::Fvar: + case cs_ident_type::FVAR: gs.code.push_back( - CsCodeFvar | cs_ret_code(ltype, CsRetFloat) | + CS_CODE_FVAR | cs_ret_code(ltype, CS_RET_FLOAT) | (id->get_index() << 8) ); switch (ltype) { - case CsValPop: + case CS_VAL_POP: gs.code.pop_back(); break; - case CsValCode: - gs.code.push_back(CsCodeCompile); + case CS_VAL_CODE: + gs.code.push_back(CS_CODE_COMPILE); break; - case CsValIdent: - gs.code.push_back(CsCodeIdentU); + case CS_VAL_IDENT: + gs.code.push_back(CS_CODE_IDENT_U); break; } return; - case cs_ident_type::Svar: + case cs_ident_type::SVAR: switch (ltype) { - case CsValPop: + case CS_VAL_POP: return; default: gs.code.push_back( - CsCodeSvar | cs_ret_code(ltype, CsRetString) | + CS_CODE_SVAR | cs_ret_code(ltype, CS_RET_STRING) | (id->get_index() << 8) ); break; } goto done; - case cs_ident_type::Alias: + case cs_ident_type::ALIAS: switch (ltype) { - case CsValPop: + case CS_VAL_POP: return; - case CsValCond: + case CS_VAL_COND: gs.code.push_back( (id->get_index() < MaxArguments - ? CsCodeLookupMarg - : CsCodeLookupM + ? CS_CODE_LOOKUP_MARG + : CS_CODE_LOOKUP_M ) | (id->get_index() << 8) ); break; - case CsValCode: - case CsValIdent: + case CS_VAL_CODE: + case CS_VAL_IDENT: gs.code.push_back( (id->get_index() < MaxArguments - ? CsCodeLookupMarg - : CsCodeLookupM - ) | CsRetString | (id->get_index() << 8) + ? CS_CODE_LOOKUP_MARG + : CS_CODE_LOOKUP_M + ) | CS_RET_STRING | (id->get_index() << 8) ); break; default: gs.code.push_back( (id->get_index() < MaxArguments - ? CsCodeLookupArg - : CsCodeLookup - ) | cs_ret_code(ltype, CsRetString) | + ? CS_CODE_LOOKUP_ARG + : CS_CODE_LOOKUP + ) | cs_ret_code(ltype, CS_RET_STRING) | (id->get_index() << 8) ); break; } goto done; - case cs_ident_type::Command: { - int comtype = CsCodeCom, numargs = 0; + case cs_ident_type::COMMAND: { + int comtype = CS_CODE_COM, numargs = 0; if (prevargs >= MaxResults) { - gs.code.push_back(CsCodeEnter); + gs.code.push_back(CS_CODE_ENTER); } auto fmt = static_cast(id)->get_args(); for (char c: fmt) { @@ -341,7 +341,7 @@ lookupid: numargs++; break; case 'F': - gs.code.push_back(CsCodeDup | CsRetFloat); + gs.code.push_back(CS_CODE_DUP | CS_RET_FLOAT); numargs++; break; case 'E': @@ -367,10 +367,10 @@ lookupid: numargs++; break; case 'C': - comtype = CsCodeComC; + comtype = CS_CODE_COM_C; goto compilecomv; case 'V': - comtype = CsCodeComV; + comtype = CS_CODE_COM_V; goto compilecomv; case '1': case '2': @@ -384,8 +384,8 @@ lookupid: ); gs.code.push_back( (prevargs >= MaxResults - ? CsCodeExit - : CsCodeResultArg + ? CS_CODE_EXIT + : CS_CODE_RESULT_ARG ) | cs_ret_code(ltype) ); goto done; @@ -396,8 +396,8 @@ lookupid: ); gs.code.push_back( (prevargs >= MaxResults - ? CsCodeExit - : CsCodeResultArg + ? CS_CODE_EXIT + : CS_CODE_RESULT_ARG ) | cs_ret_code(ltype) ); goto done; @@ -411,41 +411,41 @@ lookupid: } } switch (ltype) { - case CsValCond: - gs.code.push_back(CsCodeLookupMu); + case CS_VAL_COND: + gs.code.push_back(CS_CODE_LOOKUP_MU); break; - case CsValCode: - case CsValIdent: - gs.code.push_back(CsCodeLookupMu | CsRetString); + case CS_VAL_CODE: + case CS_VAL_IDENT: + gs.code.push_back(CS_CODE_LOOKUP_MU | CS_RET_STRING); break; default: - gs.code.push_back(CsCodeLookupU | cs_ret_code(ltype)); + gs.code.push_back(CS_CODE_LOOKUP_U | cs_ret_code(ltype)); break; } done: switch (ltype) { - case CsValPop: - gs.code.push_back(CsCodePop); + case CS_VAL_POP: + gs.code.push_back(CS_CODE_POP); break; - case CsValCode: - gs.code.push_back(CsCodeCompile); + case CS_VAL_CODE: + gs.code.push_back(CS_CODE_COMPILE); break; - case CsValCond: - gs.code.push_back(CsCodeCond); + case CS_VAL_COND: + gs.code.push_back(CS_CODE_COND); break; - case CsValIdent: - gs.code.push_back(CsCodeIdentU); + case CS_VAL_IDENT: + gs.code.push_back(CS_CODE_IDENT_U); break; } return; invalid: switch (ltype) { - case CsValPop: + case CS_VAL_POP: break; - case CsValNull: - case CsValAny: - case CsValWord: - case CsValCond: + case CS_VAL_NULL: + case CS_VAL_ANY: + case CS_VAL_WORD: + case CS_VAL_COND: gs.gen_null(); break; default: @@ -456,7 +456,7 @@ invalid: static bool compileblockstr(cs_gen_state &gs, ostd::string_range str) { int startc = gs.code.size(); - gs.code.push_back(CsCodeVal | CsRetString); + gs.code.push_back(CS_CODE_VAL | CS_RET_STRING); gs.code.reserve(gs.code.size() + str.size() / sizeof(uint32_t) + 1); char *buf = new char[(str.size() / sizeof(uint32_t) + 1) * sizeof(uint32_t)]; int len = 0; @@ -508,15 +508,15 @@ static bool compileblocksub(cs_gen_state &gs, int prevargs) { cs_string lookup; switch (gs.current()) { case '(': - if (!compilearg(gs, CsValAny, prevargs)) { + if (!compilearg(gs, CS_VAL_ANY, prevargs)) { return false; } break; case '[': - if (!compilearg(gs, CsValString, prevargs)) { + if (!compilearg(gs, CS_VAL_STRING, prevargs)) { return false; } - gs.code.push_back(CsCodeLookupMu); + gs.code.push_back(CS_CODE_LOOKUP_MU); break; case '\"': lookup = gs.get_str_dup(); @@ -530,20 +530,20 @@ lookupid: cs_ident *id = gs.cs.new_ident(lookup); if (id) { switch (id->get_type()) { - case cs_ident_type::Ivar: - gs.code.push_back(CsCodeIvar | (id->get_index() << 8)); + case cs_ident_type::IVAR: + gs.code.push_back(CS_CODE_IVAR | (id->get_index() << 8)); goto done; - case cs_ident_type::Fvar: - gs.code.push_back(CsCodeFvar | (id->get_index() << 8)); + case cs_ident_type::FVAR: + gs.code.push_back(CS_CODE_FVAR | (id->get_index() << 8)); goto done; - case cs_ident_type::Svar: - gs.code.push_back(CsCodeSvar | (id->get_index() << 8)); + case cs_ident_type::SVAR: + gs.code.push_back(CS_CODE_SVAR | (id->get_index() << 8)); goto done; - case cs_ident_type::Alias: + case cs_ident_type::ALIAS: gs.code.push_back( (id->get_index() < MaxArguments - ? CsCodeLookupMarg - : CsCodeLookupM + ? CS_CODE_LOOKUP_MARG + : CS_CODE_LOOKUP_M ) | (id->get_index() << 8) ); goto done; @@ -552,7 +552,7 @@ lookupid: } } gs.gen_str(lookup); - gs.code.push_back(CsCodeLookupMu); + gs.code.push_back(CS_CODE_LOOKUP_MU); done: break; } @@ -600,10 +600,10 @@ static void compileblockmain(cs_gen_state &gs, int wordtype, int prevargs) { return; } if (!concs && prevargs >= MaxResults) { - gs.code.push_back(CsCodeEnter); + gs.code.push_back(CS_CODE_ENTER); } if (concs + 2 > MaxArguments) { - gs.code.push_back(CsCodeConcW | CsRetString | (concs << 8)); + gs.code.push_back(CS_CODE_CONC_W | CS_RET_STRING | (concs << 8)); concs = 1; } if (compileblockstr(gs, ostd::string_range(start, esc))) { @@ -628,18 +628,18 @@ static void compileblockmain(cs_gen_state &gs, int wordtype, int prevargs) { if (gs.source.data() - 1 > start) { if (!concs) { switch (wordtype) { - case CsValPop: + case CS_VAL_POP: return; - case CsValCode: - case CsValCond: { + case CS_VAL_CODE: + case CS_VAL_COND: { auto ret = compileblock(gs, ostd::string_range( start, gs.source.data() + gs.source.size() - ), curline, CsRetNull, ']'); + ), curline, CS_RET_NULL, ']'); gs.source = ret.first; gs.current_line = ret.second; return; } - case CsValIdent: + case CS_VAL_IDENT: gs.gen_ident(ostd::string_range(start, gs.source.data() - 1)); return; } @@ -651,43 +651,43 @@ static void compileblockmain(cs_gen_state &gs, int wordtype, int prevargs) { } if (concs) { if (prevargs >= MaxResults) { - gs.code.push_back(CsCodeConcM | cs_ret_code(wordtype) | (concs << 8)); - gs.code.push_back(CsCodeExit | cs_ret_code(wordtype)); + gs.code.push_back(CS_CODE_CONC_M | cs_ret_code(wordtype) | (concs << 8)); + gs.code.push_back(CS_CODE_EXIT | cs_ret_code(wordtype)); } else { - gs.code.push_back(CsCodeConcW | cs_ret_code(wordtype) | (concs << 8)); + gs.code.push_back(CS_CODE_CONC_W | cs_ret_code(wordtype) | (concs << 8)); } } switch (wordtype) { - case CsValPop: + case CS_VAL_POP: if (concs || gs.source.data() - 1 > start) { - gs.code.push_back(CsCodePop); + gs.code.push_back(CS_CODE_POP); } break; - case CsValCond: + case CS_VAL_COND: if (!concs && gs.source.data() - 1 <= start) { gs.gen_null(); } else { - gs.code.push_back(CsCodeCond); + gs.code.push_back(CS_CODE_COND); } break; - case CsValCode: + case CS_VAL_CODE: if (!concs && gs.source.data() - 1 <= start) { compileblock(gs); } else { - gs.code.push_back(CsCodeCompile); + gs.code.push_back(CS_CODE_COMPILE); } break; - case CsValIdent: + case CS_VAL_IDENT: if (!concs && gs.source.data() - 1 <= start) { gs.gen_ident(); } else { - gs.code.push_back(CsCodeIdentU); + gs.code.push_back(CS_CODE_IDENT_U); } break; - case CsValString: - case CsValNull: - case CsValAny: - case CsValWord: + case CS_VAL_STRING: + case CS_VAL_NULL: + case CS_VAL_ANY: + case CS_VAL_WORD: if (!concs && gs.source.data() - 1 <= start) { gs.gen_str(); } @@ -697,7 +697,7 @@ static void compileblockmain(cs_gen_state &gs, int wordtype, int prevargs) { if (gs.source.data() - 1 <= start) { gs.gen_value(wordtype); } else { - gs.code.push_back(CsCodeForce | (wordtype << CsCodeRet)); + gs.code.push_back(CS_CODE_FORCE | (wordtype << CS_CODE_RET)); } } break; @@ -711,10 +711,10 @@ static bool compilearg( switch (gs.current()) { case '\"': switch (wordtype) { - case CsValPop: + case CS_VAL_POP: gs.get_str(); break; - case CsValCond: { + case CS_VAL_COND: { size_t line = gs.current_line; auto s = gs.get_str_dup(); if (!s.empty()) { @@ -724,18 +724,18 @@ static bool compilearg( } break; } - case CsValCode: { + case CS_VAL_CODE: { auto s = gs.get_str_dup(); compileblock(gs); break; } - case CsValWord: + case CS_VAL_WORD: if (word) { *word = gs.get_str_dup(); } break; - case CsValAny: - case CsValString: + case CS_VAL_ANY: + case CS_VAL_STRING: compileunescapestr(gs); break; default: { @@ -752,31 +752,31 @@ static bool compilearg( case '(': gs.next_char(); if (prevargs >= MaxResults) { - gs.code.push_back(CsCodeEnter); - compilestatements(gs, CsValAny, ')'); - gs.code.push_back(CsCodeExit | cs_ret_code(wordtype)); + gs.code.push_back(CS_CODE_ENTER); + compilestatements(gs, CS_VAL_ANY, ')'); + gs.code.push_back(CS_CODE_EXIT | cs_ret_code(wordtype)); } else { size_t start = gs.code.size(); - compilestatements(gs, CsValAny, ')', prevargs); + compilestatements(gs, CS_VAL_ANY, ')', prevargs); if (gs.code.size() > start) { - gs.code.push_back(CsCodeResultArg | cs_ret_code(wordtype)); + gs.code.push_back(CS_CODE_RESULT_ARG | cs_ret_code(wordtype)); } else { gs.gen_value(wordtype); return true; } } switch (wordtype) { - case CsValPop: - gs.code.push_back(CsCodePop); + case CS_VAL_POP: + gs.code.push_back(CS_CODE_POP); break; - case CsValCond: - gs.code.push_back(CsCodeCond); + case CS_VAL_COND: + gs.code.push_back(CS_CODE_COND); break; - case CsValCode: - gs.code.push_back(CsCodeCompile); + case CS_VAL_CODE: + gs.code.push_back(CS_CODE_COMPILE); break; - case CsValIdent: - gs.code.push_back(CsCodeIdentU); + case CS_VAL_IDENT: + gs.code.push_back(CS_CODE_IDENT_U); break; } return true; @@ -786,10 +786,10 @@ static bool compilearg( return true; default: switch (wordtype) { - case CsValPop: { + case CS_VAL_POP: { return !gs.get_word().empty(); } - case CsValCond: { + case CS_VAL_COND: { size_t line = gs.current_line; auto s = gs.get_word(); if (s.empty()) { @@ -798,7 +798,7 @@ static bool compilearg( compileblock(gs, s, line); return true; } - case CsValCode: { + case CS_VAL_CODE: { size_t line = gs.current_line; auto s = gs.get_word(); if (s.empty()) { @@ -807,7 +807,7 @@ static bool compilearg( compileblock(gs, s, line); return true; } - case CsValWord: { + case CS_VAL_WORD: { auto w = gs.get_word(); if (word) { *word = w; @@ -830,14 +830,14 @@ static bool compilearg( static void compile_cmd( cs_gen_state &gs, cs_command *id, bool &more, int rettype, int prevargs ) { - int comtype = CsCodeCom, numargs = 0, fakeargs = 0; + int comtype = CS_CODE_COM, numargs = 0, fakeargs = 0; bool rep = false; auto fmt = id->get_args(); for (; !fmt.empty(); ++fmt) { switch (*fmt) { case 's': /* string */ if (more) { - more = compilearg(gs, CsValString, prevargs + numargs); + more = compilearg(gs, CS_VAL_STRING, prevargs + numargs); } if (!more) { if (rep) { @@ -849,7 +849,7 @@ static void compile_cmd( int numconc = 1; while ((numargs + numconc) < MaxArguments) { more = compilearg( - gs, CsValString, prevargs + numargs + numconc + gs, CS_VAL_STRING, prevargs + numargs + numconc ); if (!more) { break; @@ -857,14 +857,14 @@ static void compile_cmd( numconc++; } if (numconc > 1) { - gs.code.push_back(CsCodeConc | CsRetString | (numconc << 8)); + gs.code.push_back(CS_CODE_CONC | CS_RET_STRING | (numconc << 8)); } } numargs++; break; case 'i': /* integer */ if (more) { - more = compilearg(gs, CsValInt, prevargs + numargs); + more = compilearg(gs, CS_VAL_INT, prevargs + numargs); } if (!more) { if (rep) { @@ -877,7 +877,7 @@ static void compile_cmd( break; case 'b': /* integer, INT_MIN default */ if (more) { - more = compilearg(gs, CsValInt, prevargs + numargs); + more = compilearg(gs, CS_VAL_INT, prevargs + numargs); } if (!more) { if (rep) { @@ -890,7 +890,7 @@ static void compile_cmd( break; case 'f': /* float */ if (more) { - more = compilearg(gs, CsValFloat, prevargs + numargs); + more = compilearg(gs, CS_VAL_FLOAT, prevargs + numargs); } if (!more) { if (rep) { @@ -903,13 +903,13 @@ static void compile_cmd( break; case 'F': /* float, prev-argument default */ if (more) { - more = compilearg(gs, CsValFloat, prevargs + numargs); + more = compilearg(gs, CS_VAL_FLOAT, prevargs + numargs); } if (!more) { if (rep) { break; } - gs.code.push_back(CsCodeDup | CsRetFloat); + gs.code.push_back(CS_CODE_DUP | CS_RET_FLOAT); fakeargs++; } numargs++; @@ -917,7 +917,7 @@ static void compile_cmd( case 't': /* any arg */ if (more) { more = compilearg( - gs, CsValAny, + gs, CS_VAL_ANY, prevargs + numargs ); } @@ -932,7 +932,7 @@ static void compile_cmd( break; case 'E': /* condition */ if (more) { - more = compilearg(gs, CsValCond, prevargs + numargs); + more = compilearg(gs, CS_VAL_COND, prevargs + numargs); } if (!more) { if (rep) { @@ -945,7 +945,7 @@ static void compile_cmd( break; case 'e': /* code */ if (more) { - more = compilearg(gs, CsValCode, prevargs + numargs); + more = compilearg(gs, CS_VAL_CODE, prevargs + numargs); } if (!more) { if (rep) { @@ -958,7 +958,7 @@ static void compile_cmd( break; case 'r': /* ident */ if (more) { - more = compilearg(gs, CsValIdent, prevargs + numargs); + more = compilearg(gs, CS_VAL_IDENT, prevargs + numargs); } if (!more) { if (rep) { @@ -978,10 +978,10 @@ static void compile_cmd( numargs++; break; case 'C': /* concatenated string */ - comtype = CsCodeComC; + comtype = CS_CODE_COM_C; if (more) { while (numargs < MaxArguments) { - more = compilearg(gs, CsValAny, prevargs + numargs); + more = compilearg(gs, CS_VAL_ANY, prevargs + numargs); if (!more) { break; } @@ -990,10 +990,10 @@ static void compile_cmd( } goto compilecomv; case 'V': /* varargs */ - comtype = CsCodeComV; + comtype = CS_CODE_COM_V; if (more) { while (numargs < MaxArguments) { - more = compilearg(gs, CsValAny, prevargs + numargs); + more = compilearg(gs, CS_VAL_ANY, prevargs + numargs); if (!more) { break; } @@ -1011,7 +1011,7 @@ static void compile_cmd( rep = true; } else { while (numargs > MaxArguments) { - gs.code.push_back(CsCodePop); + gs.code.push_back(CS_CODE_POP); --numargs; } } @@ -1029,14 +1029,14 @@ compilecomv: static void compile_alias(cs_gen_state &gs, cs_alias *id, bool &more, int prevargs) { int numargs = 0; while (numargs < MaxArguments) { - more = compilearg(gs, CsValAny, prevargs + numargs); + more = compilearg(gs, CS_VAL_ANY, prevargs + numargs); if (!more) { break; } ++numargs; } gs.code.push_back( - (id->get_index() < MaxArguments ? CsCodeCallArg : CsCodeCall) + (id->get_index() < MaxArguments ? CS_CODE_CALL_ARG : CS_CODE_CALL) | (numargs << 8) | (id->get_index() << 13) ); } @@ -1045,7 +1045,7 @@ static void compile_local(cs_gen_state &gs, bool &more, int prevargs) { int numargs = 0; if (more) { while (numargs < MaxArguments) { - more = compilearg(gs, CsValIdent, prevargs + numargs); + more = compilearg(gs, CS_VAL_IDENT, prevargs + numargs); if (!more) { break; } @@ -1053,80 +1053,80 @@ static void compile_local(cs_gen_state &gs, bool &more, int prevargs) { } } if (more) { - while ((more = compilearg(gs, CsValPop))); + while ((more = compilearg(gs, CS_VAL_POP))); } - gs.code.push_back(CsCodeLocal | (numargs << 8)); + gs.code.push_back(CS_CODE_LOCAL | (numargs << 8)); } static void compile_do( cs_gen_state &gs, bool &more, int prevargs, int rettype, int opcode ) { if (more) { - more = compilearg(gs, CsValCode, prevargs); + more = compilearg(gs, CS_VAL_CODE, prevargs); } - gs.code.push_back((more ? opcode : CsCodeNull) | cs_ret_code(rettype)); + gs.code.push_back((more ? opcode : CS_CODE_NULL) | cs_ret_code(rettype)); } static void compile_if( cs_gen_state &gs, cs_ident *id, bool &more, int prevargs, int rettype ) { if (more) { - more = compilearg(gs, CsValAny, prevargs); + more = compilearg(gs, CS_VAL_ANY, prevargs); } if (!more) { - gs.code.push_back(CsCodeNull | cs_ret_code(rettype)); + gs.code.push_back(CS_CODE_NULL | cs_ret_code(rettype)); } else { int start1 = gs.code.size(); - more = compilearg(gs, CsValCode, prevargs + 1); + more = compilearg(gs, CS_VAL_CODE, prevargs + 1); if (!more) { - gs.code.push_back(CsCodePop); - gs.code.push_back(CsCodeNull | cs_ret_code(rettype)); + gs.code.push_back(CS_CODE_POP); + gs.code.push_back(CS_CODE_NULL | cs_ret_code(rettype)); } else { int start2 = gs.code.size(); - more = compilearg(gs, CsValCode, prevargs + 2); + more = compilearg(gs, CS_VAL_CODE, prevargs + 2); uint32_t inst1 = gs.code[start1]; - uint32_t op1 = inst1 & ~CsCodeRetMask; + uint32_t op1 = inst1 & ~CS_CODE_RET_MASK; uint32_t len1 = start2 - (start1 + 1); if (!more) { - if (op1 == (CsCodeBlock | (len1 << 8))) { - gs.code[start1] = (len1 << 8) | CsCodeJumpB | CsCodeFlagFalse; - gs.code[start1 + 1] = CsCodeEnterResult; + if (op1 == (CS_CODE_BLOCK | (len1 << 8))) { + gs.code[start1] = (len1 << 8) | CS_CODE_JUMP_B | CS_CODE_FLAG_FALSE; + gs.code[start1 + 1] = CS_CODE_ENTER_RESULT; gs.code[start1 + len1] = ( - gs.code[start1 + len1] & ~CsCodeRetMask + gs.code[start1 + len1] & ~CS_CODE_RET_MASK ) | cs_ret_code(rettype); return; } compileblock(gs); } else { uint32_t inst2 = gs.code[start2]; - uint32_t op2 = inst2 & ~CsCodeRetMask; + uint32_t op2 = inst2 & ~CS_CODE_RET_MASK; uint32_t len2 = gs.code.size() - (start2 + 1); - if (op2 == (CsCodeBlock | (len2 << 8))) { - if (op1 == (CsCodeBlock | (len1 << 8))) { + if (op2 == (CS_CODE_BLOCK | (len2 << 8))) { + if (op1 == (CS_CODE_BLOCK | (len1 << 8))) { gs.code[start1] = ((start2 - start1) << 8) - | CsCodeJumpB | CsCodeFlagFalse; - gs.code[start1 + 1] = CsCodeEnterResult; + | CS_CODE_JUMP_B | CS_CODE_FLAG_FALSE; + gs.code[start1 + 1] = CS_CODE_ENTER_RESULT; gs.code[start1 + len1] = ( - gs.code[start1 + len1] & ~CsCodeRetMask + gs.code[start1 + len1] & ~CS_CODE_RET_MASK ) | cs_ret_code(rettype); - gs.code[start2] = (len2 << 8) | CsCodeJump; - gs.code[start2 + 1] = CsCodeEnterResult; + gs.code[start2] = (len2 << 8) | CS_CODE_JUMP; + gs.code[start2 + 1] = CS_CODE_ENTER_RESULT; gs.code[start2 + len2] = ( - gs.code[start2 + len2] & ~CsCodeRetMask + gs.code[start2 + len2] & ~CS_CODE_RET_MASK ) | cs_ret_code(rettype); return; - } else if (op1 == (CsCodeEmpty | (len1 << 8))) { - gs.code[start1] = CsCodeNull | (inst2 & CsCodeRetMask); - gs.code[start2] = (len2 << 8) | CsCodeJumpB | CsCodeFlagTrue; - gs.code[start2 + 1] = CsCodeEnterResult; + } else if (op1 == (CS_CODE_EMPTY | (len1 << 8))) { + gs.code[start1] = CS_CODE_NULL | (inst2 & CS_CODE_RET_MASK); + gs.code[start2] = (len2 << 8) | CS_CODE_JUMP_B | CS_CODE_FLAG_TRUE; + gs.code[start2 + 1] = CS_CODE_ENTER_RESULT; gs.code[start2 + len2] = ( - gs.code[start2 + len2] & ~CsCodeRetMask + gs.code[start2 + len2] & ~CS_CODE_RET_MASK ) | cs_ret_code(rettype); return; } } } - gs.code.push_back(CsCodeCom | cs_ret_code(rettype) | (id->get_index() << 8)); + gs.code.push_back(CS_CODE_COM | cs_ret_code(rettype) | (id->get_index() << 8)); } } } @@ -1136,24 +1136,24 @@ static void compile_and_or( ) { int numargs = 0; if (more) { - more = compilearg(gs, CsValCond, prevargs); + more = compilearg(gs, CS_VAL_COND, prevargs); } if (!more) { gs.code.push_back( - ((id->get_type_raw() == CsIdAnd) ? CsCodeTrue : CsCodeFalse) + ((id->get_type_raw() == CsIdAnd) ? CS_CODE_TRUE : CS_CODE_FALSE) | cs_ret_code(rettype) ); } else { numargs++; int start = gs.code.size(), end = start; while (numargs < MaxArguments) { - more = compilearg(gs, CsValCond, prevargs + numargs); + more = compilearg(gs, CS_VAL_COND, prevargs + numargs); if (!more) { break; } numargs++; - if ((gs.code[end] & ~CsCodeRetMask) != ( - CsCodeBlock | (uint32_t(gs.code.size() - (end + 1)) << 8) + if ((gs.code[end] & ~CS_CODE_RET_MASK) != ( + CS_CODE_BLOCK | (uint32_t(gs.code.size() - (end + 1)) << 8) )) { break; } @@ -1161,28 +1161,28 @@ static void compile_and_or( } if (more) { while (numargs < MaxArguments) { - more = compilearg(gs, CsValCond, prevargs + numargs); + more = compilearg(gs, CS_VAL_COND, prevargs + numargs); if (!more) { break; } numargs++; } gs.code.push_back( - CsCodeComV | cs_ret_code(rettype) | + CS_CODE_COM_V | cs_ret_code(rettype) | (numargs << 8) | (id->get_index() << 13) ); } else { uint32_t op = (id->get_type_raw() == CsIdAnd) - ? (CsCodeJumpResult | CsCodeFlagFalse) - : (CsCodeJumpResult | CsCodeFlagTrue); + ? (CS_CODE_JUMP_RESULT | CS_CODE_FLAG_FALSE) + : (CS_CODE_JUMP_RESULT | CS_CODE_FLAG_TRUE); gs.code.push_back(op); end = gs.code.size(); while ((start + 1) < end) { uint32_t len = gs.code[start] >> 8; gs.code[start] = ((end - (start + 1)) << 8) | op; - gs.code[start + 1] = CsCodeEnter; + gs.code[start + 1] = CS_CODE_ENTER; gs.code[start + len] = ( - gs.code[start + len] & ~CsCodeRetMask + gs.code[start + len] & ~CS_CODE_RET_MASK ) | cs_ret_code(rettype); start += len + 1; } @@ -1196,7 +1196,7 @@ static void compilestatements(cs_gen_state &gs, int rettype, int brak, int preva gs.skip_comments(); idname.clear(); size_t curline = gs.current_line; - bool more = compilearg(gs, CsValWord, prevargs, &idname); + bool more = compilearg(gs, CS_VAL_WORD, prevargs, &idname); if (!more) { goto endstatement; } @@ -1219,43 +1219,43 @@ static void compilestatements(cs_gen_state &gs, int rettype, int brak, int preva cs_ident *id = gs.cs.new_ident(idname); if (id) { switch (id->get_type()) { - case cs_ident_type::Alias: - more = compilearg(gs, CsValAny, prevargs); + case cs_ident_type::ALIAS: + more = compilearg(gs, CS_VAL_ANY, prevargs); if (!more) { gs.gen_str(); } gs.code.push_back( (id->get_index() < MaxArguments - ? CsCodeAliasArg - : CsCodeAlias + ? CS_CODE_ALIAS_ARG + : CS_CODE_ALIAS ) | (id->get_index() << 8) ); goto endstatement; - case cs_ident_type::Ivar: - more = compilearg(gs, CsValInt, prevargs); + case cs_ident_type::IVAR: + more = compilearg(gs, CS_VAL_INT, prevargs); if (!more) { gs.gen_int(); } gs.code.push_back( - CsCodeIvar1 | (id->get_index() << 8) + CS_CODE_IVAR1 | (id->get_index() << 8) ); goto endstatement; - case cs_ident_type::Fvar: - more = compilearg(gs, CsValFloat, prevargs); + case cs_ident_type::FVAR: + more = compilearg(gs, CS_VAL_FLOAT, prevargs); if (!more) { gs.gen_float(); } gs.code.push_back( - CsCodeFvar1 | (id->get_index() << 8) + CS_CODE_FVAR1 | (id->get_index() << 8) ); goto endstatement; - case cs_ident_type::Svar: - more = compilearg(gs, CsValString, prevargs); + case cs_ident_type::SVAR: + more = compilearg(gs, CS_VAL_STRING, prevargs); if (!more) { gs.gen_str(); } gs.code.push_back( - CsCodeSvar1 | (id->get_index() << 8) + CS_CODE_SVAR1 | (id->get_index() << 8) ); goto endstatement; default: @@ -1264,11 +1264,11 @@ static void compilestatements(cs_gen_state &gs, int rettype, int brak, int preva } gs.gen_str(idname); } - more = compilearg(gs, CsValAny); + more = compilearg(gs, CS_VAL_ANY); if (!more) { gs.gen_str(); } - gs.code.push_back(CsCodeAliasU); + gs.code.push_back(CS_CODE_ALIAS_U); goto endstatement; } } @@ -1276,13 +1276,13 @@ static void compilestatements(cs_gen_state &gs, int rettype, int brak, int preva noid: int numargs = 0; while (numargs < MaxArguments) { - more = compilearg(gs, CsValAny, prevargs + numargs); + more = compilearg(gs, CS_VAL_ANY, prevargs + numargs); if (!more) { break; } ++numargs; } - gs.code.push_back(CsCodeCallU | (numargs << 8)); + gs.code.push_back(CS_CODE_CALL_U | (numargs << 8)); } else { cs_ident *id = gs.cs.get_ident(idname); if (!id) { @@ -1291,7 +1291,7 @@ noid: goto noid; } switch (rettype) { - case CsValAny: { + case CS_VAL_ANY: { ostd::string_range end = idname; cs_int val = cs_parse_int(end, &end); if (!end.empty()) { @@ -1305,7 +1305,7 @@ noid: gs.gen_value(rettype, idname, curline); break; } - gs.code.push_back(CsCodeResult); + gs.code.push_back(CS_CODE_RESULT); } else { switch (id->get_type_raw()) { case CsIdAlias: @@ -1323,35 +1323,35 @@ noid: compile_local(gs, more, prevargs); break; case CsIdDo: - compile_do(gs, more, prevargs, rettype, CsCodeDo); + compile_do(gs, more, prevargs, rettype, CS_CODE_DO); break; case CsIdDoArgs: - compile_do(gs, more, prevargs, rettype, CsCodeDoArgs); + compile_do(gs, more, prevargs, rettype, CS_CODE_DO_ARGS); break; case CsIdIf: compile_if(gs, id, more, prevargs, rettype); break; case CsIdBreak: - gs.code.push_back(CsCodeBreak | CsCodeFlagFalse); + gs.code.push_back(CS_CODE_BREAK | CS_CODE_FLAG_FALSE); break; case CsIdContinue: - gs.code.push_back(CsCodeBreak | CsCodeFlagTrue); + gs.code.push_back(CS_CODE_BREAK | CS_CODE_FLAG_TRUE); break; case CsIdResult: if (more) { - more = compilearg(gs, CsValAny, prevargs); + more = compilearg(gs, CS_VAL_ANY, prevargs); } gs.code.push_back( - (more ? CsCodeResult : CsCodeNull) | + (more ? CS_CODE_RESULT : CS_CODE_NULL) | cs_ret_code(rettype) ); break; case CsIdNot: if (more) { - more = compilearg(gs, CsValAny, prevargs); + more = compilearg(gs, CS_VAL_ANY, prevargs); } gs.code.push_back( - (more ? CsCodeNot : CsCodeTrue) | cs_ret_code(rettype) + (more ? CS_CODE_NOT : CS_CODE_TRUE) | cs_ret_code(rettype) ); break; case CsIdAnd: @@ -1359,45 +1359,45 @@ noid: compile_and_or(gs, id, more, prevargs, rettype); break; case CsIdIvar: - if (!(more = compilearg(gs, CsValInt, prevargs))) { - gs.code.push_back(CsCodePrint | (id->get_index() << 8)); + if (!(more = compilearg(gs, CS_VAL_INT, prevargs))) { + gs.code.push_back(CS_CODE_PRINT | (id->get_index() << 8)); } else if (!(id->get_flags() & CS_IDF_HEX) || !( - more = compilearg(gs, CsValInt, prevargs + 1) + more = compilearg(gs, CS_VAL_INT, prevargs + 1) )) { - gs.code.push_back(CsCodeIvar1 | (id->get_index() << 8)); + gs.code.push_back(CS_CODE_IVAR1 | (id->get_index() << 8)); } else if (!( - more = compilearg(gs, CsValInt, prevargs + 2) + more = compilearg(gs, CS_VAL_INT, prevargs + 2) )) { - gs.code.push_back(CsCodeIvar2 | (id->get_index() << 8)); + gs.code.push_back(CS_CODE_IVAR2 | (id->get_index() << 8)); } else { - gs.code.push_back(CsCodeIvar3 | (id->get_index() << 8)); + gs.code.push_back(CS_CODE_IVAR3 | (id->get_index() << 8)); } break; case CsIdFvar: - if (!(more = compilearg(gs, CsValFloat, prevargs))) { - gs.code.push_back(CsCodePrint | (id->get_index() << 8)); + if (!(more = compilearg(gs, CS_VAL_FLOAT, prevargs))) { + gs.code.push_back(CS_CODE_PRINT | (id->get_index() << 8)); } else { - gs.code.push_back(CsCodeFvar1 | (id->get_index() << 8)); + gs.code.push_back(CS_CODE_FVAR1 | (id->get_index() << 8)); } break; case CsIdSvar: - if (!(more = compilearg(gs, CsValString, prevargs))) { - gs.code.push_back(CsCodePrint | (id->get_index() << 8)); + if (!(more = compilearg(gs, CS_VAL_STRING, prevargs))) { + gs.code.push_back(CS_CODE_PRINT | (id->get_index() << 8)); } else { int numargs = 0; do { ++numargs; } while (numargs < MaxArguments && ( more = compilearg( - gs, CsValAny, prevargs + numargs + gs, CS_VAL_ANY, prevargs + numargs ) )); if (numargs > 1) { gs.code.push_back( - CsCodeConc | CsRetString | (numargs << 8) + CS_CODE_CONC | CS_RET_STRING | (numargs << 8) ); } - gs.code.push_back(CsCodeSvar1 | (id->get_index() << 8)); + gs.code.push_back(CS_CODE_SVAR1 | (id->get_index() << 8)); } break; } @@ -1405,7 +1405,7 @@ noid: } endstatement: if (more) { - while (compilearg(gs, CsValPop)); + while (compilearg(gs, CS_VAL_POP)); } switch (gs.skip_until(")];/\n")) { case '\0': @@ -1437,9 +1437,9 @@ endstatement: void cs_gen_state::gen_main(ostd::string_range s, int ret_type) { source = s; - code.push_back(CsCodeStart); - compilestatements(*this, CsValAny); - code.push_back(CsCodeExit | ((ret_type < CsValAny) ? (ret_type << CsCodeRet) : 0)); + code.push_back(CS_CODE_START); + compilestatements(*this, CS_VAL_ANY); + code.push_back(CS_CODE_EXIT | ((ret_type < CS_VAL_ANY) ? (ret_type << CS_CODE_RET) : 0)); } } /* namespace cscript */ \ No newline at end of file diff --git a/src/cs_val.cc b/src/cs_val.cc index c88e527..2fa0fda 100644 --- a/src/cs_val.cc +++ b/src/cs_val.cc @@ -19,12 +19,12 @@ static inline T &csv_get(U &stor) { template 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(&stor)->~cs_strref(); break; - case cs_value_type::Code: { + case cs_value_type::CODE: { uint32_t *bcode = csv_get(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 *>(&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(&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(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(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(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(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(p_stor); break; - case cs_value_type::String: + case cs_value_type::STRING: rf = cs_parse_float(ostd::string_range( *reinterpret_cast(&p_stor) )); break; - case cs_value_type::Float: + case cs_value_type::FLOAT: return csv_get(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(p_stor); break; - case cs_value_type::String: + case cs_value_type::STRING: ri = cs_parse_int(ostd::string_range( *reinterpret_cast(&p_stor) )); break; - case cs_value_type::Int: + case cs_value_type::INT: return csv_get(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(p_stor)); break; - case cs_value_type::Int: + case cs_value_type::INT: rs = intstr(csv_get(p_stor)); break; - case cs_value_type::String: + case cs_value_type::STRING: return ostd::string_range( *reinterpret_cast(&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(p_stor)); - case cs_value_type::Int: + case cs_value_type::INT: return csv_get(p_stor); - case cs_value_type::String: + case cs_value_type::STRING: return cs_parse_int(ostd::string_range( *reinterpret_cast(&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(p_stor); - case cs_value_type::Int: + case cs_value_type::INT: return cs_float(csv_get(p_stor)); - case cs_value_type::String: + case cs_value_type::STRING: return cs_parse_float(ostd::string_range( *reinterpret_cast(&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(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(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(&p_stor); - case cs_value_type::Int: + case cs_value_type::INT: return cs_strref{*state(), intstr(csv_get(p_stor))}; - case cs_value_type::Float: + case cs_value_type::FLOAT: return cs_strref{*state(), floatstr(csv_get(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(p_stor)); break; - case cs_value_type::Float: + case cs_value_type::FLOAT: r.set_float(csv_get(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(code) & CsCodeOpMask - ) == CsCodeExit; + *reinterpret_cast(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(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(p_stor) != 0; - case cs_value_type::Int: + case cs_value_type::INT: return csv_get(p_stor) != 0; - case cs_value_type::String: + case cs_value_type::STRING: return cs_get_bool(ostd::string_range( *reinterpret_cast(&p_stor) )); diff --git a/src/cs_vm.cc b/src/cs_vm.cc index 5a44459..4b39fd4 100644 --- a/src/cs_vm.cc +++ b/src/cs_vm.cc @@ -113,7 +113,7 @@ cs_stack_state cs_error::save_stack(cs_state &cs) { return cs_stack_state(cs, nullptr, !!cs.p_callstack); } int total = 0, depth = 0; - for (cs_identLink *l = cs.p_callstack; l; l = l->next) { + for (cs_ident_link *l = cs.p_callstack; l; l = l->next) { total++; } if (!total) { @@ -124,7 +124,7 @@ cs_stack_state cs_error::save_stack(cs_state &cs) { ); cs_stack_state_node *ret = st, *nd = st; ++st; - for (cs_identLink *l = cs.p_callstack; l; l = l->next) { + for (cs_ident_link *l = cs.p_callstack; l; l = l->next) { ++depth; if (depth < dalias->get_value()) { nd->id = l->id; @@ -180,15 +180,15 @@ static void bcode_ref(uint32_t *code) { if (!code) { return; } - if ((*code & CsCodeOpMask) == CsCodeStart) { + if ((*code & CS_CODE_OP_MASK) == CS_CODE_START) { bcode_incr(code); return; } - switch (code[-1]&CsCodeOpMask) { - case CsCodeStart: + switch (code[-1]&CS_CODE_OP_MASK) { + case CS_CODE_START: bcode_incr(&code[-1]); break; - case CsCodeOffset: + case CS_CODE_OFFSET: code -= std::ptrdiff_t(code[-1] >> 8); bcode_incr(code); break; @@ -199,15 +199,15 @@ static void bcode_unref(uint32_t *code) { if (!code) { return; } - if ((*code & CsCodeOpMask) == CsCodeStart) { + if ((*code & CS_CODE_OP_MASK) == CS_CODE_START) { bcode_decr(code); return; } - switch (code[-1]&CsCodeOpMask) { - case CsCodeStart: + switch (code[-1]&CS_CODE_OP_MASK) { + case CS_CODE_START: bcode_decr(&code[-1]); break; - case CsCodeOffset: + case CS_CODE_OFFSET: code -= std::ptrdiff_t(code[-1] >> 8); bcode_decr(code); break; @@ -256,7 +256,7 @@ static inline uint32_t *forcecode(cs_state &cs, cs_value &v) { static inline void forcecond(cs_state &cs, cs_value &v) { switch (v.get_type()) { - case cs_value_type::String: + case cs_value_type::STRING: if (!ostd::string_range{v.get_str()}.empty()) { forcecode(cs, v); } else { @@ -268,27 +268,27 @@ static inline void forcecond(cs_state &cs, cs_value &v) { } } -static uint32_t emptyblock[CsValAny][2] = { - { CsCodeStart + 0x100, CsCodeExit | CsRetNull }, - { CsCodeStart + 0x100, CsCodeExit | CsRetInt }, - { CsCodeStart + 0x100, CsCodeExit | CsRetFloat }, - { CsCodeStart + 0x100, CsCodeExit | CsRetString } +static uint32_t emptyblock[CS_VAL_ANY][2] = { + { CS_CODE_START + 0x100, CS_CODE_EXIT | CS_RET_NULL }, + { CS_CODE_START + 0x100, CS_CODE_EXIT | CS_RET_INT }, + { CS_CODE_START + 0x100, CS_CODE_EXIT | CS_RET_FLOAT }, + { CS_CODE_START + 0x100, CS_CODE_EXIT | CS_RET_STRING } }; static inline void force_arg(cs_value &v, int type) { switch (type) { - case CsRetString: - if (v.get_type() != cs_value_type::String) { + case CS_RET_STRING: + if (v.get_type() != cs_value_type::STRING) { v.force_str(); } break; - case CsRetInt: - if (v.get_type() != cs_value_type::Int) { + case CS_RET_INT: + if (v.get_type() != cs_value_type::INT) { v.force_int(); } break; - case CsRetFloat: - if (v.get_type() != cs_value_type::Float) { + case CS_RET_FLOAT: + if (v.get_type() != cs_value_type::FLOAT) { v.force_float(); } break; @@ -300,29 +300,29 @@ static uint32_t *skipcode(uint32_t *code) { for (;;) { uint32_t op = *code++; switch (op & 0xFF) { - case CsCodeVal | CsRetString: { + case CS_CODE_VAL | CS_RET_STRING: { uint32_t len = op >> 8; code += len / sizeof(uint32_t) + 1; continue; } - case CsCodeBlock: - case CsCodeJump: - case CsCodeJumpB | CsCodeFlagTrue: - case CsCodeJumpB | CsCodeFlagFalse: - case CsCodeJumpResult | CsCodeFlagTrue: - case CsCodeJumpResult | CsCodeFlagFalse: { + case CS_CODE_BLOCK: + case CS_CODE_JUMP: + case CS_CODE_JUMP_B | CS_CODE_FLAG_TRUE: + case CS_CODE_JUMP_B | CS_CODE_FLAG_FALSE: + case CS_CODE_JUMP_RESULT | CS_CODE_FLAG_TRUE: + case CS_CODE_JUMP_RESULT | CS_CODE_FLAG_FALSE: { uint32_t len = op >> 8; code += len; continue; } - case CsCodeEnter: - case CsCodeEnterResult: + case CS_CODE_ENTER: + case CS_CODE_ENTER_RESULT: ++depth; continue; - case CsCodeExit | CsRetNull: - case CsCodeExit | CsRetString: - case CsCodeExit | CsRetInt: - case CsCodeExit | CsRetFloat: + case CS_CODE_EXIT | CS_RET_NULL: + case CS_CODE_EXIT | CS_RET_STRING: + case CS_CODE_EXIT | CS_RET_INT: + case CS_CODE_EXIT | CS_RET_FLOAT: if (depth <= 0) { return code; } @@ -336,7 +336,7 @@ cs_bcode *cs_copy_code(cs_bcode *c) { uint32_t *bcode = reinterpret_cast(c); uint32_t *end = skipcode(bcode); uint32_t *dst = new uint32_t[end - bcode + 1]; - *dst++ = CsCodeStart; + *dst++ = CS_CODE_START; memcpy(dst, bcode, (end - bcode) * sizeof(uint32_t)); return reinterpret_cast(dst); } @@ -410,7 +410,7 @@ static inline void callcommand( if (rep) { break; } - args[i].set_null(); + args[i].set_none(); fakeargs++; } break; @@ -419,7 +419,7 @@ static inline void callcommand( if (rep) { break; } - args[i].set_null(); + args[i].set_none(); fakeargs++; } else { forcecond(cs, args[i]); @@ -431,7 +431,7 @@ static inline void callcommand( break; } args[i].set_code( - reinterpret_cast(emptyblock[CsValNull] + 1) + reinterpret_cast(emptyblock[CS_VAL_NULL] + 1) ); fakeargs++; } else { @@ -505,7 +505,7 @@ static inline void cs_call_alias( anargs->set_value(callargs); int oldflags = cs.identflags; cs.identflags |= a->get_flags()&CS_IDF_OVERRIDDEN; - cs_identLink aliaslink = { + cs_ident_link aliaslink = { a, cs.p_callstack, (1<set_value(oldargs); nargs = offset - skip; }); @@ -574,13 +574,13 @@ static inline cs_alias *cs_get_lookuparg_id(cs_state &cs, uint32_t op) { static inline int cs_get_lookupu_type( cs_state &cs, cs_value &arg, cs_ident *&id, uint32_t op ) { - if (arg.get_type() != cs_value_type::String) { + if (arg.get_type() != cs_value_type::STRING) { return -2; /* default case */ } id = cs.get_ident(arg.get_str()); if (id) { switch(id->get_type()) { - case cs_ident_type::Alias: + case cs_ident_type::ALIAS: if (id->get_flags() & CS_IDF_UNKNOWN) { break; } @@ -588,17 +588,17 @@ static inline int cs_get_lookupu_type( return CsIdUnknown; } return CsIdAlias; - case cs_ident_type::Svar: + case cs_ident_type::SVAR: return CsIdSvar; - case cs_ident_type::Ivar: + case cs_ident_type::IVAR: return CsIdIvar; - case cs_ident_type::Fvar: + case cs_ident_type::FVAR: return CsIdFvar; - case cs_ident_type::Command: { - arg.set_null(); + case cs_ident_type::COMMAND: { + arg.set_none(); cs_valarray buf{cs}; callcommand(cs, static_cast(id), &buf[0], arg, 0, true); - force_arg(arg, op & CsCodeRetMask); + force_arg(arg, op & CS_CODE_RET_MASK); return -2; /* ignore */ } default: @@ -609,7 +609,7 @@ static inline int cs_get_lookupu_type( } static uint32_t *runcode(cs_state &cs, uint32_t *code, cs_value &result) { - result.set_null(); + result.set_none(); RunDepthRef level{cs}; /* incr and decr on scope exit */ int numargs = 0; cs_valarray args{cs}; @@ -620,88 +620,88 @@ static uint32_t *runcode(cs_state &cs, uint32_t *code, cs_value &result) { for (;;) { uint32_t op = *code++; switch (op & 0xFF) { - case CsCodeStart: - case CsCodeOffset: + case CS_CODE_START: + case CS_CODE_OFFSET: continue; - case CsCodeNull | CsRetNull: - result.set_null(); + case CS_CODE_NULL | CS_RET_NULL: + result.set_none(); continue; - case CsCodeNull | CsRetString: + case CS_CODE_NULL | CS_RET_STRING: result.set_str(""); continue; - case CsCodeNull | CsRetInt: + case CS_CODE_NULL | CS_RET_INT: result.set_int(0); continue; - case CsCodeNull | CsRetFloat: + case CS_CODE_NULL | CS_RET_FLOAT: result.set_float(0.0f); continue; - case CsCodeFalse | CsRetString: + case CS_CODE_FALSE | CS_RET_STRING: result.set_str("0"); continue; - case CsCodeFalse | CsRetNull: - case CsCodeFalse | CsRetInt: + case CS_CODE_FALSE | CS_RET_NULL: + case CS_CODE_FALSE | CS_RET_INT: result.set_int(0); continue; - case CsCodeFalse | CsRetFloat: + case CS_CODE_FALSE | CS_RET_FLOAT: result.set_float(0.0f); continue; - case CsCodeTrue | CsRetString: + case CS_CODE_TRUE | CS_RET_STRING: result.set_str("1"); continue; - case CsCodeTrue | CsRetNull: - case CsCodeTrue | CsRetInt: + case CS_CODE_TRUE | CS_RET_NULL: + case CS_CODE_TRUE | CS_RET_INT: result.set_int(1); continue; - case CsCodeTrue | CsRetFloat: + case CS_CODE_TRUE | CS_RET_FLOAT: result.set_float(1.0f); continue; - case CsCodeNot | CsRetString: + case CS_CODE_NOT | CS_RET_STRING: --numargs; result.set_str(args[numargs].get_bool() ? "0" : "1"); continue; - case CsCodeNot | CsRetNull: - case CsCodeNot | CsRetInt: + case CS_CODE_NOT | CS_RET_NULL: + case CS_CODE_NOT | CS_RET_INT: --numargs; result.set_int(!args[numargs].get_bool()); continue; - case CsCodeNot | CsRetFloat: + case CS_CODE_NOT | CS_RET_FLOAT: --numargs; result.set_float(cs_float(!args[numargs].get_bool())); continue; - case CsCodePop: + case CS_CODE_POP: numargs -= 1; continue; - case CsCodeEnter: + case CS_CODE_ENTER: code = runcode(cs, code, args[numargs++]); continue; - case CsCodeEnterResult: + case CS_CODE_ENTER_RESULT: code = runcode(cs, code, result); continue; - case CsCodeExit | CsRetString: - case CsCodeExit | CsRetInt: - case CsCodeExit | CsRetFloat: - force_arg(result, op & CsCodeRetMask); + case CS_CODE_EXIT | CS_RET_STRING: + case CS_CODE_EXIT | CS_RET_INT: + case CS_CODE_EXIT | CS_RET_FLOAT: + force_arg(result, op & CS_CODE_RET_MASK); /* fallthrough */ - case CsCodeExit | CsRetNull: + case CS_CODE_EXIT | CS_RET_NULL: return code; - case CsCodeResultArg | CsRetString: - case CsCodeResultArg | CsRetInt: - case CsCodeResultArg | CsRetFloat: - force_arg(result, op & CsCodeRetMask); + case CS_CODE_RESULT_ARG | CS_RET_STRING: + case CS_CODE_RESULT_ARG | CS_RET_INT: + case CS_CODE_RESULT_ARG | CS_RET_FLOAT: + force_arg(result, op & CS_CODE_RET_MASK); /* fallthrough */ - case CsCodeResultArg | CsRetNull: + case CS_CODE_RESULT_ARG | CS_RET_NULL: args[numargs++] = std::move(result); continue; - case CsCodePrint: + case CS_CODE_PRINT: cs.print_var(*static_cast(cs.p_state->identmap[op >> 8])); continue; - case CsCodeLocal: { + case CS_CODE_LOCAL: { int numlocals = op >> 8, offset = numargs - numlocals; cs_valarray locals{cs}; for (int i = 0; i < numlocals; ++i) { @@ -717,47 +717,47 @@ static uint32_t *runcode(cs_state &cs, uint32_t *code, cs_value &result) { return code; } - case CsCodeDoArgs | CsRetNull: - case CsCodeDoArgs | CsRetString: - case CsCodeDoArgs | CsRetInt: - case CsCodeDoArgs | CsRetFloat: + case CS_CODE_DO_ARGS | CS_RET_NULL: + case CS_CODE_DO_ARGS | CS_RET_STRING: + case CS_CODE_DO_ARGS | CS_RET_INT: + case CS_CODE_DO_ARGS | CS_RET_FLOAT: cs_do_args(cs, [&]() { cs.run(args[--numargs].get_code(), result); - force_arg(result, op & CsCodeRetMask); + force_arg(result, op & CS_CODE_RET_MASK); }); continue; /* fallthrough */ - case CsCodeDo | CsRetNull: - case CsCodeDo | CsRetString: - case CsCodeDo | CsRetInt: - case CsCodeDo | CsRetFloat: + case CS_CODE_DO | CS_RET_NULL: + case CS_CODE_DO | CS_RET_STRING: + case CS_CODE_DO | CS_RET_INT: + case CS_CODE_DO | CS_RET_FLOAT: cs.run(args[--numargs].get_code(), result); - force_arg(result, op & CsCodeRetMask); + force_arg(result, op & CS_CODE_RET_MASK); continue; - case CsCodeJump: { + case CS_CODE_JUMP: { uint32_t len = op >> 8; code += len; continue; } - case CsCodeJumpB | CsCodeFlagTrue: { + case CS_CODE_JUMP_B | CS_CODE_FLAG_TRUE: { uint32_t len = op >> 8; if (args[--numargs].get_bool()) { code += len; } continue; } - case CsCodeJumpB | CsCodeFlagFalse: { + case CS_CODE_JUMP_B | CS_CODE_FLAG_FALSE: { uint32_t len = op >> 8; if (!args[--numargs].get_bool()) { code += len; } continue; } - case CsCodeJumpResult | CsCodeFlagTrue: { + case CS_CODE_JUMP_RESULT | CS_CODE_FLAG_TRUE: { uint32_t len = op >> 8; --numargs; - if (args[numargs].get_type() == cs_value_type::Code) { + if (args[numargs].get_type() == cs_value_type::CODE) { cs.run(args[numargs].get_code(), result); } else { result = std::move(args[numargs]); @@ -767,10 +767,10 @@ static uint32_t *runcode(cs_state &cs, uint32_t *code, cs_value &result) { } continue; } - case CsCodeJumpResult | CsCodeFlagFalse: { + case CS_CODE_JUMP_RESULT | CS_CODE_FLAG_FALSE: { uint32_t len = op >> 8; --numargs; - if (args[numargs].get_type() == cs_value_type::Code) { + if (args[numargs].get_type() == cs_value_type::CODE) { cs.run(args[numargs].get_code(), result); } else { result = std::move(args[numargs]); @@ -780,14 +780,14 @@ static uint32_t *runcode(cs_state &cs, uint32_t *code, cs_value &result) { } continue; } - case CsCodeBreak | CsCodeFlagFalse: + case CS_CODE_BREAK | CS_CODE_FLAG_FALSE: if (cs.is_in_loop()) { throw CsBreakException(); } else { throw cs_error(cs, "no loop to break"); } break; - case CsCodeBreak | CsCodeFlagTrue: + case CS_CODE_BREAK | CS_CODE_FLAG_TRUE: if (cs.is_in_loop()) { throw CsContinueException(); } else { @@ -795,7 +795,7 @@ static uint32_t *runcode(cs_state &cs, uint32_t *code, cs_value &result) { } break; - case CsCodeVal | CsRetString: { + case CS_CODE_VAL | CS_RET_STRING: { uint32_t len = op >> 8; args[numargs++].set_str(ostd::string_range{ reinterpret_cast(code), @@ -804,7 +804,7 @@ static uint32_t *runcode(cs_state &cs, uint32_t *code, cs_value &result) { code += len / sizeof(uint32_t) + 1; continue; } - case CsCodeValInt | CsRetString: { + case CS_CODE_VAL_INT | CS_RET_STRING: { char s[4] = { char((op >> 8) & 0xFF), char((op >> 16) & 0xFF), @@ -814,88 +814,88 @@ static uint32_t *runcode(cs_state &cs, uint32_t *code, cs_value &result) { args[numargs++].set_str(static_cast(s)); continue; } - case CsCodeVal | CsRetNull: - case CsCodeValInt | CsRetNull: - args[numargs++].set_null(); + case CS_CODE_VAL | CS_RET_NULL: + case CS_CODE_VAL_INT | CS_RET_NULL: + args[numargs++].set_none(); continue; - case CsCodeVal | CsRetInt: + case CS_CODE_VAL | CS_RET_INT: args[numargs++].set_int( *reinterpret_cast(code) ); code += CsTypeStorageSize; continue; - case CsCodeValInt | CsRetInt: + case CS_CODE_VAL_INT | CS_RET_INT: args[numargs++].set_int(cs_int(op) >> 8); continue; - case CsCodeVal | CsRetFloat: + case CS_CODE_VAL | CS_RET_FLOAT: args[numargs++].set_float( *reinterpret_cast(code) ); code += CsTypeStorageSize; continue; - case CsCodeValInt | CsRetFloat: + case CS_CODE_VAL_INT | CS_RET_FLOAT: args[numargs++].set_float(cs_float(cs_int(op) >> 8)); continue; - case CsCodeDup | CsRetNull: + case CS_CODE_DUP | CS_RET_NULL: args[numargs - 1].get_val(args[numargs]); numargs++; continue; - case CsCodeDup | CsRetInt: + case CS_CODE_DUP | CS_RET_INT: args[numargs].set_int(args[numargs - 1].get_int()); numargs++; continue; - case CsCodeDup | CsRetFloat: + case CS_CODE_DUP | CS_RET_FLOAT: args[numargs].set_float(args[numargs - 1].get_float()); numargs++; continue; - case CsCodeDup | CsRetString: + case CS_CODE_DUP | CS_RET_STRING: args[numargs] = args[numargs - 1]; args[numargs].force_str(); numargs++; continue; - case CsCodeForce | CsRetString: + case CS_CODE_FORCE | CS_RET_STRING: args[numargs - 1].force_str(); continue; - case CsCodeForce | CsRetInt: + case CS_CODE_FORCE | CS_RET_INT: args[numargs - 1].force_int(); continue; - case CsCodeForce | CsRetFloat: + case CS_CODE_FORCE | CS_RET_FLOAT: args[numargs - 1].force_float(); continue; - case CsCodeResult | CsRetNull: + case CS_CODE_RESULT | CS_RET_NULL: result = std::move(args[--numargs]); continue; - case CsCodeResult | CsRetString: - case CsCodeResult | CsRetInt: - case CsCodeResult | CsRetFloat: + case CS_CODE_RESULT | CS_RET_STRING: + case CS_CODE_RESULT | CS_RET_INT: + case CS_CODE_RESULT | CS_RET_FLOAT: result = std::move(args[--numargs]); - force_arg(result, op & CsCodeRetMask); + force_arg(result, op & CS_CODE_RET_MASK); continue; - case CsCodeEmpty | CsRetNull: + case CS_CODE_EMPTY | CS_RET_NULL: args[numargs++].set_code( - reinterpret_cast(emptyblock[CsValNull] + 1) + reinterpret_cast(emptyblock[CS_VAL_NULL] + 1) ); break; - case CsCodeEmpty | CsRetString: + case CS_CODE_EMPTY | CS_RET_STRING: args[numargs++].set_code( - reinterpret_cast(emptyblock[CsValString] + 1) + reinterpret_cast(emptyblock[CS_VAL_STRING] + 1) ); break; - case CsCodeEmpty | CsRetInt: + case CS_CODE_EMPTY | CS_RET_INT: args[numargs++].set_code( - reinterpret_cast(emptyblock[CsValInt] + 1) + reinterpret_cast(emptyblock[CS_VAL_INT] + 1) ); break; - case CsCodeEmpty | CsRetFloat: + case CS_CODE_EMPTY | CS_RET_FLOAT: args[numargs++].set_code( - reinterpret_cast(emptyblock[CsValFloat] + 1) + reinterpret_cast(emptyblock[CS_VAL_FLOAT] + 1) ); break; - case CsCodeBlock: { + case CS_CODE_BLOCK: { uint32_t len = op >> 8; args[numargs++].set_code( reinterpret_cast(code + 1) @@ -903,34 +903,34 @@ static uint32_t *runcode(cs_state &cs, uint32_t *code, cs_value &result) { code += len; continue; } - case CsCodeCompile: { + case CS_CODE_COMPILE: { cs_value &arg = args[numargs - 1]; cs_gen_state gs(cs); switch (arg.get_type()) { - case cs_value_type::Int: + case cs_value_type::INT: gs.code.reserve(8); - gs.code.push_back(CsCodeStart); + gs.code.push_back(CS_CODE_START); gs.gen_int(arg.get_int()); - gs.code.push_back(CsCodeResult); - gs.code.push_back(CsCodeExit); + gs.code.push_back(CS_CODE_RESULT); + gs.code.push_back(CS_CODE_EXIT); break; - case cs_value_type::Float: + case cs_value_type::FLOAT: gs.code.reserve(8); - gs.code.push_back(CsCodeStart); + gs.code.push_back(CS_CODE_START); gs.gen_float(arg.get_float()); - gs.code.push_back(CsCodeResult); - gs.code.push_back(CsCodeExit); + gs.code.push_back(CS_CODE_RESULT); + gs.code.push_back(CS_CODE_EXIT); break; - case cs_value_type::String: + case cs_value_type::STRING: gs.code.reserve(64); gs.gen_main(arg.get_str()); break; default: gs.code.reserve(8); - gs.code.push_back(CsCodeStart); + gs.code.push_back(CS_CODE_START); gs.gen_null(); - gs.code.push_back(CsCodeResult); - gs.code.push_back(CsCodeExit); + gs.code.push_back(CS_CODE_RESULT); + gs.code.push_back(CS_CODE_EXIT); break; } gs.done(); @@ -941,10 +941,10 @@ static uint32_t *runcode(cs_state &cs, uint32_t *code, cs_value &result) { ); continue; } - case CsCodeCond: { + case CS_CODE_COND: { cs_value &arg = args[numargs - 1]; switch (arg.get_type()) { - case cs_value_type::String: { + case cs_value_type::STRING: { ostd::string_range s = arg.get_str(); if (!s.empty()) { cs_gen_state gs(cs); @@ -958,7 +958,7 @@ static uint32_t *runcode(cs_state &cs, uint32_t *code, cs_value &result) { ); arg.set_code(reinterpret_cast(cbuf + 1)); } else { - arg.force_null(); + arg.force_none(); } break; } @@ -968,10 +968,10 @@ static uint32_t *runcode(cs_state &cs, uint32_t *code, cs_value &result) { continue; } - case CsCodeIdent: + case CS_CODE_IDENT: args[numargs++].set_ident(cs.p_state->identmap[op >> 8]); continue; - case CsCodeIdentArg: { + case CS_CODE_IDENT_ARG: { cs_alias *a = static_cast( cs.p_state->identmap[op >> 8] ); @@ -985,10 +985,10 @@ static uint32_t *runcode(cs_state &cs, uint32_t *code, cs_value &result) { args[numargs++].set_ident(a); continue; } - case CsCodeIdentU: { + case CS_CODE_IDENT_U: { cs_value &arg = args[numargs - 1]; cs_ident *id = cs.p_state->identmap[DummyIdx]; - if (arg.get_type() == cs_value_type::String) { + if (arg.get_type() == cs_value_type::STRING) { id = cs.new_ident(arg.get_str()); } if ((id->get_index() < MaxArguments) && !cs_is_arg_used(cs, id)) { @@ -1003,7 +1003,7 @@ static uint32_t *runcode(cs_state &cs, uint32_t *code, cs_value &result) { continue; } - case CsCodeLookupU | CsRetString: { + case CS_CODE_LOOKUP_U | CS_RET_STRING: { cs_ident *id = nullptr; cs_value &arg = args[numargs - 1]; switch (cs_get_lookupu_type(cs, arg, id, op)) { @@ -1031,11 +1031,11 @@ static uint32_t *runcode(cs_state &cs, uint32_t *code, cs_value &result) { continue; } } - case CsCodeLookup | CsRetString: + case CS_CODE_LOOKUP | CS_RET_STRING: args[numargs] = cs_get_lookup_id(cs, op)->get_value(); args[numargs++].force_str(); continue; - case CsCodeLookupArg | CsRetString: { + case CS_CODE_LOOKUP_ARG | CS_RET_STRING: { cs_alias *a = cs_get_lookuparg_id(cs, op); if (!a) { args[numargs++].set_str(""); @@ -1045,7 +1045,7 @@ static uint32_t *runcode(cs_state &cs, uint32_t *code, cs_value &result) { } continue; } - case CsCodeLookupU | CsRetInt: { + case CS_CODE_LOOKUP_U | CS_RET_INT: { cs_ident *id = nullptr; cs_value &arg = args[numargs - 1]; switch (cs_get_lookupu_type(cs, arg, id, op)) { @@ -1074,12 +1074,12 @@ static uint32_t *runcode(cs_state &cs, uint32_t *code, cs_value &result) { continue; } } - case CsCodeLookup | CsRetInt: + case CS_CODE_LOOKUP | CS_RET_INT: args[numargs++].set_int( cs_get_lookup_id(cs, op)->get_value().get_int() ); continue; - case CsCodeLookupArg | CsRetInt: { + case CS_CODE_LOOKUP_ARG | CS_RET_INT: { cs_alias *a = cs_get_lookuparg_id(cs, op); if (!a) { args[numargs++].set_int(0); @@ -1088,7 +1088,7 @@ static uint32_t *runcode(cs_state &cs, uint32_t *code, cs_value &result) { } continue; } - case CsCodeLookupU | CsRetFloat: { + case CS_CODE_LOOKUP_U | CS_RET_FLOAT: { cs_ident *id = nullptr; cs_value &arg = args[numargs - 1]; switch (cs_get_lookupu_type(cs, arg, id, op)) { @@ -1119,12 +1119,12 @@ static uint32_t *runcode(cs_state &cs, uint32_t *code, cs_value &result) { continue; } } - case CsCodeLookup | CsRetFloat: + case CS_CODE_LOOKUP | CS_RET_FLOAT: args[numargs++].set_float( cs_get_lookup_id(cs, op)->get_value().get_float() ); continue; - case CsCodeLookupArg | CsRetFloat: { + case CS_CODE_LOOKUP_ARG | CS_RET_FLOAT: { cs_alias *a = cs_get_lookuparg_id(cs, op); if (!a) { args[numargs++].set_float(cs_float(0)); @@ -1133,7 +1133,7 @@ static uint32_t *runcode(cs_state &cs, uint32_t *code, cs_value &result) { } continue; } - case CsCodeLookupU | CsRetNull: { + case CS_CODE_LOOKUP_U | CS_RET_NULL: { cs_ident *id = nullptr; cs_value &arg = args[numargs - 1]; switch (cs_get_lookupu_type(cs, arg, id, op)) { @@ -1152,26 +1152,26 @@ static uint32_t *runcode(cs_state &cs, uint32_t *code, cs_value &result) { ); continue; case CsIdUnknown: - arg.set_null(); + arg.set_none(); continue; default: continue; } } - case CsCodeLookup | CsRetNull: + case CS_CODE_LOOKUP | CS_RET_NULL: cs_get_lookup_id(cs, op)->get_value().get_val(args[numargs++]); continue; - case CsCodeLookupArg | CsRetNull: { + case CS_CODE_LOOKUP_ARG | CS_RET_NULL: { cs_alias *a = cs_get_lookuparg_id(cs, op); if (!a) { - args[numargs++].set_null(); + args[numargs++].set_none(); } else { a->get_value().get_val(args[numargs++]); } continue; } - case CsCodeLookupMu | CsRetString: { + case CS_CODE_LOOKUP_MU | CS_RET_STRING: { cs_ident *id = nullptr; cs_value &arg = args[numargs - 1]; switch (cs_get_lookupu_type(cs, arg, id, op)) { @@ -1199,11 +1199,11 @@ static uint32_t *runcode(cs_state &cs, uint32_t *code, cs_value &result) { continue; } } - case CsCodeLookupM | CsRetString: + case CS_CODE_LOOKUP_M | CS_RET_STRING: args[numargs] = cs_get_lookup_id(cs, op)->get_value(); args[numargs++].force_str(); continue; - case CsCodeLookupMarg | CsRetString: { + case CS_CODE_LOOKUP_MARG | CS_RET_STRING: { cs_alias *a = cs_get_lookuparg_id(cs, op); if (!a) { args[numargs++].set_str(""); @@ -1213,7 +1213,7 @@ static uint32_t *runcode(cs_state &cs, uint32_t *code, cs_value &result) { } continue; } - case CsCodeLookupMu | CsRetNull: { + case CS_CODE_LOOKUP_MU | CS_RET_NULL: { cs_ident *id = nullptr; cs_value &arg = args[numargs - 1]; switch (cs_get_lookupu_type(cs, arg, id, op)) { @@ -1230,71 +1230,71 @@ static uint32_t *runcode(cs_state &cs, uint32_t *code, cs_value &result) { arg.set_float(static_cast(id)->get_value()); continue; case CsIdUnknown: - arg.set_null(); + arg.set_none(); continue; default: continue; } } - case CsCodeLookupM | CsRetNull: + case CS_CODE_LOOKUP_M | CS_RET_NULL: cs_get_lookup_id(cs, op)->get_cval(args[numargs++]); continue; - case CsCodeLookupMarg | CsRetNull: { + case CS_CODE_LOOKUP_MARG | CS_RET_NULL: { cs_alias *a = cs_get_lookuparg_id(cs, op); if (!a) { - args[numargs++].set_null(); + args[numargs++].set_none(); } else { a->get_cval(args[numargs++]); } continue; } - case CsCodeSvar | CsRetString: - case CsCodeSvar | CsRetNull: + case CS_CODE_SVAR | CS_RET_STRING: + case CS_CODE_SVAR | CS_RET_NULL: args[numargs++].set_str(static_cast( cs.p_state->identmap[op >> 8] )->get_value()); continue; - case CsCodeSvar | CsRetInt: + case CS_CODE_SVAR | CS_RET_INT: args[numargs++].set_int(cs_parse_int(static_cast( cs.p_state->identmap[op >> 8] )->get_value())); continue; - case CsCodeSvar | CsRetFloat: + case CS_CODE_SVAR | CS_RET_FLOAT: args[numargs++].set_float(cs_parse_float(static_cast( cs.p_state->identmap[op >> 8] )->get_value())); continue; - case CsCodeSvar1: + case CS_CODE_SVAR1: cs.set_var_str_checked( static_cast(cs.p_state->identmap[op >> 8]), args[--numargs].get_str() ); continue; - case CsCodeIvar | CsRetInt: - case CsCodeIvar | CsRetNull: + case CS_CODE_IVAR | CS_RET_INT: + case CS_CODE_IVAR | CS_RET_NULL: args[numargs++].set_int(static_cast( cs.p_state->identmap[op >> 8] )->get_value()); continue; - case CsCodeIvar | CsRetString: + case CS_CODE_IVAR | CS_RET_STRING: args[numargs++].set_str(intstr(static_cast( cs.p_state->identmap[op >> 8] )->get_value())); continue; - case CsCodeIvar | CsRetFloat: + case CS_CODE_IVAR | CS_RET_FLOAT: args[numargs++].set_float(cs_float(static_cast( cs.p_state->identmap[op >> 8] )->get_value())); continue; - case CsCodeIvar1: + case CS_CODE_IVAR1: cs.set_var_int_checked( static_cast(cs.p_state->identmap[op >> 8]), args[--numargs].get_int() ); continue; - case CsCodeIvar2: + case CS_CODE_IVAR2: numargs -= 2; cs.set_var_int_checked( static_cast(cs.p_state->identmap[op >> 8]), @@ -1302,7 +1302,7 @@ static uint32_t *runcode(cs_state &cs, uint32_t *code, cs_value &result) { | (args[numargs + 1].get_int() << 8) ); continue; - case CsCodeIvar3: + case CS_CODE_IVAR3: numargs -= 3; cs.set_var_int_checked( static_cast(cs.p_state->identmap[op >> 8]), @@ -1311,73 +1311,73 @@ static uint32_t *runcode(cs_state &cs, uint32_t *code, cs_value &result) { | (args[numargs + 2].get_int())); continue; - case CsCodeFvar | CsRetFloat: - case CsCodeFvar | CsRetNull: + case CS_CODE_FVAR | CS_RET_FLOAT: + case CS_CODE_FVAR | CS_RET_NULL: args[numargs++].set_float(static_cast( cs.p_state->identmap[op >> 8] )->get_value()); continue; - case CsCodeFvar | CsRetString: + case CS_CODE_FVAR | CS_RET_STRING: args[numargs++].set_str(floatstr( static_cast( cs.p_state->identmap[op >> 8] )->get_value() )); continue; - case CsCodeFvar | CsRetInt: + case CS_CODE_FVAR | CS_RET_INT: args[numargs++].set_int(int(static_cast( cs.p_state->identmap[op >> 8] )->get_value())); continue; - case CsCodeFvar1: + case CS_CODE_FVAR1: cs.set_var_float_checked( static_cast(cs.p_state->identmap[op >> 8]), args[--numargs].get_float() ); continue; - case CsCodeCom | CsRetNull: - case CsCodeCom | CsRetString: - case CsCodeCom | CsRetFloat: - case CsCodeCom | CsRetInt: { + case CS_CODE_COM | CS_RET_NULL: + case CS_CODE_COM | CS_RET_STRING: + case CS_CODE_COM | CS_RET_FLOAT: + case CS_CODE_COM | CS_RET_INT: { cs_command *id = static_cast( cs.p_state->identmap[op >> 8] ); int offset = numargs - id->get_num_args(); - result.force_null(); + result.force_none(); cs_cmd_internal::call(cs, id, cs_value_r( &args[0] + offset, &args[0] + offset + id->get_num_args() ), result); - force_arg(result, op & CsCodeRetMask); + force_arg(result, op & CS_CODE_RET_MASK); numargs = offset; continue; } - case CsCodeComV | CsRetNull: - case CsCodeComV | CsRetString: - case CsCodeComV | CsRetFloat: - case CsCodeComV | CsRetInt: { + case CS_CODE_COM_V | CS_RET_NULL: + case CS_CODE_COM_V | CS_RET_STRING: + case CS_CODE_COM_V | CS_RET_FLOAT: + case CS_CODE_COM_V | CS_RET_INT: { cs_command *id = static_cast( cs.p_state->identmap[op >> 13] ); int callargs = (op >> 8) & 0x1F, offset = numargs - callargs; - result.force_null(); + result.force_none(); cs_cmd_internal::call(cs, id, ostd::iter( &args[offset], &args[offset + callargs] ), result); - force_arg(result, op & CsCodeRetMask); + force_arg(result, op & CS_CODE_RET_MASK); numargs = offset; continue; } - case CsCodeComC | CsRetNull: - case CsCodeComC | CsRetString: - case CsCodeComC | CsRetFloat: - case CsCodeComC | CsRetInt: { + case CS_CODE_COM_C | CS_RET_NULL: + case CS_CODE_COM_C | CS_RET_STRING: + case CS_CODE_COM_C | CS_RET_FLOAT: + case CS_CODE_COM_C | CS_RET_INT: { cs_command *id = static_cast( cs.p_state->identmap[op >> 13] ); int callargs = (op >> 8) & 0x1F, offset = numargs - callargs; - result.force_null(); + result.force_none(); { auto buf = ostd::appender(); cscript::util::tvals_concat(buf, ostd::iter( @@ -1387,36 +1387,36 @@ static uint32_t *runcode(cs_state &cs, uint32_t *code, cs_value &result) { tv.set_str(buf.get()); cs_cmd_internal::call(cs, id, cs_value_r(&tv, &tv + 1), result); } - force_arg(result, op & CsCodeRetMask); + force_arg(result, op & CS_CODE_RET_MASK); numargs = offset; continue; } - case CsCodeConc | CsRetNull: - case CsCodeConc | CsRetString: - case CsCodeConc | CsRetFloat: - case CsCodeConc | CsRetInt: - case CsCodeConcW | CsRetNull: - case CsCodeConcW | CsRetString: - case CsCodeConcW | CsRetFloat: - case CsCodeConcW | CsRetInt: { + case CS_CODE_CONC | CS_RET_NULL: + case CS_CODE_CONC | CS_RET_STRING: + case CS_CODE_CONC | CS_RET_FLOAT: + case CS_CODE_CONC | CS_RET_INT: + case CS_CODE_CONC_W | CS_RET_NULL: + case CS_CODE_CONC_W | CS_RET_STRING: + case CS_CODE_CONC_W | CS_RET_FLOAT: + case CS_CODE_CONC_W | CS_RET_INT: { int numconc = op >> 8; auto buf = ostd::appender(); cscript::util::tvals_concat( buf, ostd::iter(&args[numargs - numconc], &args[numargs]), - ((op & CsCodeOpMask) == CsCodeConc) ? " " : "" + ((op & CS_CODE_OP_MASK) == CS_CODE_CONC) ? " " : "" ); numargs = numargs - numconc; args[numargs].set_str(buf.get()); - force_arg(args[numargs], op & CsCodeRetMask); + force_arg(args[numargs], op & CS_CODE_RET_MASK); numargs++; continue; } - case CsCodeConcM | CsRetNull: - case CsCodeConcM | CsRetString: - case CsCodeConcM | CsRetFloat: - case CsCodeConcM | CsRetInt: { + case CS_CODE_CONC_M | CS_RET_NULL: + case CS_CODE_CONC_M | CS_RET_STRING: + case CS_CODE_CONC_M | CS_RET_FLOAT: + case CS_CODE_CONC_M | CS_RET_INT: { int numconc = op >> 8; auto buf = ostd::appender(); cscript::util::tvals_concat( @@ -1424,38 +1424,38 @@ static uint32_t *runcode(cs_state &cs, uint32_t *code, cs_value &result) { ); numargs = numargs - numconc; result.set_str(buf.get()); - force_arg(result, op & CsCodeRetMask); + force_arg(result, op & CS_CODE_RET_MASK); continue; } - case CsCodeAlias: + case CS_CODE_ALIAS: cs_alias_internal::set_alias( static_cast(cs.p_state->identmap[op >> 8]), cs, args[--numargs] ); continue; - case CsCodeAliasArg: + case CS_CODE_ALIAS_ARG: cs_alias_internal::set_arg( static_cast(cs.p_state->identmap[op >> 8]), cs, args[--numargs] ); continue; - case CsCodeAliasU: + case CS_CODE_ALIAS_U: numargs -= 2; cs.set_alias( args[numargs].get_str(), std::move(args[numargs + 1]) ); continue; - case CsCodeCall | CsRetNull: - case CsCodeCall | CsRetString: - case CsCodeCall | CsRetFloat: - case CsCodeCall | CsRetInt: { - result.force_null(); + case CS_CODE_CALL | CS_RET_NULL: + case CS_CODE_CALL | CS_RET_STRING: + case CS_CODE_CALL | CS_RET_FLOAT: + case CS_CODE_CALL | CS_RET_INT: { + result.force_none(); cs_ident *id = cs.p_state->identmap[op >> 13]; int callargs = (op >> 8) & 0x1F, offset = numargs - callargs; if (id->get_flags() & CS_IDF_UNKNOWN) { - force_arg(result, op & CsCodeRetMask); + force_arg(result, op & CS_CODE_RET_MASK); throw cs_error( cs, "unknown command: %s", id->get_name() ); @@ -1466,16 +1466,16 @@ static uint32_t *runcode(cs_state &cs, uint32_t *code, cs_value &result) { ); continue; } - case CsCodeCallArg | CsRetNull: - case CsCodeCallArg | CsRetString: - case CsCodeCallArg | CsRetFloat: - case CsCodeCallArg | CsRetInt: { - result.force_null(); + case CS_CODE_CALL_ARG | CS_RET_NULL: + case CS_CODE_CALL_ARG | CS_RET_STRING: + case CS_CODE_CALL_ARG | CS_RET_FLOAT: + case CS_CODE_CALL_ARG | CS_RET_INT: { + result.force_none(); cs_ident *id = cs.p_state->identmap[op >> 13]; int callargs = (op >> 8) & 0x1F, offset = numargs - callargs; if (!cs_is_arg_used(cs, id)) { numargs = offset; - force_arg(result, op & CsCodeRetMask); + force_arg(result, op & CS_CODE_RET_MASK); continue; } cs_call_alias( @@ -1485,16 +1485,16 @@ static uint32_t *runcode(cs_state &cs, uint32_t *code, cs_value &result) { continue; } - case CsCodeCallU | CsRetNull: - case CsCodeCallU | CsRetString: - case CsCodeCallU | CsRetFloat: - case CsCodeCallU | CsRetInt: { + case CS_CODE_CALL_U | CS_RET_NULL: + case CS_CODE_CALL_U | CS_RET_STRING: + case CS_CODE_CALL_U | CS_RET_FLOAT: + case CS_CODE_CALL_U | CS_RET_INT: { int callargs = op >> 8, offset = numargs - callargs; cs_value &idarg = args[offset - 1]; - if (idarg.get_type() != cs_value_type::String) { + if (idarg.get_type() != cs_value_type::STRING) { litval: result = std::move(idarg); - force_arg(result, op & CsCodeRetMask); + force_arg(result, op & CS_CODE_RET_MASK); numargs = offset - 1; continue; } @@ -1505,18 +1505,18 @@ noid: if (cs_check_num(idn)) { goto litval; } - result.force_null(); - force_arg(result, op & CsCodeRetMask); + result.force_none(); + force_arg(result, op & CS_CODE_RET_MASK); throw cs_error( cs, "unknown command: %s", ostd::string_range{idn} ); } - result.force_null(); + result.force_none(); switch (id->get_type_raw()) { default: if (!cs_cmd_internal::has_cb(id)) { numargs = offset - 1; - force_arg(result, op & CsCodeRetMask); + force_arg(result, op & CS_CODE_RET_MASK); continue; } /* fallthrough */ @@ -1525,7 +1525,7 @@ noid: cs, static_cast(id), &args[offset], result, callargs ); - force_arg(result, op & CsCodeRetMask); + force_arg(result, op & CS_CODE_RET_MASK); numargs = offset - 1; continue; case CsIdLocal: { @@ -1554,7 +1554,7 @@ noid: ); } numargs = offset - 1; - force_arg(result, op & CsCodeRetMask); + force_arg(result, op & CS_CODE_RET_MASK); continue; case CsIdFvar: if (callargs <= 0) { @@ -1566,7 +1566,7 @@ noid: ); } numargs = offset - 1; - force_arg(result, op & CsCodeRetMask); + force_arg(result, op & CS_CODE_RET_MASK); continue; case CsIdSvar: if (callargs <= 0) { @@ -1578,7 +1578,7 @@ noid: ); } numargs = offset - 1; - force_arg(result, op & CsCodeRetMask); + force_arg(result, op & CS_CODE_RET_MASK); continue; case CsIdAlias: { cs_alias *a = static_cast(id); @@ -1587,10 +1587,10 @@ noid: !cs_is_arg_used(cs, a) ) { numargs = offset - 1; - force_arg(result, op & CsCodeRetMask); + force_arg(result, op & CS_CODE_RET_MASK); continue; } - if (a->get_value().get_type() == cs_value_type::Null) { + if (a->get_value().get_type() == cs_value_type::NONE) { goto noid; } cs_call_alias( @@ -1617,7 +1617,7 @@ static void cs_run( cs_gen_state gs(cs); gs.src_name = file; gs.code.reserve(64); - gs.gen_main(code, CsValAny); + gs.gen_main(code, CS_VAL_ANY); gs.done(); uint32_t *cbuf = new uint32_t[gs.code.size()]; memcpy(cbuf, gs.code.data(), gs.code.size() * sizeof(uint32_t)); @@ -1633,7 +1633,7 @@ void cs_state::run(ostd::string_range code, cs_value &ret) { void cs_state::run(cs_ident *id, cs_value_r args, cs_value &ret) { int nargs = int(args.size()); - ret.set_null(); + ret.set_none(); RunDepthRef level{*this}; /* incr and decr on scope exit */ if (id) { switch (id->get_type()) { @@ -1642,7 +1642,7 @@ void cs_state::run(cs_ident *id, cs_value_r args, cs_value &ret) { break; } /* fallthrough */ - case cs_ident_type::Command: + case cs_ident_type::COMMAND: if (nargs < static_cast(id)->get_num_args()) { cs_valarray buf{*this}; for (std::size_t i = 0; i < args.size(); ++i) { @@ -1660,14 +1660,14 @@ void cs_state::run(cs_ident *id, cs_value_r args, cs_value &ret) { } nargs = 0; break; - case cs_ident_type::Ivar: + case cs_ident_type::IVAR: if (args.empty()) { print_var(*static_cast(id)); } else { set_var_int_checked(static_cast(id), args); } break; - case cs_ident_type::Fvar: + case cs_ident_type::FVAR: if (args.empty()) { print_var(*static_cast(id)); } else { @@ -1676,7 +1676,7 @@ void cs_state::run(cs_ident *id, cs_value_r args, cs_value &ret) { ); } break; - case cs_ident_type::Svar: + case cs_ident_type::SVAR: if (args.empty()) { print_var(*static_cast(id)); } else { @@ -1685,18 +1685,18 @@ void cs_state::run(cs_ident *id, cs_value_r args, cs_value &ret) { ); } break; - case cs_ident_type::Alias: { + case cs_ident_type::ALIAS: { cs_alias *a = static_cast(id); if ( (a->get_index() < MaxArguments) && !cs_is_arg_used(*this, a) ) { break; } - if (a->get_value().get_type() == cs_value_type::Null) { + if (a->get_value().get_type() == cs_value_type::NONE) { break; } cs_call_alias( - *this, a, &args[0], ret, nargs, nargs, 0, 0, CsRetNull + *this, a, &args[0], ret, nargs, nargs, 0, 0, CS_RET_NULL ); break; } @@ -1791,24 +1791,24 @@ void cs_state::run(cs_ident *id, cs_value_r args) { run(id, args, ret); } -CsLoopState cs_state::run_loop(cs_bcode *code, cs_value &ret) { +cs_loop_state cs_state::run_loop(cs_bcode *code, cs_value &ret) { ++p_inloop; try { run(code, ret); } catch (CsBreakException) { --p_inloop; - return CsLoopState::Break; + return cs_loop_state::BREAK; } catch (CsContinueException) { --p_inloop; - return CsLoopState::Continue; + return cs_loop_state::CONTINUE; } catch (...) { --p_inloop; throw; } - return CsLoopState::Normal; + return cs_loop_state::NORMAL; } -CsLoopState cs_state::run_loop(cs_bcode *code) { +cs_loop_state cs_state::run_loop(cs_bcode *code) { cs_value ret{*this}; return run_loop(code, ret); } diff --git a/src/cs_vm.hh b/src/cs_vm.hh index ddc6e56..7dba878 100644 --- a/src/cs_vm.hh +++ b/src/cs_vm.hh @@ -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(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(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]; } 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); } } @@ -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]; } 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); } } @@ -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 diff --git a/src/cubescript.cc b/src/cubescript.cc index 816bc4f..6b95013 100644 --- a/src/cubescript.cc +++ b/src/cubescript.cc @@ -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(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(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(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(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(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(id), v.get_int()); break; - case cs_ident_type::Fvar: + case cs_ident_type::FVAR: set_var_float_checked(static_cast(id), v.get_float()); break; - case cs_ident_type::Svar: + case cs_ident_type::SVAR: set_var_str_checked(static_cast(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); } } diff --git a/src/lib_list.cc b/src/lib_list.cc index c900a07..256c34a 100644 --- a/src/lib_list.cc +++ b/src/lib_list.cc @@ -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(); diff --git a/tools/repl.cc b/tools/repl.cc index 7178010..27ca959 100644 --- a/tools/repl.cc +++ b/tools/repl.cc @@ -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(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(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(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;