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

s/run/call/

master
Daniel Kolesa 2021-04-30 02:55:20 +02:00
parent 9c14e6ca65
commit 4dd1518f6c
9 changed files with 88 additions and 88 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

24
include/cubescript/cubescript/state.hh
View File

@ -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<any_value> args);
any_value call(ident &id, span_type<any_value> 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;

46
src/cs_state.cc
View File

@ -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<command_impl *>(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<command_impl *>(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<command_impl *>(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<any_value>{&v, 1});
call(id->get(), span_type<any_value>{&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<any_value> 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;
}

8
src/cs_thread.hh
View File

@ -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 */

18
src/cs_vm.cc
View File

@ -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);
}

12
src/cs_vm.hh
View File

@ -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;
};

28
src/lib_base.cc
View File

@ -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 &) {

18
src/lib_list.cc
View File

@ -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();
}
};

8
tests/runner.cc
View File

@ -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) {

14
tools/repl.cc
View File

@ -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()
);
}
});