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

use string refs more instead of allocated strings

master
Daniel Kolesa 2021-03-17 21:46:37 +01:00
parent 8b7f36319d
commit 2f5bb697eb
6 changed files with 77 additions and 56 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

20
include/cubescript/cubescript.hh
View File

@ -85,6 +85,8 @@ struct OSTD_EXPORT cs_strref {
operator ostd::string_range() const;
bool operator==(cs_strref const &s) const;
private:
/* for internal use only */
cs_strref(char const *p, cs_shared_state &cs);
@ -113,11 +115,12 @@ struct OSTD_EXPORT cs_value {
void set_int(cs_int val);
void set_float(cs_float val);
void set_str(ostd::string_range val);
void set_str(cs_strref const &val);
void set_null();
void set_code(cs_bcode *val);
void set_ident(cs_ident *val);
cs_string get_str() const;
cs_strref get_str() const;
ostd::string_range get_strr() const;
cs_int get_int() const;
cs_float get_float() const;
@ -323,7 +326,8 @@ struct OSTD_EXPORT cs_alias: cs_ident {
void get_cval(cs_value &v) const;
private:
cs_alias(cs_state &cs, ostd::string_range n, cs_string a, int flags);
cs_alias(cs_state &cs, ostd::string_range n, cs_strref a, int flags);
cs_alias(cs_state &cs, ostd::string_range n, ostd::string_range a, int flags);
cs_alias(cs_state &cs, ostd::string_range n, cs_int a, int flags);
cs_alias(cs_state &cs, ostd::string_range n, cs_float a, int flags);
cs_alias(cs_state &cs, ostd::string_range n, int flags);
@ -453,9 +457,9 @@ struct OSTD_EXPORT cs_state {
void reset_var(ostd::string_range name);
void touch_var(ostd::string_range name);
cs_string run_str(cs_bcode *code);
cs_string run_str(ostd::string_range code);
cs_string run_str(cs_ident *id, cs_value_r args);
cs_strref run_str(cs_bcode *code);
cs_strref run_str(ostd::string_range code);
cs_strref run_str(cs_ident *id, cs_value_r args);
cs_int run_int(cs_bcode *code);
cs_int run_int(ostd::string_range code);
@ -484,7 +488,7 @@ struct OSTD_EXPORT cs_state {
return p_inloop;
}
std::optional<cs_string> run_file_str(ostd::string_range fname);
std::optional<cs_strref> run_file_str(ostd::string_range fname);
std::optional<cs_int> run_file_int(ostd::string_range fname);
std::optional<cs_float> run_file_float(ostd::string_range fname);
std::optional<bool> run_file_bool(ostd::string_range fname);
@ -512,7 +516,7 @@ struct OSTD_EXPORT cs_state {
std::optional<cs_int> get_var_int(ostd::string_range name);
std::optional<cs_float> get_var_float(ostd::string_range name);
std::optional<cs_string> get_var_str(ostd::string_range name);
std::optional<cs_strref> get_var_str(ostd::string_range name);
std::optional<cs_int> get_var_min_int(ostd::string_range name);
std::optional<cs_int> get_var_max_int(ostd::string_range name);
@ -520,7 +524,7 @@ struct OSTD_EXPORT cs_state {
std::optional<cs_float> get_var_min_float(ostd::string_range name);
std::optional<cs_float> get_var_max_float(ostd::string_range name);
std::optional<cs_string> get_alias_val(ostd::string_range name);
std::optional<cs_strref> get_alias_val(ostd::string_range name);
virtual void print_var(cs_var *v);

20
src/cs_val.cc
View File

@ -97,6 +97,12 @@ void cs_value::set_str(ostd::string_range val) {
p_type = cs_value_type::String;
}
void cs_value::set_str(cs_strref const &val) {
csv_cleanup(p_type, p_stor);
new (&p_stor) cs_strref{val};
p_type = cs_value_type::String;
}
void cs_value::set_null() {
csv_cleanup(p_type, p_stor);
p_type = cs_value_type::Null;
@ -177,7 +183,7 @@ ostd::string_range cs_value::force_str() {
default:
break;
}
set_str(std::move(rs));
set_str(rs);
return ostd::string_range(*reinterpret_cast<cs_strref const *>(&p_stor));
}
@ -227,20 +233,18 @@ cs_ident *cs_value::get_ident() const {
return csv_get<cs_ident *>(p_stor);
}
cs_string cs_value::get_str() const {
cs_strref cs_value::get_str() const {
switch (get_type()) {
case cs_value_type::String:
return cs_string{ostd::string_range{
*reinterpret_cast<cs_strref const *>(&p_stor)
}};
return *reinterpret_cast<cs_strref const *>(&p_stor);
case cs_value_type::Int:
return intstr(csv_get<cs_int>(p_stor));
return cs_strref{*state(), intstr(csv_get<cs_int>(p_stor))};
case cs_value_type::Float:
return floatstr(csv_get<cs_float>(p_stor));
return cs_strref{*state(), floatstr(csv_get<cs_float>(p_stor))};
default:
break;
}
return cs_string("");
return cs_strref{*state(), ""};
}
ostd::string_range cs_value::get_strr() const {

12
src/cs_vm.cc
View File

@ -39,6 +39,10 @@ cs_strref::operator ostd::string_range() const {
return p_state->strman->get(p_str);
}
bool cs_strref::operator==(cs_strref const &s) const {
return p_str == s.p_str;
}
struct cs_cmd_internal {
static void call(
cs_state &cs, cs_command *c, cs_value_r args, cs_value &ret
@ -1696,19 +1700,19 @@ void cs_state::run(cs_ident *id, cs_value_r args, cs_value &ret) {
}
}
cs_string cs_state::run_str(cs_bcode *code) {
cs_strref cs_state::run_str(cs_bcode *code) {
cs_value ret{*this};
run(code, ret);
return ret.get_str();
}
cs_string cs_state::run_str(ostd::string_range code) {
cs_strref cs_state::run_str(ostd::string_range code) {
cs_value ret{*this};
run(code, ret);
return ret.get_str();
}
cs_string cs_state::run_str(cs_ident *id, cs_value_r args) {
cs_strref cs_state::run_str(cs_ident *id, cs_value_r args) {
cs_value ret{*this};
run(id, args, ret);
return ret.get_str();
@ -1832,7 +1836,7 @@ static bool cs_run_file(
return true;
}
std::optional<cs_string> cs_state::run_file_str(ostd::string_range fname) {
std::optional<cs_strref> cs_state::run_file_str(ostd::string_range fname) {
cs_value ret{*this};
if (!cs_run_file(*this, fname, ret)) {
return std::nullopt;

35
src/cubescript.cc
View File

@ -57,11 +57,17 @@ cs_svar::cs_svar(ostd::string_range name, cs_string v, cs_var_cb f, int fl):
p_storage(std::move(v)), p_overrideval()
{}
cs_alias::cs_alias(cs_state &cs, ostd::string_range name, cs_string a, int fl):
cs_alias::cs_alias(cs_state &cs, ostd::string_range name, cs_strref a, int fl):
cs_ident(cs_ident_type::Alias, name, fl),
p_acode(nullptr), p_astack(nullptr), p_val{cs}
{
p_val.set_str(std::move(a));
p_val.set_str(a);
}
cs_alias::cs_alias(cs_state &cs, ostd::string_range name, ostd::string_range a, int fl):
cs_ident(cs_ident_type::Alias, name, fl),
p_acode(nullptr), p_astack(nullptr), p_val{cs}
{
p_val.set_str(a);
}
cs_alias::cs_alias(cs_state &cs, ostd::string_range name, cs_int a, int fl):
cs_ident(cs_ident_type::Alias, name, fl),
@ -794,13 +800,13 @@ cs_state::get_var_float(ostd::string_range name) {
return static_cast<cs_fvar *>(id)->get_value();
}
OSTD_EXPORT std::optional<cs_string>
OSTD_EXPORT std::optional<cs_strref>
cs_state::get_var_str(ostd::string_range name) {
cs_ident *id = get_ident(name);
if (!id || id->is_svar()) {
return std::nullopt;
}
return cs_string(static_cast<cs_svar *>(id)->get_value());
return cs_strref{*p_state, static_cast<cs_svar *>(id)->get_value()};
}
OSTD_EXPORT std::optional<cs_int>
@ -839,7 +845,7 @@ cs_state::get_var_max_float(ostd::string_range name) {
return static_cast<cs_fvar *>(id)->get_val_max();
}
OSTD_EXPORT std::optional<cs_string>
OSTD_EXPORT std::optional<cs_strref>
cs_state::get_alias_val(ostd::string_range name) {
cs_alias *a = get_alias(name);
if (!a) {
@ -1048,10 +1054,10 @@ static inline void cs_loop_conc(
if (space && i) {
s += ' ';
}
s += v.get_str();
s += ostd::string_range{v.get_str()};
}
end:
res.set_str(std::move(s));
res.set_str(s);
}
void cs_init_lib_base(cs_state &gcs) {
@ -1071,11 +1077,11 @@ void cs_init_lib_base(cs_state &gcs) {
try {
cs.run(args[0].get_code(), result);
} catch (cs_error const &e) {
result.set_str(cs_string{e.what()});
result.set_str(e.what());
if (e.get_stack().get()) {
auto app = ostd::appender<cs_string>();
cscript::util::print_stack(app, e.get_stack());
tback.set_str(std::move(app.get()));
tback.set_str(app.get());
}
rc = false;
}
@ -1133,7 +1139,7 @@ void cs_init_lib_base(cs_state &gcs) {
});
gcs.new_command("cases", "ste2V", [](auto &cs, auto args, auto &res) {
cs_string val = args[0].get_str();
cs_strref val = args[0].get_str();
for (size_t i = 1; (i + 1) < args.size(); i += 2) {
if (
(args[i].get_type() == cs_value_type::Null) ||
@ -1325,9 +1331,12 @@ end:
});
gcs.new_command("getalias", "s", [](auto &cs, auto args, auto &res) {
res.set_str(
std::move(cs.get_alias_val(args[0].get_strr()).value_or(""))
);
auto s0 = cs.get_alias_val(args[0].get_strr());
if (s0) {
res.set_str(*s0);
} else {
res.set_str("");
}
});
}

16
src/lib_list.cc
View File

@ -94,10 +94,10 @@ static void cs_loop_list_conc(
default:
break;
}
r += v.get_str();
r += ostd::string_range{v.get_str()};
}
end:
res.set_str(std::move(r));
res.set_str(r);
}
int cs_list_includes(
@ -134,7 +134,7 @@ static inline void cs_list_merge(
buf += p.get_raw_item(true);
}
}
res.set_str(std::move(buf));
res.set_str(buf);
}
static void cs_init_lib_list_sort(cs_state &cs);
@ -148,7 +148,7 @@ void cs_init_lib_list(cs_state &gcs) {
if (args.empty()) {
return;
}
cs_string str = std::move(args[0].get_str());
cs_strref str = args[0].get_str();
util::list_parser p(cs, str);
p.get_raw_item() = str;
for (size_t i = 1; i < args.size(); ++i) {
@ -401,7 +401,7 @@ end:
r += p.get_raw_item(true);
}
}
res.set_str(std::move(r));
res.set_str(r);
});
gcs.new_command("listcount", "rse", [](auto &cs, auto args, auto &res) {
@ -445,7 +445,7 @@ end:
buf.put(' ');
}
}
res.set_str(std::move(buf.get()));
res.set_str(buf.get());
});
gcs.new_command("indexof", "ss", [](auto &cs, auto args, auto &res) {
@ -507,7 +507,7 @@ end:
break;
}
}
res.set_str(std::move(buf));
res.set_str(buf);
});
cs_init_lib_list_sort(gcs);
@ -616,7 +616,7 @@ static void cs_list_sort(
}
sorted += item.quote;
}
res.set_str(std::move(sorted));
res.set_str(sorted);
}
static void cs_init_lib_list_sort(cs_state &gcs) {

30
src/lib_str.cc
View File

@ -54,43 +54,43 @@ void cs_init_lib_string(cs_state &cs) {
});
cs.new_command("strlower", "s", [](auto &, auto args, auto &res) {
cs_string s = args[0].get_str();
cs_string s{ostd::string_range{args[0].get_str()}};
for (auto i: ostd::range(s.size())) {
s[i] = tolower(s[i]);
}
res.set_str(std::move(s));
res.set_str(s);
});
cs.new_command("strupper", "s", [](auto &, auto args, auto &res) {
cs_string s = args[0].get_str();
cs_string s{ostd::string_range{args[0].get_str()}};
for (auto i: ostd::range(s.size())) {
s[i] = toupper(s[i]);
}
res.set_str(std::move(s));
res.set_str(s);
});
cs.new_command("escape", "s", [](auto &, auto args, auto &res) {
auto s = ostd::appender<cs_string>();
util::escape_string(s, args[0].get_strr());
res.set_str(std::move(s.get()));
res.set_str(s.get());
});
cs.new_command("unescape", "s", [](auto &, auto args, auto &res) {
auto s = ostd::appender<cs_string>();
util::unescape_string(s, args[0].get_strr());
res.set_str(std::move(s.get()));
res.set_str(s.get());
});
cs.new_command("concat", "V", [](auto &, auto args, auto &res) {
auto s = ostd::appender<cs_string>();
cscript::util::tvals_concat(s, args, " ");
res.set_str(std::move(s.get()));
res.set_str(s.get());
});
cs.new_command("concatword", "V", [](auto &, auto args, auto &res) {
auto s = ostd::appender<cs_string>();
cscript::util::tvals_concat(s, args);
res.set_str(std::move(s.get()));
res.set_str(s.get());
});
cs.new_command("format", "V", [](auto &, auto args, auto &res) {
@ -98,8 +98,8 @@ void cs_init_lib_string(cs_state &cs) {
return;
}
cs_string s;
cs_string fs = args[0].get_str();
ostd::string_range f = ostd::iter(fs);
cs_strref fs = args[0].get_str();
ostd::string_range f{fs};
while (!f.empty()) {
char c = *f;
++f;
@ -109,7 +109,7 @@ void cs_init_lib_string(cs_state &cs) {
if (ic >= '1' && ic <= '9') {
int i = ic - '0';
if (size_t(i) < args.size()) {
s += args[i].get_str();
s += ostd::string_range{args[i].get_str()};
}
} else {
s += ic;
@ -118,7 +118,7 @@ void cs_init_lib_string(cs_state &cs) {
s += c;
}
}
res.set_str(std::move(s));
res.set_str(s);
});
cs.new_command("tohex", "ii", [](auto &, auto args, auto &res) {
@ -131,7 +131,7 @@ void cs_init_lib_string(cs_state &cs) {
} catch (ostd::format_error const &e) {
throw cs_internal_error{e.what()};
}
res.set_str(std::move(r.get()));
res.set_str(r.get());
});
cs.new_command("substr", "siiN", [](auto &, auto args, auto &res) {
@ -197,7 +197,7 @@ void cs_init_lib_string(cs_state &cs) {
s = found.slice(oldval.size(), found.size());
} else {
buf += s;
res.set_str(std::move(buf));
res.set_str(buf);
return;
}
}
@ -221,7 +221,7 @@ void cs_init_lib_string(cs_state &cs) {
if ((offset + len) < cs_int(s.size())) {
p += s.slice(offset + len, s.size());
}
res.set_str(std::move(p));
res.set_str(p);
});
}