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

get rid of ostd requirements inside library entirely

master
Daniel Kolesa 2021-03-20 07:24:25 +01:00
parent 68669413cc
commit cb926a5750
5 changed files with 185 additions and 132 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

121
include/cubescript/cubescript.hh
View File

@ -1,9 +1,7 @@
#ifndef LIBCUBESCRIPT_CUBESCRIPT_HH
#define LIBCUBESCRIPT_CUBESCRIPT_HH
#include <stdio.h>
#include <stdlib.h>
#include <cstring>
#include <vector>
#include <optional>
#include <functional>
@ -13,10 +11,26 @@
#include "cubescript_conf.hh"
#include <ostd/platform.hh>
#include <ostd/string.hh>
#include <ostd/range.hh>
#include <ostd/format.hh>
#if defined(__CYGWIN__) || (defined(_WIN32) && !defined(_XBOX_VER))
# ifdef LIBCUBESCRIPT_DLL
# ifdef LIBCUBESCRIPT_BUILD
# define LIBCUBESCRIPT_EXPORT __declspec(dllexport)
# else
# define LIBCUBESCRIPT_EXPORT __declspec(dllimport)
# endif
# else
# define LIBCUBESCRIPT_EXPORT
# endif
# define LIBCUBESCRIPT_LOCAL
#else
# if defined(__GNUC__) && (__GNUC__ >= 4)
# define LIBCUBESCRIPT_EXPORT __attribute__((visibility("default")))
# define LIBCUBESCRIPT_LOCAL __attribute__((visibility("hidden")))
# else
# define LIBCUBESCRIPT_EXPORT
# define LIBCUBESCRIPT_LOCAL
# endif
#endif
namespace cscript {
@ -43,7 +57,7 @@ struct cs_value;
struct cs_state;
struct cs_shared_state;
struct OSTD_EXPORT cs_bcode_ref {
struct LIBCUBESCRIPT_EXPORT cs_bcode_ref {
cs_bcode_ref():
p_code(nullptr)
{}
@ -67,9 +81,9 @@ private:
cs_bcode *p_code;
};
OSTD_EXPORT bool cs_code_is_empty(cs_bcode *code);
LIBCUBESCRIPT_EXPORT bool cs_code_is_empty(cs_bcode *code);
struct OSTD_EXPORT cs_strref {
struct LIBCUBESCRIPT_EXPORT cs_strref {
friend struct cs_value;
/* FIXME: eliminate this */
friend inline cs_strref cs_make_strref(char const *p, cs_shared_state &cs);
@ -111,7 +125,7 @@ enum class cs_value_type {
NONE = 0, INT, FLOAT, STRING, CODE, IDENT
};
struct OSTD_EXPORT cs_value {
struct LIBCUBESCRIPT_EXPORT cs_value {
cs_value() = delete;
~cs_value();
@ -191,7 +205,7 @@ struct cs_svar;
struct cs_alias;
struct cs_command;
struct OSTD_EXPORT cs_ident {
struct LIBCUBESCRIPT_EXPORT cs_ident {
friend struct cs_state;
friend struct cs_shared_state;
@ -253,7 +267,7 @@ private:
int p_index = -1;
};
struct OSTD_EXPORT cs_var: cs_ident {
struct LIBCUBESCRIPT_EXPORT cs_var: cs_ident {
friend struct cs_state;
friend struct cs_shared_state;
@ -270,7 +284,7 @@ private:
}
};
struct OSTD_EXPORT cs_ivar: cs_var {
struct LIBCUBESCRIPT_EXPORT cs_ivar: cs_var {
friend struct cs_state;
friend struct cs_shared_state;
@ -288,7 +302,7 @@ private:
cs_int p_storage, p_minval, p_maxval, p_overrideval;
};
struct OSTD_EXPORT cs_fvar: cs_var {
struct LIBCUBESCRIPT_EXPORT cs_fvar: cs_var {
friend struct cs_state;
friend struct cs_shared_state;
@ -307,7 +321,7 @@ private:
cs_float p_storage, p_minval, p_maxval, p_overrideval;
};
struct OSTD_EXPORT cs_svar: cs_var {
struct LIBCUBESCRIPT_EXPORT cs_svar: cs_var {
friend struct cs_state;
friend struct cs_shared_state;
@ -320,7 +334,7 @@ private:
cs_strref p_storage, p_overrideval;
};
struct OSTD_EXPORT cs_alias: cs_ident {
struct LIBCUBESCRIPT_EXPORT cs_alias: cs_ident {
friend struct cs_state;
friend struct cs_shared_state;
friend struct cs_alias_internal;
@ -380,7 +394,7 @@ static inline void *cs_default_alloc(void *, void *p, size_t, size_t ns) {
return new unsigned char[ns];
}
struct OSTD_EXPORT cs_state {
struct LIBCUBESCRIPT_EXPORT cs_state {
friend struct cs_error;
friend struct cs_strman;
friend struct cs_strref;
@ -515,11 +529,11 @@ struct OSTD_EXPORT cs_state {
void print_var(cs_var const &v) const;
private:
OSTD_LOCAL cs_state(cs_shared_state *s);
LIBCUBESCRIPT_LOCAL cs_state(cs_shared_state *s);
cs_ident *add_ident(cs_ident *id);
OSTD_LOCAL void *alloc(void *ptr, size_t olds, size_t news);
LIBCUBESCRIPT_LOCAL void *alloc(void *ptr, size_t olds, size_t news);
cs_gen_state *p_pstate = nullptr;
int p_inloop = 0;
@ -587,16 +601,20 @@ struct cs_error {
cs_error(cs_state &cs, std::string_view msg, A &&...args):
p_errmsg(), p_stack(cs)
{
try {
char fbuf[512];
auto ret = ostd::format(
ostd::counting_sink(ostd::char_range(fbuf, fbuf + sizeof(fbuf))),
msg, std::forward<A>(args)...
).get_written();
p_errmsg = save_msg(cs, ostd::char_range(fbuf, fbuf + ret));
} catch (...) {
p_errmsg = save_msg(cs, msg);
char fbuf[512];
int written = std::snprintf(
fbuf, sizeof(fbuf), "%.*s", int(msg.size()), msg.data()
);
if (written >= int(sizeof(fbuf))) {
written = std::strlen(fbuf);
} else if (written <= 0) {
std::strncpy(fbuf, "format error", sizeof(fbuf));
written = std::strlen(fbuf);
}
p_errmsg = save_msg(cs, std::string_view{
static_cast<char const *>(fbuf),
std::size_t(written)
});
p_stack = save_stack(cs);
}
@ -608,7 +626,7 @@ private:
cs_stack_state p_stack;
};
struct OSTD_EXPORT cs_stacked_value: cs_value {
struct LIBCUBESCRIPT_EXPORT cs_stacked_value: cs_value {
cs_stacked_value(cs_state &cs, cs_ident *id = nullptr);
~cs_stacked_value();
@ -634,7 +652,7 @@ private:
bool p_pushed;
};
struct OSTD_EXPORT cs_list_parse_state {
struct LIBCUBESCRIPT_EXPORT cs_list_parse_state {
cs_list_parse_state(std::string_view s = std::string_view{}):
input_beg{s.data()}, input_end{s.data() + s.size()}
{}
@ -653,12 +671,12 @@ struct OSTD_EXPORT cs_list_parse_state {
std::string_view quoted_item{};
};
OSTD_EXPORT bool list_parse(cs_list_parse_state &ps, cs_state &cs);
OSTD_EXPORT std::size_t list_count(cs_list_parse_state &ps, cs_state &cs);
OSTD_EXPORT cs_strref list_get_item(cs_list_parse_state &ps, cs_state &cs);
OSTD_EXPORT void list_find_item(cs_list_parse_state &ps);
LIBCUBESCRIPT_EXPORT bool list_parse(cs_list_parse_state &ps, cs_state &cs);
LIBCUBESCRIPT_EXPORT std::size_t list_count(cs_list_parse_state &ps, cs_state &cs);
LIBCUBESCRIPT_EXPORT cs_strref list_get_item(cs_list_parse_state &ps, cs_state &cs);
LIBCUBESCRIPT_EXPORT void list_find_item(cs_list_parse_state &ps);
OSTD_EXPORT cs_strref value_list_concat(
LIBCUBESCRIPT_EXPORT cs_strref value_list_concat(
cs_state &cs, std::span<cs_value> vals,
std::string_view sep = std::string_view{}
);
@ -666,7 +684,6 @@ OSTD_EXPORT cs_strref value_list_concat(
namespace util {
template<typename R>
inline R escape_string(R writer, std::string_view str) {
using namespace ostd::string_literals;
*writer++ = '"';
for (auto c: str) {
switch (c) {
@ -720,7 +737,7 @@ namespace util {
return writer;
}
OSTD_EXPORT char const *parse_string(
LIBCUBESCRIPT_EXPORT char const *parse_string(
cs_state &cs, std::string_view str, size_t &nlines
);
@ -731,27 +748,31 @@ namespace util {
return parse_string(cs, str, nlines);
}
OSTD_EXPORT char const *parse_word(cs_state &cs, std::string_view str);
LIBCUBESCRIPT_EXPORT char const *parse_word(cs_state &cs, std::string_view str);
template<typename R>
inline void print_stack(R &&writer, cs_stack_state const &st) {
inline R print_stack(R writer, cs_stack_state const &st) {
char buf[32] = {0};
auto nd = st.get();
while (nd) {
try {
ostd::format(
std::forward<R>(writer),
((nd->index == 1) && st.gap())
? " ..%d) %s" : " %d) %s",
nd->index, nd->id->get_name()
);
} catch (ostd::format_error const &e) {
throw cs_internal_error{e.what()};
auto name = nd->id->get_name();
*writer++ = ' ';
*writer++ = ' ';
if ((nd->index == 1) && st.gap()) {
*writer++ = '.';
*writer++ = '.';
}
snprintf(buf, sizeof(buf), "%d", nd->index);
char const *p = buf;
std::copy(p, p + strlen(p), writer);
*writer++ = ')';
std::copy(name.begin(), name.end(), writer);
nd = nd->next;
if (nd) {
writer.put('\n');
*writer++ = '\n';
}
}
return writer;
}
} /* namespace util */

14
src/cs_util.cc
View File

@ -330,7 +330,7 @@ bool cs_strref::operator==(cs_strref const &s) const {
}
namespace util {
OSTD_EXPORT char const *parse_string(
LIBCUBESCRIPT_EXPORT char const *parse_string(
cs_state &cs, std::string_view str, size_t &nlines
) {
size_t nl = 0;
@ -383,7 +383,7 @@ end:
return ++beg;
}
OSTD_EXPORT char const *parse_word(cs_state &cs, std::string_view str) {
LIBCUBESCRIPT_EXPORT char const *parse_word(cs_state &cs, std::string_view str) {
char const *it = str.begin();
char const *end = str.end();
for (; it != end; ++it) {
@ -432,7 +432,7 @@ end:
}
} /* namespace util */
OSTD_EXPORT bool list_parse(cs_list_parse_state &ps, cs_state &cs) {
LIBCUBESCRIPT_EXPORT bool list_parse(cs_list_parse_state &ps, cs_state &cs) {
list_find_item(ps);
if (ps.input_beg == ps.input_end) {
return false;
@ -521,7 +521,7 @@ endblock:
return true;
}
OSTD_EXPORT std::size_t list_count(cs_list_parse_state &ps, cs_state &cs) {
LIBCUBESCRIPT_EXPORT std::size_t list_count(cs_list_parse_state &ps, cs_state &cs) {
size_t ret = 0;
while (list_parse(ps, cs)) {
++ret;
@ -529,7 +529,7 @@ OSTD_EXPORT std::size_t list_count(cs_list_parse_state &ps, cs_state &cs) {
return ret;
}
OSTD_EXPORT cs_strref list_get_item(cs_list_parse_state &ps, cs_state &cs) {
LIBCUBESCRIPT_EXPORT cs_strref list_get_item(cs_list_parse_state &ps, cs_state &cs) {
if (!ps.quoted_item.empty() && (ps.quoted_item.front() == '"')) {
cs_charbuf buf{cs};
util::unescape_string(std::back_inserter(buf), ps.item);
@ -538,7 +538,7 @@ OSTD_EXPORT cs_strref list_get_item(cs_list_parse_state &ps, cs_state &cs) {
return cs_strref{cs, ps.item};
}
OSTD_EXPORT void list_find_item(cs_list_parse_state &ps) {
LIBCUBESCRIPT_EXPORT void list_find_item(cs_list_parse_state &ps) {
for (;;) {
while (ps.input_beg != ps.input_end) {
char c = *ps.input_beg;
@ -558,7 +558,7 @@ OSTD_EXPORT void list_find_item(cs_list_parse_state &ps) {
}
}
OSTD_EXPORT cs_strref value_list_concat(
LIBCUBESCRIPT_EXPORT cs_strref value_list_concat(
cs_state &cs, std::span<cs_value> vals, std::string_view sep
) {
cs_charbuf buf{cs};

84
src/cs_val.cc
View File

@ -2,28 +2,54 @@
#include "cs_vm.hh"
#include "cs_util.hh"
#include <cmath>
namespace cscript {
static cs_charbuf intstr(cs_int v, cs_shared_state &cs) {
auto app = ostd::appender<cs_charbuf>(cs);
try {
ostd::format(app, CS_INT_FORMAT, v);
} catch (ostd::format_error const &e) {
throw cs_internal_error{e.what()};
static std::string_view intstr(cs_int v, cs_charbuf &buf) {
buf.reserve(32);
int n = snprintf(buf.data(), 32, CS_INT_FORMAT, v);
if (n > 32) {
buf.reserve(n + 1);
int nn = snprintf(buf.data(), n + 1, CS_INT_FORMAT, v);
if ((nn > n) || (nn <= 0)) {
n = -1;
} else {
n = nn;
}
}
return std::move(app.get());
if (n <= 0) {
throw cs_internal_error{"format error"};
}
return std::string_view{buf.data(), std::size_t(n)};
}
static cs_charbuf floatstr(cs_float v, cs_shared_state &cs) {
auto app = ostd::appender<cs_charbuf>(cs);
try {
ostd::format(
app, (v == floor(v)) ? CS_ROUND_FLOAT_FORMAT : CS_FLOAT_FORMAT, v
);
} catch (ostd::format_error const &e) {
throw cs_internal_error{e.what()};
static std::string_view floatstr(cs_float v, cs_charbuf &buf) {
buf.reserve(32);
int n;
if (v == std::floor(v)) {
n = snprintf(buf.data(), 32, CS_ROUND_FLOAT_FORMAT, v);
} else {
n = snprintf(buf.data(), 32, CS_FLOAT_FORMAT, v);
}
return std::move(app.get());
if (n > 32) {
buf.reserve(n + 1);
int nn;
if (v == std::floor(v)) {
nn = snprintf(buf.data(), n + 1, CS_ROUND_FLOAT_FORMAT, v);
} else {
nn = snprintf(buf.data(), n + 1, CS_FLOAT_FORMAT, v);
}
if ((nn > n) || (nn <= 0)) {
n = -1;
} else {
n = nn;
}
}
if (n <= 0) {
throw cs_internal_error{"format error"};
}
return std::string_view{buf.data(), std::size_t(n)};
}
template<typename T>
@ -201,19 +227,21 @@ cs_int cs_value::force_int() {
std::string_view cs_value::force_str() {
cs_charbuf rs{*state()};
std::string_view str;
switch (get_type()) {
case cs_value_type::FLOAT:
rs = std::move(floatstr(csv_get<cs_float>(p_stor), *state()));
str = floatstr(csv_get<cs_float>(p_stor), rs);
break;
case cs_value_type::INT:
rs = std::move(intstr(csv_get<cs_int>(p_stor), *state()));
str = intstr(csv_get<cs_int>(p_stor), rs);
break;
case cs_value_type::STRING:
return *reinterpret_cast<cs_strref const *>(&p_stor);
default:
str = rs.str();
break;
}
set_str(rs.str());
set_str(str);
return std::string_view(*reinterpret_cast<cs_strref const *>(&p_stor));
}
@ -267,14 +295,14 @@ cs_strref cs_value::get_str() const {
switch (get_type()) {
case cs_value_type::STRING:
return *reinterpret_cast<cs_strref const *>(&p_stor);
case cs_value_type::INT:
return cs_strref{
*state(), intstr(csv_get<cs_int>(p_stor), *state()).str()
};
case cs_value_type::FLOAT:
return cs_strref{
*state(), floatstr(csv_get<cs_float>(p_stor), *state()).str()
};
case cs_value_type::INT: {
cs_charbuf rs{*state()};
return cs_strref{*state(), intstr(csv_get<cs_int>(p_stor), rs)};
}
case cs_value_type::FLOAT: {
cs_charbuf rs{*state()};
return cs_strref{*state(), floatstr(csv_get<cs_float>(p_stor), rs)};
}
default:
break;
}
@ -298,7 +326,7 @@ void cs_value::get_val(cs_value &r) const {
}
}
OSTD_EXPORT bool cs_code_is_empty(cs_bcode *code) {
LIBCUBESCRIPT_EXPORT bool cs_code_is_empty(cs_bcode *code) {
if (!code) {
return true;
}

92
src/cubescript.cc
View File

@ -1,6 +1,8 @@
#include <cubescript/cubescript.hh>
#include "cs_vm.hh"
#include <iterator>
namespace cscript {
bool cs_check_num(std::string_view s) {
@ -359,11 +361,11 @@ cs_state::cs_state(cs_alloc_cb func, void *data):
cs_init_lib_base(*this);
}
OSTD_EXPORT cs_state::~cs_state() {
LIBCUBESCRIPT_EXPORT cs_state::~cs_state() {
destroy();
}
OSTD_EXPORT void cs_state::destroy() {
LIBCUBESCRIPT_EXPORT void cs_state::destroy() {
if (!p_state || !p_owner) {
return;
}
@ -384,31 +386,31 @@ cs_state::cs_state(cs_shared_state *s):
p_state(s), p_owner(false)
{}
OSTD_EXPORT cs_state cs_state::new_thread() {
LIBCUBESCRIPT_EXPORT cs_state cs_state::new_thread() {
return cs_state{p_state};
}
OSTD_EXPORT cs_hook_cb cs_state::set_call_hook(cs_hook_cb func) {
LIBCUBESCRIPT_EXPORT cs_hook_cb cs_state::set_call_hook(cs_hook_cb func) {
auto hk = std::move(p_callhook);
p_callhook = std::move(func);
return hk;
}
OSTD_EXPORT cs_hook_cb const &cs_state::get_call_hook() const {
LIBCUBESCRIPT_EXPORT cs_hook_cb const &cs_state::get_call_hook() const {
return p_callhook;
}
OSTD_EXPORT cs_hook_cb &cs_state::get_call_hook() {
LIBCUBESCRIPT_EXPORT cs_hook_cb &cs_state::get_call_hook() {
return p_callhook;
}
OSTD_EXPORT cs_vprint_cb cs_state::set_var_printer(cs_vprint_cb func) {
LIBCUBESCRIPT_EXPORT cs_vprint_cb cs_state::set_var_printer(cs_vprint_cb func) {
auto fn = std::move(p_state->varprintf);
p_state->varprintf = std::move(func);
return fn;
}
OSTD_EXPORT cs_vprint_cb const &cs_state::get_var_printer() const {
LIBCUBESCRIPT_EXPORT cs_vprint_cb const &cs_state::get_var_printer() const {
return p_state->varprintf;
}
@ -416,7 +418,7 @@ void *cs_state::alloc(void *ptr, size_t os, size_t ns) {
return p_state->alloc(ptr, os, ns);
}
OSTD_EXPORT void cs_state::clear_override(cs_ident &id) {
LIBCUBESCRIPT_EXPORT void cs_state::clear_override(cs_ident &id) {
if (!(id.get_flags() & CS_IDF_OVERRIDDEN)) {
return;
}
@ -451,13 +453,13 @@ OSTD_EXPORT void cs_state::clear_override(cs_ident &id) {
id.p_flags &= ~CS_IDF_OVERRIDDEN;
}
OSTD_EXPORT void cs_state::clear_overrides() {
LIBCUBESCRIPT_EXPORT void cs_state::clear_overrides() {
for (auto &p: p_state->idents) {
clear_override(*(p.second));
}
}
OSTD_EXPORT cs_ident *cs_state::add_ident(cs_ident *id) {
LIBCUBESCRIPT_EXPORT cs_ident *cs_state::add_ident(cs_ident *id) {
if (!id) {
return nullptr;
}
@ -467,7 +469,7 @@ OSTD_EXPORT cs_ident *cs_state::add_ident(cs_ident *id) {
return p_state->identmap.back();
}
OSTD_EXPORT cs_ident *cs_state::new_ident(std::string_view name, int flags) {
LIBCUBESCRIPT_EXPORT cs_ident *cs_state::new_ident(std::string_view name, int flags) {
cs_ident *id = get_ident(name);
if (!id) {
if (cs_check_num(name)) {
@ -482,7 +484,7 @@ OSTD_EXPORT cs_ident *cs_state::new_ident(std::string_view name, int flags) {
return id;
}
OSTD_EXPORT cs_ident *cs_state::force_ident(cs_value &v) {
LIBCUBESCRIPT_EXPORT cs_ident *cs_state::force_ident(cs_value &v) {
switch (v.get_type()) {
case cs_value_type::IDENT:
return v.get_ident();
@ -498,7 +500,7 @@ OSTD_EXPORT cs_ident *cs_state::force_ident(cs_value &v) {
return p_state->identmap[DummyIdx];
}
OSTD_EXPORT cs_ident *cs_state::get_ident(std::string_view name) {
LIBCUBESCRIPT_EXPORT cs_ident *cs_state::get_ident(std::string_view name) {
auto id = p_state->idents.find(name);
if (id != p_state->idents.end()) {
return id->second;
@ -506,7 +508,7 @@ OSTD_EXPORT cs_ident *cs_state::get_ident(std::string_view name) {
return nullptr;
}
OSTD_EXPORT cs_alias *cs_state::get_alias(std::string_view name) {
LIBCUBESCRIPT_EXPORT cs_alias *cs_state::get_alias(std::string_view name) {
auto id = get_ident(name);
if (!id || !id->is_alias()) {
return nullptr;
@ -514,23 +516,23 @@ OSTD_EXPORT cs_alias *cs_state::get_alias(std::string_view name) {
return static_cast<cs_alias *>(id);
}
OSTD_EXPORT bool cs_state::have_ident(std::string_view name) {
LIBCUBESCRIPT_EXPORT bool cs_state::have_ident(std::string_view name) {
return p_state->idents.find(name) != p_state->idents.end();
}
OSTD_EXPORT std::span<cs_ident *> cs_state::get_idents() {
LIBCUBESCRIPT_EXPORT std::span<cs_ident *> cs_state::get_idents() {
return std::span<cs_ident *>{
p_state->identmap.data(),
p_state->identmap.size()
};
}
OSTD_EXPORT std::span<cs_ident const *> cs_state::get_idents() const {
LIBCUBESCRIPT_EXPORT std::span<cs_ident const *> cs_state::get_idents() const {
auto ptr = const_cast<cs_ident const **>(p_state->identmap.data());
return std::span<cs_ident const *>{ptr, p_state->identmap.size()};
}
OSTD_EXPORT cs_ivar *cs_state::new_ivar(
LIBCUBESCRIPT_EXPORT cs_ivar *cs_state::new_ivar(
std::string_view n, cs_int m, cs_int x, cs_int v, cs_var_cb f, int flags
) {
return add_ident(p_state->create<cs_ivar>(
@ -538,7 +540,7 @@ OSTD_EXPORT cs_ivar *cs_state::new_ivar(
))->get_ivar();
}
OSTD_EXPORT cs_fvar *cs_state::new_fvar(
LIBCUBESCRIPT_EXPORT cs_fvar *cs_state::new_fvar(
std::string_view n, cs_float m, cs_float x, cs_float v, cs_var_cb f, int flags
) {
return add_ident(p_state->create<cs_fvar>(
@ -546,7 +548,7 @@ OSTD_EXPORT cs_fvar *cs_state::new_fvar(
))->get_fvar();
}
OSTD_EXPORT cs_svar *cs_state::new_svar(
LIBCUBESCRIPT_EXPORT cs_svar *cs_state::new_svar(
std::string_view n, std::string_view v, cs_var_cb f, int flags
) {
return add_ident(p_state->create<cs_svar>(
@ -555,7 +557,7 @@ OSTD_EXPORT cs_svar *cs_state::new_svar(
))->get_svar();
}
OSTD_EXPORT void cs_state::reset_var(std::string_view name) {
LIBCUBESCRIPT_EXPORT void cs_state::reset_var(std::string_view name) {
cs_ident *id = get_ident(name);
if (!id) {
throw cs_error(*this, "variable %s does not exist", name);
@ -566,14 +568,14 @@ OSTD_EXPORT void cs_state::reset_var(std::string_view name) {
clear_override(*id);
}
OSTD_EXPORT void cs_state::touch_var(std::string_view name) {
LIBCUBESCRIPT_EXPORT void cs_state::touch_var(std::string_view name) {
cs_ident *id = get_ident(name);
if (id && id->is_var()) {
static_cast<cs_var *>(id)->changed(*this);
}
}
OSTD_EXPORT void cs_state::set_alias(std::string_view name, cs_value v) {
LIBCUBESCRIPT_EXPORT void cs_state::set_alias(std::string_view name, cs_value v) {
cs_ident *id = get_ident(name);
if (id) {
switch (id->get_type()) {
@ -610,7 +612,7 @@ OSTD_EXPORT void cs_state::set_alias(std::string_view name, cs_value v) {
}
}
OSTD_EXPORT void cs_state::print_var(cs_var const &v) const {
LIBCUBESCRIPT_EXPORT void cs_state::print_var(cs_var const &v) const {
p_state->varprintf(*this, v);
}
@ -669,7 +671,7 @@ static inline void cs_override_var(cs_state &cs, cs_var *v, int &vflags, SF sf)
}
}
OSTD_EXPORT void cs_state::set_var_int(
LIBCUBESCRIPT_EXPORT void cs_state::set_var_int(
std::string_view name, cs_int v, bool dofunc, bool doclamp
) {
cs_ident *id = get_ident(name);
@ -691,7 +693,7 @@ OSTD_EXPORT void cs_state::set_var_int(
}
}
OSTD_EXPORT void cs_state::set_var_float(
LIBCUBESCRIPT_EXPORT void cs_state::set_var_float(
std::string_view name, cs_float v, bool dofunc, bool doclamp
) {
cs_ident *id = get_ident(name);
@ -713,7 +715,7 @@ OSTD_EXPORT void cs_state::set_var_float(
}
}
OSTD_EXPORT void cs_state::set_var_str(
LIBCUBESCRIPT_EXPORT void cs_state::set_var_str(
std::string_view name, std::string_view v, bool dofunc
) {
cs_ident *id = get_ident(name);
@ -731,7 +733,7 @@ OSTD_EXPORT void cs_state::set_var_str(
}
}
OSTD_EXPORT std::optional<cs_int>
LIBCUBESCRIPT_EXPORT std::optional<cs_int>
cs_state::get_var_int(std::string_view name) {
cs_ident *id = get_ident(name);
if (!id || id->is_ivar()) {
@ -740,7 +742,7 @@ cs_state::get_var_int(std::string_view name) {
return static_cast<cs_ivar *>(id)->get_value();
}
OSTD_EXPORT std::optional<cs_float>
LIBCUBESCRIPT_EXPORT std::optional<cs_float>
cs_state::get_var_float(std::string_view name) {
cs_ident *id = get_ident(name);
if (!id || id->is_fvar()) {
@ -749,7 +751,7 @@ cs_state::get_var_float(std::string_view name) {
return static_cast<cs_fvar *>(id)->get_value();
}
OSTD_EXPORT std::optional<cs_strref>
LIBCUBESCRIPT_EXPORT std::optional<cs_strref>
cs_state::get_var_str(std::string_view name) {
cs_ident *id = get_ident(name);
if (!id || id->is_svar()) {
@ -758,7 +760,7 @@ cs_state::get_var_str(std::string_view name) {
return cs_strref{*p_state, static_cast<cs_svar *>(id)->get_value()};
}
OSTD_EXPORT std::optional<cs_int>
LIBCUBESCRIPT_EXPORT std::optional<cs_int>
cs_state::get_var_min_int(std::string_view name) {
cs_ident *id = get_ident(name);
if (!id || id->is_ivar()) {
@ -767,7 +769,7 @@ cs_state::get_var_min_int(std::string_view name) {
return static_cast<cs_ivar *>(id)->get_val_min();
}
OSTD_EXPORT std::optional<cs_int>
LIBCUBESCRIPT_EXPORT std::optional<cs_int>
cs_state::get_var_max_int(std::string_view name) {
cs_ident *id = get_ident(name);
if (!id || id->is_ivar()) {
@ -776,7 +778,7 @@ cs_state::get_var_max_int(std::string_view name) {
return static_cast<cs_ivar *>(id)->get_val_max();
}
OSTD_EXPORT std::optional<cs_float>
LIBCUBESCRIPT_EXPORT std::optional<cs_float>
cs_state::get_var_min_float(std::string_view name) {
cs_ident *id = get_ident(name);
if (!id || id->is_fvar()) {
@ -785,7 +787,7 @@ cs_state::get_var_min_float(std::string_view name) {
return static_cast<cs_fvar *>(id)->get_val_min();
}
OSTD_EXPORT std::optional<cs_float>
LIBCUBESCRIPT_EXPORT std::optional<cs_float>
cs_state::get_var_max_float(std::string_view name) {
cs_ident *id = get_ident(name);
if (!id || id->is_fvar()) {
@ -794,7 +796,7 @@ cs_state::get_var_max_float(std::string_view name) {
return static_cast<cs_fvar *>(id)->get_val_max();
}
OSTD_EXPORT std::optional<cs_strref>
LIBCUBESCRIPT_EXPORT std::optional<cs_strref>
cs_state::get_alias_val(std::string_view name) {
cs_alias *a = get_alias(name);
if (!a) {
@ -827,7 +829,7 @@ cs_int cs_clamp_var(cs_state &cs, cs_ivar *iv, cs_int v) {
);
}
OSTD_EXPORT void cs_state::set_var_int_checked(cs_ivar *iv, cs_int v) {
LIBCUBESCRIPT_EXPORT void cs_state::set_var_int_checked(cs_ivar *iv, cs_int v) {
if (iv->get_flags() & CS_IDF_READONLY) {
throw cs_error(
*this, "variable '%s' is read only", iv->get_name()
@ -844,7 +846,7 @@ OSTD_EXPORT void cs_state::set_var_int_checked(cs_ivar *iv, cs_int v) {
iv->changed(*this);
}
OSTD_EXPORT void cs_state::set_var_int_checked(
LIBCUBESCRIPT_EXPORT void cs_state::set_var_int_checked(
cs_ivar *iv, std::span<cs_value> args
) {
cs_int v = args[0].force_int();
@ -875,7 +877,7 @@ cs_float cs_clamp_fvar(cs_state &cs, cs_fvar *fv, cs_float v) {
return v;
}
OSTD_EXPORT void cs_state::set_var_float_checked(cs_fvar *fv, cs_float v) {
LIBCUBESCRIPT_EXPORT void cs_state::set_var_float_checked(cs_fvar *fv, cs_float v) {
if (fv->get_flags() & CS_IDF_READONLY) {
throw cs_error(
*this, "variable '%s' is read only", fv->get_name()
@ -892,7 +894,7 @@ OSTD_EXPORT void cs_state::set_var_float_checked(cs_fvar *fv, cs_float v) {
fv->changed(*this);
}
OSTD_EXPORT void cs_state::set_var_str_checked(
LIBCUBESCRIPT_EXPORT void cs_state::set_var_str_checked(
cs_svar *sv, std::string_view v
) {
if (sv->get_flags() & CS_IDF_READONLY) {
@ -908,7 +910,7 @@ OSTD_EXPORT void cs_state::set_var_str_checked(
sv->changed(*this);
}
OSTD_EXPORT cs_command *cs_state::new_command(
LIBCUBESCRIPT_EXPORT cs_command *cs_state::new_command(
std::string_view name, std::string_view args, cs_command_cb func
) {
int nargs = 0;
@ -1037,9 +1039,9 @@ void cs_init_lib_base(cs_state &gcs) {
} catch (cs_error const &e) {
result.set_str(e.what());
if (e.get_stack().get()) {
auto app = ostd::appender<cs_charbuf>(cs);
cscript::util::print_stack(app, e.get_stack());
tback.set_str(app.get().str());
cs_charbuf buf{cs};
util::print_stack(std::back_inserter(buf), e.get_stack());
tback.set_str(buf.str());
}
rc = false;
}
@ -1302,7 +1304,7 @@ void cs_init_lib_math(cs_state &cs);
void cs_init_lib_string(cs_state &cs);
void cs_init_lib_list(cs_state &cs);
OSTD_EXPORT void cs_state::init_libs(int libs) {
LIBCUBESCRIPT_EXPORT void cs_state::init_libs(int libs) {
if (libs & CS_LIB_MATH) {
cs_init_lib_math(*this);
}

6
tools/repl.cc
View File

@ -2,6 +2,7 @@
#include <optional>
#include <memory>
#include <iterator>
#include <ostd/platform.hh>
#include <ostd/io.hh>
@ -292,8 +293,9 @@ static bool do_call(cs_state &cs, std::string_view line, bool file = false) {
}
ostd::writeln(!is_lnum ? "stdin: " : "stdin:", e.what());
if (e.get_stack().get()) {
cscript::util::print_stack(ostd::cout.iter(), e.get_stack());
ostd::write('\n');
std::string str;
cscript::util::print_stack(std::back_inserter(str), e.get_stack());
ostd::writeln(str);
}
return false;
}