use string refs more instead of allocated strings

include/cubescript/cubescript.hh

@@ -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_strref run_str(cs_bcode *code);
-    cs_string run_str(ostd::string_range code);
+    cs_strref run_str(ostd::string_range code);
-    cs_string run_str(cs_ident *id, cs_value_r args);
+    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);
 

src/cs_val.cc

@@ -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{
+            return *reinterpret_cast<cs_strref const *>(&p_stor);
-                *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 {

src/cs_vm.cc

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

src/cubescript.cc

@@ -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(
+        auto s0 = cs.get_alias_val(args[0].get_strr());
-            std::move(cs.get_alias_val(args[0].get_strr()).value_or(""))
+        if (s0) {
-        );
+            res.set_str(*s0);
+        } else {
+            res.set_str("");
+        }
     });
 }
 

src/lib_list.cc

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

src/lib_str.cc

@@ -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();
+        cs_strref fs = args[0].get_str();
-        ostd::string_range f = ostd::iter(fs);
+        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);
     });
 }