From 4dd1518f6c5673254499615c7a239329fa80f975 Mon Sep 17 00:00:00 2001 From: Daniel Kolesa Date: Fri, 30 Apr 2021 02:55:20 +0200 Subject: [PATCH] s/run/call/ --- include/cubescript/cubescript/state.hh | 24 +++++++------- src/cs_state.cc | 46 +++++++++++++------------- src/cs_thread.hh | 8 ++--- src/cs_vm.cc | 18 +++++----- src/cs_vm.hh | 12 +++---- src/lib_base.cc | 28 ++++++++-------- src/lib_list.cc | 18 +++++----- tests/runner.cc | 8 ++--- tools/repl.cc | 14 ++++---- 9 files changed, 88 insertions(+), 88 deletions(-) diff --git a/include/cubescript/cubescript/state.hh b/include/cubescript/cubescript/state.hh index 70d8c3b..2c8c013 100644 --- a/include/cubescript/cubescript/state.hh +++ b/include/cubescript/cubescript/state.hh @@ -73,7 +73,7 @@ using command_func = internal::callable< /** @brief The loop state * - * This is returned by state::run_loop(). + * This is returned by state::call_loop(). */ enum class loop_state { NORMAL = 0, /**< @brief The iteration ended normally. */ @@ -381,13 +381,13 @@ struct LIBCUBESCRIPT_EXPORT state { * * @return the return value */ - any_value run(bcode_ref const &code); + any_value call(bcode_ref const &code); /** @brief Execute the given string as code * * @return the return value */ - any_value run(std::string_view code); + any_value call(std::string_view code); /** @brief Execute the given string as code * @@ -399,7 +399,7 @@ struct LIBCUBESCRIPT_EXPORT state { * * @return the return value */ - any_value run(std::string_view code, std::string_view source); + any_value call(std::string_view code, std::string_view source); /** @brief Execute the given ident * @@ -411,7 +411,7 @@ struct LIBCUBESCRIPT_EXPORT state { * * @return the return value */ - any_value run(ident &id, span_type args); + any_value call(ident &id, span_type args); /** @brief Execute a loop body * @@ -423,13 +423,13 @@ struct LIBCUBESCRIPT_EXPORT state { * * Some loops may evaluate to values, while others may not. */ - loop_state run_loop(bcode_ref const &code, any_value &ret); + loop_state call_loop(bcode_ref const &code, any_value &ret); /** @brief Execute a loop body * * This version ignores the return value of the body. */ - loop_state run_loop(bcode_ref const &code); + loop_state call_loop(bcode_ref const &code); /** @brief Get if the thread is in override mode * @@ -475,16 +475,16 @@ struct LIBCUBESCRIPT_EXPORT state { */ bool set_persist_mode(bool v); - /** @brief Get the maximum run depth of the VM + /** @brief Get the maximum call depth of the VM * * If zero, it is unlimited, otherwise it specifies how much the VM is * allowed to recurse. By default, it is zero. * - * @see set_max_run_depth() + * @see set_max_call_depth() */ - std::size_t get_max_run_depth() const; + std::size_t get_max_call_depth() const; - /** @brief Set the maximum run depth ov the VM + /** @brief Set the maximum call depth ov the VM * * If zero, it is unlimited (this is the default). You can limit how much * the VM is allowed to recurse if you have specific constraints to adhere @@ -492,7 +492,7 @@ struct LIBCUBESCRIPT_EXPORT state { * * @return the old value */ - std::size_t set_max_run_depth(std::size_t v); + std::size_t set_max_call_depth(std::size_t v); private: friend struct state_p; diff --git a/src/cs_state.cc b/src/cs_state.cc index 9377d24..620f5c1 100644 --- a/src/cs_state.cc +++ b/src/cs_state.cc @@ -173,19 +173,19 @@ state::state(alloc_func func, void *data) { /* builtins */ p = &new_command("do", "b", [](auto &cs, auto args, auto &res) { - res = cs.run(args[0].get_code()); + res = cs.call(args[0].get_code()); }); static_cast(p)->p_type = ID_DO; p = &new_command("doargs", "b", [](auto &cs, auto args, auto &res) { call_with_args(*cs.p_tstate, [&cs, &res, &args]() { - res = cs.run(args[0].get_code()); + res = cs.call(args[0].get_code()); }); }); static_cast(p)->p_type = ID_DOARGS; p = &new_command("if", "abb", [](auto &cs, auto args, auto &res) { - res = cs.run((args[0].get_bool() ? args[1] : args[2]).get_code()); + res = cs.call((args[0].get_bool() ? args[1] : args[2]).get_code()); }); static_cast(p)->p_type = ID_IF; @@ -206,7 +206,7 @@ state::state(alloc_func func, void *data) { for (size_t i = 0; i < args.size(); ++i) { auto code = args[i].get_code(); if (code) { - res = cs.run(code); + res = cs.call(code); } else { res = std::move(args[i]); } @@ -225,7 +225,7 @@ state::state(alloc_func func, void *data) { for (size_t i = 0; i < args.size(); ++i) { auto code = args[i].get_code(); if (code) { - res = cs.run(code); + res = cs.call(code); } else { res = std::move(args[i]); } @@ -485,7 +485,7 @@ LIBCUBESCRIPT_EXPORT void state::assign_value( case ident_type::IVAR: case ident_type::FVAR: case ident_type::SVAR: - run(id->get(), span_type{&v, 1}); + call(id->get(), span_type{&v, 1}); break; default: throw error{ @@ -693,13 +693,13 @@ do_add: return *cmd; } -LIBCUBESCRIPT_EXPORT any_value state::run(bcode_ref const &code) { +LIBCUBESCRIPT_EXPORT any_value state::call(bcode_ref const &code) { any_value ret{}; vm_exec(*p_tstate, bcode_p{code}.get()->get_raw(), ret); return ret; } -static any_value do_run( +static any_value do_call( thread_state &ts, std::string_view file, std::string_view code ) { any_value ret{}; @@ -710,22 +710,22 @@ static any_value do_run( return ret; } -LIBCUBESCRIPT_EXPORT any_value state::run(std::string_view code) { - return do_run(*p_tstate, std::string_view{}, code); +LIBCUBESCRIPT_EXPORT any_value state::call(std::string_view code) { + return do_call(*p_tstate, std::string_view{}, code); } -LIBCUBESCRIPT_EXPORT any_value state::run( +LIBCUBESCRIPT_EXPORT any_value state::call( std::string_view code, std::string_view source ) { - return do_run(*p_tstate, source, code); + return do_call(*p_tstate, source, code); } -LIBCUBESCRIPT_EXPORT any_value state::run( +LIBCUBESCRIPT_EXPORT any_value state::call( ident &id, span_type args ) { any_value ret{}; std::size_t nargs = args.size(); - run_depth_guard level{*p_tstate}; /* incr and decr on scope exit */ + call_depth_guard level{*p_tstate}; /* incr and decr on scope exit */ switch (id.get_type()) { default: if (!ident_is_callable(&id)) { @@ -819,12 +819,12 @@ LIBCUBESCRIPT_EXPORT any_value state::run( return ret; } -LIBCUBESCRIPT_EXPORT loop_state state::run_loop( +LIBCUBESCRIPT_EXPORT loop_state state::call_loop( bcode_ref const &code, any_value &ret ) { ++p_tstate->loop_level; try { - ret = run(code); + ret = call(code); } catch (break_exception) { --p_tstate->loop_level; return loop_state::BREAK; @@ -838,9 +838,9 @@ LIBCUBESCRIPT_EXPORT loop_state state::run_loop( return loop_state::NORMAL; } -LIBCUBESCRIPT_EXPORT loop_state state::run_loop(bcode_ref const &code) { +LIBCUBESCRIPT_EXPORT loop_state state::call_loop(bcode_ref const &code) { any_value ret{}; - return run_loop(code, ret); + return call_loop(code, ret); } LIBCUBESCRIPT_EXPORT bool state::get_override_mode() const { @@ -871,13 +871,13 @@ LIBCUBESCRIPT_EXPORT bool state::set_persist_mode(bool v) { return was; } -LIBCUBESCRIPT_EXPORT std::size_t state::get_max_run_depth() const { - return p_tstate->max_run_depth; +LIBCUBESCRIPT_EXPORT std::size_t state::get_max_call_depth() const { + return p_tstate->max_call_depth; } -LIBCUBESCRIPT_EXPORT std::size_t state::set_max_run_depth(std::size_t v) { - auto old = p_tstate->max_run_depth; - p_tstate->max_run_depth = v; +LIBCUBESCRIPT_EXPORT std::size_t state::set_max_call_depth(std::size_t v) { + auto old = p_tstate->max_call_depth; + p_tstate->max_call_depth = v; return old; } diff --git a/src/cs_thread.hh b/src/cs_thread.hh index 5e572d0..e50dbe1 100644 --- a/src/cs_thread.hh +++ b/src/cs_thread.hh @@ -35,10 +35,10 @@ struct thread_state { bool owner = false; /* thread ident flags */ int ident_flags = 0; - /* run depth limit */ - std::size_t max_run_depth = 0; - /* current run depth */ - std::size_t run_depth = 0; + /* call depth limit */ + std::size_t max_call_depth = 0; + /* current call depth */ + std::size_t call_depth = 0; /* loop nesting level */ std::size_t loop_level = 0; /* debug info */ diff --git a/src/cs_vm.cc b/src/cs_vm.cc index 356182a..9e66f40 100644 --- a/src/cs_vm.cc +++ b/src/cs_vm.cc @@ -210,14 +210,14 @@ bool exec_alias( return true; } -run_depth_guard::run_depth_guard(thread_state &ts): tsp(&ts) { - if (ts.max_run_depth && (ts.run_depth >= ts.max_run_depth)) { +call_depth_guard::call_depth_guard(thread_state &ts): tsp(&ts) { + if (ts.max_call_depth && (ts.call_depth >= ts.max_call_depth)) { throw error{*ts.pstate, "exceeded recursion limit"}; } - ++ts.run_depth; + ++ts.call_depth; } -run_depth_guard::~run_depth_guard() { --tsp->run_depth; } +call_depth_guard::~call_depth_guard() { --tsp->call_depth; } static inline alias *get_lookup_id( thread_state &ts, std::uint32_t op, alias_stack *&ast @@ -246,7 +246,7 @@ std::uint32_t *vm_exec( ) { result.set_none(); auto &cs = *ts.pstate; - run_depth_guard level{ts}; /* incr and decr on scope exit */ + call_depth_guard level{ts}; /* incr and decr on scope exit */ stack_guard guard{ts}; /* resize back to original */ auto &args = ts.vmstack; auto &chook = cs.get_call_hook(); @@ -458,7 +458,7 @@ std::uint32_t *vm_exec( call_with_args(ts, [&]() { auto v = std::move(args.back()); args.pop_back(); - result = cs.run(v.get_code()); + result = cs.call(v.get_code()); force_arg(cs, result, op & BC_INST_RET_MASK); }); continue; @@ -469,7 +469,7 @@ std::uint32_t *vm_exec( case BC_INST_DO | BC_RET_FLOAT: { auto v = std::move(args.back()); args.pop_back(); - result = cs.run(v.get_code()); + result = cs.call(v.get_code()); force_arg(cs, result, op & BC_INST_RET_MASK); continue; } @@ -500,7 +500,7 @@ std::uint32_t *vm_exec( auto v = std::move(args.back()); args.pop_back(); if (v.get_type() == value_type::CODE) { - result = cs.run(v.get_code()); + result = cs.call(v.get_code()); } else { result = std::move(v); } @@ -514,7 +514,7 @@ std::uint32_t *vm_exec( auto v = std::move(args.back()); args.pop_back(); if (v.get_type() == value_type::CODE) { - result = cs.run(v.get_code()); + result = cs.call(v.get_code()); } else { result = std::move(v); } diff --git a/src/cs_vm.hh b/src/cs_vm.hh index 368c1c6..7f142b6 100644 --- a/src/cs_vm.hh +++ b/src/cs_vm.hh @@ -15,12 +15,12 @@ struct break_exception { struct continue_exception { }; -struct run_depth_guard { - run_depth_guard() = delete; - run_depth_guard(thread_state &ts); - run_depth_guard(run_depth_guard const &) = delete; - run_depth_guard(run_depth_guard &&) = delete; - ~run_depth_guard(); +struct call_depth_guard { + call_depth_guard() = delete; + call_depth_guard(thread_state &ts); + call_depth_guard(call_depth_guard const &) = delete; + call_depth_guard(call_depth_guard &&) = delete; + ~call_depth_guard(); thread_state *tsp; }; diff --git a/src/lib_base.cc b/src/lib_base.cc index 35c292d..3ebf0c5 100644 --- a/src/lib_base.cc +++ b/src/lib_base.cc @@ -20,10 +20,10 @@ static inline void do_loop( for (integer_type i = 0; i < n; ++i) { idv.set_integer(offset + i * step); st.set(idv); - if (cond && !cs.run(cond).get_bool()) { + if (cond && !cs.call(cond).get_bool()) { break; } - switch (cs.run_loop(body)) { + switch (cs.call_loop(body)) { case loop_state::BREAK: return; default: /* continue and normal */ @@ -46,7 +46,7 @@ static inline void do_loop_conc( idv.set_integer(offset + i * step); st.set(idv); any_value v{}; - switch (cs.run_loop(body, v)) { + switch (cs.call_loop(body, v)) { case loop_state::BREAK: goto end; case loop_state::CONTINUE: @@ -80,7 +80,7 @@ LIBCUBESCRIPT_EXPORT void std_init_base(state &gcs) { any_value result{}, tback{}; bool rc = true; try { - result = cs.run(args[0].get_code()); + result = cs.call(args[0].get_code()); } catch (error const &e) { result.set_string(e.what(), cs); if (e.get_stack().get()) { @@ -109,12 +109,12 @@ LIBCUBESCRIPT_EXPORT void std_init_base(state &gcs) { new_cmd_quiet(gcs, "cond", "bb2...", [](auto &cs, auto args, auto &res) { for (size_t i = 0; i < args.size(); i += 2) { if ((i + 1) < args.size()) { - if (cs.run(args[i].get_code()).get_bool()) { - res = cs.run(args[i + 1].get_code()); + if (cs.call(args[i].get_code()).get_bool()) { + res = cs.call(args[i + 1].get_code()); break; } } else { - res = cs.run(args[i].get_code()); + res = cs.call(args[i].get_code()); break; } } @@ -127,7 +127,7 @@ LIBCUBESCRIPT_EXPORT void std_init_base(state &gcs) { (args[i].get_type() == value_type::NONE) || (args[i].get_integer() == val) ) { - res = cs.run(args[i + 1].get_code()); + res = cs.call(args[i + 1].get_code()); return; } } @@ -140,7 +140,7 @@ LIBCUBESCRIPT_EXPORT void std_init_base(state &gcs) { (args[i].get_type() == value_type::NONE) || (args[i].get_float() == val) ) { - res = cs.run(args[i + 1].get_code()); + res = cs.call(args[i + 1].get_code()); return; } } @@ -153,7 +153,7 @@ LIBCUBESCRIPT_EXPORT void std_init_base(state &gcs) { (args[i].get_type() == value_type::NONE) || (args[i].get_string(cs) == val) ) { - res = cs.run(args[i + 1].get_code()); + res = cs.call(args[i + 1].get_code()); return; } } @@ -166,7 +166,7 @@ LIBCUBESCRIPT_EXPORT void std_init_base(state &gcs) { } if (args[1].get_bool()) { st.set(args[1]); - res = cs.run(args[2].get_code()); + res = cs.call(args[2].get_code()); } }); @@ -233,8 +233,8 @@ LIBCUBESCRIPT_EXPORT void std_init_base(state &gcs) { new_cmd_quiet(gcs, "while", "bb", [](auto &cs, auto args, auto &) { auto cond = args[0].get_code(); auto body = args[1].get_code(); - while (cs.run(cond).get_bool()) { - switch (cs.run_loop(body)) { + while (cs.call(cond).get_bool()) { + switch (cs.call_loop(body)) { case loop_state::BREAK: goto end; default: /* continue and normal */ @@ -325,7 +325,7 @@ end: throw error{cs, "cannot push an argument"}; } st.set(args[1]); - res = cs.run(args[2].get_code()); + res = cs.call(args[2].get_code()); }); new_cmd_quiet(gcs, "resetvar", "s", [](auto &cs, auto args, auto &) { diff --git a/src/lib_list.cc b/src/lib_list.cc index 34654ac..e192567 100644 --- a/src/lib_list.cc +++ b/src/lib_list.cc @@ -87,7 +87,7 @@ static void loop_list_conc( r.push_back(' '); } any_value v{}; - switch (cs.run_loop(body, v)) { + switch (cs.call_loop(body, v)) { case loop_state::BREAK: goto end; case loop_state::CONTINUE: @@ -213,7 +213,7 @@ LIBCUBESCRIPT_EXPORT void std_init_list(state &gcs) { ++n; idv.set_string(p.get_raw_item(), cs); st.set(std::move(idv)); - if (cs.run(body).get_bool()) { + if (cs.call(body).get_bool()) { res.set_integer(integer_type(n)); return; } @@ -230,7 +230,7 @@ LIBCUBESCRIPT_EXPORT void std_init_list(state &gcs) { ++n; idv.set_string(p.get_raw_item(), cs); st.set(std::move(idv)); - if (cs.run(body).get_bool()) { + if (cs.call(body).get_bool()) { if (p.parse()) { res.set_string(p.get_item()); } @@ -294,7 +294,7 @@ LIBCUBESCRIPT_EXPORT void std_init_list(state &gcs) { for (list_parser p{cs, args[1].get_string(cs)}; p.parse(); ++n) { idv.set_string(p.get_item()); st.set(std::move(idv)); - switch (cs.run_loop(body)) { + switch (cs.call_loop(body)) { case loop_state::BREAK: return; default: /* continue and normal */ @@ -318,7 +318,7 @@ LIBCUBESCRIPT_EXPORT void std_init_list(state &gcs) { idv.set_string("", cs); } st2.set(std::move(idv)); - switch (cs.run_loop(body)) { + switch (cs.call_loop(body)) { case loop_state::BREAK: return; default: /* continue and normal */ @@ -349,7 +349,7 @@ LIBCUBESCRIPT_EXPORT void std_init_list(state &gcs) { idv.set_string("", cs); } st3.set(std::move(idv)); - switch (cs.run_loop(body)) { + switch (cs.call_loop(body)) { case loop_state::BREAK: return; default: /* continue and normal */ @@ -387,7 +387,7 @@ LIBCUBESCRIPT_EXPORT void std_init_list(state &gcs) { for (list_parser p{cs, args[1].get_string(cs)}; p.parse(); ++n) { idv.set_string(p.get_raw_item(), cs); st.set(std::move(idv)); - if (cs.run(body).get_bool()) { + if (cs.call(body).get_bool()) { if (r.size()) { r.push_back(' '); } @@ -405,7 +405,7 @@ LIBCUBESCRIPT_EXPORT void std_init_list(state &gcs) { for (list_parser p{cs, args[1].get_string(cs)}; p.parse(); ++n) { idv.set_string(p.get_raw_item(), cs); st.set(std::move(idv)); - if (cs.run(body).get_bool()) { + if (cs.call(body).get_bool()) { r++; } } @@ -525,7 +525,7 @@ struct ListSortFun { xst.set(std::move(v)); v.set_string(yval.str, cs); yst.set(std::move(v)); - return cs.run(*body).get_bool(); + return cs.call(*body).get_bool(); } }; diff --git a/tests/runner.cc b/tests/runner.cc index 4661de6..4d71b75 100644 --- a/tests/runner.cc +++ b/tests/runner.cc @@ -15,7 +15,7 @@ namespace cs = cubescript; struct skip_test {}; -static bool do_run_file(cs::state &cs, char const *fname) { +static bool do_exec_file(cs::state &cs, char const *fname) { FILE *f = std::fopen(fname, "rb"); if (!f) { return false; @@ -38,7 +38,7 @@ static bool do_run_file(cs::state &cs, char const *fname) { buf[len] = '\0'; - cs.run(std::string_view{buf.get(), std::size_t(len)}, fname); + cs.call(std::string_view{buf.get(), std::size_t(len)}, fname); return true; } @@ -62,7 +62,7 @@ int main(int argc, char **argv) { gcs.new_command("assert", "ss#", [](auto &s, auto args, auto &ret) { auto val = args[0]; val.force_code(s); - if (!s.run(val.get_code()).get_bool()) { + if (!s.call(val.get_code()).get_bool()) { if (args[2].get_integer() > 1) { throw cs::error{ s, "assertion failed: [%s] (%s)", @@ -79,7 +79,7 @@ int main(int argc, char **argv) { }); try { - do_run_file(gcs, argv[1]); + do_exec_file(gcs, argv[1]); } catch (skip_test) { return 77; } catch (cs::error const &e) { diff --git a/tools/repl.cc b/tools/repl.cc index 1333b28..43c031f 100644 --- a/tools/repl.cc +++ b/tools/repl.cc @@ -164,7 +164,7 @@ void print_usage(std::string_view progname, bool err) { err ? stderr : stdout, "Usage: %s [options] [file]\n" "Options:\n" - " -e str run string \"str\"\n" + " -e str call string \"str\"\n" " -i enter interactive mode after the above\n" " -v show version information\n" " -h show this message\n" @@ -189,7 +189,7 @@ static void do_sigint(int n) { }); } -static bool do_run_file( +static bool do_exec_file( cs::state &cs, std::string_view fname, cs::any_value &ret ) { FILE *f = std::fopen(fname.data(), "rb"); @@ -214,7 +214,7 @@ static bool do_run_file( buf[len] = '\0'; - ret = cs.run(std::string_view{buf.get(), std::size_t(len)}, fname); + ret = cs.call(std::string_view{buf.get(), std::size_t(len)}, fname); return true; } @@ -224,11 +224,11 @@ static bool do_call(cs::state &cs, std::string_view line, bool file = false) { signal(SIGINT, do_sigint); try { if (file) { - if (!do_run_file(cs, line, ret)) { + if (!do_exec_file(cs, line, ret)) { std::fprintf(stderr, "cannot read file: %s\n", line.data()); } } else { - ret = cs.run(line); + ret = cs.call(line); } } catch (cs::error const &e) { signal(SIGINT, SIG_DFL); @@ -355,10 +355,10 @@ int main(int argc, char **argv) { gcs.new_command("exec", "s", [](auto &css, auto args, auto &) { auto file = args[0].get_string(css); cs::any_value val{}; - bool ret = do_run_file(css, file, val); + bool ret = do_exec_file(css, file, val); if (!ret) { throw cs::error( - css, "could not run file \"%s\"", file.data() + css, "could not execute file \"%s\"", file.data() ); } });