An embeddable, thread-safe implementation of the cubescript language
You can not select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
 
 
 

476 lines
12 KiB

#include <cubescript/cubescript.hh>
#include "cs_std.hh"
#include "cs_parser.hh"
#include "cs_state.hh"
#include "cs_strman.hh"
#include <cmath>
#include <cstdlib>
#include <iterator>
namespace cubescript {
static std::string_view intstr(integer_type v, charbuf &buf) {
buf.reserve(32);
int n = snprintf(buf.data(), 32, INTEGER_FORMAT, v);
if (n > 32) {
buf.reserve(n + 1);
int nn = snprintf(buf.data(), n + 1, INTEGER_FORMAT, v);
if ((nn > n) || (nn <= 0)) {
n = -1;
} else {
n = nn;
}
}
if (n <= 0) {
abort(); /* unreachable, provided a well-formed format string */
}
return std::string_view{buf.data(), std::size_t(n)};
}
static std::string_view floatstr(float_type v, charbuf &buf) {
buf.reserve(32);
int n;
if (v == std::floor(v)) {
n = snprintf(buf.data(), 32, ROUND_FLOAT_FORMAT, v);
} else {
n = snprintf(buf.data(), 32, FLOAT_FORMAT, v);
}
if (n > 32) {
buf.reserve(n + 1);
int nn;
if (v == std::floor(v)) {
nn = snprintf(buf.data(), n + 1, ROUND_FLOAT_FORMAT, v);
} else {
nn = snprintf(buf.data(), n + 1, FLOAT_FORMAT, v);
}
if ((nn > n) || (nn <= 0)) {
n = -1;
} else {
n = nn;
}
}
if (n <= 0) {
abort(); /* unreachable, provided a well-formed format string */
}
return std::string_view{buf.data(), std::size_t(n)};
}
template<typename T, typename U>
static inline T &csv_get(U *stor) {
/* ugly, but internal and unlikely to cause bugs */
return const_cast<T &>(*std::launder(
reinterpret_cast<T const *>(stor)
));
}
template<typename T>
static inline void csv_cleanup(value_type tv, T *stor) {
switch (tv) {
case value_type::STRING:
str_managed_unref(csv_get<char const *>(stor));
break;
case value_type::CODE: {
bcode_unref(csv_get<uint32_t *>(stor));
break;
}
default:
break;
}
}
any_value::any_value():
p_stor{}, p_type{value_type::NONE}
{}
any_value::any_value(integer_type val):
p_stor{}, p_type{value_type::INTEGER}
{
csv_get<integer_type>(&p_stor) = val;
}
any_value::any_value(float_type val):
p_stor{}, p_type{value_type::FLOAT}
{
csv_get<float_type>(&p_stor) = val;
}
any_value::any_value(std::string_view val, state &cs):
p_stor{}, p_type{value_type::STRING}
{
csv_get<char const *>(&p_stor) = state_p{cs}.ts().istate->strman->add(val);
}
any_value::any_value(string_ref const &val):
p_stor{}, p_type{value_type::STRING}
{
csv_get<char const *>(&p_stor) = str_managed_ref(val.p_str);
}
any_value::any_value(bcode_ref const &val):
p_stor{}, p_type{value_type::CODE}
{
bcode *p = bcode_p{val}.get();
bcode_addref(p->raw());
csv_get<bcode *>(&p_stor) = p;
}
any_value::any_value(ident &val):
p_stor{}, p_type{value_type::IDENT}
{
csv_get<ident *>(&p_stor) = &val;
}
any_value::~any_value() {
csv_cleanup(p_type, &p_stor);
}
any_value::any_value(any_value const &v): any_value{} {
*this = v;
}
any_value::any_value(any_value &&v): any_value{} {
*this = std::move(v);
}
any_value &any_value::operator=(any_value const &v) {
csv_cleanup(p_type, &p_stor);
p_type = value_type::NONE;
switch (v.type()) {
case value_type::INTEGER:
case value_type::FLOAT:
case value_type::IDENT:
p_type = v.p_type;
p_stor = v.p_stor;
break;
case value_type::STRING:
p_type = value_type::STRING;
p_stor = v.p_stor;
str_managed_ref(csv_get<char const *>(&p_stor));
break;
case value_type::CODE:
set_code(v.get_code());
break;
default:
break;
}
return *this;
}
any_value &any_value::operator=(any_value &&v) {
*this = v;
v.set_none();
return *this;
}
any_value &any_value::operator=(integer_type val) {
set_integer(val);
return *this;
}
any_value &any_value::operator=(float_type val) {
set_float(val);
return *this;
}
any_value &any_value::operator=(string_ref const &val) {
set_string(val);
return *this;
}
any_value &any_value::operator=(bcode_ref const &val) {
set_code(val);
return *this;
}
any_value &any_value::operator=(ident &val) {
set_ident(val);
return *this;
}
value_type any_value::type() const {
return p_type;
}
void any_value::set_integer(integer_type val) {
csv_cleanup(p_type, &p_stor);
p_type = value_type::INTEGER;
csv_get<integer_type>(&p_stor) = val;
}
void any_value::set_float(float_type val) {
csv_cleanup(p_type, &p_stor);
p_type = value_type::FLOAT;
csv_get<float_type>(&p_stor) = val;
}
void any_value::set_string(std::string_view val, state &cs) {
csv_cleanup(p_type, &p_stor);
csv_get<char const *>(&p_stor) = state_p{cs}.ts().istate->strman->add(val);
p_type = value_type::STRING;
}
void any_value::set_string(string_ref const &val) {
csv_cleanup(p_type, &p_stor);
csv_get<char const *>(&p_stor) = str_managed_ref(val.p_str);
p_type = value_type::STRING;
}
void any_value::set_none() {
csv_cleanup(p_type, &p_stor);
p_type = value_type::NONE;
}
void any_value::set_code(bcode_ref const &val) {
bcode *p = bcode_p{val}.get();
csv_cleanup(p_type, &p_stor);
p_type = value_type::CODE;
bcode_addref(p->raw());
csv_get<bcode *>(&p_stor) = p;
}
void any_value::set_ident(ident &val) {
csv_cleanup(p_type, &p_stor);
p_type = value_type::IDENT;
csv_get<ident *>(&p_stor) = &val;
}
void any_value::force_none() {
if (type() == value_type::NONE) {
return;
}
set_none();
}
void any_value::force_plain() {
switch (type()) {
case value_type::FLOAT:
case value_type::INTEGER:
case value_type::STRING:
return;
default:
break;
}
force_none();
}
float_type any_value::force_float() {
float_type rf = 0.0f;
switch (type()) {
case value_type::INTEGER:
rf = float_type(csv_get<integer_type>(&p_stor));
break;
case value_type::STRING:
rf = parse_float(str_managed_view(csv_get<char const *>(&p_stor)));
break;
case value_type::FLOAT:
return csv_get<float_type>(&p_stor);
default:
break;
}
set_float(rf);
return rf;
}
integer_type any_value::force_integer() {
integer_type ri = 0;
switch (type()) {
case value_type::FLOAT:
ri = integer_type(std::floor(csv_get<float_type>(&p_stor)));
break;
case value_type::STRING:
ri = parse_int(str_managed_view(csv_get<char const *>(&p_stor)));
break;
case value_type::INTEGER:
return csv_get<integer_type>(&p_stor);
default:
break;
}
set_integer(ri);
return ri;
}
std::string_view any_value::force_string(state &cs) {
charbuf rs{cs};
std::string_view str;
switch (type()) {
case value_type::FLOAT:
str = floatstr(csv_get<float_type>(&p_stor), rs);
break;
case value_type::INTEGER:
str = intstr(csv_get<integer_type>(&p_stor), rs);
break;
case value_type::STRING:
return str_managed_view(csv_get<char const *>(&p_stor));
default:
str = rs.str();
break;
}
set_string(str, cs);
return str_managed_view(csv_get<char const *>(&p_stor));
}
bcode_ref any_value::force_code(state &cs, std::string_view source) {
switch (type()) {
case value_type::CODE:
return bcode_p::make_ref(csv_get<bcode *>(&p_stor));
default:
break;
}
gen_state gs{state_p{cs}.ts()};
gs.gen_main(get_string(cs), source);
auto bc = gs.steal_ref();
set_code(bc);
return bc;
}
ident &any_value::force_ident(state &cs) {
switch (type()) {
case value_type::IDENT:
return *csv_get<ident *>(&p_stor);
default:
break;
}
auto &id = state_p{cs}.ts().istate->new_ident(
cs, get_string(cs), IDENT_FLAG_UNKNOWN
);
set_ident(id);
return id;
}
integer_type any_value::get_integer() const {
switch (type()) {
case value_type::FLOAT:
return integer_type(csv_get<float_type>(&p_stor));
case value_type::INTEGER:
return csv_get<integer_type>(&p_stor);
case value_type::STRING:
return parse_int(str_managed_view(csv_get<char const *>(&p_stor)));
default:
break;
}
return 0;
}
float_type any_value::get_float() const {
switch (type()) {
case value_type::FLOAT:
return csv_get<float_type>(&p_stor);
case value_type::INTEGER:
return float_type(csv_get<integer_type>(&p_stor));
case value_type::STRING:
return parse_float(
str_managed_view(csv_get<char const *>(&p_stor))
);
default:
break;
}
return 0.0f;
}
bcode_ref any_value::get_code() const {
if (type() != value_type::CODE) {
return bcode_ref{};
}
return bcode_p::make_ref(csv_get<bcode *>(&p_stor));
}
ident &any_value::get_ident(state &cs) const {
if (type() != value_type::IDENT) {
return *state_p{cs}.ts().istate->id_dummy;
}
return *csv_get<ident *>(&p_stor);
}
string_ref any_value::get_string(state &cs) const {
switch (type()) {
case value_type::STRING:
return string_ref{csv_get<char const *>(&p_stor)};
case value_type::INTEGER: {
charbuf rs{cs};
return string_ref{
cs, intstr(csv_get<integer_type>(&p_stor), rs)
};
}
case value_type::FLOAT: {
charbuf rs{cs};
return string_ref{
cs, floatstr(csv_get<float_type>(&p_stor), rs)
};
}
default:
break;
}
return string_ref{cs, ""};
}
any_value any_value::get_plain() const {
switch (type()) {
case value_type::STRING:
case value_type::INTEGER:
case value_type::FLOAT:
return *this;
default:
break;
}
return any_value{};
}
bool any_value::get_bool() const {
switch (type()) {
case value_type::FLOAT:
return csv_get<float_type>(&p_stor) != 0;
case value_type::INTEGER:
return csv_get<integer_type>(&p_stor) != 0;
case value_type::STRING: {
std::string_view s = str_managed_view(
csv_get<char const *>(&p_stor)
);
if (s.empty()) {
return false;
}
std::string_view end = s;
integer_type ival = parse_int(end, &end);
if (end.empty()) {
return !!ival;
}
end = s;
float_type fval = parse_float(end, &end);
if (end.empty()) {
return !!fval;
}
return true;
}
default:
return false;
}
}
/* public utilities */
LIBCUBESCRIPT_EXPORT string_ref concat_values(
state &cs, span_type<any_value> vals, std::string_view sep
) {
charbuf buf{cs};
for (std::size_t i = 0; i < vals.size(); ++i) {
switch (vals[i].type()) {
case value_type::INTEGER:
case value_type::FLOAT:
case value_type::STRING: {
auto val = any_value{vals[i]};
auto str = val.force_string(cs);
std::copy(str.begin(), str.end(), std::back_inserter(buf));
break;
}
default:
break;
}
if (i == (vals.size() - 1)) {
break;
}
std::copy(sep.begin(), sep.end(), std::back_inserter(buf));
}
return string_ref{cs, buf.str()};
}
} /* namespace cubescript */