2016-08-14 18:35:38 +02:00
|
|
|
#ifndef LIBCUBESCRIPT_CUBESCRIPT_HH
|
|
|
|
#define LIBCUBESCRIPT_CUBESCRIPT_HH
|
2015-09-10 19:53:43 +02:00
|
|
|
|
2021-03-20 07:24:25 +01:00
|
|
|
#include <cstring>
|
2021-03-22 00:58:35 +01:00
|
|
|
#include <cstddef>
|
2017-04-23 15:34:45 +02:00
|
|
|
#include <vector>
|
2017-01-30 19:38:11 +01:00
|
|
|
#include <optional>
|
2017-02-08 01:07:35 +01:00
|
|
|
#include <functional>
|
2017-02-09 20:59:14 +01:00
|
|
|
#include <type_traits>
|
2021-03-20 06:18:31 +01:00
|
|
|
#include <algorithm>
|
2021-03-22 00:58:35 +01:00
|
|
|
#include <memory>
|
2017-02-16 20:51:03 +01:00
|
|
|
#include <utility>
|
2021-03-22 00:58:35 +01:00
|
|
|
#include <span>
|
2017-01-30 19:38:11 +01:00
|
|
|
|
2016-08-14 18:35:38 +02:00
|
|
|
#include "cubescript_conf.hh"
|
|
|
|
|
2021-03-20 07:24:25 +01:00
|
|
|
#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
|
2015-08-05 23:58:45 +02:00
|
|
|
|
2015-08-08 17:13:46 +02:00
|
|
|
namespace cscript {
|
|
|
|
|
2017-02-13 18:10:40 +01:00
|
|
|
static_assert(std::is_integral_v<cs_int>, "cs_int must be integral");
|
|
|
|
static_assert(std::is_signed_v<cs_int>, "cs_int must be signed");
|
|
|
|
static_assert(std::is_floating_point_v<cs_float>, "cs_float must be floating point");
|
2016-11-12 19:15:28 +01:00
|
|
|
|
2017-02-13 18:10:40 +01:00
|
|
|
struct cs_internal_error: std::runtime_error {
|
2017-02-12 22:52:43 +01:00
|
|
|
using std::runtime_error::runtime_error;
|
|
|
|
};
|
|
|
|
|
2021-03-22 00:58:35 +01:00
|
|
|
template<typename R, typename ...A>
|
|
|
|
struct cs_callable {
|
|
|
|
private:
|
|
|
|
struct base {
|
|
|
|
base(base const &);
|
|
|
|
base &operator=(base const &);
|
|
|
|
|
|
|
|
public:
|
|
|
|
base() {}
|
|
|
|
virtual ~base() {}
|
|
|
|
virtual void move_to(base *) = 0;
|
|
|
|
virtual R operator()(A &&...args) = 0;
|
|
|
|
};
|
|
|
|
|
|
|
|
template<typename F>
|
|
|
|
struct store: base {
|
|
|
|
explicit store(F &&f): p_stor{std::move(f)} {}
|
|
|
|
|
|
|
|
virtual void move_to(base *p) {
|
|
|
|
::new (p) store{std::move(p_stor)};
|
|
|
|
}
|
|
|
|
|
|
|
|
virtual R operator()(A &&...args) {
|
|
|
|
return std::invoke(
|
|
|
|
*reinterpret_cast<F *>(&p_stor), std::forward<A>(args)...
|
|
|
|
);
|
|
|
|
}
|
|
|
|
|
|
|
|
private:
|
|
|
|
F p_stor;
|
|
|
|
};
|
|
|
|
|
|
|
|
using alloc_f = void *(*)(void *, void *, std::size_t, std::size_t);
|
|
|
|
|
|
|
|
struct f_alloc {
|
|
|
|
alloc_f af;
|
|
|
|
void *ud;
|
|
|
|
size_t asize;
|
|
|
|
};
|
|
|
|
|
|
|
|
std::aligned_storage_t<sizeof(void *) * 4> p_stor;
|
|
|
|
base *p_func;
|
|
|
|
|
|
|
|
static inline base *as_base(void *p) {
|
|
|
|
return static_cast<base *>(p);
|
|
|
|
}
|
|
|
|
|
|
|
|
template<typename T>
|
|
|
|
static inline bool f_not_null(T const &) { return true; }
|
|
|
|
|
|
|
|
template<typename T>
|
|
|
|
static inline bool f_not_null(T *p) { return !!p; }
|
|
|
|
|
|
|
|
template<typename CR, typename C>
|
|
|
|
static inline bool f_not_null(CR C::*p) { return !!p; }
|
|
|
|
|
|
|
|
template<typename T>
|
|
|
|
static inline bool f_not_null(cs_callable<T> const &f) { return !!f; }
|
|
|
|
|
|
|
|
bool small_storage() {
|
|
|
|
return (static_cast<void *>(p_func) == &p_stor);
|
|
|
|
}
|
|
|
|
|
|
|
|
void cleanup() {
|
|
|
|
if (!p_func) {
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
p_func->~base();
|
|
|
|
if (!small_storage()) {
|
|
|
|
auto &ad = *reinterpret_cast<f_alloc *>(&p_stor);
|
|
|
|
ad.af(ad.ud, p_func, ad.asize, 0);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
public:
|
|
|
|
cs_callable() noexcept: p_func{nullptr} {}
|
|
|
|
cs_callable(std::nullptr_t) noexcept: p_func{nullptr} {}
|
|
|
|
cs_callable(std::nullptr_t, alloc_f, void *) noexcept: p_func{nullptr} {}
|
|
|
|
|
|
|
|
cs_callable(cs_callable &&f) noexcept {
|
|
|
|
if (!f.p_func) {
|
|
|
|
p_func = nullptr;
|
|
|
|
} else if (f.small_storage()) {
|
|
|
|
p_func = as_base(&p_stor);
|
|
|
|
f.p_func->move_to(p_func);
|
|
|
|
} else {
|
|
|
|
p_func = f.p_func;
|
|
|
|
f.p_func = nullptr;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
template<typename F>
|
|
|
|
cs_callable(F func, alloc_f af, void *ud) {
|
|
|
|
if (!f_not_null(func)) {
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
if constexpr (sizeof(store<F>) <= sizeof(p_stor)) {
|
|
|
|
auto *p = static_cast<void *>(&p_stor);
|
|
|
|
p_func = ::new (p) store<F>{std::move(func)};
|
|
|
|
} else {
|
|
|
|
auto &ad = *reinterpret_cast<f_alloc *>(&p_stor);
|
|
|
|
ad.af = af;
|
|
|
|
ad.ud = ud;
|
|
|
|
ad.asize = sizeof(store<F>);
|
|
|
|
p_func = static_cast<store<F> *>(
|
|
|
|
af(ud, nullptr, 0, sizeof(store<F>))
|
|
|
|
);
|
|
|
|
try {
|
|
|
|
new (p_func) store<F>{std::move(func)};
|
|
|
|
} catch (...) {
|
|
|
|
af(ud, p_func, sizeof(store<F>), 0);
|
|
|
|
throw;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
cs_callable &operator=(cs_callable const &) = delete;
|
|
|
|
|
|
|
|
cs_callable &operator=(cs_callable &&f) noexcept {
|
|
|
|
cleanup();
|
|
|
|
if (f.p_func == nullptr) {
|
|
|
|
p_func = nullptr;
|
|
|
|
} else if (f.small_storage()) {
|
|
|
|
p_func = as_base(&p_stor);
|
|
|
|
f.p_func->move_to(p_func);
|
|
|
|
} else {
|
|
|
|
p_func = f.p_func;
|
|
|
|
f.p_func = nullptr;
|
|
|
|
}
|
|
|
|
return *this;
|
|
|
|
}
|
|
|
|
|
|
|
|
cs_callable &operator=(std::nullptr_t) noexcept {
|
|
|
|
cleanup();
|
|
|
|
p_func = nullptr;
|
|
|
|
return *this;
|
|
|
|
}
|
|
|
|
|
|
|
|
template<typename F>
|
|
|
|
cs_callable &operator=(F &&func) {
|
|
|
|
cs_callable{std::forward<F>(func)}.swap(*this);
|
|
|
|
return *this;
|
|
|
|
}
|
|
|
|
|
|
|
|
~cs_callable() {
|
|
|
|
cleanup();
|
|
|
|
}
|
|
|
|
|
|
|
|
void swap(cs_callable &f) noexcept {
|
|
|
|
std::aligned_storage_t<sizeof(p_stor)> tmp_stor;
|
|
|
|
if (small_storage() && f.small_storage()) {
|
|
|
|
auto *t = as_base(&tmp_stor);
|
|
|
|
p_func->move_to(t);
|
|
|
|
p_func->~base();
|
|
|
|
p_func = nullptr;
|
|
|
|
f.p_func->move_to(as_base(&p_stor));
|
|
|
|
f.p_func->~base();
|
|
|
|
f.p_func = nullptr;
|
|
|
|
p_func = as_base(&p_stor);
|
|
|
|
t->move_to(as_base(&f.p_stor));
|
|
|
|
t->~base();
|
|
|
|
f.p_func = as_base(&f.p_stor);
|
|
|
|
} else if (small_storage()) {
|
|
|
|
/* copy allocator address/size */
|
|
|
|
memcpy(&tmp_stor, &f.p_stor, sizeof(tmp_stor));
|
|
|
|
p_func->move_to(as_base(&f.p_stor));
|
|
|
|
p_func->~base();
|
|
|
|
p_func = f.p_func;
|
|
|
|
f.p_func = as_base(&f.p_stor);
|
|
|
|
memcpy(&p_stor, &tmp_stor, sizeof(tmp_stor));
|
|
|
|
} else if (f.small_storage()) {
|
|
|
|
/* copy allocator address/size */
|
|
|
|
memcpy(&tmp_stor, &p_stor, sizeof(tmp_stor));
|
|
|
|
f.p_func->move_to(as_base(&p_stor));
|
|
|
|
f.p_func->~base();
|
|
|
|
f.p_func = p_func;
|
|
|
|
p_func = as_base(&p_stor);
|
|
|
|
memcpy(&f.p_stor, &tmp_stor, sizeof(tmp_stor));
|
|
|
|
} else {
|
|
|
|
/* copy allocator address/size */
|
|
|
|
memcpy(&tmp_stor, &p_stor, sizeof(tmp_stor));
|
|
|
|
memcpy(&p_stor, &f.p_stor, sizeof(tmp_stor));
|
|
|
|
memcpy(&f.p_stor, &tmp_stor, sizeof(tmp_stor));
|
|
|
|
std::swap(p_func, f.p_func);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
explicit operator bool() const noexcept {
|
|
|
|
return !!p_func;
|
|
|
|
}
|
|
|
|
|
|
|
|
R operator()(A ...args) {
|
|
|
|
return (*p_func)(std::forward<A>(args)...);
|
|
|
|
}
|
|
|
|
};
|
|
|
|
|
|
|
|
using cs_alloc_cb = void *(*)(void *, void *, size_t, size_t);
|
|
|
|
|
|
|
|
struct cs_state;
|
|
|
|
struct cs_ident;
|
|
|
|
struct cs_value;
|
|
|
|
struct cs_var;
|
|
|
|
|
|
|
|
using cs_hook_cb = cs_callable<void, cs_state &>;
|
|
|
|
using cs_var_cb = cs_callable<void, cs_state &, cs_ident &>;
|
|
|
|
using cs_vprint_cb = cs_callable<void, cs_state const &, cs_var const &>;
|
|
|
|
using cs_command_cb = cs_callable<
|
|
|
|
void, cs_state &, std::span<cs_value>, cs_value &
|
|
|
|
>;
|
|
|
|
|
2015-08-05 23:58:45 +02:00
|
|
|
enum {
|
2017-02-13 18:10:40 +01:00
|
|
|
CS_IDF_PERSIST = 1 << 0,
|
|
|
|
CS_IDF_OVERRIDE = 1 << 1,
|
|
|
|
CS_IDF_HEX = 1 << 2,
|
|
|
|
CS_IDF_READONLY = 1 << 3,
|
|
|
|
CS_IDF_OVERRIDDEN = 1 << 4,
|
|
|
|
CS_IDF_UNKNOWN = 1 << 5,
|
|
|
|
CS_IDF_ARG = 1 << 6
|
2015-08-05 23:58:45 +02:00
|
|
|
};
|
|
|
|
|
2017-02-13 18:10:40 +01:00
|
|
|
struct cs_bcode;
|
2021-03-16 00:44:25 +01:00
|
|
|
struct cs_shared_state;
|
2021-03-21 02:41:04 +01:00
|
|
|
struct cs_ident_impl;
|
2016-08-06 20:12:38 +02:00
|
|
|
|
2021-03-20 07:24:25 +01:00
|
|
|
struct LIBCUBESCRIPT_EXPORT cs_bcode_ref {
|
2017-02-13 18:10:40 +01:00
|
|
|
cs_bcode_ref():
|
2016-08-07 22:39:27 +02:00
|
|
|
p_code(nullptr)
|
|
|
|
{}
|
2017-02-13 18:10:40 +01:00
|
|
|
cs_bcode_ref(cs_bcode *v);
|
|
|
|
cs_bcode_ref(cs_bcode_ref const &v);
|
|
|
|
cs_bcode_ref(cs_bcode_ref &&v):
|
2016-08-07 22:39:27 +02:00
|
|
|
p_code(v.p_code)
|
|
|
|
{
|
|
|
|
v.p_code = nullptr;
|
|
|
|
}
|
2015-12-20 00:28:12 +01:00
|
|
|
|
2017-02-13 18:10:40 +01:00
|
|
|
~cs_bcode_ref();
|
2015-12-24 15:57:19 +01:00
|
|
|
|
2017-02-13 18:10:40 +01:00
|
|
|
cs_bcode_ref &operator=(cs_bcode_ref const &v);
|
|
|
|
cs_bcode_ref &operator=(cs_bcode_ref &&v);
|
2015-12-20 00:28:12 +01:00
|
|
|
|
|
|
|
operator bool() const { return p_code != nullptr; }
|
2017-02-13 18:10:40 +01:00
|
|
|
operator cs_bcode *() const { return p_code; }
|
2015-12-20 00:28:12 +01:00
|
|
|
|
|
|
|
private:
|
2017-02-13 18:10:40 +01:00
|
|
|
cs_bcode *p_code;
|
2015-12-20 00:28:12 +01:00
|
|
|
};
|
|
|
|
|
2021-03-20 07:24:25 +01:00
|
|
|
LIBCUBESCRIPT_EXPORT bool cs_code_is_empty(cs_bcode *code);
|
2016-08-06 18:33:01 +02:00
|
|
|
|
2021-03-20 07:24:25 +01:00
|
|
|
struct LIBCUBESCRIPT_EXPORT cs_strref {
|
2021-03-16 00:44:25 +01:00
|
|
|
friend struct cs_value;
|
2021-03-23 01:35:04 +01:00
|
|
|
friend struct cs_strman;
|
2021-03-16 00:44:25 +01:00
|
|
|
|
|
|
|
cs_strref() = delete;
|
2021-03-23 01:25:47 +01:00
|
|
|
cs_strref(cs_shared_state *cs, std::string_view str);
|
2021-03-20 02:26:37 +01:00
|
|
|
cs_strref(cs_state &cs, std::string_view str);
|
2021-03-16 00:44:25 +01:00
|
|
|
|
|
|
|
cs_strref(cs_strref const &ref);
|
|
|
|
|
|
|
|
~cs_strref();
|
|
|
|
|
|
|
|
cs_strref &operator=(cs_strref const &ref);
|
|
|
|
|
2021-03-20 02:26:37 +01:00
|
|
|
operator std::string_view() const;
|
2021-03-16 00:44:25 +01:00
|
|
|
|
2021-03-17 21:57:47 +01:00
|
|
|
std::size_t size() const {
|
2021-03-20 02:26:37 +01:00
|
|
|
return std::string_view{*this}.size();
|
2021-03-17 21:57:47 +01:00
|
|
|
}
|
|
|
|
std::size_t length() const {
|
2021-03-20 02:26:37 +01:00
|
|
|
return std::string_view{*this}.length();
|
2021-03-17 21:57:47 +01:00
|
|
|
}
|
|
|
|
|
2021-03-17 23:32:38 +01:00
|
|
|
char const *data() const {
|
2021-03-20 02:26:37 +01:00
|
|
|
return std::string_view{*this}.data();
|
2021-03-17 23:32:38 +01:00
|
|
|
}
|
|
|
|
|
2021-03-17 21:46:37 +01:00
|
|
|
bool operator==(cs_strref const &s) const;
|
|
|
|
|
2021-03-16 00:44:25 +01:00
|
|
|
private:
|
|
|
|
/* for internal use only */
|
2021-03-23 01:25:47 +01:00
|
|
|
cs_strref(char const *p, cs_shared_state *cs);
|
2021-03-16 00:44:25 +01:00
|
|
|
|
|
|
|
cs_shared_state *p_state;
|
2021-03-17 01:26:16 +01:00
|
|
|
char const *p_str;
|
2021-03-16 00:44:25 +01:00
|
|
|
};
|
|
|
|
|
2017-02-13 18:10:40 +01:00
|
|
|
enum class cs_value_type {
|
2021-03-18 20:55:14 +01:00
|
|
|
NONE = 0, INT, FLOAT, STRING, CODE, IDENT
|
2016-08-30 23:30:40 +02:00
|
|
|
};
|
|
|
|
|
2021-03-20 07:24:25 +01:00
|
|
|
struct LIBCUBESCRIPT_EXPORT cs_value {
|
2021-03-17 01:26:16 +01:00
|
|
|
cs_value() = delete;
|
2017-02-13 18:10:40 +01:00
|
|
|
~cs_value();
|
2016-09-06 22:23:03 +02:00
|
|
|
|
2021-03-17 01:26:16 +01:00
|
|
|
cs_value(cs_state &);
|
|
|
|
cs_value(cs_shared_state &);
|
|
|
|
|
2017-02-13 18:10:40 +01:00
|
|
|
cs_value(cs_value const &);
|
2021-03-20 04:49:47 +01:00
|
|
|
cs_value(cs_value &&v);
|
2016-09-06 22:23:03 +02:00
|
|
|
|
2021-03-17 01:26:16 +01:00
|
|
|
cs_value &operator=(cs_value const &);
|
2021-03-20 04:49:47 +01:00
|
|
|
cs_value &operator=(cs_value &&);
|
2016-09-06 22:23:03 +02:00
|
|
|
|
2017-02-13 18:10:40 +01:00
|
|
|
cs_value_type get_type() const;
|
2016-08-25 22:24:23 +02:00
|
|
|
|
2017-02-13 18:10:40 +01:00
|
|
|
void set_int(cs_int val);
|
|
|
|
void set_float(cs_float val);
|
2021-03-20 02:26:37 +01:00
|
|
|
void set_str(std::string_view val);
|
2021-03-17 21:46:37 +01:00
|
|
|
void set_str(cs_strref const &val);
|
2021-03-18 20:55:14 +01:00
|
|
|
void set_none();
|
2017-02-13 18:10:40 +01:00
|
|
|
void set_code(cs_bcode *val);
|
|
|
|
void set_ident(cs_ident *val);
|
2016-08-25 22:24:23 +02:00
|
|
|
|
2021-03-17 21:46:37 +01:00
|
|
|
cs_strref get_str() const;
|
2017-02-13 18:10:40 +01:00
|
|
|
cs_int get_int() const;
|
|
|
|
cs_float get_float() const;
|
|
|
|
cs_bcode *get_code() const;
|
|
|
|
cs_ident *get_ident() const;
|
|
|
|
void get_val(cs_value &r) const;
|
2015-08-05 23:58:45 +02:00
|
|
|
|
2016-08-02 02:21:36 +02:00
|
|
|
bool get_bool() const;
|
|
|
|
|
2021-03-18 20:55:14 +01:00
|
|
|
void force_none();
|
2017-02-13 18:10:40 +01:00
|
|
|
cs_float force_float();
|
|
|
|
cs_int force_int();
|
2021-03-20 02:26:37 +01:00
|
|
|
std::string_view force_str();
|
2015-08-05 23:58:45 +02:00
|
|
|
|
2016-08-06 18:33:01 +02:00
|
|
|
bool code_is_empty() const;
|
|
|
|
|
2015-08-13 22:48:03 +02:00
|
|
|
private:
|
2021-03-17 01:26:16 +01:00
|
|
|
template<typename T>
|
|
|
|
struct stor_t {
|
|
|
|
cs_shared_state *state;
|
|
|
|
T val;
|
|
|
|
};
|
|
|
|
|
|
|
|
cs_shared_state *state() const {
|
|
|
|
return reinterpret_cast<stor_t<void *> const *>(&p_stor)->state;
|
|
|
|
}
|
|
|
|
|
|
|
|
std::aligned_union_t<1,
|
|
|
|
stor_t<cs_int>,
|
|
|
|
stor_t<cs_float>,
|
|
|
|
stor_t<void *>,
|
|
|
|
cs_strref
|
|
|
|
> p_stor;
|
2017-02-13 18:10:40 +01:00
|
|
|
cs_value_type p_type;
|
2015-08-05 23:58:45 +02:00
|
|
|
};
|
|
|
|
|
2017-02-13 18:10:40 +01:00
|
|
|
struct cs_ident_stack {
|
|
|
|
cs_value val_s;
|
|
|
|
cs_ident_stack *next;
|
2021-03-17 01:26:16 +01:00
|
|
|
|
|
|
|
cs_ident_stack(cs_state &cs): val_s{cs}, next{nullptr} {}
|
2015-08-05 23:58:45 +02:00
|
|
|
};
|
|
|
|
|
2017-02-13 18:10:40 +01:00
|
|
|
struct cs_error;
|
|
|
|
struct cs_gen_state;
|
2015-08-05 23:58:45 +02:00
|
|
|
|
2017-02-13 18:10:40 +01:00
|
|
|
enum class cs_ident_type {
|
2021-03-18 20:55:14 +01:00
|
|
|
IVAR = 0, FVAR, SVAR, COMMAND, ALIAS, SPECIAL
|
2016-08-10 19:33:43 +02:00
|
|
|
};
|
|
|
|
|
2017-02-13 18:10:40 +01:00
|
|
|
struct cs_var;
|
|
|
|
struct cs_ivar;
|
|
|
|
struct cs_fvar;
|
|
|
|
struct cs_svar;
|
|
|
|
struct cs_alias;
|
|
|
|
struct cs_command;
|
2016-08-18 00:54:57 +02:00
|
|
|
|
2021-03-20 07:24:25 +01:00
|
|
|
struct LIBCUBESCRIPT_EXPORT cs_ident {
|
2021-03-21 02:41:04 +01:00
|
|
|
int get_raw_type() const;
|
2017-02-13 18:10:40 +01:00
|
|
|
cs_ident_type get_type() const;
|
2021-03-20 02:26:37 +01:00
|
|
|
std::string_view get_name() const;
|
2016-08-18 03:53:51 +02:00
|
|
|
int get_flags() const;
|
|
|
|
int get_index() const;
|
2016-08-10 19:33:43 +02:00
|
|
|
|
2016-08-18 00:54:57 +02:00
|
|
|
bool is_alias() const;
|
2017-02-13 18:10:40 +01:00
|
|
|
cs_alias *get_alias();
|
|
|
|
cs_alias const *get_alias() const;
|
2016-08-10 19:33:43 +02:00
|
|
|
|
2016-08-18 00:54:57 +02:00
|
|
|
bool is_command() const;
|
2017-02-13 18:10:40 +01:00
|
|
|
cs_command *get_command();
|
|
|
|
cs_command const *get_command() const;
|
2016-09-02 18:20:53 +02:00
|
|
|
|
2016-08-18 03:53:51 +02:00
|
|
|
bool is_special() const;
|
2016-08-10 19:33:43 +02:00
|
|
|
|
2016-08-18 00:54:57 +02:00
|
|
|
bool is_var() const;
|
2017-02-13 18:10:40 +01:00
|
|
|
cs_var *get_var();
|
|
|
|
cs_var const *get_var() const;
|
2016-08-10 19:33:43 +02:00
|
|
|
|
2016-08-18 00:54:57 +02:00
|
|
|
bool is_ivar() const;
|
2017-02-13 18:10:40 +01:00
|
|
|
cs_ivar *get_ivar();
|
|
|
|
cs_ivar const *get_ivar() const;
|
2016-08-10 19:33:43 +02:00
|
|
|
|
2016-08-18 00:54:57 +02:00
|
|
|
bool is_fvar() const;
|
2017-02-13 18:10:40 +01:00
|
|
|
cs_fvar *get_fvar();
|
|
|
|
cs_fvar const *get_fvar() const;
|
2016-08-10 19:33:43 +02:00
|
|
|
|
2016-08-18 00:54:57 +02:00
|
|
|
bool is_svar() const;
|
2017-02-13 18:10:40 +01:00
|
|
|
cs_svar *get_svar();
|
|
|
|
cs_svar const *get_svar() const;
|
2016-08-17 23:04:43 +02:00
|
|
|
|
|
|
|
protected:
|
2021-03-21 02:41:04 +01:00
|
|
|
cs_ident() = default;
|
2016-08-18 03:53:51 +02:00
|
|
|
|
|
|
|
private:
|
2021-03-21 02:41:04 +01:00
|
|
|
friend struct cs_state;
|
|
|
|
|
|
|
|
cs_ident_impl *p_impl{};
|
2016-08-17 23:04:43 +02:00
|
|
|
};
|
|
|
|
|
2021-03-20 07:24:25 +01:00
|
|
|
struct LIBCUBESCRIPT_EXPORT cs_var: cs_ident {
|
2016-08-18 04:14:55 +02:00
|
|
|
protected:
|
2021-03-21 02:41:04 +01:00
|
|
|
cs_var() = default;
|
2016-08-17 23:04:43 +02:00
|
|
|
};
|
|
|
|
|
2021-03-20 07:24:25 +01:00
|
|
|
struct LIBCUBESCRIPT_EXPORT cs_ivar: cs_var {
|
2017-02-13 18:10:40 +01:00
|
|
|
cs_int get_val_min() const;
|
|
|
|
cs_int get_val_max() const;
|
2016-08-18 04:14:55 +02:00
|
|
|
|
2017-02-13 18:10:40 +01:00
|
|
|
cs_int get_value() const;
|
|
|
|
void set_value(cs_int val);
|
2016-08-18 00:36:37 +02:00
|
|
|
|
2021-03-21 02:41:04 +01:00
|
|
|
protected:
|
|
|
|
cs_ivar() = default;
|
2016-08-17 23:04:43 +02:00
|
|
|
};
|
|
|
|
|
2021-03-20 07:24:25 +01:00
|
|
|
struct LIBCUBESCRIPT_EXPORT cs_fvar: cs_var {
|
2017-02-13 18:10:40 +01:00
|
|
|
cs_float get_val_min() const;
|
|
|
|
cs_float get_val_max() const;
|
2016-08-18 04:14:55 +02:00
|
|
|
|
2017-02-13 18:10:40 +01:00
|
|
|
cs_float get_value() const;
|
|
|
|
void set_value(cs_float val);
|
2016-08-18 00:36:37 +02:00
|
|
|
|
2021-03-21 02:41:04 +01:00
|
|
|
protected:
|
|
|
|
cs_fvar() = default;
|
2016-08-17 23:04:43 +02:00
|
|
|
};
|
|
|
|
|
2021-03-20 07:24:25 +01:00
|
|
|
struct LIBCUBESCRIPT_EXPORT cs_svar: cs_var {
|
2021-03-17 23:32:38 +01:00
|
|
|
cs_strref get_value() const;
|
|
|
|
void set_value(cs_strref val);
|
2016-08-18 00:36:37 +02:00
|
|
|
|
2021-03-21 02:41:04 +01:00
|
|
|
protected:
|
|
|
|
cs_svar() = default;
|
2016-08-17 23:04:43 +02:00
|
|
|
};
|
|
|
|
|
2021-03-20 07:24:25 +01:00
|
|
|
struct LIBCUBESCRIPT_EXPORT cs_alias: cs_ident {
|
2021-03-21 02:41:04 +01:00
|
|
|
cs_value get_value() const;
|
2017-02-13 18:10:40 +01:00
|
|
|
void get_cval(cs_value &v) const;
|
2021-03-21 02:41:04 +01:00
|
|
|
|
|
|
|
protected:
|
|
|
|
cs_alias() = default;
|
2016-08-17 23:04:43 +02:00
|
|
|
};
|
|
|
|
|
2017-02-13 18:10:40 +01:00
|
|
|
struct cs_command: cs_ident {
|
2021-03-20 02:26:37 +01:00
|
|
|
std::string_view get_args() const;
|
2016-09-02 22:49:05 +02:00
|
|
|
int get_num_args() const;
|
2016-09-02 18:20:53 +02:00
|
|
|
|
2021-03-21 02:41:04 +01:00
|
|
|
protected:
|
|
|
|
cs_command() = default;
|
2016-09-02 18:20:53 +02:00
|
|
|
};
|
|
|
|
|
2021-03-18 20:55:14 +01:00
|
|
|
struct cs_ident_link;
|
2015-08-06 22:43:36 +02:00
|
|
|
|
2016-08-18 20:47:29 +02:00
|
|
|
enum {
|
2021-03-18 20:55:14 +01:00
|
|
|
CS_LIB_MATH = 1 << 0,
|
|
|
|
CS_LIB_STRING = 1 << 1,
|
|
|
|
CS_LIB_LIST = 1 << 2,
|
|
|
|
CS_LIB_ALL = 0b111
|
2016-08-18 20:47:29 +02:00
|
|
|
};
|
|
|
|
|
2021-03-18 20:55:14 +01:00
|
|
|
enum class cs_loop_state {
|
|
|
|
NORMAL = 0, BREAK, CONTINUE
|
2016-09-14 23:24:13 +02:00
|
|
|
};
|
|
|
|
|
2021-03-20 07:24:25 +01:00
|
|
|
struct LIBCUBESCRIPT_EXPORT cs_state {
|
2017-02-13 18:10:40 +01:00
|
|
|
friend struct cs_error;
|
2021-03-16 00:44:25 +01:00
|
|
|
friend struct cs_strman;
|
2021-03-18 23:53:16 +01:00
|
|
|
friend struct cs_strref;
|
2021-03-17 01:26:16 +01:00
|
|
|
friend struct cs_value;
|
2017-02-13 18:10:40 +01:00
|
|
|
friend struct cs_gen_state;
|
2021-03-19 01:31:34 +01:00
|
|
|
friend inline cs_shared_state *cs_get_sstate(cs_state &);
|
2016-09-14 00:14:21 +02:00
|
|
|
|
2017-02-13 18:10:40 +01:00
|
|
|
cs_shared_state *p_state;
|
2021-03-18 20:55:14 +01:00
|
|
|
cs_ident_link *p_callstack = nullptr;
|
2015-08-06 22:43:36 +02:00
|
|
|
|
2015-08-05 23:58:45 +02:00
|
|
|
int identflags = 0;
|
|
|
|
|
2021-03-20 21:06:26 +01:00
|
|
|
cs_state();
|
|
|
|
cs_state(cs_alloc_cb func, void *data);
|
2017-02-13 18:10:40 +01:00
|
|
|
virtual ~cs_state();
|
2015-08-05 23:58:45 +02:00
|
|
|
|
2018-04-26 19:23:11 +02:00
|
|
|
cs_state(cs_state const &) = delete;
|
|
|
|
cs_state(cs_state &&s) {
|
|
|
|
swap(s);
|
|
|
|
}
|
|
|
|
|
|
|
|
cs_state &operator=(cs_state const &) = delete;
|
|
|
|
cs_state &operator=(cs_state &&s) {
|
|
|
|
swap(s);
|
|
|
|
s.destroy();
|
|
|
|
return *this;
|
|
|
|
}
|
|
|
|
|
|
|
|
void destroy();
|
|
|
|
|
|
|
|
void swap(cs_state &s) {
|
|
|
|
std::swap(p_state, s.p_state);
|
|
|
|
std::swap(p_callstack, s.p_callstack);
|
|
|
|
std::swap(identflags, s.identflags);
|
|
|
|
std::swap(p_pstate, s.p_pstate);
|
|
|
|
std::swap(p_inloop, s.p_inloop);
|
|
|
|
std::swap(p_owner, s.p_owner);
|
|
|
|
std::swap(p_callhook, s.p_callhook);
|
|
|
|
}
|
|
|
|
|
|
|
|
cs_state new_thread();
|
|
|
|
|
2021-03-22 00:58:35 +01:00
|
|
|
template<typename F>
|
|
|
|
cs_hook_cb set_call_hook(F &&f) {
|
|
|
|
return std::move(set_call_hook(
|
|
|
|
cs_hook_cb{std::forward<F>(f), callable_alloc, this}
|
|
|
|
));
|
|
|
|
}
|
2017-02-13 18:10:40 +01:00
|
|
|
cs_hook_cb const &get_call_hook() const;
|
|
|
|
cs_hook_cb &get_call_hook();
|
2016-09-05 21:34:48 +02:00
|
|
|
|
2021-03-22 00:58:35 +01:00
|
|
|
template<typename F>
|
|
|
|
cs_vprint_cb set_var_printer(F &&f) {
|
|
|
|
return std::move(set_var_printer(
|
|
|
|
cs_vprint_cb{std::forward<F>(f), callable_alloc, this}
|
|
|
|
));
|
|
|
|
}
|
2021-03-18 00:03:30 +01:00
|
|
|
cs_vprint_cb const &get_var_printer() const;
|
|
|
|
|
2021-03-18 20:55:14 +01:00
|
|
|
void init_libs(int libs = CS_LIB_ALL);
|
2016-09-13 23:46:51 +02:00
|
|
|
|
2017-02-13 18:10:40 +01:00
|
|
|
void clear_override(cs_ident &id);
|
2015-08-05 23:58:45 +02:00
|
|
|
void clear_overrides();
|
|
|
|
|
2021-03-20 02:26:37 +01:00
|
|
|
cs_ident *new_ident(std::string_view name, int flags = CS_IDF_UNKNOWN);
|
2017-02-13 18:10:40 +01:00
|
|
|
cs_ident *force_ident(cs_value &v);
|
2015-08-05 23:58:45 +02:00
|
|
|
|
2021-03-22 00:58:35 +01:00
|
|
|
template<typename F>
|
2017-02-13 18:10:40 +01:00
|
|
|
cs_ivar *new_ivar(
|
2021-03-22 00:58:35 +01:00
|
|
|
std::string_view name, cs_int m, cs_int x, cs_int v,
|
|
|
|
F &&f, int flags = 0
|
|
|
|
) {
|
|
|
|
return new_ivar(
|
|
|
|
name, m, x, v,
|
|
|
|
cs_var_cb{std::forward<F>(f), callable_alloc, this}, flags
|
|
|
|
);
|
|
|
|
}
|
|
|
|
cs_ivar *new_ivar(std::string_view name, cs_int m, cs_int x, cs_int v) {
|
|
|
|
return new_ivar(name, m, x, v, cs_var_cb{}, 0);
|
|
|
|
}
|
|
|
|
|
|
|
|
template<typename F>
|
2017-02-13 18:10:40 +01:00
|
|
|
cs_fvar *new_fvar(
|
2021-03-22 00:58:35 +01:00
|
|
|
std::string_view name, cs_float m, cs_float x, cs_float v,
|
|
|
|
F &&f, int flags = 0
|
|
|
|
) {
|
|
|
|
return new_fvar(
|
|
|
|
name, m, x, v,
|
|
|
|
cs_var_cb{std::forward<F>(f), callable_alloc, this}, flags
|
|
|
|
);
|
|
|
|
}
|
|
|
|
cs_fvar *new_fvar(
|
|
|
|
std::string_view name, cs_float m, cs_float x, cs_float v
|
|
|
|
) {
|
|
|
|
return new_fvar(name, m, x, v, cs_var_cb{}, 0);
|
|
|
|
}
|
|
|
|
|
|
|
|
template<typename F>
|
2017-02-13 18:10:40 +01:00
|
|
|
cs_svar *new_svar(
|
2021-03-22 00:58:35 +01:00
|
|
|
std::string_view name, std::string_view v, F &&f, int flags = 0
|
|
|
|
) {
|
|
|
|
return new_svar(
|
|
|
|
name, v,
|
|
|
|
cs_var_cb{std::forward<F>(f), callable_alloc, this}, flags
|
|
|
|
);
|
|
|
|
}
|
|
|
|
cs_svar *new_svar(std::string_view name, std::string_view v) {
|
|
|
|
return new_svar(name, v, cs_var_cb{}, 0);
|
|
|
|
}
|
2016-08-20 17:52:54 +02:00
|
|
|
|
2021-03-22 00:58:35 +01:00
|
|
|
template<typename F>
|
2017-02-13 18:10:40 +01:00
|
|
|
cs_command *new_command(
|
2021-03-22 00:58:35 +01:00
|
|
|
std::string_view name, std::string_view args, F &&f
|
|
|
|
) {
|
|
|
|
return new_command(
|
|
|
|
name, args,
|
|
|
|
cs_command_cb{std::forward<F>(f), callable_alloc, this}
|
|
|
|
);
|
|
|
|
}
|
2016-09-02 19:03:01 +02:00
|
|
|
|
2021-03-20 02:26:37 +01:00
|
|
|
cs_ident *get_ident(std::string_view name);
|
|
|
|
cs_alias *get_alias(std::string_view name);
|
|
|
|
bool have_ident(std::string_view name);
|
2015-08-05 23:58:45 +02:00
|
|
|
|
2021-03-20 05:41:25 +01:00
|
|
|
std::span<cs_ident *> get_idents();
|
|
|
|
std::span<cs_ident const *> get_idents() const;
|
2015-08-05 23:58:45 +02:00
|
|
|
|
2021-03-20 02:26:37 +01:00
|
|
|
void reset_var(std::string_view name);
|
|
|
|
void touch_var(std::string_view name);
|
2015-08-05 23:58:45 +02:00
|
|
|
|
2017-02-13 18:10:40 +01:00
|
|
|
void run(cs_bcode *code, cs_value &ret);
|
2021-03-20 02:26:37 +01:00
|
|
|
void run(std::string_view code, cs_value &ret);
|
2021-03-20 05:09:49 +01:00
|
|
|
void run(std::string_view code, cs_value &ret, std::string_view source);
|
2021-03-20 05:41:25 +01:00
|
|
|
void run(cs_ident *id, std::span<cs_value> args, cs_value &ret);
|
2015-08-07 22:04:31 +02:00
|
|
|
|
2021-03-20 05:09:49 +01:00
|
|
|
cs_value run(cs_bcode *code);
|
|
|
|
cs_value run(std::string_view code);
|
|
|
|
cs_value run(std::string_view code, std::string_view source);
|
2021-03-20 05:41:25 +01:00
|
|
|
cs_value run(cs_ident *id, std::span<cs_value> args);
|
2016-08-18 20:34:24 +02:00
|
|
|
|
2021-03-18 20:55:14 +01:00
|
|
|
cs_loop_state run_loop(cs_bcode *code, cs_value &ret);
|
|
|
|
cs_loop_state run_loop(cs_bcode *code);
|
2016-09-14 23:24:13 +02:00
|
|
|
|
|
|
|
bool is_in_loop() const {
|
|
|
|
return p_inloop;
|
|
|
|
}
|
|
|
|
|
2021-03-20 02:26:37 +01:00
|
|
|
void set_alias(std::string_view name, cs_value v);
|
2015-08-07 03:11:53 +02:00
|
|
|
|
2016-08-07 22:39:27 +02:00
|
|
|
void set_var_int(
|
2021-03-20 02:26:37 +01:00
|
|
|
std::string_view name, cs_int v,
|
2016-08-07 22:39:27 +02:00
|
|
|
bool dofunc = true, bool doclamp = true
|
|
|
|
);
|
|
|
|
void set_var_float(
|
2021-03-20 02:26:37 +01:00
|
|
|
std::string_view name, cs_float v,
|
2016-08-07 22:39:27 +02:00
|
|
|
bool dofunc = true, bool doclamp = true
|
|
|
|
);
|
|
|
|
void set_var_str(
|
2021-03-20 02:26:37 +01:00
|
|
|
std::string_view name, std::string_view v, bool dofunc = true
|
2016-08-07 22:39:27 +02:00
|
|
|
);
|
2015-08-07 03:11:53 +02:00
|
|
|
|
2017-02-13 18:10:40 +01:00
|
|
|
void set_var_int_checked(cs_ivar *iv, cs_int v);
|
2021-03-20 05:41:25 +01:00
|
|
|
void set_var_int_checked(cs_ivar *iv, std::span<cs_value> args);
|
2017-02-13 18:10:40 +01:00
|
|
|
void set_var_float_checked(cs_fvar *fv, cs_float v);
|
2021-03-20 02:26:37 +01:00
|
|
|
void set_var_str_checked(cs_svar *fv, std::string_view v);
|
2015-08-07 03:44:51 +02:00
|
|
|
|
2021-03-20 02:26:37 +01:00
|
|
|
std::optional<cs_int> get_var_int(std::string_view name);
|
|
|
|
std::optional<cs_float> get_var_float(std::string_view name);
|
|
|
|
std::optional<cs_strref> get_var_str(std::string_view name);
|
2015-08-07 03:11:53 +02:00
|
|
|
|
2021-03-20 02:26:37 +01:00
|
|
|
std::optional<cs_int> get_var_min_int(std::string_view name);
|
|
|
|
std::optional<cs_int> get_var_max_int(std::string_view name);
|
2015-08-07 03:11:53 +02:00
|
|
|
|
2021-03-20 02:26:37 +01:00
|
|
|
std::optional<cs_float> get_var_min_float(std::string_view name);
|
|
|
|
std::optional<cs_float> get_var_max_float(std::string_view name);
|
2015-08-07 03:11:53 +02:00
|
|
|
|
2021-03-20 02:26:37 +01:00
|
|
|
std::optional<cs_strref> get_alias_val(std::string_view name);
|
2015-08-07 22:38:57 +02:00
|
|
|
|
2021-03-18 00:03:30 +01:00
|
|
|
void print_var(cs_var const &v) const;
|
2016-08-21 02:34:03 +02:00
|
|
|
|
|
|
|
private:
|
2021-03-22 00:58:35 +01:00
|
|
|
cs_hook_cb set_call_hook(cs_hook_cb func);
|
|
|
|
cs_vprint_cb set_var_printer(cs_vprint_cb func);
|
|
|
|
|
|
|
|
cs_ivar *new_ivar(
|
|
|
|
std::string_view n, cs_int m, cs_int x, cs_int v,
|
|
|
|
cs_var_cb f, int flags
|
|
|
|
);
|
|
|
|
cs_fvar *new_fvar(
|
|
|
|
std::string_view n, cs_float m, cs_float x, cs_float v,
|
|
|
|
cs_var_cb f, int flags
|
|
|
|
);
|
|
|
|
cs_svar *new_svar(
|
|
|
|
std::string_view n, std::string_view v, cs_var_cb f, int flags
|
|
|
|
);
|
|
|
|
|
|
|
|
cs_command *new_command(
|
|
|
|
std::string_view name, std::string_view args, cs_command_cb func
|
|
|
|
);
|
|
|
|
|
|
|
|
static void *callable_alloc(
|
|
|
|
void *data, void *p, std::size_t os, std::size_t ns
|
|
|
|
) {
|
|
|
|
return static_cast<cs_state *>(data)->alloc(p, os, ns);
|
|
|
|
}
|
|
|
|
|
2021-03-20 07:24:25 +01:00
|
|
|
LIBCUBESCRIPT_LOCAL cs_state(cs_shared_state *s);
|
2018-04-26 19:23:11 +02:00
|
|
|
|
2021-03-21 02:41:04 +01:00
|
|
|
cs_ident *add_ident(cs_ident *id, cs_ident_impl *impl);
|
2016-09-02 20:22:19 +02:00
|
|
|
|
2021-03-22 00:58:35 +01:00
|
|
|
void *alloc(void *ptr, size_t olds, size_t news);
|
2016-10-03 19:23:15 +02:00
|
|
|
|
2017-02-13 18:10:40 +01:00
|
|
|
cs_gen_state *p_pstate = nullptr;
|
2021-03-20 21:06:26 +01:00
|
|
|
void *p_errbuf = nullptr;
|
2016-09-14 23:24:13 +02:00
|
|
|
int p_inloop = 0;
|
2018-04-26 19:23:11 +02:00
|
|
|
bool p_owner = false;
|
2016-09-14 23:24:13 +02:00
|
|
|
|
2017-02-13 18:10:40 +01:00
|
|
|
cs_hook_cb p_callhook;
|
2015-08-05 23:58:45 +02:00
|
|
|
};
|
|
|
|
|
2017-02-13 18:10:40 +01:00
|
|
|
struct cs_stack_state_node {
|
|
|
|
cs_stack_state_node const *next;
|
|
|
|
cs_ident const *id;
|
2016-09-14 21:46:47 +02:00
|
|
|
int index;
|
|
|
|
};
|
|
|
|
|
2017-02-13 18:10:40 +01:00
|
|
|
struct cs_stack_state {
|
|
|
|
cs_stack_state() = delete;
|
|
|
|
cs_stack_state(cs_state &cs, cs_stack_state_node *nd = nullptr, bool gap = false);
|
|
|
|
cs_stack_state(cs_stack_state const &) = delete;
|
|
|
|
cs_stack_state(cs_stack_state &&st);
|
|
|
|
~cs_stack_state();
|
2016-09-14 00:14:21 +02:00
|
|
|
|
2017-02-13 18:10:40 +01:00
|
|
|
cs_stack_state &operator=(cs_stack_state const &) = delete;
|
|
|
|
cs_stack_state &operator=(cs_stack_state &&);
|
2016-09-14 00:14:21 +02:00
|
|
|
|
2017-02-13 18:10:40 +01:00
|
|
|
cs_stack_state_node const *get() const;
|
2016-09-14 00:14:21 +02:00
|
|
|
bool gap() const;
|
|
|
|
|
|
|
|
private:
|
2017-02-13 18:10:40 +01:00
|
|
|
cs_state &p_state;
|
|
|
|
cs_stack_state_node *p_node;
|
2016-09-14 00:14:21 +02:00
|
|
|
bool p_gap;
|
|
|
|
};
|
|
|
|
|
2021-03-20 19:54:46 +01:00
|
|
|
struct LIBCUBESCRIPT_EXPORT cs_error {
|
2017-02-13 18:10:40 +01:00
|
|
|
friend struct cs_state;
|
2016-09-14 00:14:21 +02:00
|
|
|
|
2017-02-13 18:10:40 +01:00
|
|
|
cs_error() = delete;
|
|
|
|
cs_error(cs_error const &) = delete;
|
|
|
|
cs_error(cs_error &&v):
|
2017-01-25 01:57:33 +01:00
|
|
|
p_errmsg(v.p_errmsg), p_stack(std::move(v.p_stack))
|
2016-09-14 00:14:21 +02:00
|
|
|
{}
|
|
|
|
|
2021-03-20 02:26:37 +01:00
|
|
|
std::string_view what() const {
|
2016-09-14 00:14:21 +02:00
|
|
|
return p_errmsg;
|
|
|
|
}
|
|
|
|
|
2017-02-13 18:10:40 +01:00
|
|
|
cs_stack_state &get_stack() {
|
2016-09-14 00:14:21 +02:00
|
|
|
return p_stack;
|
|
|
|
}
|
|
|
|
|
2017-02-13 18:10:40 +01:00
|
|
|
cs_stack_state const &get_stack() const {
|
2016-09-14 00:14:21 +02:00
|
|
|
return p_stack;
|
|
|
|
}
|
|
|
|
|
2021-03-20 02:26:37 +01:00
|
|
|
cs_error(cs_state &cs, std::string_view msg):
|
2016-09-14 21:46:47 +02:00
|
|
|
p_errmsg(), p_stack(cs)
|
2016-09-14 00:14:21 +02:00
|
|
|
{
|
2021-03-20 21:06:26 +01:00
|
|
|
char *sp;
|
|
|
|
char *buf = request_buf(cs, msg.size(), sp);
|
|
|
|
std::memcpy(buf, msg.data(), msg.size());
|
|
|
|
buf[msg.size()] = '\0';
|
|
|
|
p_errmsg = std::string_view{sp, buf + msg.size()};
|
2016-09-14 00:14:21 +02:00
|
|
|
p_stack = save_stack(cs);
|
|
|
|
}
|
|
|
|
|
|
|
|
template<typename ...A>
|
2021-03-20 08:22:15 +01:00
|
|
|
cs_error(cs_state &cs, std::string_view msg, A const &...args):
|
2016-09-14 21:46:47 +02:00
|
|
|
p_errmsg(), p_stack(cs)
|
2016-09-14 00:14:21 +02:00
|
|
|
{
|
2021-03-20 21:06:26 +01:00
|
|
|
std::size_t sz = msg.size() + 64;
|
|
|
|
char *buf, *sp;
|
|
|
|
for (;;) {
|
|
|
|
buf = request_buf(cs, sz, sp);
|
|
|
|
int written = std::snprintf(buf, sz, msg.data(), args...);
|
|
|
|
if (written <= 0) {
|
|
|
|
throw cs_internal_error{"format error"};
|
|
|
|
} else if (std::size_t(written) <= sz) {
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
sz = std::size_t(written);
|
2016-09-14 00:14:21 +02:00
|
|
|
}
|
2021-03-20 21:06:26 +01:00
|
|
|
p_errmsg = std::string_view{sp, buf + sz};
|
2016-09-14 00:14:21 +02:00
|
|
|
p_stack = save_stack(cs);
|
|
|
|
}
|
|
|
|
|
|
|
|
private:
|
2017-02-13 18:10:40 +01:00
|
|
|
cs_stack_state save_stack(cs_state &cs);
|
2021-03-20 21:06:26 +01:00
|
|
|
char *request_buf(cs_state &cs, std::size_t bufs, char *&sp);
|
2016-09-14 00:14:21 +02:00
|
|
|
|
2021-03-20 02:26:37 +01:00
|
|
|
std::string_view p_errmsg;
|
2017-02-13 18:10:40 +01:00
|
|
|
cs_stack_state p_stack;
|
2016-09-14 00:14:21 +02:00
|
|
|
};
|
|
|
|
|
2021-03-20 07:24:25 +01:00
|
|
|
struct LIBCUBESCRIPT_EXPORT cs_stacked_value: cs_value {
|
2021-03-17 01:26:16 +01:00
|
|
|
cs_stacked_value(cs_state &cs, cs_ident *id = nullptr);
|
2017-02-13 18:10:40 +01:00
|
|
|
~cs_stacked_value();
|
2015-08-13 20:48:58 +02:00
|
|
|
|
2017-02-13 18:10:40 +01:00
|
|
|
cs_stacked_value(cs_stacked_value const &) = delete;
|
|
|
|
cs_stacked_value(cs_stacked_value &&) = delete;
|
2016-09-06 22:23:03 +02:00
|
|
|
|
2017-02-13 18:10:40 +01:00
|
|
|
cs_stacked_value &operator=(cs_stacked_value const &) = delete;
|
|
|
|
cs_stacked_value &operator=(cs_stacked_value &&v) = delete;
|
2016-09-06 22:23:03 +02:00
|
|
|
|
2017-02-13 18:10:40 +01:00
|
|
|
cs_stacked_value &operator=(cs_value const &v);
|
|
|
|
cs_stacked_value &operator=(cs_value &&v);
|
2016-09-06 22:23:03 +02:00
|
|
|
|
2017-02-13 18:10:40 +01:00
|
|
|
bool set_alias(cs_ident *id);
|
|
|
|
cs_alias *get_alias() const;
|
2016-09-02 22:42:10 +02:00
|
|
|
bool has_alias() const;
|
2015-08-13 20:48:58 +02:00
|
|
|
|
2016-09-02 22:42:10 +02:00
|
|
|
bool push();
|
|
|
|
bool pop();
|
2015-08-14 00:18:48 +02:00
|
|
|
|
|
|
|
private:
|
2017-02-13 18:10:40 +01:00
|
|
|
cs_alias *p_a;
|
|
|
|
cs_ident_stack p_stack;
|
2015-08-14 00:18:48 +02:00
|
|
|
bool p_pushed;
|
2015-08-13 20:48:58 +02:00
|
|
|
};
|
|
|
|
|
2021-03-20 19:34:26 +01:00
|
|
|
struct LIBCUBESCRIPT_EXPORT cs_list_parser {
|
|
|
|
cs_list_parser(cs_state &cs, std::string_view s = std::string_view{}):
|
|
|
|
p_state{&cs}, p_input_beg{s.data()}, p_input_end{s.data() + s.size()}
|
2021-03-20 02:26:37 +01:00
|
|
|
{}
|
2021-03-18 23:53:16 +01:00
|
|
|
|
2021-03-20 02:26:37 +01:00
|
|
|
void set_input(std::string_view s) {
|
2021-03-20 19:34:26 +01:00
|
|
|
p_input_beg = s.data();
|
|
|
|
p_input_end = s.data() + s.size();
|
2021-03-20 02:26:37 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
std::string_view get_input() const {
|
2021-03-20 19:34:26 +01:00
|
|
|
return std::string_view{p_input_beg, p_input_end};
|
2021-03-20 02:26:37 +01:00
|
|
|
}
|
|
|
|
|
2021-03-20 19:34:26 +01:00
|
|
|
bool parse();
|
|
|
|
std::size_t count();
|
|
|
|
|
|
|
|
cs_strref get_item() const;
|
|
|
|
|
|
|
|
std::string_view get_raw_item() const { return p_item; }
|
|
|
|
std::string_view get_quoted_item() const { return p_quoted_item; }
|
|
|
|
|
|
|
|
void skip_until_item();
|
2021-03-18 23:53:16 +01:00
|
|
|
|
2021-03-20 19:34:26 +01:00
|
|
|
private:
|
|
|
|
cs_state *p_state;
|
|
|
|
char const *p_input_beg, *p_input_end;
|
|
|
|
|
|
|
|
std::string_view p_item{};
|
|
|
|
std::string_view p_quoted_item{};
|
|
|
|
};
|
2021-03-18 23:53:16 +01:00
|
|
|
|
2021-03-23 02:02:43 +01:00
|
|
|
|
|
|
|
LIBCUBESCRIPT_EXPORT char const *cs_parse_string(
|
|
|
|
cs_state &cs, std::string_view str, size_t &nlines
|
|
|
|
);
|
|
|
|
|
|
|
|
inline char const *cs_parse_string(
|
|
|
|
cs_state &cs, std::string_view str
|
|
|
|
) {
|
|
|
|
size_t nlines;
|
|
|
|
return cs_parse_string(cs, str, nlines);
|
|
|
|
}
|
|
|
|
|
|
|
|
LIBCUBESCRIPT_EXPORT char const *cs_parse_word(
|
|
|
|
cs_state &cs, std::string_view str
|
|
|
|
);
|
|
|
|
|
|
|
|
LIBCUBESCRIPT_EXPORT cs_strref cs_concat_values(
|
2021-03-20 05:41:25 +01:00
|
|
|
cs_state &cs, std::span<cs_value> vals,
|
|
|
|
std::string_view sep = std::string_view{}
|
2021-03-19 00:30:54 +01:00
|
|
|
);
|
|
|
|
|
2021-03-23 02:02:43 +01:00
|
|
|
template<typename R>
|
|
|
|
inline R cs_escape_string(R writer, std::string_view str) {
|
|
|
|
*writer++ = '"';
|
|
|
|
for (auto c: str) {
|
|
|
|
switch (c) {
|
|
|
|
case '\n': *writer++ = '^'; *writer++ = 'n'; break;
|
|
|
|
case '\t': *writer++ = '^'; *writer++ = 't'; break;
|
|
|
|
case '\f': *writer++ = '^'; *writer++ = 'f'; break;
|
|
|
|
case '"': *writer++ = '^'; *writer++ = '"'; break;
|
|
|
|
case '^': *writer++ = '^'; *writer++ = '^'; break;
|
|
|
|
default: *writer++ = c; break;
|
2015-08-08 17:06:18 +02:00
|
|
|
}
|
|
|
|
}
|
2021-03-23 02:02:43 +01:00
|
|
|
*writer++ = '"';
|
|
|
|
return writer;
|
|
|
|
}
|
2015-08-08 18:07:01 +02:00
|
|
|
|
2021-03-23 02:02:43 +01:00
|
|
|
template<typename R>
|
|
|
|
inline R cs_unescape_string(R writer, std::string_view str) {
|
|
|
|
for (auto it = str.begin(); it != str.end(); ++it) {
|
|
|
|
if (*it == '^') {
|
|
|
|
++it;
|
|
|
|
if (it == str.end()) {
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
switch (*it) {
|
|
|
|
case 'n': *writer++ = '\n'; break;
|
|
|
|
case 't': *writer++ = '\r'; break;
|
|
|
|
case 'f': *writer++ = '\f'; break;
|
|
|
|
case '"': *writer++ = '"'; break;
|
|
|
|
case '^': *writer++ = '^'; break;
|
|
|
|
default: *writer++ = *it; break;
|
|
|
|
}
|
|
|
|
} else if (*it == '\\') {
|
|
|
|
++it;
|
|
|
|
if (it == str.end()) {
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
char c = *it;
|
|
|
|
if ((c == '\r') || (c == '\n')) {
|
|
|
|
if ((c == '\r') && ((it + 1) != str.end())) {
|
|
|
|
if (it[1] == '\n') {
|
|
|
|
++it;
|
2016-09-24 03:31:41 +02:00
|
|
|
}
|
|
|
|
}
|
2021-03-23 02:02:43 +01:00
|
|
|
continue;
|
2015-08-11 03:18:53 +02:00
|
|
|
}
|
2021-03-23 02:02:43 +01:00
|
|
|
*writer++ = '\\';
|
|
|
|
} else {
|
|
|
|
*writer++ = *it;
|
2015-08-11 03:18:53 +02:00
|
|
|
}
|
|
|
|
}
|
2021-03-23 02:02:43 +01:00
|
|
|
return writer;
|
|
|
|
}
|
|
|
|
|
|
|
|
template<typename R>
|
|
|
|
inline R cs_print_stack(R writer, cs_stack_state const &st) {
|
|
|
|
char buf[32] = {0};
|
|
|
|
auto nd = st.get();
|
|
|
|
while (nd) {
|
|
|
|
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++ = '\n';
|
2016-09-09 19:19:50 +02:00
|
|
|
}
|
|
|
|
}
|
2021-03-23 02:02:43 +01:00
|
|
|
return writer;
|
|
|
|
}
|
2015-08-08 17:13:46 +02:00
|
|
|
|
2015-09-10 19:53:43 +02:00
|
|
|
} /* namespace cscript */
|
|
|
|
|
2016-08-14 18:35:38 +02:00
|
|
|
#endif /* LIBCUBESCRIPT_CUBESCRIPT_HH */
|