From e531ab3434640b19cdaa1dc910f5cd071a92d01b Mon Sep 17 00:00:00 2001 From: Daniel Kolesa Date: Tue, 6 Apr 2021 00:54:46 +0200 Subject: [PATCH] clean up any_value APIs for consistency --- include/cubescript/cubescript/value.hh | 19 +-- src/cs_ident.cc | 8 +- src/cs_state.cc | 18 +-- src/cs_val.cc | 69 +++++----- src/cs_vm.cc | 171 ++++++++++++++----------- src/lib_base.cc | 96 +++++++------- src/lib_list.cc | 136 ++++++++++---------- src/lib_math.cc | 44 +++---- src/lib_str.cc | 95 +++++++------- tools/repl.cc | 17 +-- 10 files changed, 353 insertions(+), 320 deletions(-) diff --git a/include/cubescript/cubescript/value.hh b/include/cubescript/cubescript/value.hh index a122481..9ce13b4 100644 --- a/include/cubescript/cubescript/value.hh +++ b/include/cubescript/cubescript/value.hh @@ -74,7 +74,7 @@ private: }; enum class value_type { - NONE = 0, INT, FLOAT, STRING, CODE, IDENT + NONE = 0, INTEGER, FLOAT, STRING, CODE, IDENT }; struct LIBCUBESCRIPT_EXPORT any_value { @@ -92,27 +92,28 @@ struct LIBCUBESCRIPT_EXPORT any_value { value_type get_type() const; - void set_int(integer_type val); + void set_integer(integer_type val); void set_float(float_type val); - void set_str(std::string_view val); - void set_str(string_ref const &val); + void set_string(std::string_view val); + void set_string(string_ref const &val); void set_none(); void set_code(bcode_ref const &val); void set_ident(ident *val); - string_ref get_str() const; - integer_type get_int() const; + string_ref get_string() const; + integer_type get_integer() const; float_type get_float() const; bcode_ref get_code() const; ident *get_ident() const; - void get_val(any_value &r) const; + any_value get_plain() const; bool get_bool() const; void force_none(); + void force_plain(); float_type force_float(); - integer_type force_int(); - std::string_view force_str(); + integer_type force_integer(); + std::string_view force_string(); bcode_ref force_code(state &cs); ident &force_ident(state &cs); diff --git a/src/cs_ident.cc b/src/cs_ident.cc index 9d90889..cfc6545 100644 --- a/src/cs_ident.cc +++ b/src/cs_ident.cc @@ -40,7 +40,7 @@ alias_impl::alias_impl( ): ident_impl{ident_type::ALIAS, name, fl}, p_initial{cs} { - p_initial.val_s.set_str(a); + p_initial.val_s.set_string(a); } alias_impl::alias_impl( @@ -48,13 +48,13 @@ alias_impl::alias_impl( ): ident_impl{ident_type::ALIAS, name, fl}, p_initial{cs} { - p_initial.val_s.set_str(a); + p_initial.val_s.set_string(a); } alias_impl::alias_impl(state &cs, string_ref name, integer_type a, int fl): ident_impl{ident_type::ALIAS, name, fl}, p_initial{cs} { - p_initial.val_s.set_int(a); + p_initial.val_s.set_integer(a); } alias_impl::alias_impl(state &cs, string_ref name, float_type a, int fl): @@ -72,7 +72,7 @@ alias_impl::alias_impl(state &cs, string_ref name, int fl): alias_impl::alias_impl(state &cs, string_ref name, any_value v, int fl): ident_impl{ident_type::ALIAS, name, fl}, p_initial{cs} { - p_initial.val_s = v; + p_initial.val_s = v.get_plain(); } command_impl::command_impl( diff --git a/src/cs_state.cc b/src/cs_state.cc index 5de7855..0091da1 100644 --- a/src/cs_state.cc +++ b/src/cs_state.cc @@ -131,10 +131,10 @@ state::state(alloc_func func, void *data) { auto &cs, auto args, auto & ) { auto *iv = args[0].get_ident()->get_ivar(); - if (args[2].get_int() <= 1) { + if (args[2].get_integer() <= 1) { std::printf("%s = %d\n", iv->get_name().data(), iv->get_value()); } else { - iv->set_value(cs, args[1].get_int()); + iv->set_value(cs, args[1].get_integer()); } }); @@ -142,7 +142,7 @@ state::state(alloc_func func, void *data) { auto &cs, auto args, auto & ) { auto *fv = args[0].get_ident()->get_fvar(); - if (args[2].get_int() <= 1) { + if (args[2].get_integer() <= 1) { auto val = fv->get_value(); if (std::floor(val) == val) { std::printf("%s = %.1f\n", fv->get_name().data(), val); @@ -158,7 +158,7 @@ state::state(alloc_func func, void *data) { auto &cs, auto args, auto & ) { auto *sv = args[0].get_ident()->get_svar(); - if (args[2].get_int() <= 1) { + if (args[2].get_integer() <= 1) { auto val = std::string_view{sv->get_value()}; if (val.find('"') == val.npos) { std::printf("%s = \"%s\"\n", sv->get_name().data(), val.data()); @@ -166,7 +166,7 @@ state::state(alloc_func func, void *data) { std::printf("%s = [%s]\n", sv->get_name().data(), val.data()); } } else { - sv->set_value(cs, args[1].get_str()); + sv->set_value(cs, args[1].get_string()); } }); @@ -197,13 +197,13 @@ state::state(alloc_func func, void *data) { static_cast(p)->p_type = ID_RESULT; p = &new_command("!", "t", [](auto &, auto args, auto &res) { - res.set_int(!args[0].get_bool()); + res.set_integer(!args[0].get_bool()); }); static_cast(p)->p_type = ID_NOT; p = &new_command("&&", "E1V", [](auto &cs, auto args, auto &res) { if (args.empty()) { - res.set_int(1); + res.set_integer(1); } else { for (size_t i = 0; i < args.size(); ++i) { auto code = args[i].get_code(); @@ -222,7 +222,7 @@ state::state(alloc_func func, void *data) { p = &new_command("||", "E1V", [](auto &cs, auto args, auto &res) { if (args.empty()) { - res.set_int(0); + res.set_integer(0); } else { for (size_t i = 0; i < args.size(); ++i) { auto code = args[i].get_code(); @@ -339,7 +339,7 @@ LIBCUBESCRIPT_EXPORT void state::clear_override(ident &id) { switch (id.get_type()) { case ident_type::ALIAS: { auto &ast = p_tstate->get_astack(static_cast(&id)); - ast.node->val_s.set_str(""); + ast.node->val_s.set_string(""); ast.node->code = bcode_ref{}; ast.flags &= ~IDENT_FLAG_OVERRIDDEN; return; diff --git a/src/cs_val.cc b/src/cs_val.cc index b59eae5..e1225dc 100644 --- a/src/cs_val.cc +++ b/src/cs_val.cc @@ -108,7 +108,7 @@ any_value &any_value::operator=(any_value const &v) { csv_cleanup(p_type, &p_stor); p_type = value_type::NONE; switch (v.get_type()) { - case value_type::INT: + case value_type::INTEGER: case value_type::FLOAT: case value_type::IDENT: p_type = v.p_type; @@ -139,9 +139,9 @@ value_type any_value::get_type() const { return p_type; } -void any_value::set_int(integer_type val) { +void any_value::set_integer(integer_type val) { csv_cleanup(p_type, &p_stor); - p_type = value_type::INT; + p_type = value_type::INTEGER; csv_get(&p_stor) = val; } @@ -151,13 +151,13 @@ void any_value::set_float(float_type val) { csv_get(&p_stor) = val; } -void any_value::set_str(std::string_view val) { +void any_value::set_string(std::string_view val) { csv_cleanup(p_type, &p_stor); new (&p_stor) string_ref{get_state(), val}; p_type = value_type::STRING; } -void any_value::set_str(string_ref const &val) { +void any_value::set_string(string_ref const &val) { csv_cleanup(p_type, &p_stor); new (&p_stor) string_ref{val}; p_type = value_type::STRING; @@ -189,10 +189,22 @@ void any_value::force_none() { set_none(); } +void any_value::force_plain() { + switch (get_type()) { + case value_type::FLOAT: + case value_type::INTEGER: + case value_type::STRING: + return; + default: + break; + } + force_none(); +} + float_type any_value::force_float() { float_type rf = 0.0f; switch (get_type()) { - case value_type::INT: + case value_type::INTEGER: rf = float_type(csv_get(&p_stor)); break; case value_type::STRING: @@ -209,7 +221,7 @@ float_type any_value::force_float() { return rf; } -integer_type any_value::force_int() { +integer_type any_value::force_integer() { integer_type ri = 0; switch (get_type()) { case value_type::FLOAT: @@ -220,23 +232,23 @@ integer_type any_value::force_int() { *std::launder(reinterpret_cast(&p_stor)) ); break; - case value_type::INT: + case value_type::INTEGER: return csv_get(&p_stor); default: break; } - set_int(ri); + set_integer(ri); return ri; } -std::string_view any_value::force_str() { +std::string_view any_value::force_string() { charbuf rs{get_state()}; std::string_view str; switch (get_type()) { case value_type::FLOAT: str = floatstr(csv_get(&p_stor), rs); break; - case value_type::INT: + case value_type::INTEGER: str = intstr(csv_get(&p_stor), rs); break; case value_type::STRING: @@ -245,7 +257,7 @@ std::string_view any_value::force_str() { str = rs.str(); break; } - set_str(str); + set_string(str); return std::string_view(*std::launder( reinterpret_cast(&p_stor) )); @@ -260,7 +272,7 @@ bcode_ref any_value::force_code(state &cs) { } codegen_state gs{state_p{cs}.ts()}; gs.code.reserve(64); - gs.gen_main(get_str()); + gs.gen_main(get_string()); gs.done(); uint32_t *cbuf = bcode_alloc(state_p{cs}.ts().istate, gs.code.size()); std::memcpy(cbuf, gs.code.data(), gs.code.size() * sizeof(std::uint32_t)); @@ -277,17 +289,17 @@ ident &any_value::force_ident(state &cs) { break; } auto &id = state_p{cs}.ts().istate->new_ident( - cs, get_str(), IDENT_FLAG_UNKNOWN + cs, get_string(), IDENT_FLAG_UNKNOWN ); set_ident(&id); return id; } -integer_type any_value::get_int() const { +integer_type any_value::get_integer() const { switch (get_type()) { case value_type::FLOAT: return integer_type(csv_get(&p_stor)); - case value_type::INT: + case value_type::INTEGER: return csv_get(&p_stor); case value_type::STRING: return parse_int( @@ -303,7 +315,7 @@ float_type any_value::get_float() const { switch (get_type()) { case value_type::FLOAT: return csv_get(&p_stor); - case value_type::INT: + case value_type::INTEGER: return float_type(csv_get(&p_stor)); case value_type::STRING: return parse_float( @@ -329,11 +341,11 @@ ident *any_value::get_ident() const { return csv_get(&p_stor); } -string_ref any_value::get_str() const { +string_ref any_value::get_string() const { switch (get_type()) { case value_type::STRING: return *std::launder(reinterpret_cast(&p_stor)); - case value_type::INT: { + case value_type::INTEGER: { charbuf rs{get_state()}; return string_ref{ get_state(), intstr(csv_get(&p_stor), rs) @@ -351,28 +363,23 @@ string_ref any_value::get_str() const { return string_ref{get_state(), ""}; } -void any_value::get_val(any_value &r) const { +any_value any_value::get_plain() const { switch (get_type()) { case value_type::STRING: - r = *this; - break; - case value_type::INT: - r.set_int(csv_get(&p_stor)); - break; + case value_type::INTEGER: case value_type::FLOAT: - r.set_float(csv_get(&p_stor)); - break; + return *this; default: - r.set_none(); break; } + return any_value{*get_state()}; } bool any_value::get_bool() const { switch (get_type()) { case value_type::FLOAT: return csv_get(&p_stor) != 0; - case value_type::INT: + case value_type::INTEGER: return csv_get(&p_stor) != 0; case value_type::STRING: { std::string_view s = *std::launder( @@ -406,11 +413,11 @@ LIBCUBESCRIPT_EXPORT string_ref concat_values( charbuf buf{cs}; for (std::size_t i = 0; i < vals.size(); ++i) { switch (vals[i].get_type()) { - case value_type::INT: + case value_type::INTEGER: case value_type::FLOAT: case value_type::STRING: std::ranges::copy( - any_value{vals[i]}.force_str(), std::back_inserter(buf) + any_value{vals[i]}.force_string(), std::back_inserter(buf) ); break; default: diff --git a/src/cs_vm.cc b/src/cs_vm.cc index 61a53e2..d889c0a 100644 --- a/src/cs_vm.cc +++ b/src/cs_vm.cc @@ -28,12 +28,12 @@ static inline void force_arg(any_value &v, int type) { switch (type) { case BC_RET_STRING: if (v.get_type() != value_type::STRING) { - v.force_str(); + v.force_string(); } break; case BC_RET_INT: - if (v.get_type() != value_type::INT) { - v.force_int(); + if (v.get_type() != value_type::INTEGER) { + v.force_integer(); } break; case BC_RET_FLOAT: @@ -58,10 +58,10 @@ void exec_command( if (rep) { break; } - args[i].set_int(0); + args[i].set_integer(0); fakeargs++; } else { - args[i].force_int(); + args[i].force_integer(); } break; case 'b': @@ -69,10 +69,12 @@ void exec_command( if (rep) { break; } - args[i].set_int(std::numeric_limits::min()); + args[i].set_integer( + std::numeric_limits::min() + ); fakeargs++; } else { - args[i].force_int(); + args[i].force_integer(); } break; case 'f': @@ -102,10 +104,10 @@ void exec_command( if (rep) { break; } - args[i].set_str(""); + args[i].set_string(""); fakeargs++; } else { - args[i].force_str(); + args[i].force_string(); } break; case 'T': @@ -126,9 +128,9 @@ void exec_command( args[i].set_none(); fakeargs++; } else if (args[i].get_type() == value_type::STRING) { - auto str = std::string_view{args[i].get_str()}; + auto str = std::string_view{args[i].get_string()}; if (str.empty()) { - args[i].set_int(0); + args[i].set_integer(0); } else { args[i].force_code(*ts.pstate); } @@ -164,12 +166,12 @@ void exec_command( break; case 'N': i += 1; - args[i].set_int(integer_type(lookup ? -1 : i - fakeargs)); + args[i].set_integer(integer_type(lookup ? -1 : i - fakeargs)); break; case 'C': { i = std::max(i + 1, numargs); any_value tv{*ts.pstate}; - tv.set_str(concat_values( + tv.set_string(concat_values( *ts.pstate, std::span{args, std::size_t(i)}, " " )); static_cast(id)->call( @@ -198,6 +200,7 @@ void exec_command( static_cast(id)->call( ts, std::span{args, std::size_t(i)}, res ); + res.force_plain(); } bool exec_alias( @@ -238,7 +241,7 @@ bool exec_alias( if (!aast.node->code) { codegen_state gs{ts}; gs.code.reserve(64); - gs.gen_main(aast.node->val_s.get_str()); + gs.gen_main(aast.node->val_s.get_string()); /* i wish i could steal the memory somehow */ uint32_t *code = bcode_alloc(ts.istate, gs.code.size()); memcpy(code, gs.code.data(), gs.code.size() * sizeof(uint32_t)); @@ -317,7 +320,7 @@ static inline int get_lookupu_type( if (arg.get_type() != value_type::STRING) { return -2; /* default case */ } - id = ts.pstate->get_ident(arg.get_str()); + id = ts.pstate->get_ident(arg.get_string()); if (id) { switch(id->get_type()) { case ident_type::ALIAS: { @@ -354,7 +357,7 @@ static inline int get_lookupu_type( return ID_UNKNOWN; } } - throw error{*ts.pstate, "unknown alias lookup: %s", arg.get_str().data()}; + throw error{*ts.pstate, "unknown alias lookup: %s", arg.get_string().data()}; } std::uint32_t *vm_exec( @@ -380,44 +383,44 @@ std::uint32_t *vm_exec( result.set_none(); continue; case BC_INST_NULL | BC_RET_STRING: - result.set_str(""); + result.set_string(""); continue; case BC_INST_NULL | BC_RET_INT: - result.set_int(0); + result.set_integer(0); continue; case BC_INST_NULL | BC_RET_FLOAT: result.set_float(0.0f); continue; case BC_INST_FALSE | BC_RET_STRING: - result.set_str("0"); + result.set_string("0"); continue; case BC_INST_FALSE | BC_RET_NULL: case BC_INST_FALSE | BC_RET_INT: - result.set_int(0); + result.set_integer(0); continue; case BC_INST_FALSE | BC_RET_FLOAT: result.set_float(0.0f); continue; case BC_INST_TRUE | BC_RET_STRING: - result.set_str("1"); + result.set_string("1"); continue; case BC_INST_TRUE | BC_RET_NULL: case BC_INST_TRUE | BC_RET_INT: - result.set_int(1); + result.set_integer(1); continue; case BC_INST_TRUE | BC_RET_FLOAT: result.set_float(1.0f); continue; case BC_INST_NOT | BC_RET_STRING: - result.set_str(args.back().get_bool() ? "0" : "1"); + result.set_string(args.back().get_bool() ? "0" : "1"); args.pop_back(); continue; case BC_INST_NOT | BC_RET_NULL: case BC_INST_NOT | BC_RET_INT: - result.set_int(!args.back().get_bool()); + result.set_integer(!args.back().get_bool()); args.pop_back(); continue; case BC_INST_NOT | BC_RET_FLOAT: @@ -464,10 +467,10 @@ std::uint32_t *vm_exec( continue; case BC_INST_FORCE | BC_RET_STRING: - args.back().force_str(); + args.back().force_string(); continue; case BC_INST_FORCE | BC_RET_INT: - args.back().force_int(); + args.back().force_integer(); continue; case BC_INST_FORCE | BC_RET_FLOAT: args.back().force_float(); @@ -475,12 +478,12 @@ std::uint32_t *vm_exec( case BC_INST_DUP | BC_RET_NULL: { auto &v = args.back(); - v.get_val(args.emplace_back(cs)); + args.emplace_back(cs) = v.get_plain(); continue; } case BC_INST_DUP | BC_RET_INT: { auto &v = args.back(); - args.emplace_back(cs).set_int(v.get_int()); + args.emplace_back(cs).set_integer(v.get_integer()); continue; } case BC_INST_DUP | BC_RET_FLOAT: { @@ -492,13 +495,13 @@ std::uint32_t *vm_exec( auto &v = args.back(); auto &nv = args.emplace_back(cs); nv = v; - nv.force_str(); + nv.force_string(); continue; } case BC_INST_VAL | BC_RET_STRING: { std::uint32_t len = op >> 8; - args.emplace_back(cs).set_str(std::string_view{ + args.emplace_back(cs).set_string(std::string_view{ reinterpret_cast(code), len }); code += len / sizeof(std::uint32_t) + 1; @@ -511,7 +514,7 @@ std::uint32_t *vm_exec( char((op >> 24) & 0xFF), '\0' }; /* gotta cast or r.size() == potentially 3 */ - args.emplace_back(cs).set_str(static_cast(s)); + args.emplace_back(cs).set_string(static_cast(s)); continue; } case BC_INST_VAL | BC_RET_NULL: @@ -519,13 +522,13 @@ std::uint32_t *vm_exec( args.emplace_back(cs).set_none(); continue; case BC_INST_VAL | BC_RET_INT: - args.emplace_back(cs).set_int( + args.emplace_back(cs).set_integer( *reinterpret_cast(code) ); code += bc_store_size; continue; case BC_INST_VAL_INT | BC_RET_INT: - args.emplace_back(cs).set_int(integer_type(op) >> 8); + args.emplace_back(cs).set_integer(integer_type(op) >> 8); continue; case BC_INST_VAL | BC_RET_FLOAT: args.emplace_back(cs).set_float( @@ -686,10 +689,10 @@ std::uint32_t *vm_exec( any_value &arg = args.back(); codegen_state gs{ts}; switch (arg.get_type()) { - case value_type::INT: + case value_type::INTEGER: gs.code.reserve(8); gs.code.push_back(BC_INST_START); - gs.gen_int(arg.get_int()); + gs.gen_int(arg.get_integer()); gs.code.push_back(BC_INST_RESULT); gs.code.push_back(BC_INST_EXIT); break; @@ -702,7 +705,7 @@ std::uint32_t *vm_exec( break; case value_type::STRING: gs.code.reserve(64); - gs.gen_main(arg.get_str()); + gs.gen_main(arg.get_string()); break; default: gs.code.reserve(8); @@ -728,7 +731,7 @@ std::uint32_t *vm_exec( any_value &arg = args.back(); switch (arg.get_type()) { case value_type::STRING: { - std::string_view s = arg.get_str(); + std::string_view s = arg.get_string(); if (!s.empty()) { codegen_state gs{ts}; gs.code.reserve(64); @@ -769,7 +772,7 @@ std::uint32_t *vm_exec( ident *id = ts.istate->id_dummy; if (arg.get_type() == value_type::STRING) { id = &ts.istate->new_ident( - cs, arg.get_str(), IDENT_FLAG_UNKNOWN + cs, arg.get_string(), IDENT_FLAG_UNKNOWN ); } alias *a = static_cast(id); @@ -788,21 +791,27 @@ std::uint32_t *vm_exec( switch (get_lookupu_type(ts, arg, id, op, ast)) { case ID_ALIAS: arg = ast->node->val_s; - arg.force_str(); + arg.force_string(); continue; case ID_SVAR: - arg.set_str(static_cast(id)->get_value()); + arg.set_string( + static_cast(id)->get_value() + ); continue; case ID_IVAR: - arg.set_int(static_cast(id)->get_value()); - arg.force_str(); + arg.set_integer( + static_cast(id)->get_value() + ); + arg.force_string(); continue; case ID_FVAR: - arg.set_float(static_cast(id)->get_value()); - arg.force_str(); + arg.set_float( + static_cast(id)->get_value() + ); + arg.force_string(); continue; case ID_UNKNOWN: - arg.set_str(""); + arg.set_string(""); continue; default: continue; @@ -813,11 +822,11 @@ std::uint32_t *vm_exec( alias_stack *ast; alias *a = get_lookup_id(ts, op, ast); if (!a) { - args.emplace_back(cs).set_str(""); + args.emplace_back(cs).set_string(""); } else { auto &v = args.emplace_back(cs); v = ast->node->val_s; - v.force_str(); + v.force_string(); } continue; } @@ -828,23 +837,25 @@ std::uint32_t *vm_exec( any_value &arg = args.back(); switch (get_lookupu_type(ts, arg, id, op, ast)) { case ID_ALIAS: - arg.set_int(ast->node->val_s.get_int()); + arg.set_integer(ast->node->val_s.get_integer()); continue; case ID_SVAR: - arg.set_int(parse_int( + arg.set_integer(parse_int( static_cast(id)->get_value() )); continue; case ID_IVAR: - arg.set_int(static_cast(id)->get_value()); - continue; - case ID_FVAR: - arg.set_int( - integer_type(static_cast(id)->get_value()) + arg.set_integer( + static_cast(id)->get_value() ); continue; + case ID_FVAR: + arg.set_integer(integer_type( + static_cast(id)->get_value() + )); + continue; case ID_UNKNOWN: - arg.set_int(0); + arg.set_integer(0); continue; default: continue; @@ -854,9 +865,11 @@ std::uint32_t *vm_exec( alias_stack *ast; alias *a = get_lookup_id(ts, op, ast); if (!a) { - args.emplace_back(cs).set_int(0); + args.emplace_back(cs).set_integer(0); } else { - args.emplace_back(cs).set_int(ast->node->val_s.get_int()); + args.emplace_back(cs).set_integer( + ast->node->val_s.get_integer() + ); } continue; } @@ -908,13 +921,17 @@ std::uint32_t *vm_exec( any_value &arg = args.back(); switch (get_lookupu_type(ts, arg, id, op, ast)) { case ID_ALIAS: - ast->node->val_s.get_val(arg); + arg = ast->node->val_s.get_plain(); continue; case ID_SVAR: - arg.set_str(static_cast(id)->get_value()); + arg.set_string( + static_cast(id)->get_value() + ); continue; case ID_IVAR: - arg.set_int(static_cast(id)->get_value()); + arg.set_integer( + static_cast(id)->get_value() + ); continue; case ID_FVAR: arg.set_float( @@ -934,7 +951,7 @@ std::uint32_t *vm_exec( if (!a) { args.emplace_back(cs).set_none(); } else { - ast->node->val_s.get_val(args.emplace_back(cs)); + args.emplace_back(cs) = ast->node->val_s.get_plain(); } continue; } @@ -953,19 +970,19 @@ std::uint32_t *vm_exec( ((op & BC_INST_OP_MASK) == BC_INST_CONC) ? " " : "" ); args.resize(args.size() - numconc, any_value{cs}); - args.emplace_back(cs).set_str(buf); + args.emplace_back(cs).set_string(buf); force_arg(args.back(), op & BC_INST_RET_MASK); continue; } case BC_INST_SVAR | BC_RET_STRING: case BC_INST_SVAR | BC_RET_NULL: - args.emplace_back(cs).set_str(static_cast( + args.emplace_back(cs).set_string(static_cast( ts.istate->identmap[op >> 8] )->get_value()); continue; case BC_INST_SVAR | BC_RET_INT: - args.emplace_back(cs).set_int(parse_int( + args.emplace_back(cs).set_integer(parse_int( static_cast( ts.istate->identmap[op >> 8] )->get_value() @@ -981,16 +998,16 @@ std::uint32_t *vm_exec( case BC_INST_IVAR | BC_RET_INT: case BC_INST_IVAR | BC_RET_NULL: - args.emplace_back(cs).set_int(static_cast( + args.emplace_back(cs).set_integer(static_cast( ts.istate->identmap[op >> 8] )->get_value()); continue; case BC_INST_IVAR | BC_RET_STRING: { auto &v = args.emplace_back(cs); - v.set_int(static_cast( + v.set_integer(static_cast( ts.istate->identmap[op >> 8] )->get_value()); - v.force_str(); + v.force_string(); continue; } case BC_INST_IVAR | BC_RET_FLOAT: @@ -1009,16 +1026,18 @@ std::uint32_t *vm_exec( continue; case BC_INST_FVAR | BC_RET_STRING: { auto &v = args.emplace_back(cs); - v.set_int(integer_type(std::floor(static_cast( + v.set_float(static_cast( ts.istate->identmap[op >> 8] - )->get_value()))); - v.force_str(); + )->get_value()); + v.force_string(); continue; } case BC_INST_FVAR | BC_RET_INT: - args.emplace_back(cs).set_int(int(static_cast( - ts.istate->identmap[op >> 8] - )->get_value())); + args.emplace_back(cs).set_integer( + integer_type(std::floor(static_cast( + ts.istate->identmap[op >> 8] + )->get_value())) + ); continue; case BC_INST_ALIAS: { @@ -1037,7 +1056,7 @@ std::uint32_t *vm_exec( case BC_INST_ALIAS_U: { auto v = std::move(args.back()); args.pop_back(); - cs.set_alias(args.back().get_str(), std::move(v)); + cs.set_alias(args.back().get_string(), std::move(v)); args.pop_back(); continue; } @@ -1082,7 +1101,7 @@ litval: args.resize(offset - 1, any_value{cs}); continue; } - auto idn = idarg.get_str(); + auto idn = idarg.get_string(); ident *id = cs.get_ident(idn); if (!id) { noid: @@ -1248,7 +1267,7 @@ noid: result.force_none(); { any_value tv{cs}; - tv.set_str(concat_values(cs, std::span{ + tv.set_string(concat_values(cs, std::span{ &args[offset], callargs }, " ")); id->call(ts, std::span{&tv, 1}, result); diff --git a/src/lib_base.cc b/src/lib_base.cc index b11a966..9f39448 100644 --- a/src/lib_base.cc +++ b/src/lib_base.cc @@ -18,7 +18,7 @@ static inline void do_loop( if (alias_local st{cs, &id}; st) { any_value idv{cs}; for (integer_type i = 0; i < n; ++i) { - idv.set_int(offset + i * step); + idv.set_integer(offset + i * step); st.set(idv); if (cond && !cs.run(cond).get_bool()) { break; @@ -44,7 +44,7 @@ static inline void do_loop_conc( charbuf s{cs}; any_value idv{cs}; for (integer_type i = 0; i < n; ++i) { - idv.set_int(offset + i * step); + idv.set_integer(offset + i * step); st.set(idv); any_value v{cs}; switch (cs.run_loop(body, v)) { @@ -58,23 +58,23 @@ static inline void do_loop_conc( if (space && i) { s.push_back(' '); } - s.append(v.get_str()); + s.append(v.get_string()); } end: - res.set_str(s.str()); + res.set_string(s.str()); } } void init_lib_base(state &gcs) { gcs.new_command("error", "s", [](auto &cs, auto args, auto &) { - throw error{cs, args[0].get_str()}; + throw error{cs, args[0].get_string()}; }); gcs.new_command("pcall", "err", [](auto &cs, auto args, auto &ret) { alias *cret = args[1].get_ident()->get_alias(); alias *css = args[2].get_ident()->get_alias(); if (!cret || !css) { - ret.set_int(0); + ret.set_integer(0); return; } any_value result{cs}, tback{cs}; @@ -82,15 +82,15 @@ void init_lib_base(state &gcs) { try { result = cs.run(args[0].get_code()); } catch (error const &e) { - result.set_str(e.what()); + result.set_string(e.what()); if (e.get_stack().get()) { charbuf buf{cs}; print_stack(std::back_inserter(buf), e.get_stack()); - tback.set_str(buf.str()); + tback.set_string(buf.str()); } rc = false; } - ret.set_int(rc); + ret.set_integer(rc); auto &ts = state_p{cs}.ts(); ts.get_astack(cret).set_alias(cret, ts, result); ts.get_astack(css).set_alias(css, ts, tback); @@ -119,11 +119,11 @@ void init_lib_base(state &gcs) { }); gcs.new_command("case", "ite2V", [](auto &cs, auto args, auto &res) { - integer_type val = args[0].get_int(); + integer_type val = args[0].get_integer(); for (size_t i = 1; (i + 1) < args.size(); i += 2) { if ( (args[i].get_type() == value_type::NONE) || - (args[i].get_int() == val) + (args[i].get_integer() == val) ) { res = cs.run(args[i + 1].get_code()); return; @@ -145,11 +145,11 @@ void init_lib_base(state &gcs) { }); gcs.new_command("cases", "ste2V", [](auto &cs, auto args, auto &res) { - string_ref val = args[0].get_str(); + string_ref val = args[0].get_string(); for (size_t i = 1; (i + 1) < args.size(); i += 2) { if ( (args[i].get_type() == value_type::NONE) || - (args[i].get_str() == val) + (args[i].get_string() == val) ) { res = cs.run(args[i + 1].get_code()); return; @@ -171,57 +171,59 @@ void init_lib_base(state &gcs) { gcs.new_command("loop", "rie", [](auto &cs, auto args, auto &) { do_loop( - cs, *args[0].get_ident(), 0, args[1].get_int(), 1, nullptr, + cs, *args[0].get_ident(), 0, args[1].get_integer(), 1, nullptr, args[2].get_code() ); }); gcs.new_command("loop+", "riie", [](auto &cs, auto args, auto &) { do_loop( - cs, *args[0].get_ident(), args[1].get_int(), args[2].get_int(), 1, - nullptr, args[3].get_code() + cs, *args[0].get_ident(), args[1].get_integer(), + args[2].get_integer(), 1, nullptr, args[3].get_code() ); }); gcs.new_command("loop*", "riie", [](auto &cs, auto args, auto &) { do_loop( - cs, *args[0].get_ident(), 0, args[1].get_int(), args[2].get_int(), - nullptr, args[3].get_code() + cs, *args[0].get_ident(), 0, args[1].get_integer(), + args[2].get_integer(), nullptr, args[3].get_code() ); }); gcs.new_command("loop+*", "riiie", [](auto &cs, auto args, auto &) { do_loop( - cs, *args[0].get_ident(), args[1].get_int(), args[3].get_int(), - args[2].get_int(), nullptr, args[4].get_code() + cs, *args[0].get_ident(), args[1].get_integer(), + args[3].get_integer(), args[2].get_integer(), + nullptr, args[4].get_code() ); }); gcs.new_command("loopwhile", "riee", [](auto &cs, auto args, auto &) { do_loop( - cs, *args[0].get_ident(), 0, args[1].get_int(), 1, + cs, *args[0].get_ident(), 0, args[1].get_integer(), 1, args[2].get_code(), args[3].get_code() ); }); gcs.new_command("loopwhile+", "riiee", [](auto &cs, auto args, auto &) { do_loop( - cs, *args[0].get_ident(), args[1].get_int(), args[2].get_int(), 1, - args[3].get_code(), args[4].get_code() + cs, *args[0].get_ident(), args[1].get_integer(), + args[2].get_integer(), 1, args[3].get_code(), args[4].get_code() ); }); gcs.new_command("loopwhile*", "riiee", [](auto &cs, auto args, auto &) { do_loop( - cs, *args[0].get_ident(), 0, args[2].get_int(), args[1].get_int(), - args[3].get_code(), args[4].get_code() + cs, *args[0].get_ident(), 0, args[2].get_integer(), + args[1].get_integer(), args[3].get_code(), args[4].get_code() ); }); gcs.new_command("loopwhile+*", "riiiee", [](auto &cs, auto args, auto &) { do_loop( - cs, *args[0].get_ident(), args[1].get_int(), args[3].get_int(), - args[2].get_int(), args[4].get_code(), args[5].get_code() + cs, *args[0].get_ident(), args[1].get_integer(), + args[3].get_integer(), args[2].get_integer(), args[4].get_code(), + args[5].get_code() ); }); @@ -242,35 +244,36 @@ end: gcs.new_command("loopconcat", "rie", [](auto &cs, auto args, auto &res) { do_loop_conc( - cs, res, *args[0].get_ident(), 0, args[1].get_int(), 1, + cs, res, *args[0].get_ident(), 0, args[1].get_integer(), 1, args[2].get_code(), true ); }); gcs.new_command("loopconcat+", "riie", [](auto &cs, auto args, auto &res) { do_loop_conc( - cs, res, *args[0].get_ident(), args[1].get_int(), - args[2].get_int(), 1, args[3].get_code(), true + cs, res, *args[0].get_ident(), args[1].get_integer(), + args[2].get_integer(), 1, args[3].get_code(), true ); }); gcs.new_command("loopconcat*", "riie", [](auto &cs, auto args, auto &res) { do_loop_conc( - cs, res, *args[0].get_ident(), 0, args[2].get_int(), - args[1].get_int(), args[3].get_code(), true + cs, res, *args[0].get_ident(), 0, args[2].get_integer(), + args[1].get_integer(), args[3].get_code(), true ); }); gcs.new_command("loopconcat+*", "riiie", [](auto &cs, auto args, auto &res) { do_loop_conc( - cs, res, *args[0].get_ident(), args[1].get_int(), - args[3].get_int(), args[2].get_int(), args[4].get_code(), true + cs, res, *args[0].get_ident(), args[1].get_integer(), + args[3].get_integer(), args[2].get_integer(), + args[4].get_code(), true ); }); gcs.new_command("loopconcatword", "rie", [](auto &cs, auto args, auto &res) { do_loop_conc( - cs, res, *args[0].get_ident(), 0, args[1].get_int(), 1, + cs, res, *args[0].get_ident(), 0, args[1].get_integer(), 1, args[2].get_code(), false ); }); @@ -279,8 +282,8 @@ end: auto &cs, auto args, auto &res ) { do_loop_conc( - cs, res, *args[0].get_ident(), args[1].get_int(), - args[2].get_int(), 1, args[3].get_code(), false + cs, res, *args[0].get_ident(), args[1].get_integer(), + args[2].get_integer(), 1, args[3].get_code(), false ); }); @@ -288,8 +291,8 @@ end: auto &cs, auto args, auto &res ) { do_loop_conc( - cs, res, *args[0].get_ident(), 0, args[2].get_int(), - args[1].get_int(), args[3].get_code(), false + cs, res, *args[0].get_ident(), 0, args[2].get_integer(), + args[1].get_integer(), args[3].get_code(), false ); }); @@ -297,8 +300,9 @@ end: auto &cs, auto args, auto &res ) { do_loop_conc( - cs, res, *args[0].get_ident(), args[1].get_int(), args[3].get_int(), - args[2].get_int(), args[4].get_code(), false + cs, res, *args[0].get_ident(), args[1].get_integer(), + args[3].get_integer(), args[2].get_integer(), + args[4].get_code(), false ); }); @@ -313,21 +317,21 @@ end: }); gcs.new_command("resetvar", "s", [](auto &cs, auto args, auto &) { - cs.reset_var(args[0].get_str()); + cs.reset_var(args[0].get_string()); }); gcs.new_command("alias", "st", [](auto &cs, auto args, auto &) { - cs.set_alias(args[0].get_str(), args[1]); + cs.set_alias(args[0].get_string(), args[1]); }); gcs.new_command("identexists", "s", [](auto &cs, auto args, auto &res) { - res.set_int(cs.have_ident(args[0].get_str())); + res.set_integer(cs.have_ident(args[0].get_string())); }); gcs.new_command("getalias", "s", [](auto &cs, auto args, auto &res) { - auto *id = cs.get_alias(args[0].get_str()); + auto *id = cs.get_alias(args[0].get_string()); if (id) { - id->get_value(cs).get_val(res); + res = id->get_value(cs); } }); } diff --git a/src/lib_list.cc b/src/lib_list.cc index 7e474cf..9328f68 100644 --- a/src/lib_list.cc +++ b/src/lib_list.cc @@ -14,7 +14,7 @@ struct arg_val; template<> struct arg_val { static integer_type get(any_value &tv) { - return tv.get_int(); + return tv.get_integer(); } }; @@ -28,7 +28,7 @@ struct arg_val { template<> struct arg_val { static std::string_view get(any_value &tv) { - return tv.get_str(); + return tv.get_string(); } }; @@ -36,11 +36,11 @@ template static inline void list_find( state &cs, std::span args, any_value &res, F cmp ) { - integer_type n = 0, skip = args[2].get_int(); + integer_type n = 0, skip = args[2].get_integer(); T val = arg_val::get(args[1]); - for (list_parser p{cs, args[0].get_str()}; p.parse(); ++n) { + for (list_parser p{cs, args[0].get_string()}; p.parse(); ++n) { if (cmp(p, val)) { - res.set_int(n); + res.set_integer(n); return; } for (int i = 0; i < skip; ++i) { @@ -51,7 +51,7 @@ static inline void list_find( } } notfound: - res.set_int(-1); + res.set_integer(-1); } template @@ -59,10 +59,10 @@ static inline void list_assoc( state &cs, std::span args, any_value &res, F cmp ) { T val = arg_val::get(args[1]); - for (list_parser p{cs, args[0].get_str()}; p.parse();) { + for (list_parser p{cs, args[0].get_string()}; p.parse();) { if (cmp(p, val)) { if (p.parse()) { - res.set_str(p.get_item()); + res.set_string(p.get_item()); } return; } @@ -81,7 +81,7 @@ static void loop_list_conc( charbuf r{cs}; int n = 0; for (list_parser p{cs, list}; p.parse(); ++n) { - idv.set_str(p.get_item()); + idv.set_string(p.get_item()); st.set(std::move(idv)); if (n && space) { r.push_back(' '); @@ -95,10 +95,10 @@ static void loop_list_conc( default: break; } - r.append(v.get_str()); + r.append(v.get_string()); } end: - res.set_str(r.str()); + res.set_string(r.str()); } } @@ -119,8 +119,8 @@ template static inline void list_merge( state &cs, std::span args, any_value &res, F cmp ) { - std::string_view list = args[0].get_str(); - std::string_view elems = args[1].get_str(); + std::string_view list = args[0].get_string(); + std::string_view elems = args[1].get_string(); charbuf buf{cs}; if (PushList) { buf.append(list); @@ -136,14 +136,14 @@ static inline void list_merge( buf.append(p.get_quoted_item()); } } - res.set_str(buf.str()); + res.set_string(buf.str()); } static void init_lib_list_sort(state &cs); void init_lib_list(state &gcs) { gcs.new_command("listlen", "s", [](auto &cs, auto args, auto &res) { - res.set_int(integer_type(list_parser{cs, args[0].get_str()}.count())); + res.set_integer(integer_type(list_parser{cs, args[0].get_string()}.count())); }); gcs.new_command("at", "si1V", [](auto &cs, auto args, auto &res) { @@ -154,11 +154,11 @@ void init_lib_list(state &gcs) { res = args[0]; return; } - auto str = args[0].get_str(); + auto str = args[0].get_string(); list_parser p{cs, str}; for (size_t i = 1; i < args.size(); ++i) { p.set_input(str); - integer_type pos = args[i].get_int(); + integer_type pos = args[i].get_integer(); for (; pos > 0; --pos) { if (!p.parse()) { break; @@ -168,18 +168,18 @@ void init_lib_list(state &gcs) { p.set_input(""); } } - res.set_str(p.get_item()); + res.set_string(p.get_item()); }); gcs.new_command("sublist", "siiN", [](auto &cs, auto args, auto &res) { - integer_type skip = args[1].get_int(), - count = args[2].get_int(), - numargs = args[3].get_int(); + integer_type skip = args[1].get_integer(), + count = args[2].get_integer(), + numargs = args[3].get_integer(); integer_type offset = std::max(skip, integer_type(0)), len = (numargs >= 3) ? std::max(count, integer_type(0)) : -1; - list_parser p{cs, args[0].get_str()}; + list_parser p{cs, args[0].get_string()}; for (integer_type i = 0; i < offset; ++i) { if (!p.parse()) break; } @@ -187,7 +187,7 @@ void init_lib_list(state &gcs) { if (offset > 0) { p.skip_until_item(); } - res.set_str(p.get_input()); + res.set_string(p.get_input()); return; } @@ -195,12 +195,12 @@ void init_lib_list(state &gcs) { if (len > 0 && p.parse()) { while (--len > 0 && p.parse()); } else { - res.set_str(""); + res.set_string(""); return; } auto quote = p.get_quoted_item(); auto *qend = "e[quote.size()]; - res.set_str(std::string_view{list, qend}); + res.set_string(std::string_view{list, qend}); }); gcs.new_command("listfind", "rse", [](auto &cs, auto args, auto &res) { @@ -208,17 +208,17 @@ void init_lib_list(state &gcs) { any_value idv{cs}; auto body = args[2].get_code(); int n = -1; - for (list_parser p{cs, args[1].get_str()}; p.parse();) { + for (list_parser p{cs, args[1].get_string()}; p.parse();) { ++n; - idv.set_str(p.get_raw_item()); + idv.set_string(p.get_raw_item()); st.set(std::move(idv)); if (cs.run(body).get_bool()) { - res.set_int(integer_type(n)); + res.set_integer(integer_type(n)); return; } } } - res.set_int(-1); + res.set_integer(-1); }); gcs.new_command("listassoc", "rse", [](auto &cs, auto args, auto &res) { @@ -226,13 +226,13 @@ void init_lib_list(state &gcs) { any_value idv{cs}; auto body = args[2].get_code(); int n = -1; - for (list_parser p{cs, args[1].get_str()}; p.parse();) { + for (list_parser p{cs, args[1].get_string()}; p.parse();) { ++n; - idv.set_str(p.get_raw_item()); + idv.set_string(p.get_raw_item()); st.set(std::move(idv)); if (cs.run(body).get_bool()) { if (p.parse()) { - res.set_str(p.get_item()); + res.set_string(p.get_item()); } break; } @@ -292,8 +292,8 @@ void init_lib_list(state &gcs) { any_value idv{cs}; auto body = args[2].get_code(); int n = 0; - for (list_parser p{cs, args[1].get_str()}; p.parse(); ++n) { - idv.set_str(p.get_item()); + for (list_parser p{cs, args[1].get_string()}; p.parse(); ++n) { + idv.set_string(p.get_item()); st.set(std::move(idv)); switch (cs.run_loop(body)) { case loop_state::BREAK: @@ -314,13 +314,13 @@ void init_lib_list(state &gcs) { any_value idv{cs}; auto body = args[3].get_code(); int n = 0; - for (list_parser p{cs, args[2].get_str()}; p.parse(); n += 2) { - idv.set_str(p.get_item()); + for (list_parser p{cs, args[2].get_string()}; p.parse(); n += 2) { + idv.set_string(p.get_item()); st1.set(std::move(idv)); if (p.parse()) { - idv.set_str(p.get_item()); + idv.set_string(p.get_item()); } else { - idv.set_str(""); + idv.set_string(""); } st2.set(std::move(idv)); switch (cs.run_loop(body)) { @@ -342,19 +342,19 @@ void init_lib_list(state &gcs) { any_value idv{cs}; auto body = args[4].get_code(); int n = 0; - for (list_parser p{cs, args[3].get_str()}; p.parse(); n += 3) { - idv.set_str(p.get_item()); + for (list_parser p{cs, args[3].get_string()}; p.parse(); n += 3) { + idv.set_string(p.get_item()); st1.set(std::move(idv)); if (p.parse()) { - idv.set_str(p.get_item()); + idv.set_string(p.get_item()); } else { - idv.set_str(""); + idv.set_string(""); } st2.set(std::move(idv)); if (p.parse()) { - idv.set_str(p.get_item()); + idv.set_string(p.get_item()); } else { - idv.set_str(""); + idv.set_string(""); } st3.set(std::move(idv)); switch (cs.run_loop(body)) { @@ -368,7 +368,7 @@ void init_lib_list(state &gcs) { gcs.new_command("looplistconcat", "rse", [](auto &cs, auto args, auto &res) { loop_list_conc( - cs, res, args[0].get_ident(), args[1].get_str(), + cs, res, args[0].get_ident(), args[1].get_string(), args[2].get_code(), true ); }); @@ -377,7 +377,7 @@ void init_lib_list(state &gcs) { auto &cs, auto args, auto &res ) { loop_list_conc( - cs, res, args[0].get_ident(), args[1].get_str(), + cs, res, args[0].get_ident(), args[1].get_string(), args[2].get_code(), false ); }); @@ -388,8 +388,8 @@ void init_lib_list(state &gcs) { auto body = args[2].get_code(); charbuf r{cs}; int n = 0; - for (list_parser p{cs, args[1].get_str()}; p.parse(); ++n) { - idv.set_str(p.get_raw_item()); + for (list_parser p{cs, args[1].get_string()}; p.parse(); ++n) { + idv.set_string(p.get_raw_item()); st.set(std::move(idv)); if (cs.run(body).get_bool()) { if (r.size()) { @@ -398,7 +398,7 @@ void init_lib_list(state &gcs) { r.append(p.get_quoted_item()); } } - res.set_str(r.str()); + res.set_string(r.str()); } }); @@ -407,21 +407,21 @@ void init_lib_list(state &gcs) { any_value idv{cs}; auto body = args[2].get_code(); int n = 0, r = 0; - for (list_parser p{cs, args[1].get_str()}; p.parse(); ++n) { - idv.set_str(p.get_raw_item()); + for (list_parser p{cs, args[1].get_string()}; p.parse(); ++n) { + idv.set_string(p.get_raw_item()); st.set(std::move(idv)); if (cs.run(body).get_bool()) { r++; } } - res.set_int(r); + res.set_integer(r); } }); gcs.new_command("prettylist", "ss", [](auto &cs, auto args, auto &res) { charbuf buf{cs}; - std::string_view s = args[0].get_str(); - std::string_view conj = args[1].get_str(); + std::string_view s = args[0].get_string(); + std::string_view conj = args[1].get_string(); list_parser p{cs, s}; size_t len = p.count(); size_t n = 0; @@ -443,12 +443,12 @@ void init_lib_list(state &gcs) { buf.push_back(' '); } } - res.set_str(buf.str()); + res.set_string(buf.str()); }); gcs.new_command("indexof", "ss", [](auto &cs, auto args, auto &res) { - res.set_int( - list_includes(cs, args[0].get_str(), args[1].get_str()) + res.set_integer( + list_includes(cs, args[0].get_string(), args[1].get_string()) ); }); @@ -463,10 +463,10 @@ void init_lib_list(state &gcs) { }); gcs.new_command("listsplice", "ssii", [](auto &cs, auto args, auto &res) { - integer_type offset = std::max(args[2].get_int(), integer_type(0)); - integer_type len = std::max(args[3].get_int(), integer_type(0)); - std::string_view s = args[0].get_str(); - std::string_view vals = args[1].get_str(); + integer_type offset = std::max(args[2].get_integer(), integer_type(0)); + integer_type len = std::max(args[3].get_integer(), integer_type(0)); + std::string_view s = args[0].get_string(); + std::string_view vals = args[1].get_string(); char const *list = s.data(); list_parser p{cs, s}; for (integer_type i = 0; i < offset; ++i) { @@ -505,7 +505,7 @@ void init_lib_list(state &gcs) { break; } } - res.set_str(buf.str()); + res.set_string(buf.str()); }); init_lib_list_sort(gcs); @@ -523,9 +523,9 @@ struct ListSortFun { bool operator()(ListSortItem const &xval, ListSortItem const &yval) { any_value v{cs}; - v.set_str(xval.str); + v.set_string(xval.str); xst.set(std::move(v)); - v.set_str(yval.str); + v.set_string(yval.str); yst.set(std::move(v)); return cs.run(*body).get_bool(); } @@ -554,7 +554,7 @@ static void list_sort( } if (items.empty()) { - res.set_str(list); + res.set_string(list); return; } @@ -609,19 +609,19 @@ static void list_sort( } sorted.append(item.quote); } - res.set_str(sorted.str()); + res.set_string(sorted.str()); } static void init_lib_list_sort(state &gcs) { gcs.new_command("sortlist", "srree", [](auto &cs, auto args, auto &res) { list_sort( - cs, res, args[0].get_str(), args[1].get_ident(), + cs, res, args[0].get_string(), args[1].get_ident(), args[2].get_ident(), args[3].get_code(), args[4].get_code() ); }); gcs.new_command("uniquelist", "srre", [](auto &cs, auto args, auto &res) { list_sort( - cs, res, args[0].get_str(), args[1].get_ident(), + cs, res, args[0].get_string(), args[1].get_ident(), args[2].get_ident(), nullptr, args[3].get_code() ); }); diff --git a/src/lib_math.cc b/src/lib_math.cc index bbdb561..50c0563 100644 --- a/src/lib_math.cc +++ b/src/lib_math.cc @@ -18,10 +18,10 @@ struct math_val; template<> struct math_val { static integer_type get(any_value &tv) { - return tv.get_int(); + return tv.get_integer(); } static void set(any_value &res, integer_type val) { - res.set_int(val); + res.set_integer(val); } }; @@ -70,7 +70,7 @@ static inline void cmp_op(std::span args, any_value &res, F cmp) { } else { val = cmp(!args.empty() ? math_val::get(args[0]) : T(0), T(0)); } - res.set_int(integer_type(val)); + res.set_integer(integer_type(val)); } void init_lib_math(state &cs) { @@ -115,18 +115,18 @@ void init_lib_math(state &cs) { }); cs.new_command("min", "i1V", [](auto &, auto args, auto &res) { - integer_type v = (!args.empty() ? args[0].get_int() : 0); + integer_type v = (!args.empty() ? args[0].get_integer() : 0); for (size_t i = 1; i < args.size(); ++i) { - v = std::min(v, args[i].get_int()); + v = std::min(v, args[i].get_integer()); } - res.set_int(v); + res.set_integer(v); }); cs.new_command("max", "i1V", [](auto &, auto args, auto &res) { - integer_type v = (!args.empty() ? args[0].get_int() : 0); + integer_type v = (!args.empty() ? args[0].get_integer() : 0); for (size_t i = 1; i < args.size(); ++i) { - v = std::max(v, args[i].get_int()); + v = std::max(v, args[i].get_integer()); } - res.set_int(v); + res.set_integer(v); }); cs.new_command("minf", "f1V", [](auto &, auto args, auto &res) { float_type v = (!args.empty() ? args[0].get_float() : 0); @@ -144,7 +144,7 @@ void init_lib_math(state &cs) { }); cs.new_command("abs", "i", [](auto &, auto args, auto &res) { - res.set_int(std::abs(args[0].get_int())); + res.set_integer(std::abs(args[0].get_integer())); }); cs.new_command("absf", "f", [](auto &, auto args, auto &res) { res.set_float(std::abs(args[0].get_float())); @@ -208,38 +208,38 @@ void init_lib_math(state &cs) { cs.new_command("^~", "i1V", [](auto &, auto args, auto &res) { integer_type val; if (args.size() >= 2) { - val = args[0].get_int() ^ ~args[1].get_int(); + val = args[0].get_integer() ^ ~args[1].get_integer(); for (size_t i = 2; i < args.size(); ++i) { - val ^= ~args[i].get_int(); + val ^= ~args[i].get_integer(); } } else { - val = !args.empty() ? args[0].get_int() : 0; + val = !args.empty() ? args[0].get_integer() : 0; } - res.set_int(val); + res.set_integer(val); }); cs.new_command("&~", "i1V", [](auto &, auto args, auto &res) { integer_type val; if (args.size() >= 2) { - val = args[0].get_int() & ~args[1].get_int(); + val = args[0].get_integer() & ~args[1].get_integer(); for (size_t i = 2; i < args.size(); ++i) { - val &= ~args[i].get_int(); + val &= ~args[i].get_integer(); } } else { - val = !args.empty() ? args[0].get_int() : 0; + val = !args.empty() ? args[0].get_integer() : 0; } - res.set_int(val); + res.set_integer(val); }); cs.new_command("|~", "i1V", [](auto &, auto args, auto &res) { integer_type val; if (args.size() >= 2) { - val = args[0].get_int() | ~args[1].get_int(); + val = args[0].get_integer() | ~args[1].get_integer(); for (size_t i = 2; i < args.size(); ++i) { - val |= ~args[i].get_int(); + val |= ~args[i].get_integer(); } } else { - val = !args.empty() ? args[0].get_int() : 0; + val = !args.empty() ? args[0].get_integer() : 0; } - res.set_int(val); + res.set_integer(val); }); cs.new_command("<<", "i1V", [](auto &, auto args, auto &res) { diff --git a/src/lib_str.cc b/src/lib_str.cc index 8357606..2dc0dd3 100644 --- a/src/lib_str.cc +++ b/src/lib_str.cc @@ -15,87 +15,87 @@ static inline void str_cmp_by( ) { bool val; if (args.size() >= 2) { - val = cfunc(args[0].get_str(), args[1].get_str()); + val = cfunc(args[0].get_string(), args[1].get_string()); for (size_t i = 2; (i < args.size()) && val; ++i) { - val = cfunc(args[i - 1].get_str(), args[i].get_str()); + val = cfunc(args[i - 1].get_string(), args[i].get_string()); } } else { val = cfunc( - !args.empty() ? args[0].get_str() : std::string_view(), + !args.empty() ? args[0].get_string() : std::string_view(), std::string_view() ); } - res.set_int(integer_type(val)); + res.set_integer(integer_type(val)); } void init_lib_string(state &cs) { cs.new_command("strstr", "ss", [](auto &, auto args, auto &res) { - std::string_view a = args[0].get_str(), b = args[1].get_str(); + std::string_view a = args[0].get_string(), b = args[1].get_string(); auto pos = a.find(b); if (pos == a.npos) { - res.set_int(-1); + res.set_integer(-1); } else { - res.set_int(integer_type(pos)); + res.set_integer(integer_type(pos)); } }); cs.new_command("strlen", "s", [](auto &, auto args, auto &res) { - res.set_int(integer_type(args[0].get_str().size())); + res.set_integer(integer_type(args[0].get_string().size())); }); cs.new_command("strcode", "si", [](auto &, auto args, auto &res) { - std::string_view str = args[0].get_str(); - integer_type i = args[1].get_int(); + std::string_view str = args[0].get_string(); + integer_type i = args[1].get_integer(); if (i >= integer_type(str.size())) { - res.set_int(0); + res.set_integer(0); } else { - res.set_int(static_cast(str[i])); + res.set_integer(static_cast(str[i])); } }); cs.new_command("codestr", "i", [](auto &, auto args, auto &res) { - char const p[2] = { char(args[0].get_int()), '\0' }; - res.set_str(std::string_view{static_cast(p)}); + char const p[2] = { char(args[0].get_integer()), '\0' }; + res.set_string(std::string_view{static_cast(p)}); }); cs.new_command("strlower", "s", [](auto &ccs, auto args, auto &res) { - auto inps = std::string_view{args[0].get_str()}; + auto inps = std::string_view{args[0].get_string()}; auto *ics = state_p{ccs}.ts().istate; auto *buf = ics->strman->alloc_buf(inps.size()); for (std::size_t i = 0; i < inps.size(); ++i) { buf[i] = char(tolower(inps[i])); } - res.set_str(ics->strman->steal(buf)); + res.set_string(ics->strman->steal(buf)); }); cs.new_command("strupper", "s", [](auto &ccs, auto args, auto &res) { - auto inps = std::string_view{args[0].get_str()}; + auto inps = std::string_view{args[0].get_string()}; auto *ics = state_p{ccs}.ts().istate; auto *buf = ics->strman->alloc_buf(inps.size()); for (std::size_t i = 0; i < inps.size(); ++i) { buf[i] = char(toupper(inps[i])); } - res.set_str(ics->strman->steal(buf)); + res.set_string(ics->strman->steal(buf)); }); cs.new_command("escape", "s", [](auto &ccs, auto args, auto &res) { charbuf s{ccs}; - escape_string(std::back_inserter(s), args[0].get_str()); - res.set_str(s.str()); + escape_string(std::back_inserter(s), args[0].get_string()); + res.set_string(s.str()); }); cs.new_command("unescape", "s", [](auto &ccs, auto args, auto &res) { charbuf s{ccs}; - unescape_string(std::back_inserter(s), args[0].get_str()); - res.set_str(s.str()); + unescape_string(std::back_inserter(s), args[0].get_string()); + res.set_string(s.str()); }); cs.new_command("concat", "V", [](auto &ccs, auto args, auto &res) { - res.set_str(concat_values(ccs, args, " ")); + res.set_string(concat_values(ccs, args, " ")); }); cs.new_command("concatword", "V", [](auto &ccs, auto args, auto &res) { - res.set_str(concat_values(ccs, args)); + res.set_string(concat_values(ccs, args)); }); cs.new_command("format", "V", [](auto &ccs, auto args, auto &res) { @@ -103,7 +103,7 @@ void init_lib_string(state &cs) { return; } charbuf s{ccs}; - string_ref fs = args[0].get_str(); + string_ref fs = args[0].get_string(); std::string_view f{fs}; for (auto it = f.begin(); it != f.end(); ++it) { char c = *it; @@ -114,7 +114,7 @@ void init_lib_string(state &cs) { if ((ic >= '1') && (ic <= '9')) { int i = ic - '0'; if (std::size_t(i) < args.size()) { - s.append(args[i].get_str()); + s.append(args[i].get_string()); } } else { s.push_back(ic); @@ -123,14 +123,14 @@ void init_lib_string(state &cs) { s.push_back(c); } } - res.set_str(s.str()); + res.set_string(s.str()); }); cs.new_command("tohex", "ii", [](auto &ccs, auto args, auto &res) { char buf[32]; /* use long long as the largest signed integer type */ - auto val = static_cast(args[0].get_int()); - int prec = std::max(int(args[1].get_int()), 1); + auto val = static_cast(args[0].get_integer()); + int prec = std::max(int(args[1].get_integer()), 1); int n = snprintf(buf, sizeof(buf), "0x%.*llX", prec, val); if (n >= int(sizeof(buf))) { charbuf s{ccs}; @@ -138,11 +138,11 @@ void init_lib_string(state &cs) { s.data()[0] = '\0'; int nn = snprintf(s.data(), n + 1, "0x%.*llX", prec, val); if ((nn > 0) && (nn <= n)) { - res.set_str(std::string_view{s.data(), std::size_t(nn)}); + res.set_string(std::string_view{s.data(), std::size_t(nn)}); return; } } else if (n > 0) { - res.set_str(static_cast(buf)); + res.set_string(static_cast(buf)); return; } /* should pretty much be unreachable */ @@ -150,11 +150,12 @@ void init_lib_string(state &cs) { }); cs.new_command("substr", "siiN", [](auto &, auto args, auto &res) { - std::string_view s = args[0].get_str(); - integer_type start = args[1].get_int(), count = args[2].get_int(); - integer_type numargs = args[3].get_int(); - integer_type len = integer_type(s.size()), offset = std::clamp(start, integer_type(0), len); - res.set_str(std::string_view{ + std::string_view s = args[0].get_string(); + auto start = args[1].get_integer(), count = args[2].get_integer(); + auto numargs = args[3].get_integer(); + auto len = integer_type(s.size()); + auto offset = std::clamp(start, integer_type(0), len); + res.set_string(std::string_view{ &s[offset], ((numargs >= 3) ? size_t(std::clamp(count, integer_type(0), len - offset)) @@ -185,15 +186,15 @@ void init_lib_string(state &cs) { }); cs.new_command("strreplace", "ssss", [](auto &ccs, auto args, auto &res) { - std::string_view s = args[0].get_str(); - std::string_view oldval = args[1].get_str(), - newval = args[2].get_str(), - newval2 = args[3].get_str(); + std::string_view s = args[0].get_string(); + std::string_view oldval = args[1].get_string(), + newval = args[2].get_string(), + newval2 = args[3].get_string(); if (newval2.empty()) { newval2 = newval; } if (oldval.empty()) { - res.set_str(s); + res.set_string(s); return; } charbuf buf{ccs}; @@ -201,7 +202,7 @@ void init_lib_string(state &cs) { auto p = s.find(oldval); if (p == s.npos) { buf.append(s); - res.set_str(s); + res.set_string(s); return; } buf.append(s.substr(0, p)); @@ -214,10 +215,10 @@ void init_lib_string(state &cs) { }); cs.new_command("strsplice", "ssii", [](auto &ccs, auto args, auto &res) { - std::string_view s = args[0].get_str(); - std::string_view vals = args[1].get_str(); - integer_type skip = args[2].get_int(), - count = args[3].get_int(); + std::string_view s = args[0].get_string(); + std::string_view vals = args[1].get_string(); + integer_type skip = args[2].get_integer(), + count = args[3].get_integer(); integer_type offset = std::clamp(skip, integer_type(0), integer_type(s.size())), len = std::clamp(count, integer_type(0), integer_type(s.size()) - offset); charbuf p{ccs}; @@ -229,7 +230,7 @@ void init_lib_string(state &cs) { if ((offset + len) < integer_type(s.size())) { p.append(s.substr(offset + len, s.size() - offset - len)); } - res.set_str(p.str()); + res.set_string(p.str()); }); } diff --git a/tools/repl.cc b/tools/repl.cc index 621b68c..90d8dd5 100644 --- a/tools/repl.cc +++ b/tools/repl.cc @@ -271,7 +271,7 @@ static bool do_call(cs::state &cs, std::string_view line, bool file = false) { signal(SIGINT, SIG_DFL); scs = nullptr; if (ret.get_type() != cs::value_type::NONE) { - std::printf("%s\n", std::string_view{ret.get_str()}.data()); + std::printf("%s\n", std::string_view{ret.get_string()}.data()); } return false; } @@ -326,7 +326,7 @@ int main(int argc, char **argv) { */ gcs.new_command("//ivar", "$iiiN", [](auto &css, auto args, auto &) { auto *iv = args[0].get_ident()->get_ivar(); - auto nargs = args[4].get_int(); + auto nargs = args[4].get_integer(); if (nargs <= 1) { auto val = iv->get_value(); if ((val >= 0) && (val < 0xFFFFFF)) { @@ -341,15 +341,16 @@ int main(int argc, char **argv) { return; } if (nargs == 2) { - iv->set_value(css, args[1].get_int()); + iv->set_value(css, args[1].get_integer()); } else if (nargs == 3) { iv->set_value( - css, (args[1].get_int() << 8) | (args[2].get_int() << 16) + css, (args[1].get_integer() << 8) | + (args[2].get_integer() << 16) ); } else { iv->set_value( - css, args[1].get_int() | (args[2].get_int() << 8) | - (args[3].get_int() << 16) + css, args[1].get_integer() | (args[2].get_integer() << 8) | + (args[3].get_integer() << 16) ); } }); @@ -361,7 +362,7 @@ int main(int argc, char **argv) { }); gcs.new_command("exec", "s", [](auto &css, auto args, auto &) { - auto file = args[0].get_str(); + auto file = args[0].get_string(); cs::any_value val{css}; bool ret = do_run_file(css, file, val); if (!ret) { @@ -372,7 +373,7 @@ int main(int argc, char **argv) { }); gcs.new_command("echo", "C", [](auto &, auto args, auto &) { - std::printf("%s\n", std::string_view{args[0].get_str()}.data()); + std::printf("%s\n", std::string_view{args[0].get_string()}.data()); }); int firstarg = 0;