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

use string_view everywhere that returns or takes a string

master
Daniel Kolesa 2021-03-20 02:26:37 +01:00
parent 70d7e15ed5
commit 5648c1a757
14 changed files with 611 additions and 575 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

173
include/cubescript/cubescript.hh
View File

@ -74,8 +74,8 @@ struct OSTD_EXPORT cs_strref {
friend inline cs_strref cs_make_strref(char const *p, cs_shared_state &cs); friend inline cs_strref cs_make_strref(char const *p, cs_shared_state &cs);
cs_strref() = delete; cs_strref() = delete;
cs_strref(cs_shared_state &cs, ostd::string_range str); cs_strref(cs_shared_state &cs, std::string_view str);
cs_strref(cs_state &cs, ostd::string_range str); cs_strref(cs_state &cs, std::string_view str);
cs_strref(cs_strref const &ref); cs_strref(cs_strref const &ref);
@ -83,17 +83,17 @@ struct OSTD_EXPORT cs_strref {
cs_strref &operator=(cs_strref const &ref); cs_strref &operator=(cs_strref const &ref);
operator ostd::string_range() const; operator std::string_view() const;
std::size_t size() const { std::size_t size() const {
return ostd::string_range{*this}.size(); return std::string_view{*this}.size();
} }
std::size_t length() const { std::size_t length() const {
return ostd::string_range{*this}.length(); return std::string_view{*this}.length();
} }
char const *data() const { char const *data() const {
return ostd::string_range{*this}.data(); return std::string_view{*this}.data();
} }
bool operator==(cs_strref const &s) const; bool operator==(cs_strref const &s) const;
@ -125,7 +125,7 @@ struct OSTD_EXPORT cs_value {
void set_int(cs_int val); void set_int(cs_int val);
void set_float(cs_float val); void set_float(cs_float val);
void set_str(ostd::string_range val); void set_str(std::string_view val);
void set_str(cs_strref const &val); void set_str(cs_strref const &val);
void set_none(); void set_none();
void set_code(cs_bcode *val); void set_code(cs_bcode *val);
@ -143,7 +143,7 @@ struct OSTD_EXPORT cs_value {
void force_none(); void force_none();
cs_float force_float(); cs_float force_float();
cs_int force_int(); cs_int force_int();
ostd::string_range force_str(); std::string_view force_str();
bool code_is_empty() const; bool code_is_empty() const;
@ -203,7 +203,7 @@ struct OSTD_EXPORT cs_ident {
cs_ident &operator=(cs_ident &&) = delete; cs_ident &operator=(cs_ident &&) = delete;
cs_ident_type get_type() const; cs_ident_type get_type() const;
ostd::string_range get_name() const; std::string_view get_name() const;
int get_flags() const; int get_flags() const;
int get_index() const; int get_index() const;
@ -329,7 +329,7 @@ struct OSTD_EXPORT cs_alias: cs_ident {
void get_cval(cs_value &v) const; void get_cval(cs_value &v) const;
private: private:
cs_alias(cs_state &cs, cs_strref n, cs_strref a, int flags); cs_alias(cs_state &cs, cs_strref n, cs_strref a, int flags);
cs_alias(cs_state &cs, cs_strref n, ostd::string_range a, int flags); cs_alias(cs_state &cs, cs_strref n, std::string_view a, int flags);
cs_alias(cs_state &cs, cs_strref n, cs_int a, int flags); cs_alias(cs_state &cs, cs_strref n, cs_int a, int flags);
cs_alias(cs_state &cs, cs_strref n, cs_float a, int flags); cs_alias(cs_state &cs, cs_strref n, cs_float a, int flags);
cs_alias(cs_state &cs, cs_strref n, int flags); cs_alias(cs_state &cs, cs_strref n, int flags);
@ -345,7 +345,7 @@ struct cs_command: cs_ident {
friend struct cs_shared_state; friend struct cs_shared_state;
friend struct cs_cmd_internal; friend struct cs_cmd_internal;
ostd::string_range get_args() const; std::string_view get_args() const;
int get_num_args() const; int get_num_args() const;
private: private:
@ -431,58 +431,58 @@ struct OSTD_EXPORT cs_state {
void clear_override(cs_ident &id); void clear_override(cs_ident &id);
void clear_overrides(); void clear_overrides();
cs_ident *new_ident(ostd::string_range name, int flags = CS_IDF_UNKNOWN); cs_ident *new_ident(std::string_view name, int flags = CS_IDF_UNKNOWN);
cs_ident *force_ident(cs_value &v); cs_ident *force_ident(cs_value &v);
cs_ivar *new_ivar( cs_ivar *new_ivar(
ostd::string_range n, cs_int m, cs_int x, cs_int v, std::string_view n, cs_int m, cs_int x, cs_int v,
cs_var_cb f = cs_var_cb(), int flags = 0 cs_var_cb f = cs_var_cb(), int flags = 0
); );
cs_fvar *new_fvar( cs_fvar *new_fvar(
ostd::string_range n, cs_float m, cs_float x, cs_float v, std::string_view n, cs_float m, cs_float x, cs_float v,
cs_var_cb f = cs_var_cb(), int flags = 0 cs_var_cb f = cs_var_cb(), int flags = 0
); );
cs_svar *new_svar( cs_svar *new_svar(
ostd::string_range n, ostd::string_range v, std::string_view n, std::string_view v,
cs_var_cb f = cs_var_cb(), int flags = 0 cs_var_cb f = cs_var_cb(), int flags = 0
); );
cs_command *new_command( cs_command *new_command(
ostd::string_range name, ostd::string_range args, cs_command_cb func std::string_view name, std::string_view args, cs_command_cb func
); );
cs_ident *get_ident(ostd::string_range name); cs_ident *get_ident(std::string_view name);
cs_alias *get_alias(ostd::string_range name); cs_alias *get_alias(std::string_view name);
bool have_ident(ostd::string_range name); bool have_ident(std::string_view name);
cs_ident_r get_idents(); cs_ident_r get_idents();
cs_const_ident_r get_idents() const; cs_const_ident_r get_idents() const;
void reset_var(ostd::string_range name); void reset_var(std::string_view name);
void touch_var(ostd::string_range name); void touch_var(std::string_view name);
cs_strref run_str(cs_bcode *code); cs_strref run_str(cs_bcode *code);
cs_strref run_str(ostd::string_range code); cs_strref run_str(std::string_view code);
cs_strref 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(cs_bcode *code);
cs_int run_int(ostd::string_range code); cs_int run_int(std::string_view code);
cs_int run_int(cs_ident *id, cs_value_r args); cs_int run_int(cs_ident *id, cs_value_r args);
cs_float run_float(cs_bcode *code); cs_float run_float(cs_bcode *code);
cs_float run_float(ostd::string_range code); cs_float run_float(std::string_view code);
cs_float run_float(cs_ident *id, cs_value_r args); cs_float run_float(cs_ident *id, cs_value_r args);
bool run_bool(cs_bcode *code); bool run_bool(cs_bcode *code);
bool run_bool(ostd::string_range code); bool run_bool(std::string_view code);
bool run_bool(cs_ident *id, cs_value_r args); bool run_bool(cs_ident *id, cs_value_r args);
void run(cs_bcode *code, cs_value &ret); void run(cs_bcode *code, cs_value &ret);
void run(ostd::string_range code, cs_value &ret); void run(std::string_view code, cs_value &ret);
void run(cs_ident *id, cs_value_r args, cs_value &ret); void run(cs_ident *id, cs_value_r args, cs_value &ret);
void run(cs_bcode *code); void run(cs_bcode *code);
void run(ostd::string_range code); void run(std::string_view code);
void run(cs_ident *id, cs_value_r args); void run(cs_ident *id, cs_value_r args);
cs_loop_state run_loop(cs_bcode *code, cs_value &ret); cs_loop_state run_loop(cs_bcode *code, cs_value &ret);
@ -492,43 +492,43 @@ struct OSTD_EXPORT cs_state {
return p_inloop; return p_inloop;
} }
std::optional<cs_strref> run_file_str(ostd::string_range fname); std::optional<cs_strref> run_file_str(std::string_view fname);
std::optional<cs_int> run_file_int(ostd::string_range fname); std::optional<cs_int> run_file_int(std::string_view fname);
std::optional<cs_float> run_file_float(ostd::string_range fname); std::optional<cs_float> run_file_float(std::string_view fname);
std::optional<bool> run_file_bool(ostd::string_range fname); std::optional<bool> run_file_bool(std::string_view fname);
bool run_file(ostd::string_range fname, cs_value &ret); bool run_file(std::string_view fname, cs_value &ret);
bool run_file(ostd::string_range fname); bool run_file(std::string_view fname);
void set_alias(ostd::string_range name, cs_value v); void set_alias(std::string_view name, cs_value v);
void set_var_int( void set_var_int(
ostd::string_range name, cs_int v, std::string_view name, cs_int v,
bool dofunc = true, bool doclamp = true bool dofunc = true, bool doclamp = true
); );
void set_var_float( void set_var_float(
ostd::string_range name, cs_float v, std::string_view name, cs_float v,
bool dofunc = true, bool doclamp = true bool dofunc = true, bool doclamp = true
); );
void set_var_str( void set_var_str(
ostd::string_range name, ostd::string_range v, bool dofunc = true std::string_view name, std::string_view v, bool dofunc = true
); );
void set_var_int_checked(cs_ivar *iv, cs_int v); void set_var_int_checked(cs_ivar *iv, cs_int v);
void set_var_int_checked(cs_ivar *iv, cs_value_r args); void set_var_int_checked(cs_ivar *iv, cs_value_r args);
void set_var_float_checked(cs_fvar *fv, cs_float v); void set_var_float_checked(cs_fvar *fv, cs_float v);
void set_var_str_checked(cs_svar *fv, ostd::string_range v); void set_var_str_checked(cs_svar *fv, std::string_view v);
std::optional<cs_int> get_var_int(ostd::string_range name); std::optional<cs_int> get_var_int(std::string_view name);
std::optional<cs_float> get_var_float(ostd::string_range name); std::optional<cs_float> get_var_float(std::string_view name);
std::optional<cs_strref> get_var_str(ostd::string_range name); std::optional<cs_strref> get_var_str(std::string_view name);
std::optional<cs_int> get_var_min_int(ostd::string_range name); std::optional<cs_int> get_var_min_int(std::string_view name);
std::optional<cs_int> get_var_max_int(ostd::string_range name); std::optional<cs_int> get_var_max_int(std::string_view name);
std::optional<cs_float> get_var_min_float(ostd::string_range name); std::optional<cs_float> get_var_min_float(std::string_view name);
std::optional<cs_float> get_var_max_float(ostd::string_range name); std::optional<cs_float> get_var_max_float(std::string_view name);
std::optional<cs_strref> get_alias_val(ostd::string_range name); std::optional<cs_strref> get_alias_val(std::string_view name);
void print_var(cs_var const &v) const; void print_var(cs_var const &v) const;
@ -582,7 +582,7 @@ struct cs_error {
p_errmsg(v.p_errmsg), p_stack(std::move(v.p_stack)) p_errmsg(v.p_errmsg), p_stack(std::move(v.p_stack))
{} {}
ostd::string_range what() const { std::string_view what() const {
return p_errmsg; return p_errmsg;
} }
@ -594,7 +594,7 @@ struct cs_error {
return p_stack; return p_stack;
} }
cs_error(cs_state &cs, ostd::string_range msg): cs_error(cs_state &cs, std::string_view msg):
p_errmsg(), p_stack(cs) p_errmsg(), p_stack(cs)
{ {
p_errmsg = save_msg(cs, msg); p_errmsg = save_msg(cs, msg);
@ -602,7 +602,7 @@ struct cs_error {
} }
template<typename ...A> template<typename ...A>
cs_error(cs_state &cs, ostd::string_range msg, A &&...args): cs_error(cs_state &cs, std::string_view msg, A &&...args):
p_errmsg(), p_stack(cs) p_errmsg(), p_stack(cs)
{ {
try { try {
@ -620,9 +620,9 @@ struct cs_error {
private: private:
cs_stack_state save_stack(cs_state &cs); cs_stack_state save_stack(cs_state &cs);
ostd::string_range save_msg(cs_state &cs, ostd::string_range v); std::string_view save_msg(cs_state &cs, std::string_view v);
ostd::string_range p_errmsg; std::string_view p_errmsg;
cs_stack_state p_stack; cs_stack_state p_stack;
}; };
@ -652,12 +652,23 @@ private:
bool p_pushed; bool p_pushed;
}; };
struct cs_list_parse_state { struct OSTD_EXPORT cs_list_parse_state {
cs_list_parse_state(ostd::string_range s = ostd::string_range{}): input{s} {} cs_list_parse_state(std::string_view s = std::string_view{}):
input_beg{s.data()}, input_end{s.data() + s.size()}
{}
ostd::string_range input{}; void set_input(std::string_view s) {
ostd::string_range item{}; input_beg = s.data();
ostd::string_range quoted_item{}; input_end = s.data() + s.size();
}
std::string_view get_input() const {
return std::string_view{input_beg, std::size_t(input_end - input_beg)};
}
char const *input_beg, *input_end;
std::string_view item{};
std::string_view quoted_item{};
}; };
OSTD_EXPORT bool list_parse(cs_list_parse_state &ps, cs_state &cs); OSTD_EXPORT bool list_parse(cs_list_parse_state &ps, cs_state &cs);
@ -666,16 +677,16 @@ 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); OSTD_EXPORT void list_find_item(cs_list_parse_state &ps);
OSTD_EXPORT cs_strref value_list_concat( OSTD_EXPORT cs_strref value_list_concat(
cs_state &cs, cs_value_r vals, ostd::string_range sep = ostd::string_range{} cs_state &cs, cs_value_r vals, std::string_view sep = std::string_view{}
); );
namespace util { namespace util {
template<typename R> template<typename R>
inline R &&escape_string(R &&writer, ostd::string_range str) { inline R &&escape_string(R &&writer, std::string_view str) {
using namespace ostd::string_literals; using namespace ostd::string_literals;
writer.put('"'); writer.put('"');
for (; !str.empty(); str.pop_front()) { for (auto c: str) {
switch (str.front()) { switch (c) {
case '\n': case '\n':
ostd::range_put_all(writer, "^n"_sr); ostd::range_put_all(writer, "^n"_sr);
break; break;
@ -692,7 +703,7 @@ namespace util {
ostd::range_put_all(writer, "^^"_sr); ostd::range_put_all(writer, "^^"_sr);
break; break;
default: default:
writer.put(str.front()); writer.put(c);
break; break;
} }
} }
@ -701,14 +712,14 @@ namespace util {
} }
template<typename R> template<typename R>
inline R &&unescape_string(R &&writer, ostd::string_range str) { inline R &&unescape_string(R &&writer, std::string_view str) {
for (; !str.empty(); str.pop_front()) { for (auto it = str.begin(); it != str.end(); ++it) {
if (str.front() == '^') { if (*it == '^') {
str.pop_front(); ++it;
if (str.empty()) { if (it == str.end()) {
break; break;
} }
switch (str.front()) { switch (*it) {
case 'n': case 'n':
writer.put('\n'); writer.put('\n');
break; break;
@ -725,18 +736,20 @@ namespace util {
writer.put('^'); writer.put('^');
break; break;
default: default:
writer.put(str.front()); writer.put(*it);
break; break;
} }
} else if (str.front() == '\\') { } else if (*it == '\\') {
str.pop_front(); ++it;
if (str.empty()) { if (it == str.end()) {
break; break;
} }
char c = str.front(); char c = *it;
if ((c == '\r') || (c == '\n')) { if ((c == '\r') || (c == '\n')) {
if (!str.empty() && (c == '\r') && (str.front() == '\n')) { if ((c == '\r') && ((it + 1) != str.end())) {
str.pop_front(); if (it[1] == '\n') {
++it;
}
} }
continue; continue;
} }
@ -748,20 +761,18 @@ namespace util {
return std::forward<R>(writer); return std::forward<R>(writer);
} }
OSTD_EXPORT ostd::string_range parse_string( OSTD_EXPORT char const *parse_string(
cs_state &cs, ostd::string_range str, size_t &nlines cs_state &cs, std::string_view str, size_t &nlines
); );
inline ostd::string_range parse_string( inline char const *parse_string(
cs_state &cs, ostd::string_range str cs_state &cs, std::string_view str
) { ) {
size_t nlines; size_t nlines;
return parse_string(cs, str, nlines); return parse_string(cs, str, nlines);
} }
OSTD_EXPORT ostd::string_range parse_word( OSTD_EXPORT char const *parse_word(cs_state &cs, std::string_view str);
cs_state &cs, ostd::string_range str
);
template<typename R> template<typename R>
inline void print_stack(R &&writer, cs_stack_state const &st) { inline void print_stack(R &&writer, cs_stack_state const &st) {

160
src/cs_gen.cc
View File

@ -8,13 +8,15 @@
namespace cscript { namespace cscript {
ostd::string_range cs_gen_state::get_str() { std::string_view cs_gen_state::get_str() {
size_t nl; size_t nl;
ostd::string_range beg = source; char const *beg = source;
source = util::parse_string(cs, source, nl); source = util::parse_string(
cs, std::string_view{source, std::size_t(send - source)}, nl
);
current_line += nl - 1; current_line += nl - 1;
ostd::string_range ret = beg.slice(0, &source[0] - &beg[0]); auto ret = std::string_view{beg, std::size_t(source - beg)};
return ret.slice(1, ret.size() - 1); return ret.substr(1, ret.size() - 2);
} }
cs_charbuf cs_gen_state::get_str_dup() { cs_charbuf cs_gen_state::get_str_dup() {
@ -24,21 +26,21 @@ cs_charbuf cs_gen_state::get_str_dup() {
return std::move(app.get()); return std::move(app.get());
} }
ostd::string_range cs_gen_state::read_macro_name() { std::string_view cs_gen_state::read_macro_name() {
auto op = source; char const *op = source;
char c = current(); char c = current();
if (!isalpha(c) && (c != '_')) { if (!isalpha(c) && (c != '_')) {
return nullptr; return std::string_view{};
} }
for (; isalnum(c) || (c == '_'); c = current()) { for (; isalnum(c) || (c == '_'); c = current()) {
next_char(); next_char();
} }
return op.slice(0, &source[0] - &op[0]); return std::string_view{op, std::size_t(source - op)};
} }
char cs_gen_state::skip_until(ostd::string_range chars) { char cs_gen_state::skip_until(std::string_view chars) {
char c = current(); char c = current();
while (c && ostd::find(chars, c).empty()) { while (c && (chars.find(c) == std::string_view::npos)) {
next_char(); next_char();
c = current(); c = current();
} }
@ -88,10 +90,12 @@ void cs_gen_state::skip_comments() {
} }
} }
ostd::string_range cs_gen_state::get_word() { std::string_view cs_gen_state::get_word() {
auto beg = source; char const *beg = source;
source = util::parse_word(cs, source); source = util::parse_word(
return beg.slice(0, &source[0] - &beg[0]); cs, std::string_view{source, std::size_t(send - source)}
);
return std::string_view{beg, std::size_t(source - beg)};
} }
static inline int cs_ret_code(int type, int def = 0) { static inline int cs_ret_code(int type, int def = 0) {
@ -104,20 +108,20 @@ static inline int cs_ret_code(int type, int def = 0) {
static void compilestatements( static void compilestatements(
cs_gen_state &gs, int rettype, int brak = '\0', int prevargs = 0 cs_gen_state &gs, int rettype, int brak = '\0', int prevargs = 0
); );
static inline std::pair<ostd::string_range, size_t> compileblock( static inline std::pair<std::string_view, size_t> compileblock(
cs_gen_state &gs, ostd::string_range p, size_t line, cs_gen_state &gs, std::string_view p, size_t line,
int rettype = CS_RET_NULL, int brak = '\0' int rettype = CS_RET_NULL, int brak = '\0'
); );
void cs_gen_state::gen_int(ostd::string_range word) { void cs_gen_state::gen_int(std::string_view word) {
gen_int(cs_parse_int(word)); gen_int(cs_parse_int(word));
} }
void cs_gen_state::gen_float(ostd::string_range word) { void cs_gen_state::gen_float(std::string_view word) {
gen_float(cs_parse_float(word)); gen_float(cs_parse_float(word));
} }
void cs_gen_state::gen_value(int wordtype, ostd::string_range word, int line) { void cs_gen_state::gen_value(int wordtype, std::string_view word, int line) {
switch (wordtype) { switch (wordtype) {
case CS_VAL_ANY: case CS_VAL_ANY:
if (!word.empty()) { if (!word.empty()) {
@ -157,22 +161,24 @@ static inline void compileblock(cs_gen_state &gs) {
gs.code.push_back(CS_CODE_EMPTY); gs.code.push_back(CS_CODE_EMPTY);
} }
static inline std::pair<ostd::string_range, size_t> compileblock( static inline std::pair<std::string_view, size_t> compileblock(
cs_gen_state &gs, ostd::string_range p, size_t line, int rettype, int brak cs_gen_state &gs, std::string_view p, size_t line, int rettype, int brak
) { ) {
size_t start = gs.code.size(); size_t start = gs.code.size();
gs.code.push_back(CS_CODE_BLOCK); gs.code.push_back(CS_CODE_BLOCK);
gs.code.push_back(CS_CODE_OFFSET | ((start + 2) << 8)); gs.code.push_back(CS_CODE_OFFSET | ((start + 2) << 8));
size_t retline = line; size_t retline = line;
if (p) { if (!p.empty()) {
ostd::string_range op = gs.source; char const *op = gs.source, *oe = gs.send;
size_t oldline = gs.current_line; size_t oldline = gs.current_line;
gs.source = p; gs.source = p.data();
gs.send = p.data() + p.size();
gs.current_line = line; gs.current_line = line;
compilestatements(gs, CS_VAL_ANY, brak); compilestatements(gs, CS_VAL_ANY, brak);
p = gs.source; p = std::string_view{gs.source, std::size_t(gs.send - gs.source)};
retline = gs.current_line; retline = gs.current_line;
gs.source = op; gs.source = op;
gs.send = oe;
gs.current_line = oldline; gs.current_line = oldline;
} }
if (gs.code.size() > start + 2) { if (gs.code.size() > start + 2) {
@ -323,7 +329,7 @@ lookupid:
numargs++; numargs++;
break; break;
case 's': case 's':
gs.gen_str(ostd::string_range()); gs.gen_str(std::string_view{});
numargs++; numargs++;
break; break;
case 'i': case 'i':
@ -452,44 +458,44 @@ invalid:
} }
} }
static bool compileblockstr(cs_gen_state &gs, ostd::string_range str) { static bool compileblockstr(cs_gen_state &gs, char const *str, char const *send) {
int startc = gs.code.size(); int startc = gs.code.size();
gs.code.push_back(CS_CODE_VAL | CS_RET_STRING); gs.code.push_back(CS_CODE_VAL | CS_RET_STRING);
gs.code.reserve(gs.code.size() + str.size() / sizeof(uint32_t) + 1); gs.code.reserve(gs.code.size() + (send - str) / sizeof(uint32_t) + 1);
char *buf = new char[(str.size() / sizeof(uint32_t) + 1) * sizeof(uint32_t)]; char *buf = new char[((send - str) / sizeof(uint32_t) + 1) * sizeof(uint32_t)];
int len = 0; int len = 0;
while (!str.empty()) { for (auto it = str; it != send; ++it) {
char const *p = str.data(); char const *p = it;
str = ostd::find_one_of(str, ostd::string_range("\r/\"@]")); std::string_view chrs{"\r/\"@]"};
memcpy(&buf[len], p, str.data() - p); it = std::find_first_of(it, send, chrs.begin(), chrs.end());
len += str.data() - p; memcpy(&buf[len], p, std::size_t(it - p));
if (str.empty()) { len += (it - p);
if (it == send) {
goto done; goto done;
} }
switch (str.front()) { switch (*it) {
case '\r': case '\r':
str.pop_front(); ++it;
break; break;
case '\"': { case '\"': {
auto start = str; char const *start = it;
str = util::parse_string(gs.cs, str); it = util::parse_string(
auto strr = start.slice(0, &str[0] - &start[0]); gs.cs, std::string_view{it, std::size_t(send - it)}
memcpy(&buf[len], strr.data(), strr.size()); );
len += strr.size(); memcpy(&buf[len], start, std::size_t(it - start));
len += (it - start);
break; break;
} }
case '/': case '/':
if (str[1] == '/') { if (((it + 1) != send) && it[1] == '/') {
str = ostd::find(str, '\n'); it = std::find(it, send, '\n');
} else { } else {
buf[len++] = str.front(); buf[len++] = *it++;
str.pop_front();
} }
break; break;
case '@': case '@':
case ']': case ']':
buf[len++] = str.front(); buf[len++] = *it++;
str.pop_front();
break; break;
} }
} }
@ -561,7 +567,7 @@ done:
} }
static void compileblockmain(cs_gen_state &gs, int wordtype, int prevargs) { static void compileblockmain(cs_gen_state &gs, int wordtype, int prevargs) {
char const *start = gs.source.data(); char const *start = gs.source;
size_t curline = gs.current_line; size_t curline = gs.current_line;
int concs = 0; int concs = 0;
for (int brak = 1; brak;) { for (int brak = 1; brak;) {
@ -587,7 +593,7 @@ static void compileblockmain(cs_gen_state &gs, int wordtype, int prevargs) {
brak--; brak--;
break; break;
case '@': { case '@': {
char const *esc = gs.source.data(); char const *esc = gs.source;
int level = 0; int level = 0;
while (gs.current() == '@') { while (gs.current() == '@') {
++level; ++level;
@ -606,14 +612,14 @@ static void compileblockmain(cs_gen_state &gs, int wordtype, int prevargs) {
gs.code.push_back(CS_CODE_CONC_W | CS_RET_STRING | (concs << 8)); gs.code.push_back(CS_CODE_CONC_W | CS_RET_STRING | (concs << 8));
concs = 1; concs = 1;
} }
if (compileblockstr(gs, ostd::string_range(start, esc))) { if (compileblockstr(gs, start, esc)) {
concs++; concs++;
} }
if (compileblocksub(gs, prevargs + concs)) { if (compileblocksub(gs, prevargs + concs)) {
concs++; concs++;
} }
if (concs) { if (concs) {
start = gs.source.data(); start = gs.source;
curline = gs.current_line; curline = gs.current_line;
} else if (prevargs >= MaxResults) { } else if (prevargs >= MaxResults) {
gs.code.pop_back(); gs.code.pop_back();
@ -625,26 +631,29 @@ static void compileblockmain(cs_gen_state &gs, int wordtype, int prevargs) {
break; break;
} }
} }
if (gs.source.data() - 1 > start) { if (gs.source - 1 > start) {
if (!concs) { if (!concs) {
switch (wordtype) { switch (wordtype) {
case CS_VAL_POP: case CS_VAL_POP:
return; return;
case CS_VAL_CODE: case CS_VAL_CODE:
case CS_VAL_COND: { case CS_VAL_COND: {
auto ret = compileblock(gs, ostd::string_range( auto ret = compileblock(gs, std::string_view{
start, gs.source.data() + gs.source.size() start, std::size_t(gs.send - start)
), curline, CS_RET_NULL, ']'); }, curline, CS_RET_NULL, ']');
gs.source = ret.first; gs.source = ret.first.data();
gs.send = ret.first.data() + ret.first.size();
gs.current_line = ret.second; gs.current_line = ret.second;
return; return;
} }
case CS_VAL_IDENT: case CS_VAL_IDENT:
gs.gen_ident(ostd::string_range(start, gs.source.data() - 1)); gs.gen_ident(std::string_view{
start, std::size_t((gs.source - 1) - start)
});
return; return;
} }
} }
compileblockstr(gs, ostd::string_range(start, gs.source.data() - 1)); compileblockstr(gs, start, gs.source - 1);
if (concs > 1) { if (concs > 1) {
concs++; concs++;
} }
@ -659,26 +668,26 @@ static void compileblockmain(cs_gen_state &gs, int wordtype, int prevargs) {
} }
switch (wordtype) { switch (wordtype) {
case CS_VAL_POP: case CS_VAL_POP:
if (concs || gs.source.data() - 1 > start) { if (concs || gs.source - 1 > start) {
gs.code.push_back(CS_CODE_POP); gs.code.push_back(CS_CODE_POP);
} }
break; break;
case CS_VAL_COND: case CS_VAL_COND:
if (!concs && gs.source.data() - 1 <= start) { if (!concs && gs.source - 1 <= start) {
gs.gen_null(); gs.gen_null();
} else { } else {
gs.code.push_back(CS_CODE_COND); gs.code.push_back(CS_CODE_COND);
} }
break; break;
case CS_VAL_CODE: case CS_VAL_CODE:
if (!concs && gs.source.data() - 1 <= start) { if (!concs && gs.source - 1 <= start) {
compileblock(gs); compileblock(gs);
} else { } else {
gs.code.push_back(CS_CODE_COMPILE); gs.code.push_back(CS_CODE_COMPILE);
} }
break; break;
case CS_VAL_IDENT: case CS_VAL_IDENT:
if (!concs && gs.source.data() - 1 <= start) { if (!concs && gs.source - 1 <= start) {
gs.gen_ident(); gs.gen_ident();
} else { } else {
gs.code.push_back(CS_CODE_IDENT_U); gs.code.push_back(CS_CODE_IDENT_U);
@ -688,13 +697,13 @@ static void compileblockmain(cs_gen_state &gs, int wordtype, int prevargs) {
case CS_VAL_NULL: case CS_VAL_NULL:
case CS_VAL_ANY: case CS_VAL_ANY:
case CS_VAL_WORD: case CS_VAL_WORD:
if (!concs && gs.source.data() - 1 <= start) { if (!concs && gs.source - 1 <= start) {
gs.gen_str(); gs.gen_str();
} }
break; break;
default: default:
if (!concs) { if (!concs) {
if (gs.source.data() - 1 <= start) { if (gs.source - 1 <= start) {
gs.gen_value(wordtype); gs.gen_value(wordtype);
} else { } else {
gs.code.push_back(CS_CODE_FORCE | (wordtype << CS_CODE_RET)); gs.code.push_back(CS_CODE_FORCE | (wordtype << CS_CODE_RET));
@ -837,8 +846,8 @@ static void compile_cmd(
int comtype = CS_CODE_COM, numargs = 0, fakeargs = 0; int comtype = CS_CODE_COM, numargs = 0, fakeargs = 0;
bool rep = false; bool rep = false;
auto fmt = id->get_args(); auto fmt = id->get_args();
for (; !fmt.empty(); ++fmt) { for (auto it = fmt.begin(); it != fmt.end(); ++it) {
switch (*fmt) { switch (*it) {
case 's': /* string */ case 's': /* string */
if (more) { if (more) {
more = compilearg(gs, CS_VAL_STRING, prevargs + numargs); more = compilearg(gs, CS_VAL_STRING, prevargs + numargs);
@ -847,9 +856,9 @@ static void compile_cmd(
if (rep) { if (rep) {
break; break;
} }
gs.gen_str(ostd::string_range()); gs.gen_str(std::string_view{});
fakeargs++; fakeargs++;
} else if (fmt.size() == 1) { } else if ((it + 1) == fmt.end()) {
int numconc = 1; int numconc = 1;
while ((numargs + numconc) < MaxArguments) { while ((numargs + numconc) < MaxArguments) {
more = compilearg( more = compilearg(
@ -1010,8 +1019,8 @@ static void compile_cmd(
case '3': case '3':
case '4': case '4':
if (more && (numargs < MaxArguments)) { if (more && (numargs < MaxArguments)) {
int numrep = -int(*fmt) + '0' - 1; int numrep = *it - '0' + 1;
fmt = ostd::string_range{&fmt[numrep], &fmt[fmt.size()]}; it -= numrep;
rep = true; rep = true;
} else { } else {
while (numargs > MaxArguments) { while (numargs > MaxArguments) {
@ -1298,7 +1307,7 @@ noid:
} }
switch (rettype) { switch (rettype) {
case CS_VAL_ANY: { case CS_VAL_ANY: {
ostd::string_range end = idname.str_term(); std::string_view end = idname.str_term();
cs_int val = cs_parse_int(end, &end); cs_int val = cs_parse_int(end, &end);
if (!end.empty()) { if (!end.empty()) {
gs.gen_str(idname.str_term()); gs.gen_str(idname.str_term());
@ -1441,8 +1450,9 @@ endstatement:
} }
} }
void cs_gen_state::gen_main(ostd::string_range s, int ret_type) { void cs_gen_state::gen_main(std::string_view s, int ret_type) {
source = s; source = s.data();
send = s.data() + s.size();
code.push_back(CS_CODE_START); code.push_back(CS_CODE_START);
compilestatements(*this, CS_VAL_ANY); compilestatements(*this, CS_VAL_ANY);
code.push_back(CS_CODE_EXIT | ((ret_type < CS_VAL_ANY) ? (ret_type << CS_CODE_RET) : 0)); code.push_back(CS_CODE_EXIT | ((ret_type < CS_VAL_ANY) ? (ret_type << CS_CODE_RET) : 0));

335
src/cs_util.cc
View File

@ -7,19 +7,20 @@
namespace cscript { namespace cscript {
static inline void p_skip_white(ostd::string_range &v) { static inline char const *p_skip_white(char const *beg, char const *end) {
while (!v.empty() && isspace(*v)) { while ((beg != end) && isspace(*beg)) {
++v; ++beg;
} }
return beg;
} }
static inline void p_set_end( static inline void p_set_end(
const ostd::string_range &v, ostd::string_range *end char const *nbeg, char const *nend, std::string_view *end
) { ) {
if (!end) { if (!end) {
return; return;
} }
*end = v; *end = std::string_view{nbeg, std::size_t(nend - nbeg)};
} }
/* this function assumes the input is definitely a hex digit */ /* this function assumes the input is definitely a hex digit */
@ -33,7 +34,7 @@ static inline cs_int p_hexd_to_int(char c) {
return c - '0'; return c - '0';
} }
static inline bool p_check_neg(ostd::string_range &input) { static inline bool p_check_neg(char const *&input) {
bool neg = (*input == '-'); bool neg = (*input == '-');
if (neg || (*input == '+')) { if (neg || (*input == '+')) {
++input; ++input;
@ -41,46 +42,41 @@ static inline bool p_check_neg(ostd::string_range &input) {
return neg; return neg;
} }
cs_int cs_parse_int(ostd::string_range input, ostd::string_range *end) { cs_int cs_parse_int(std::string_view input, std::string_view *endstr) {
ostd::string_range orig = input; char const *beg = input.begin();
p_skip_white(input); char const *end = input.end();
if (input.empty()) { char const *orig = beg;
p_set_end(orig, end); beg = p_skip_white(beg, end);
if (beg == end) {
p_set_end(orig, end, endstr);
return cs_int(0); return cs_int(0);
} }
bool neg = p_check_neg(input); bool neg = p_check_neg(beg);
cs_int ret = 0; cs_int ret = 0;
ostd::string_range past = input; char const *past = beg;
if (input.size() >= 2) { if ((end - beg) >= 2) {
ostd::string_range pfx = input.slice(0, 2); std::string_view pfx = std::string_view{beg, 2};
if ((pfx == "0x") || (pfx == "0X")) { if ((pfx == "0x") || (pfx == "0X")) {
input = input.slice(2, input.size()); beg += 2;
past = input; past = beg;
while (!past.empty() && isxdigit(*past)) { while ((past != end) && isxdigit(*past)) {
ret = ret * 16 + p_hexd_to_int(*past); ret = ret * 16 + p_hexd_to_int(*past++);
++past;
} }
goto done; goto done;
} else if ((pfx == "0b") || (pfx == "0B")) { } else if ((pfx == "0b") || (pfx == "0B")) {
input = input.slice(2, input.size()); beg += 2;
past = input; past = beg;
while (!past.empty() && ((*past == '0') || (*past == '1'))) { while ((past != end) && ((*past == '0') || (*past == '1'))) {
ret = ret * 2 + (*past - '0'); ret = ret * 2 + (*past++ - '0');
++past;
} }
goto done; goto done;
} }
} }
while (!past.empty() && isdigit(*past)) { while ((past != end) && isdigit(*past)) {
ret = ret * 10 + (*past - '0'); ret = ret * 10 + (*past++ - '0');
++past;
} }
done: done:
if (&past[0] == &input[0]) { p_set_end((past == beg) ? orig : past, end, endstr);
p_set_end(orig, end);
} else {
p_set_end(past, end);
}
if (neg) { if (neg) {
return -ret; return -ret;
} }
@ -88,25 +84,23 @@ done:
} }
template<bool Hex, char e1 = Hex ? 'p' : 'e', char e2 = Hex ? 'P' : 'E'> template<bool Hex, char e1 = Hex ? 'p' : 'e', char e2 = Hex ? 'P' : 'E'>
static inline bool p_read_exp(ostd::string_range &input, cs_int &fn) { static inline bool p_read_exp(char const *&beg, char const *end, cs_int &fn) {
if (input.empty()) { if (beg == end) {
return true; return true;
} }
if ((*input != e1) && (*input != e2)) { if ((*beg != e1) && (*beg != e2)) {
return true; return true;
} }
++input; if (++beg == end) {
if (input.empty()) {
return false; return false;
} }
bool neg = p_check_neg(input); bool neg = p_check_neg(beg);
if (input.empty() || !isdigit(*input)) { if ((beg == end) || !isdigit(*beg)) {
return false; return false;
} }
cs_int exp = 0; cs_int exp = 0;
while (!input.empty() && isdigit(*input)) { while ((beg != end) && isdigit(*beg)) {
exp = exp * 10 + (*input - '0'); exp = exp * 10 + (*beg++ - '0');
++input;
} }
if (neg) { if (neg) {
exp = -exp; exp = -exp;
@ -117,33 +111,33 @@ static inline bool p_read_exp(ostd::string_range &input, cs_int &fn) {
template<bool Hex> template<bool Hex>
static inline bool parse_gen_float( static inline bool parse_gen_float(
ostd::string_range input, ostd::string_range *end, cs_float &ret char const *&beg, char const *end, std::string_view *endstr, cs_float &ret
) { ) {
auto read_digits = [&input](double r, cs_int &n) { auto read_digits = [&beg, end](double r, cs_int &n) {
while (!input.empty() && (Hex ? isxdigit(*input) : isdigit(*input))) { while ((beg != end) && (Hex ? isxdigit(*beg) : isdigit(*beg))) {
if (Hex) { if (Hex) {
r = r * 16.0 + double(p_hexd_to_int(*input)); r = r * 16.0 + double(p_hexd_to_int(*beg));
} else { } else {
r = r * 10.0 + double(*input - '0'); r = r * 10.0 + double(*beg - '0');
} }
++n; ++n;
++input; ++beg;
} }
return r; return r;
}; };
cs_int wn = 0, fn = 0; cs_int wn = 0, fn = 0;
double r = read_digits(0.0, wn); double r = read_digits(0.0, wn);
if (!input.empty() && (*input == '.')) { if ((beg != end) && (*beg == '.')) {
++input; ++beg;
r = read_digits(r, fn); r = read_digits(r, fn);
} }
if (!wn && !fn) { if (!wn && !fn) {
return false; return false;
} }
fn = -fn; fn = -fn;
p_set_end(input, end); /* we have a valid number until here */ p_set_end(beg, end, endstr); /* we have a valid number until here */
if (p_read_exp<Hex>(input, fn)) { if (p_read_exp<Hex>(beg, end, fn)) {
p_set_end(input, end); p_set_end(beg, end, endstr);
} }
if (Hex) { if (Hex) {
ret = cs_float(ldexp(r, fn * 4)); ret = cs_float(ldexp(r, fn * 4));
@ -153,28 +147,30 @@ static inline bool parse_gen_float(
return true; return true;
} }
cs_float cs_parse_float(ostd::string_range input, ostd::string_range *end) { cs_float cs_parse_float(std::string_view input, std::string_view *endstr) {
ostd::string_range orig = input; char const *beg = input.begin();
p_skip_white(input); char const *end = input.end();
if (input.empty()) { char const *orig = beg;
p_set_end(orig, end); beg = p_skip_white(beg, end);
if (beg == end) {
p_set_end(orig, end, endstr);
return cs_float(0); return cs_float(0);
} }
bool neg = p_check_neg(input); bool neg = p_check_neg(beg);
cs_float ret = cs_float(0); cs_float ret = cs_float(0);
if (input.size() >= 2) { if ((end - beg) >= 2) {
ostd::string_range pfx = input.slice(0, 2); std::string_view pfx = std::string_view{beg, 2};
if ((pfx == "0x") || (pfx == "0X")) { if ((pfx == "0x") || (pfx == "0X")) {
input = input.slice(2, input.size()); beg += 2;
if (!parse_gen_float<true>(input, end, ret)) { if (!parse_gen_float<true>(beg, end, endstr, ret)) {
p_set_end(orig, end); p_set_end(orig, end, endstr);
return ret; return ret;
} }
goto done; goto done;
} }
} }
if (!parse_gen_float<false>(input, end, ret)) { if (!parse_gen_float<false>(beg, end, endstr, ret)) {
p_set_end(orig, end); p_set_end(orig, end, endstr);
return ret; return ret;
} }
done: done:
@ -192,7 +188,7 @@ inline cs_strref_state *get_ref_state(char const *ptr) {
) - 1; ) - 1;
} }
char const *cs_strman::add(ostd::string_range str) { char const *cs_strman::add(std::string_view str) {
auto it = counts.find(str); auto it = counts.find(str);
/* already present: just increment ref */ /* already present: just increment ref */
if (it != counts.end()) { if (it != counts.end()) {
@ -209,7 +205,7 @@ char const *cs_strman::add(ostd::string_range str) {
/* write string data, it's already pre-terminated */ /* write string data, it's already pre-terminated */
memcpy(strp, str.data(), ss); memcpy(strp, str.data(), ss);
/* store it */ /* store it */
counts.emplace(ostd::string_range{strp, strp + ss}, get_ref_state(strp)); counts.emplace(std::string_view{strp, ss}, get_ref_state(strp));
return strp; return strp;
} }
@ -221,7 +217,7 @@ char const *cs_strman::ref(char const *ptr) {
char const *cs_strman::steal(char *ptr) { char const *cs_strman::steal(char *ptr) {
auto *ss = get_ref_state(ptr); auto *ss = get_ref_state(ptr);
auto sr = ostd::string_range{ptr, ptr + ss->length}; auto sr = std::string_view{ptr, ss->length};
/* much like add(), but we already have memory */ /* much like add(), but we already have memory */
auto it = counts.find(sr); auto it = counts.find(sr);
if (it != counts.end()) { if (it != counts.end()) {
@ -244,7 +240,7 @@ void cs_strman::unref(char const *ptr) {
/* refcount zero, so ditch it /* refcount zero, so ditch it
* this path is a little slow... * this path is a little slow...
*/ */
auto sr = ostd::string_range{ptr, ptr + ss->length}; auto sr = std::string_view{ptr, ss->length};
auto it = counts.find(sr); auto it = counts.find(sr);
if (it == counts.end()) { if (it == counts.end()) {
/* internal error: this should *never* happen */ /* internal error: this should *never* happen */
@ -257,7 +253,7 @@ void cs_strman::unref(char const *ptr) {
} }
} }
char const *cs_strman::find(ostd::string_range str) const { char const *cs_strman::find(std::string_view str) const {
auto it = counts.find(str); auto it = counts.find(str);
if (it == counts.end()) { if (it == counts.end()) {
return nullptr; return nullptr;
@ -265,9 +261,9 @@ char const *cs_strman::find(ostd::string_range str) const {
return reinterpret_cast<char const *>(it->second + 1); return reinterpret_cast<char const *>(it->second + 1);
} }
ostd::string_range cs_strman::get(char const *ptr) const { std::string_view cs_strman::get(char const *ptr) const {
auto *ss = get_ref_state(ptr); auto *ss = get_ref_state(ptr);
return ostd::string_range{ptr, ptr + ss->length}; return std::string_view{ptr, ss->length};
} }
char *cs_strman::alloc_buf(std::size_t len) const { char *cs_strman::alloc_buf(std::size_t len) const {
@ -288,13 +284,13 @@ char *cs_strman::alloc_buf(std::size_t len) const {
/* strref */ /* strref */
cs_strref::cs_strref(cs_shared_state &cs, ostd::string_range str): cs_strref::cs_strref(cs_shared_state &cs, std::string_view str):
p_state{&cs} p_state{&cs}
{ {
p_str = cs.strman->add(str); p_str = cs.strman->add(str);
} }
cs_strref::cs_strref(cs_state &cs, ostd::string_range str): cs_strref::cs_strref(cs_state &cs, std::string_view str):
p_state{cs.p_state} p_state{cs.p_state}
{ {
p_str = p_state->strman->add(str); p_str = p_state->strman->add(str);
@ -323,7 +319,7 @@ cs_strref &cs_strref::operator=(cs_strref const &ref) {
return *this; return *this;
} }
cs_strref::operator ostd::string_range() const { cs_strref::operator std::string_view() const {
return p_state->strman->get(p_str); return p_state->strman->get(p_str);
} }
@ -332,140 +328,151 @@ bool cs_strref::operator==(cs_strref const &s) const {
} }
namespace util { namespace util {
OSTD_EXPORT ostd::string_range parse_string( OSTD_EXPORT char const *parse_string(
cs_state &cs, ostd::string_range str, size_t &nlines cs_state &cs, std::string_view str, size_t &nlines
) { ) {
size_t nl = 0; size_t nl = 0;
nlines = nl; nlines = nl;
if (str.empty() || (*str != '\"')) { if (str.empty() || (str.front() != '\"')) {
return str; return str.data();
} }
ostd::string_range orig = str; char const *beg = str.begin();
++str; char const *end = str.end();
char const *orig = beg++;
++nl; ++nl;
while (!str.empty()) { while (beg != end) {
switch (*str) { switch (*beg) {
case '\r': case '\r':
case '\n': case '\n':
case '\"': case '\"':
goto end; goto end;
case '^': case '^':
case '\\': { case '\\': {
bool needn = (*str == '\\'); bool needn = (*beg == '\\');
++str; if (++beg == end) {
if (str.empty()) {
goto end; goto end;
} }
if ((*str == '\r') || (*str == '\n')) { if ((*beg == '\r') || (*beg == '\n')) {
char c = *str; char c = *beg++;
++str;
++nl; ++nl;
if (!str.empty() && (c == '\r') && (*str == '\n')) { if ((beg != end) && (c == '\r') && (*beg == '\n')) {
++str; ++beg;
} }
} else if (needn) { } else if (needn) {
goto end; goto end;
} else { } else {
++str; ++beg;
} }
continue; continue;
} }
default:
break;
} }
++str; ++beg;
} }
end: end:
nlines = nl; nlines = nl;
if (str.empty() || (*str != '\"')) { if ((beg == end) || (*beg != '\"')) {
throw cs_error( throw cs_error(
cs, "unfinished string '%s'", orig.slice(0, &str[0] - &orig[0]) cs, "unfinished string '%s'",
std::string_view{orig, std::size_t(beg - orig)}
); );
} }
str.pop_front(); return ++beg;
return str;
} }
OSTD_EXPORT ostd::string_range parse_word( OSTD_EXPORT char const *parse_word(cs_state &cs, std::string_view str) {
cs_state &cs, ostd::string_range str char const *it = str.begin();
) { char const *end = str.end();
for (;;) { for (; it != end; ++it) {
str = ostd::find_one_of(str, ostd::string_range("\"/;()[] \t\r\n")); std::string_view chrs{"\"/;()[] \t\r\n"};
if (str.empty()) { it = std::find_first_of(it, end, chrs.begin(), chrs.end());
return str; if (it == end) {
return it;
} }
switch (*str) { switch (*it) {
case '"': case '"':
case ';': case ';':
case ' ': case ' ':
case '\t': case '\t':
case '\r': case '\r':
case '\n': case '\n':
return str; return it;
case '/': case '/':
if ((str.size() > 1) && (str[1] == '/')) { if (((end - it) > 1) && (it[1] == '/')) {
return str; return it;
} }
break; break;
case '[': case '[':
str.pop_front(); ++it;
str = parse_word(cs, str); it = parse_word(cs, std::string_view{
if (str.empty() || (*str != ']')) { it, std::size_t(end - it)
});
if ((it == end) || (*it != ']')) {
throw cs_error(cs, "missing \"]\""); throw cs_error(cs, "missing \"]\"");
} }
break; break;
case '(': case '(':
str.pop_front(); ++it;
str = parse_word(cs, str); it = parse_word(cs, std::string_view{
if (str.empty() || (*str != ')')) { it, std::size_t(end - it)
});
if ((it == end) || (*it != ')')) {
throw cs_error(cs, "missing \")\""); throw cs_error(cs, "missing \")\"");
} }
break; break;
case ']': case ']':
case ')': case ')':
return str; return it;
} }
++str;
} }
return str; return it;
} }
} /* namespace util */ } /* namespace util */
OSTD_EXPORT bool list_parse(cs_list_parse_state &ps, cs_state &cs) { OSTD_EXPORT bool list_parse(cs_list_parse_state &ps, cs_state &cs) {
list_find_item(ps); list_find_item(ps);
if (ps.input.empty()) { if (ps.input_beg == ps.input_end) {
return false; return false;
} }
switch (*ps.input) { switch (*ps.input_beg) {
case '"': case '"': {
ps.quoted_item = ps.input; char const *qi = ps.input_beg;
ps.input = util::parse_string(cs, ps.input); ps.input_beg = util::parse_string(cs, ps.get_input());
ps.quoted_item = ps.quoted_item.slice( ps.quoted_item = std::string_view{
0, &ps.input[0] - &ps.quoted_item[0] qi, std::size_t(ps.input_beg - qi)
); };
ps.item = ps.quoted_item.slice(1, ps.quoted_item.size() - 1); ps.item = ps.quoted_item.substr(1, ps.quoted_item.size() - 2);
break; break;
}
case '(': case '(':
case '[': { case '[': {
ps.quoted_item = ps.input; char btype = *ps.input_beg;
++ps.input;
ps.item = ps.input;
char btype = *ps.quoted_item;
int brak = 1; int brak = 1;
char const *ibeg = ps.input_beg++;
for (;;) { for (;;) {
ps.input = ostd::find_one_of( std::string_view chrs{"\"/;()[]"};
ps.input, ostd::string_range("\"/;()[]") ps.input_beg = std::find_first_of(
ps.input_beg, ps.input_end, chrs.begin(), chrs.end()
); );
if (ps.input.empty()) { if (ps.input_beg == ps.input_end) {
return true; return true;
} }
char c = *ps.input; char c = *ps.input_beg++;
++ps.input;
switch (c) { switch (c) {
case '"': case '"':
ps.input = util::parse_string(cs, ps.input); /* the quote is needed in str parsing */
--ps.input_beg;
ps.input_beg = util::parse_string(cs, ps.get_input());
break; break;
case '/': case '/':
if (!ps.input.empty() && (*ps.input == '/')) { if (
ps.input = ostd::find(ps.input, '\n'); (ps.input_beg != ps.input_end) &&
(*ps.input_beg == '/')
) {
ps.input_beg = std::find(
ps.input_beg, ps.input_end, '\n'
);
} }
break; break;
case '(': case '(':
@ -485,26 +492,29 @@ OSTD_EXPORT bool list_parse(cs_list_parse_state &ps, cs_state &cs) {
} }
} }
endblock: endblock:
ps.item = ps.item.slice(0, &ps.input[0] - &ps.item[0]); ps.item = std::string_view{
ps.item.pop_back(); ibeg + 1, std::size_t(ps.input_beg - ibeg - 2)
ps.quoted_item = ps.quoted_item.slice( };
0, &ps.input[0] - &ps.quoted_item[0] ps.quoted_item = std::string_view{
); ibeg, std::size_t(ps.input_beg - ibeg)
};
break; break;
} }
case ')': case ')':
case ']': case ']':
return false; return false;
default: { default: {
ostd::string_range e = util::parse_word(cs, ps.input); char const *e = util::parse_word(cs, ps.get_input());
ps.quoted_item = ps.item = ps.input.slice(0, &e[0] - &ps.input[0]); ps.quoted_item = ps.item = std::string_view{
ps.input = e; ps.input_beg, std::size_t(e - ps.input_beg)
};
ps.input_beg = e;
break; break;
} }
} }
list_find_item(ps); list_find_item(ps);
if (!ps.input.empty() && (*ps.input == ';')) { if ((ps.input_beg != ps.input_end) && (*ps.input_beg == ';')) {
++ps.input; ++ps.input_beg;
} }
return true; return true;
} }
@ -518,7 +528,7 @@ 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 cs_strref list_get_item(cs_list_parse_state &ps, cs_state &cs) {
if (!ps.quoted_item.empty() && (*ps.quoted_item == '"')) { if (!ps.quoted_item.empty() && (ps.quoted_item.front() == '"')) {
auto app = ostd::appender<cs_charbuf>(cs); auto app = ostd::appender<cs_charbuf>(cs);
util::unescape_string(app, ps.item); util::unescape_string(app, ps.item);
return cs_strref{cs, app.get().str()}; return cs_strref{cs, app.get().str()};
@ -528,23 +538,26 @@ 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) { OSTD_EXPORT void list_find_item(cs_list_parse_state &ps) {
for (;;) { for (;;) {
while (!ps.input.empty()) { while (ps.input_beg != ps.input_end) {
char c = *ps.input; char c = *ps.input_beg;
if ((c == ' ') || (c == '\t') || (c == '\r') || (c == '\n')) { if ((c == ' ') || (c == '\t') || (c == '\r') || (c == '\n')) {
++ps.input; ++ps.input_beg;
} else { } else {
break; break;
} }
} }
if ((ps.input.size() < 2) || (ps.input[0] != '/') || (ps.input[1] != '/')) { if ((ps.input_end - ps.input_beg) < 2) {
break; break;
} }
ps.input = ostd::find(ps.input, '\n'); if ((ps.input_beg[0] != '/') || (ps.input_beg[1]) != '/') {
break;
}
ps.input_beg = std::find(ps.input_beg, ps.input_end, '\n');
} }
} }
OSTD_EXPORT cs_strref value_list_concat( OSTD_EXPORT cs_strref value_list_concat(
cs_state &cs, cs_value_r vals, ostd::string_range sep cs_state &cs, cs_value_r vals, std::string_view sep
) { ) {
auto app = ostd::appender<cs_charbuf>(cs); auto app = ostd::appender<cs_charbuf>(cs);
for (std::size_t i = 0; i < vals.size(); ++i) { for (std::size_t i = 0; i < vals.size(); ++i) {
@ -553,7 +566,9 @@ OSTD_EXPORT cs_strref value_list_concat(
case cs_value_type::FLOAT: case cs_value_type::FLOAT:
case cs_value_type::STRING: { case cs_value_type::STRING: {
cs_value v{vals[i]}; cs_value v{vals[i]};
ostd::range_put_all(app, cs_value{vals[i]}.force_str()); for (auto c: v.force_str()) {
app.put(c);
}
break; break;
} }
default: default:
@ -562,7 +577,9 @@ OSTD_EXPORT cs_strref value_list_concat(
if (i == (vals.size() - 1)) { if (i == (vals.size() - 1)) {
break; break;
} }
ostd::range_put_all(app, sep); for (auto c: sep) {
app.put(c);
}
} }
return cs_strref{cs, app.get().str()}; return cs_strref{cs, app.get().str()};
} }

36
src/cs_util.hh
View File

@ -10,11 +10,11 @@
namespace cscript { namespace cscript {
cs_int cs_parse_int( cs_int cs_parse_int(
ostd::string_range input, ostd::string_range *end = nullptr std::string_view input, std::string_view *end = nullptr
); );
cs_float cs_parse_float( cs_float cs_parse_float(
ostd::string_range input, ostd::string_range *end = nullptr std::string_view input, std::string_view *end = nullptr
); );
template<typename F> template<typename F>
@ -111,30 +111,30 @@ struct cs_charbuf: cs_valbuf<char> {
cs_valbuf<char>::append(beg, end); cs_valbuf<char>::append(beg, end);
} }
void append(ostd::string_range v) { void append(std::string_view v) {
append(&v[0], &v[v.size()]); append(&v[0], &v[v.size()]);
} }
ostd::string_range str() { std::string_view str() {
return ostd::string_range{buf.data(), buf.data() + buf.size()}; return std::string_view{buf.data(), buf.size()};
} }
ostd::string_range str_term() { std::string_view str_term() {
return ostd::string_range{buf.data(), buf.data() + buf.size() - 1}; return std::string_view{buf.data(), buf.size() - 1};
} }
}; };
struct cs_shared_state { struct cs_shared_state {
using allocator_type = cs_allocator< using allocator_type = cs_allocator<
std::pair<ostd::string_range const, cs_ident *> std::pair<std::string_view const, cs_ident *>
>; >;
cs_alloc_cb allocf; cs_alloc_cb allocf;
void *aptr; void *aptr;
std::unordered_map< std::unordered_map<
ostd::string_range, cs_ident *, std::string_view, cs_ident *,
std::hash<ostd::string_range>, std::hash<std::string_view>,
std::equal_to<ostd::string_range>, std::equal_to<std::string_view>,
allocator_type allocator_type
> idents; > idents;
std::vector<cs_ident *, cs_allocator<cs_ident *>> identmap; std::vector<cs_ident *, cs_allocator<cs_ident *>> identmap;
@ -226,7 +226,7 @@ struct cs_strref_state {
struct cs_strman { struct cs_strman {
using allocator_type = cs_allocator< using allocator_type = cs_allocator<
std::pair<ostd::string_range const, cs_strref_state *> std::pair<std::string_view const, cs_strref_state *>
>; >;
cs_strman() = delete; cs_strman() = delete;
cs_strman(cs_shared_state *cs): cstate{cs}, counts{allocator_type{cs}} {} cs_strman(cs_shared_state *cs): cstate{cs}, counts{allocator_type{cs}} {}
@ -242,7 +242,7 @@ struct cs_strman {
* version; this is "slow" as it has to hash the string and potentially * version; this is "slow" as it has to hash the string and potentially
* allocate fresh memory for it, but is perfectly safe at any time * allocate fresh memory for it, but is perfectly safe at any time
*/ */
char const *add(ostd::string_range str); char const *add(std::string_view str);
/* this simply increments the reference count of an existing managed /* this simply increments the reference count of an existing managed
* string, this is only safe when you know the pointer you are passing * string, this is only safe when you know the pointer you are passing
@ -263,10 +263,10 @@ struct cs_strman {
/* just finds a managed pointer with the same contents /* just finds a managed pointer with the same contents
* as the input, if not found then a null pointer is returned * as the input, if not found then a null pointer is returned
*/ */
char const *find(ostd::string_range str) const; char const *find(std::string_view str) const;
/* a quick helper to make a proper ostd string range out of a ptr */ /* a quick helper to make a proper ostd string range out of a ptr */
ostd::string_range get(char const *ptr) const; std::string_view get(char const *ptr) const;
/* this will allocate a buffer of the given length (plus one for /* this will allocate a buffer of the given length (plus one for
* terminating zero) so you can fill it; use steal() to write it * terminating zero) so you can fill it; use steal() to write it
@ -275,9 +275,9 @@ struct cs_strman {
cs_shared_state *cstate; cs_shared_state *cstate;
std::unordered_map< std::unordered_map<
ostd::string_range, cs_strref_state *, std::string_view, cs_strref_state *,
std::hash<ostd::string_range>, std::hash<std::string_view>,
std::equal_to<ostd::string_range>, std::equal_to<std::string_view>,
allocator_type allocator_type
> counts; > counts;
}; };

34
src/cs_val.cc
View File

@ -113,7 +113,7 @@ void cs_value::set_float(cs_float val) {
csv_get<cs_float>(p_stor) = val; csv_get<cs_float>(p_stor) = val;
} }
void cs_value::set_str(ostd::string_range val) { void cs_value::set_str(std::string_view val) {
csv_cleanup(p_type, p_stor); csv_cleanup(p_type, p_stor);
new (&p_stor) cs_strref{*state(), val}; new (&p_stor) cs_strref{*state(), val};
p_type = cs_value_type::STRING; p_type = cs_value_type::STRING;
@ -156,9 +156,9 @@ cs_float cs_value::force_float() {
rf = csv_get<cs_int>(p_stor); rf = csv_get<cs_int>(p_stor);
break; break;
case cs_value_type::STRING: case cs_value_type::STRING:
rf = cs_parse_float(ostd::string_range( rf = cs_parse_float(
*reinterpret_cast<cs_strref const *>(&p_stor) *reinterpret_cast<cs_strref const *>(&p_stor)
)); );
break; break;
case cs_value_type::FLOAT: case cs_value_type::FLOAT:
return csv_get<cs_float>(p_stor); return csv_get<cs_float>(p_stor);
@ -176,9 +176,9 @@ cs_int cs_value::force_int() {
ri = csv_get<cs_float>(p_stor); ri = csv_get<cs_float>(p_stor);
break; break;
case cs_value_type::STRING: case cs_value_type::STRING:
ri = cs_parse_int(ostd::string_range( ri = cs_parse_int(
*reinterpret_cast<cs_strref const *>(&p_stor) *reinterpret_cast<cs_strref const *>(&p_stor)
)); );
break; break;
case cs_value_type::INT: case cs_value_type::INT:
return csv_get<cs_int>(p_stor); return csv_get<cs_int>(p_stor);
@ -189,7 +189,7 @@ cs_int cs_value::force_int() {
return ri; return ri;
} }
ostd::string_range cs_value::force_str() { std::string_view cs_value::force_str() {
cs_charbuf rs{*state()}; cs_charbuf rs{*state()};
switch (get_type()) { switch (get_type()) {
case cs_value_type::FLOAT: case cs_value_type::FLOAT:
@ -199,14 +199,12 @@ ostd::string_range cs_value::force_str() {
rs = std::move(intstr(csv_get<cs_int>(p_stor), *state())); rs = std::move(intstr(csv_get<cs_int>(p_stor), *state()));
break; break;
case cs_value_type::STRING: case cs_value_type::STRING:
return ostd::string_range( return *reinterpret_cast<cs_strref const *>(&p_stor);
*reinterpret_cast<cs_strref const *>(&p_stor)
);
default: default:
break; break;
} }
set_str(rs.str()); set_str(rs.str());
return ostd::string_range(*reinterpret_cast<cs_strref const *>(&p_stor)); return std::string_view(*reinterpret_cast<cs_strref const *>(&p_stor));
} }
cs_int cs_value::get_int() const { cs_int cs_value::get_int() const {
@ -216,9 +214,9 @@ cs_int cs_value::get_int() const {
case cs_value_type::INT: case cs_value_type::INT:
return csv_get<cs_int>(p_stor); return csv_get<cs_int>(p_stor);
case cs_value_type::STRING: case cs_value_type::STRING:
return cs_parse_int(ostd::string_range( return cs_parse_int(
*reinterpret_cast<cs_strref const *>(&p_stor) *reinterpret_cast<cs_strref const *>(&p_stor)
)); );
default: default:
break; break;
} }
@ -232,9 +230,9 @@ cs_float cs_value::get_float() const {
case cs_value_type::INT: case cs_value_type::INT:
return cs_float(csv_get<cs_int>(p_stor)); return cs_float(csv_get<cs_int>(p_stor));
case cs_value_type::STRING: case cs_value_type::STRING:
return cs_parse_float(ostd::string_range( return cs_parse_float(
*reinterpret_cast<cs_strref const *>(&p_stor) *reinterpret_cast<cs_strref const *>(&p_stor)
)); );
default: default:
break; break;
} }
@ -306,11 +304,11 @@ bool cs_value::code_is_empty() const {
return cscript::cs_code_is_empty(csv_get<cs_bcode *>(p_stor)); return cscript::cs_code_is_empty(csv_get<cs_bcode *>(p_stor));
} }
static inline bool cs_get_bool(ostd::string_range s) { static inline bool cs_get_bool(std::string_view s) {
if (s.empty()) { if (s.empty()) {
return false; return false;
} }
ostd::string_range end = s; std::string_view end = s;
cs_int ival = cs_parse_int(end, &end); cs_int ival = cs_parse_int(end, &end);
if (end.empty()) { if (end.empty()) {
return !!ival; return !!ival;
@ -330,9 +328,9 @@ bool cs_value::get_bool() const {
case cs_value_type::INT: case cs_value_type::INT:
return csv_get<cs_int>(p_stor) != 0; return csv_get<cs_int>(p_stor) != 0;
case cs_value_type::STRING: case cs_value_type::STRING:
return cs_get_bool(ostd::string_range( return cs_get_bool(
*reinterpret_cast<cs_strref const *>(&p_stor) *reinterpret_cast<cs_strref const *>(&p_stor)
)); );
default: default:
return false; return false;
} }

62
src/cs_vm.cc
View File

@ -107,11 +107,11 @@ cs_stack_state cs_error::save_stack(cs_state &cs) {
return cs_stack_state(cs, ret, total > dalias->get_value()); return cs_stack_state(cs, ret, total > dalias->get_value());
} }
ostd::string_range cs_error::save_msg( std::string_view cs_error::save_msg(
cs_state &cs, ostd::string_range msg cs_state &cs, std::string_view msg
) { ) {
if (msg.size() > sizeof(cs.p_errbuf)) { if (msg.size() > sizeof(cs.p_errbuf)) {
msg = msg.slice(0, sizeof(cs.p_errbuf)); msg = msg.substr(0, sizeof(cs.p_errbuf));
} }
cs_gen_state *gs = cs.p_pstate; cs_gen_state *gs = cs.p_pstate;
if (gs) { if (gs) {
@ -133,10 +133,10 @@ ostd::string_range cs_error::save_msg(
memcpy(cs.p_errbuf, msg.data(), msg.size()); memcpy(cs.p_errbuf, msg.data(), msg.size());
sz = msg.size(); sz = msg.size();
} }
return ostd::string_range(cs.p_errbuf, cs.p_errbuf + sz); return std::string_view{cs.p_errbuf, sz};
} }
memcpy(cs.p_errbuf, msg.data(), msg.size()); memcpy(cs.p_errbuf, msg.data(), msg.size());
return ostd::string_range(cs.p_errbuf, cs.p_errbuf + msg.size()); return std::string_view{cs.p_errbuf, msg.size()};
} }
static void bcode_ref(uint32_t *code) { static void bcode_ref(uint32_t *code) {
@ -220,7 +220,7 @@ static inline uint32_t *forcecode(cs_state &cs, cs_value &v) {
static inline void forcecond(cs_state &cs, cs_value &v) { static inline void forcecond(cs_state &cs, cs_value &v) {
switch (v.get_type()) { switch (v.get_type()) {
case cs_value_type::STRING: case cs_value_type::STRING:
if (!ostd::string_range{v.get_str()}.empty()) { if (!std::string_view{v.get_str()}.empty()) {
forcecode(cs, v); forcecode(cs, v);
} else { } else {
v.set_int(0); v.set_int(0);
@ -310,8 +310,9 @@ static inline void callcommand(
) { ) {
int i = -1, fakeargs = 0; int i = -1, fakeargs = 0;
bool rep = false; bool rep = false;
for (auto fmt = id->get_args(); !fmt.empty(); ++fmt) { auto fmt = id->get_args();
switch (*fmt) { for (auto it = fmt.begin(); it != fmt.end(); ++it) {
switch (*it) {
case 'i': case 'i':
if (++i >= numargs) { if (++i >= numargs) {
if (rep) { if (rep) {
@ -436,9 +437,7 @@ static inline void callcommand(
case '3': case '3':
case '4': case '4':
if (i + 1 < numargs) { if (i + 1 < numargs) {
fmt = ostd::string_range{ it -= *it - '0' + 1;
&fmt[-int(*fmt) + '0' - 1], &fmt[fmt.size()]
};
rep = true; rep = true;
} }
break; break;
@ -758,9 +757,8 @@ static uint32_t *runcode(cs_state &cs, uint32_t *code, cs_value &result) {
case CS_CODE_VAL | CS_RET_STRING: { case CS_CODE_VAL | CS_RET_STRING: {
uint32_t len = op >> 8; uint32_t len = op >> 8;
args[numargs++].set_str(ostd::string_range{ args[numargs++].set_str(std::string_view{
reinterpret_cast<char const *>(code), reinterpret_cast<char const *>(code), len
reinterpret_cast<char const *>(code) + len
}); });
code += len / sizeof(uint32_t) + 1; code += len / sizeof(uint32_t) + 1;
continue; continue;
@ -906,7 +904,7 @@ static uint32_t *runcode(cs_state &cs, uint32_t *code, cs_value &result) {
cs_value &arg = args[numargs - 1]; cs_value &arg = args[numargs - 1];
switch (arg.get_type()) { switch (arg.get_type()) {
case cs_value_type::STRING: { case cs_value_type::STRING: {
ostd::string_range s = arg.get_str(); std::string_view s = arg.get_str();
if (!s.empty()) { if (!s.empty()) {
cs_gen_state gs(cs); cs_gen_state gs(cs);
gs.code.reserve(64); gs.code.reserve(64);
@ -1461,7 +1459,7 @@ noid:
result.force_none(); result.force_none();
force_arg(result, op & CS_CODE_RET_MASK); force_arg(result, op & CS_CODE_RET_MASK);
throw cs_error( throw cs_error(
cs, "unknown command: %s", ostd::string_range{idn} cs, "unknown command: %s", std::string_view{idn}
); );
} }
result.force_none(); result.force_none();
@ -1564,7 +1562,7 @@ void cs_state::run(cs_bcode *code, cs_value &ret) {
} }
static void cs_run( static void cs_run(
cs_state &cs, ostd::string_range file, ostd::string_range code, cs_state &cs, std::string_view file, std::string_view code,
cs_value &ret cs_value &ret
) { ) {
cs_gen_state gs(cs); cs_gen_state gs(cs);
@ -1580,8 +1578,8 @@ static void cs_run(
} }
} }
void cs_state::run(ostd::string_range code, cs_value &ret) { void cs_state::run(std::string_view code, cs_value &ret) {
cs_run(*this, ostd::string_range(), code, ret); cs_run(*this, std::string_view{}, code, ret);
} }
void cs_state::run(cs_ident *id, cs_value_r args, cs_value &ret) { void cs_state::run(cs_ident *id, cs_value_r args, cs_value &ret) {
@ -1663,7 +1661,7 @@ cs_strref cs_state::run_str(cs_bcode *code) {
return ret.get_str(); return ret.get_str();
} }
cs_strref cs_state::run_str(ostd::string_range code) { cs_strref cs_state::run_str(std::string_view code) {
cs_value ret{*this}; cs_value ret{*this};
run(code, ret); run(code, ret);
return ret.get_str(); return ret.get_str();
@ -1681,7 +1679,7 @@ cs_int cs_state::run_int(cs_bcode *code) {
return ret.get_int(); return ret.get_int();
} }
cs_int cs_state::run_int(ostd::string_range code) { cs_int cs_state::run_int(std::string_view code) {
cs_value ret{*this}; cs_value ret{*this};
run(code, ret); run(code, ret);
return ret.get_int(); return ret.get_int();
@ -1699,7 +1697,7 @@ cs_float cs_state::run_float(cs_bcode *code) {
return ret.get_float(); return ret.get_float();
} }
cs_float cs_state::run_float(ostd::string_range code) { cs_float cs_state::run_float(std::string_view code) {
cs_value ret{*this}; cs_value ret{*this};
run(code, ret); run(code, ret);
return ret.get_float(); return ret.get_float();
@ -1717,7 +1715,7 @@ bool cs_state::run_bool(cs_bcode *code) {
return ret.get_bool(); return ret.get_bool();
} }
bool cs_state::run_bool(ostd::string_range code) { bool cs_state::run_bool(std::string_view code) {
cs_value ret{*this}; cs_value ret{*this};
run(code, ret); run(code, ret);
return ret.get_bool(); return ret.get_bool();
@ -1734,7 +1732,7 @@ void cs_state::run(cs_bcode *code) {
run(code, ret); run(code, ret);
} }
void cs_state::run(ostd::string_range code) { void cs_state::run(std::string_view code) {
cs_value ret{*this}; cs_value ret{*this};
run(code, ret); run(code, ret);
} }
@ -1767,7 +1765,7 @@ cs_loop_state cs_state::run_loop(cs_bcode *code) {
} }
static bool cs_run_file( static bool cs_run_file(
cs_state &cs, ostd::string_range fname, cs_value &ret cs_state &cs, std::string_view fname, cs_value &ret
) { ) {
std::unique_ptr<char[]> buf; std::unique_ptr<char[]> buf;
size_t len; size_t len;
@ -1789,11 +1787,11 @@ static bool cs_run_file(
} }
buf[len] = '\0'; buf[len] = '\0';
cs_run(cs, fname, ostd::string_range(buf.get(), buf.get() + len), ret); cs_run(cs, fname, std::string_view{buf.get(), len}, ret);
return true; return true;
} }
std::optional<cs_strref> cs_state::run_file_str(ostd::string_range fname) { std::optional<cs_strref> cs_state::run_file_str(std::string_view fname) {
cs_value ret{*this}; cs_value ret{*this};
if (!cs_run_file(*this, fname, ret)) { if (!cs_run_file(*this, fname, ret)) {
return std::nullopt; return std::nullopt;
@ -1801,7 +1799,7 @@ std::optional<cs_strref> cs_state::run_file_str(ostd::string_range fname) {
return ret.get_str(); return ret.get_str();
} }
std::optional<cs_int> cs_state::run_file_int(ostd::string_range fname) { std::optional<cs_int> cs_state::run_file_int(std::string_view fname) {
cs_value ret{*this}; cs_value ret{*this};
if (!cs_run_file(*this, fname, ret)) { if (!cs_run_file(*this, fname, ret)) {
return std::nullopt; return std::nullopt;
@ -1809,7 +1807,7 @@ std::optional<cs_int> cs_state::run_file_int(ostd::string_range fname) {
return ret.get_int(); return ret.get_int();
} }
std::optional<cs_float> cs_state::run_file_float(ostd::string_range fname) { std::optional<cs_float> cs_state::run_file_float(std::string_view fname) {
cs_value ret{*this}; cs_value ret{*this};
if (!cs_run_file(*this, fname, ret)) { if (!cs_run_file(*this, fname, ret)) {
return std::nullopt; return std::nullopt;
@ -1817,7 +1815,7 @@ std::optional<cs_float> cs_state::run_file_float(ostd::string_range fname) {
return ret.get_float(); return ret.get_float();
} }
std::optional<bool> cs_state::run_file_bool(ostd::string_range fname) { std::optional<bool> cs_state::run_file_bool(std::string_view fname) {
cs_value ret{*this}; cs_value ret{*this};
if (!cs_run_file(*this, fname, ret)) { if (!cs_run_file(*this, fname, ret)) {
return std::nullopt; return std::nullopt;
@ -1825,11 +1823,11 @@ std::optional<bool> cs_state::run_file_bool(ostd::string_range fname) {
return ret.get_bool(); return ret.get_bool();
} }
bool cs_state::run_file(ostd::string_range fname, cs_value &ret) { bool cs_state::run_file(std::string_view fname, cs_value &ret) {
return cs_run_file(*this, fname, ret); return cs_run_file(*this, fname, ret);
} }
bool cs_state::run_file(ostd::string_range fname) { bool cs_state::run_file(std::string_view fname) {
cs_value ret{*this}; cs_value ret{*this};
if (!cs_run_file(*this, fname, ret)) { if (!cs_run_file(*this, fname, ret)) {
return false; return false;

36
src/cs_vm.hh
View File

@ -129,14 +129,14 @@ struct cs_gen_state {
cs_gen_state *prevps; cs_gen_state *prevps;
bool parsing = true; bool parsing = true;
cs_valbuf<uint32_t> code; cs_valbuf<uint32_t> code;
ostd::string_range source; char const *source, *send;
size_t current_line; size_t current_line;
ostd::string_range src_name; std::string_view src_name;
cs_gen_state() = delete; cs_gen_state() = delete;
cs_gen_state(cs_state &csr): cs_gen_state(cs_state &csr):
cs(csr), prevps(csr.p_pstate), code{cs}, cs{csr}, prevps{csr.p_pstate}, code{cs},
source(nullptr), current_line(1), src_name() source{}, send{}, current_line{1}, src_name{}
{ {
csr.p_pstate = this; csr.p_pstate = this;
} }
@ -153,12 +153,12 @@ struct cs_gen_state {
parsing = false; parsing = false;
} }
ostd::string_range get_str(); std::string_view get_str();
cs_charbuf get_str_dup(); cs_charbuf get_str_dup();
ostd::string_range get_word(); std::string_view get_word();
void gen_str(ostd::string_range word) { void gen_str(std::string_view word) {
if (word.size() <= 3) { if (word.size() <= 3) {
uint32_t op = CS_CODE_VAL_INT | CS_RET_STRING; uint32_t op = CS_CODE_VAL_INT | CS_RET_STRING;
for (size_t i = 0; i < word.size(); ++i) { for (size_t i = 0; i < word.size(); ++i) {
@ -204,7 +204,7 @@ struct cs_gen_state {
} }
} }
void gen_int(ostd::string_range word); void gen_int(std::string_view word);
void gen_float(cs_float f = 0.0f) { void gen_float(cs_float f = 0.0f) {
if (cs_int(f) == f && f >= -0x800000 && f <= 0x7FFFFF) { if (cs_int(f) == f && f >= -0x800000 && f <= 0x7FFFFF) {
@ -220,7 +220,7 @@ struct cs_gen_state {
} }
} }
void gen_float(ostd::string_range word); void gen_float(std::string_view word);
void gen_ident(cs_ident *id) { void gen_ident(cs_ident *id) {
code.push_back( code.push_back(
@ -235,43 +235,43 @@ struct cs_gen_state {
gen_ident(cs.p_state->identmap[DummyIdx]); gen_ident(cs.p_state->identmap[DummyIdx]);
} }
void gen_ident(ostd::string_range word) { void gen_ident(std::string_view word) {
gen_ident(cs.new_ident(word)); gen_ident(cs.new_ident(word));
} }
void gen_value( void gen_value(
int wordtype, ostd::string_range word = ostd::string_range(), int wordtype, std::string_view word = std::string_view(),
int line = 0 int line = 0
); );
void gen_main(ostd::string_range s, int ret_type = CS_VAL_ANY); void gen_main(std::string_view s, int ret_type = CS_VAL_ANY);
void next_char() { void next_char() {
if (source.empty()) { if (source == send) {
return; return;
} }
if (*source == '\n') { if (*source == '\n') {
++current_line; ++current_line;
} }
source.pop_front(); ++source;
} }
char current(size_t ahead = 0) { char current(size_t ahead = 0) {
if (source.size() <= ahead) { if (std::size_t(send - source) <= ahead) {
return '\0'; return '\0';
} }
return source[ahead]; return source[ahead];
} }
ostd::string_range read_macro_name(); std::string_view read_macro_name();
char skip_until(ostd::string_range chars); char skip_until(std::string_view chars);
char skip_until(char cf); char skip_until(char cf);
void skip_comments(); void skip_comments();
}; };
bool cs_check_num(ostd::string_range s); bool cs_check_num(std::string_view s);
static inline void bcode_incr(uint32_t *bc) { static inline void bcode_incr(uint32_t *bc) {
*bc += 0x100; *bc += 0x100;

67
src/cubescript.cc
View File

@ -3,7 +3,7 @@
namespace cscript { namespace cscript {
bool cs_check_num(ostd::string_range s) { bool cs_check_num(std::string_view s) {
if (isdigit(s[0])) { if (isdigit(s[0])) {
return true; return true;
} }
@ -51,7 +51,7 @@ cs_alias::cs_alias(cs_state &cs, cs_strref name, cs_strref a, int fl):
{ {
p_val.set_str(a); p_val.set_str(a);
} }
cs_alias::cs_alias(cs_state &cs, cs_strref name, ostd::string_range a, int fl): cs_alias::cs_alias(cs_state &cs, cs_strref name, std::string_view a, int fl):
cs_ident(cs_ident_type::ALIAS, name, fl), cs_ident(cs_ident_type::ALIAS, name, fl),
p_acode(nullptr), p_astack(nullptr), p_val{cs} p_acode(nullptr), p_astack(nullptr), p_val{cs}
{ {
@ -236,7 +236,7 @@ void cs_svar::set_value(cs_strref val) {
p_storage = val; p_storage = val;
} }
ostd::string_range cs_command::get_args() const { std::string_view cs_command::get_args() const {
return p_cargs; return p_cargs;
} }
@ -338,7 +338,7 @@ cs_state::cs_state(cs_alloc_cb func, void *data):
} }
})->p_type = CsIdOr; })->p_type = CsIdOr;
new_command("local", nullptr, nullptr)->p_type = CsIdLocal; new_command("local", "", nullptr)->p_type = CsIdLocal;
new_command("break", "", [](auto &cs, auto, auto &) { new_command("break", "", [](auto &cs, auto, auto &) {
if (cs.is_in_loop()) { if (cs.is_in_loop()) {
@ -467,7 +467,7 @@ OSTD_EXPORT cs_ident *cs_state::add_ident(cs_ident *id) {
return p_state->identmap.back(); return p_state->identmap.back();
} }
OSTD_EXPORT cs_ident *cs_state::new_ident(ostd::string_range name, int flags) { OSTD_EXPORT cs_ident *cs_state::new_ident(std::string_view name, int flags) {
cs_ident *id = get_ident(name); cs_ident *id = get_ident(name);
if (!id) { if (!id) {
if (cs_check_num(name)) { if (cs_check_num(name)) {
@ -498,7 +498,7 @@ OSTD_EXPORT cs_ident *cs_state::force_ident(cs_value &v) {
return p_state->identmap[DummyIdx]; return p_state->identmap[DummyIdx];
} }
OSTD_EXPORT cs_ident *cs_state::get_ident(ostd::string_range name) { OSTD_EXPORT cs_ident *cs_state::get_ident(std::string_view name) {
auto id = p_state->idents.find(name); auto id = p_state->idents.find(name);
if (id != p_state->idents.end()) { if (id != p_state->idents.end()) {
return id->second; return id->second;
@ -506,7 +506,7 @@ OSTD_EXPORT cs_ident *cs_state::get_ident(ostd::string_range name) {
return nullptr; return nullptr;
} }
OSTD_EXPORT cs_alias *cs_state::get_alias(ostd::string_range name) { OSTD_EXPORT cs_alias *cs_state::get_alias(std::string_view name) {
auto id = get_ident(name); auto id = get_ident(name);
if (!id || !id->is_alias()) { if (!id || !id->is_alias()) {
return nullptr; return nullptr;
@ -514,7 +514,7 @@ OSTD_EXPORT cs_alias *cs_state::get_alias(ostd::string_range name) {
return static_cast<cs_alias *>(id); return static_cast<cs_alias *>(id);
} }
OSTD_EXPORT bool cs_state::have_ident(ostd::string_range name) { OSTD_EXPORT bool cs_state::have_ident(std::string_view name) {
return p_state->idents.find(name) != p_state->idents.end(); return p_state->idents.find(name) != p_state->idents.end();
} }
@ -531,7 +531,7 @@ OSTD_EXPORT cs_const_ident_r cs_state::get_idents() const {
} }
OSTD_EXPORT cs_ivar *cs_state::new_ivar( OSTD_EXPORT cs_ivar *cs_state::new_ivar(
ostd::string_range n, cs_int m, cs_int x, cs_int v, cs_var_cb f, int flags 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>( return add_ident(p_state->create<cs_ivar>(
cs_strref{*p_state, n}, m, x, v, std::move(f), flags cs_strref{*p_state, n}, m, x, v, std::move(f), flags
@ -539,7 +539,7 @@ OSTD_EXPORT cs_ivar *cs_state::new_ivar(
} }
OSTD_EXPORT cs_fvar *cs_state::new_fvar( OSTD_EXPORT cs_fvar *cs_state::new_fvar(
ostd::string_range n, cs_float m, cs_float x, cs_float v, cs_var_cb f, int flags 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>( return add_ident(p_state->create<cs_fvar>(
cs_strref{*p_state, n}, m, x, v, std::move(f), flags cs_strref{*p_state, n}, m, x, v, std::move(f), flags
@ -547,7 +547,7 @@ OSTD_EXPORT cs_fvar *cs_state::new_fvar(
} }
OSTD_EXPORT cs_svar *cs_state::new_svar( OSTD_EXPORT cs_svar *cs_state::new_svar(
ostd::string_range n, ostd::string_range v, cs_var_cb f, int flags std::string_view n, std::string_view v, cs_var_cb f, int flags
) { ) {
return add_ident(p_state->create<cs_svar>( return add_ident(p_state->create<cs_svar>(
cs_strref{*p_state, n}, cs_strref{*p_state, v}, cs_strref{*p_state, n}, cs_strref{*p_state, v},
@ -555,7 +555,7 @@ OSTD_EXPORT cs_svar *cs_state::new_svar(
))->get_svar(); ))->get_svar();
} }
OSTD_EXPORT void cs_state::reset_var(ostd::string_range name) { OSTD_EXPORT void cs_state::reset_var(std::string_view name) {
cs_ident *id = get_ident(name); cs_ident *id = get_ident(name);
if (!id) { if (!id) {
throw cs_error(*this, "variable %s does not exist", name); throw cs_error(*this, "variable %s does not exist", name);
@ -566,14 +566,14 @@ OSTD_EXPORT void cs_state::reset_var(ostd::string_range name) {
clear_override(*id); clear_override(*id);
} }
OSTD_EXPORT void cs_state::touch_var(ostd::string_range name) { OSTD_EXPORT void cs_state::touch_var(std::string_view name) {
cs_ident *id = get_ident(name); cs_ident *id = get_ident(name);
if (id && id->is_var()) { if (id && id->is_var()) {
static_cast<cs_var *>(id)->changed(*this); static_cast<cs_var *>(id)->changed(*this);
} }
} }
OSTD_EXPORT void cs_state::set_alias(ostd::string_range name, cs_value v) { OSTD_EXPORT void cs_state::set_alias(std::string_view name, cs_value v) {
cs_ident *id = get_ident(name); cs_ident *id = get_ident(name);
if (id) { if (id) {
switch (id->get_type()) { switch (id->get_type()) {
@ -638,7 +638,7 @@ cs_ident_type cs_ident::get_type() const {
return cs_ident_type(p_type); return cs_ident_type(p_type);
} }
ostd::string_range cs_ident::get_name() const { std::string_view cs_ident::get_name() const {
return p_name; return p_name;
} }
@ -670,7 +670,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( OSTD_EXPORT void cs_state::set_var_int(
ostd::string_range name, cs_int v, bool dofunc, bool doclamp std::string_view name, cs_int v, bool dofunc, bool doclamp
) { ) {
cs_ident *id = get_ident(name); cs_ident *id = get_ident(name);
if (!id || id->is_ivar()) { if (!id || id->is_ivar()) {
@ -692,7 +692,7 @@ OSTD_EXPORT void cs_state::set_var_int(
} }
OSTD_EXPORT void cs_state::set_var_float( OSTD_EXPORT void cs_state::set_var_float(
ostd::string_range name, cs_float v, bool dofunc, bool doclamp std::string_view name, cs_float v, bool dofunc, bool doclamp
) { ) {
cs_ident *id = get_ident(name); cs_ident *id = get_ident(name);
if (!id || id->is_fvar()) { if (!id || id->is_fvar()) {
@ -714,7 +714,7 @@ OSTD_EXPORT void cs_state::set_var_float(
} }
OSTD_EXPORT void cs_state::set_var_str( OSTD_EXPORT void cs_state::set_var_str(
ostd::string_range name, ostd::string_range v, bool dofunc std::string_view name, std::string_view v, bool dofunc
) { ) {
cs_ident *id = get_ident(name); cs_ident *id = get_ident(name);
if (!id || id->is_svar()) { if (!id || id->is_svar()) {
@ -732,7 +732,7 @@ OSTD_EXPORT void cs_state::set_var_str(
} }
OSTD_EXPORT std::optional<cs_int> OSTD_EXPORT std::optional<cs_int>
cs_state::get_var_int(ostd::string_range name) { cs_state::get_var_int(std::string_view name) {
cs_ident *id = get_ident(name); cs_ident *id = get_ident(name);
if (!id || id->is_ivar()) { if (!id || id->is_ivar()) {
return std::nullopt; return std::nullopt;
@ -741,7 +741,7 @@ cs_state::get_var_int(ostd::string_range name) {
} }
OSTD_EXPORT std::optional<cs_float> OSTD_EXPORT std::optional<cs_float>
cs_state::get_var_float(ostd::string_range name) { cs_state::get_var_float(std::string_view name) {
cs_ident *id = get_ident(name); cs_ident *id = get_ident(name);
if (!id || id->is_fvar()) { if (!id || id->is_fvar()) {
return std::nullopt; return std::nullopt;
@ -750,7 +750,7 @@ cs_state::get_var_float(ostd::string_range name) {
} }
OSTD_EXPORT std::optional<cs_strref> OSTD_EXPORT std::optional<cs_strref>
cs_state::get_var_str(ostd::string_range name) { cs_state::get_var_str(std::string_view name) {
cs_ident *id = get_ident(name); cs_ident *id = get_ident(name);
if (!id || id->is_svar()) { if (!id || id->is_svar()) {
return std::nullopt; return std::nullopt;
@ -759,7 +759,7 @@ cs_state::get_var_str(ostd::string_range name) {
} }
OSTD_EXPORT std::optional<cs_int> OSTD_EXPORT std::optional<cs_int>
cs_state::get_var_min_int(ostd::string_range name) { cs_state::get_var_min_int(std::string_view name) {
cs_ident *id = get_ident(name); cs_ident *id = get_ident(name);
if (!id || id->is_ivar()) { if (!id || id->is_ivar()) {
return std::nullopt; return std::nullopt;
@ -768,7 +768,7 @@ cs_state::get_var_min_int(ostd::string_range name) {
} }
OSTD_EXPORT std::optional<cs_int> OSTD_EXPORT std::optional<cs_int>
cs_state::get_var_max_int(ostd::string_range name) { cs_state::get_var_max_int(std::string_view name) {
cs_ident *id = get_ident(name); cs_ident *id = get_ident(name);
if (!id || id->is_ivar()) { if (!id || id->is_ivar()) {
return std::nullopt; return std::nullopt;
@ -777,7 +777,7 @@ cs_state::get_var_max_int(ostd::string_range name) {
} }
OSTD_EXPORT std::optional<cs_float> OSTD_EXPORT std::optional<cs_float>
cs_state::get_var_min_float(ostd::string_range name) { cs_state::get_var_min_float(std::string_view name) {
cs_ident *id = get_ident(name); cs_ident *id = get_ident(name);
if (!id || id->is_fvar()) { if (!id || id->is_fvar()) {
return std::nullopt; return std::nullopt;
@ -786,7 +786,7 @@ cs_state::get_var_min_float(ostd::string_range name) {
} }
OSTD_EXPORT std::optional<cs_float> OSTD_EXPORT std::optional<cs_float>
cs_state::get_var_max_float(ostd::string_range name) { cs_state::get_var_max_float(std::string_view name) {
cs_ident *id = get_ident(name); cs_ident *id = get_ident(name);
if (!id || id->is_fvar()) { if (!id || id->is_fvar()) {
return std::nullopt; return std::nullopt;
@ -795,7 +795,7 @@ cs_state::get_var_max_float(ostd::string_range name) {
} }
OSTD_EXPORT std::optional<cs_strref> OSTD_EXPORT std::optional<cs_strref>
cs_state::get_alias_val(ostd::string_range name) { cs_state::get_alias_val(std::string_view name) {
cs_alias *a = get_alias(name); cs_alias *a = get_alias(name);
if (!a) { if (!a) {
return std::nullopt; return std::nullopt;
@ -891,7 +891,7 @@ OSTD_EXPORT void cs_state::set_var_float_checked(cs_fvar *fv, cs_float v) {
} }
OSTD_EXPORT void cs_state::set_var_str_checked( OSTD_EXPORT void cs_state::set_var_str_checked(
cs_svar *sv, ostd::string_range v cs_svar *sv, std::string_view v
) { ) {
if (sv->get_flags() & CS_IDF_READONLY) { if (sv->get_flags() & CS_IDF_READONLY) {
throw cs_error( throw cs_error(
@ -907,10 +907,10 @@ OSTD_EXPORT void cs_state::set_var_str_checked(
} }
OSTD_EXPORT cs_command *cs_state::new_command( OSTD_EXPORT cs_command *cs_state::new_command(
ostd::string_range name, ostd::string_range args, cs_command_cb func std::string_view name, std::string_view args, cs_command_cb func
) { ) {
int nargs = 0; int nargs = 0;
for (ostd::string_range fmt(args); !fmt.empty(); ++fmt) { for (auto fmt = args.begin(); fmt != args.end(); ++fmt) {
switch (*fmt) { switch (*fmt) {
case 'i': case 'i':
case 'b': case 'b':
@ -935,16 +935,19 @@ OSTD_EXPORT cs_command *cs_state::new_command(
if (nargs < (*fmt - '0')) { if (nargs < (*fmt - '0')) {
return nullptr; return nullptr;
} }
if ((fmt.size() != 2) || ((fmt[1] != 'C') && (fmt[1] != 'V'))) { if ((args.end() - fmt) != 2) {
return nullptr;
}
if ((fmt[1] != 'C') && (fmt[1] != 'V')) {
return nullptr; return nullptr;
} }
if (nargs < MaxArguments) { if (nargs < MaxArguments) {
fmt = ostd::string_range{&fmt[-int(*fmt) + '0' - 1], &fmt[fmt.size()]}; fmt -= *fmt - '0' + 1;
} }
break; break;
case 'C': case 'C':
case 'V': case 'V':
if (fmt.size() != 1) { if ((fmt + 1) != args.end()) {
return nullptr; return nullptr;
} }
break; break;

66
src/lib_list.cc
View File

@ -23,8 +23,8 @@ struct cs_arg_val<cs_float> {
}; };
template<> template<>
struct cs_arg_val<ostd::string_range> { struct cs_arg_val<std::string_view> {
static ostd::string_range get(cs_value &tv) { static std::string_view get(cs_value &tv) {
return tv.get_str(); return tv.get_str();
} }
}; };
@ -70,7 +70,7 @@ static inline void cs_list_assoc(
} }
static void cs_loop_list_conc( static void cs_loop_list_conc(
cs_state &cs, cs_value &res, cs_ident *id, ostd::string_range list, cs_state &cs, cs_value &res, cs_ident *id, std::string_view list,
cs_bcode *body, bool space cs_bcode *body, bool space
) { ) {
cs_stacked_value idv{cs, id}; cs_stacked_value idv{cs, id};
@ -101,7 +101,7 @@ end:
} }
int cs_list_includes( int cs_list_includes(
cs_state &cs, ostd::string_range list, ostd::string_range needle cs_state &cs, std::string_view list, std::string_view needle
) { ) {
int offset = 0; int offset = 0;
for (cs_list_parse_state p{list}; list_parse(p, cs);) { for (cs_list_parse_state p{list}; list_parse(p, cs);) {
@ -117,8 +117,8 @@ template<bool PushList, bool Swap, typename F>
static inline void cs_list_merge( static inline void cs_list_merge(
cs_state &cs, cs_value_r args, cs_value &res, F cmp cs_state &cs, cs_value_r args, cs_value &res, F cmp
) { ) {
ostd::string_range list = args[0].get_str(); std::string_view list = args[0].get_str();
ostd::string_range elems = args[1].get_str(); std::string_view elems = args[1].get_str();
cs_charbuf buf{cs}; cs_charbuf buf{cs};
if (PushList) { if (PushList) {
buf.append(list); buf.append(list);
@ -153,7 +153,7 @@ void cs_init_lib_list(cs_state &gcs) {
cs_list_parse_state p{str}; cs_list_parse_state p{str};
p.item = str; p.item = str;
for (size_t i = 1; i < args.size(); ++i) { for (size_t i = 1; i < args.size(); ++i) {
p.input = str; p.set_input(str);
cs_int pos = args[i].get_int(); cs_int pos = args[i].get_int();
for (; pos > 0; --pos) { for (; pos > 0; --pos) {
if (!list_parse(p, cs)) { if (!list_parse(p, cs)) {
@ -161,7 +161,7 @@ void cs_init_lib_list(cs_state &gcs) {
} }
} }
if (pos > 0 || !list_parse(p, cs)) { if (pos > 0 || !list_parse(p, cs)) {
p.item = p.quoted_item = ostd::string_range(); p.item = p.quoted_item = std::string_view{};
} }
} }
res.set_str(list_get_item(p, cs)); res.set_str(list_get_item(p, cs));
@ -183,18 +183,18 @@ void cs_init_lib_list(cs_state &gcs) {
if (offset > 0) { if (offset > 0) {
list_find_item(p); list_find_item(p);
} }
res.set_str(p.input); res.set_str(p.get_input());
return; return;
} }
char const *list = p.input.data(); char const *list = p.get_input().data();
p.quoted_item = ostd::string_range(); p.quoted_item = std::string_view{};
if (len > 0 && list_parse(p, cs)) { if (len > 0 && list_parse(p, cs)) {
while (--len > 0 && list_parse(p, cs)); while (--len > 0 && list_parse(p, cs));
} }
ostd::string_range quote = p.quoted_item; std::string_view quote = p.quoted_item;
char const *qend = !quote.empty() ? &quote[quote.size()] : list; char const *qend = !quote.empty() ? &quote[quote.size()] : list;
res.set_str(ostd::string_range{list, qend}); res.set_str(std::string_view{list, std::size_t(qend - list)});
}); });
gcs.new_command("listfind", "rse", [](auto &cs, auto args, auto &res) { gcs.new_command("listfind", "rse", [](auto &cs, auto args, auto &res) {
@ -255,8 +255,8 @@ void cs_init_lib_list(cs_state &gcs) {
); );
}); });
gcs.new_command("listfind=s", "s", [](auto &cs, auto args, auto &res) { gcs.new_command("listfind=s", "s", [](auto &cs, auto args, auto &res) {
cs_list_find<ostd::string_range>( cs_list_find<std::string_view>(
cs, args, res, [](cs_list_parse_state const &p, ostd::string_range val) { cs, args, res, [](cs_list_parse_state const &p, std::string_view val) {
return p.item == val; return p.item == val;
} }
); );
@ -277,8 +277,8 @@ void cs_init_lib_list(cs_state &gcs) {
); );
}); });
gcs.new_command("listassoc=s", "s", [](auto &cs, auto args, auto &res) { gcs.new_command("listassoc=s", "s", [](auto &cs, auto args, auto &res) {
cs_list_assoc<ostd::string_range>( cs_list_assoc<std::string_view>(
cs, args, res, [](cs_list_parse_state const &p, ostd::string_range val) { cs, args, res, [](cs_list_parse_state const &p, std::string_view val) {
return p.item == val; return p.item == val;
} }
); );
@ -424,16 +424,16 @@ end:
gcs.new_command("prettylist", "ss", [](auto &cs, auto args, auto &res) { gcs.new_command("prettylist", "ss", [](auto &cs, auto args, auto &res) {
auto buf = ostd::appender<cs_charbuf>(cs); auto buf = ostd::appender<cs_charbuf>(cs);
ostd::string_range s = args[0].get_str(); std::string_view s = args[0].get_str();
ostd::string_range conj = args[1].get_str(); std::string_view conj = args[1].get_str();
cs_list_parse_state p{s}; cs_list_parse_state p{s};
size_t len = list_count(p, cs); size_t len = list_count(p, cs);
size_t n = 0; size_t n = 0;
for (p.input = s; list_parse(p, cs); ++n) { for (p.set_input(s); list_parse(p, cs); ++n) {
if (!p.quoted_item.empty() && (p.quoted_item.front() == '"')) { if (!p.quoted_item.empty() && (p.quoted_item.front() == '"')) {
util::unescape_string(buf, p.item); util::unescape_string(buf, p.item);
} else { } else {
ostd::range_put_all(buf, p.item); buf.get().append(p.item);
} }
if ((n + 1) < len) { if ((n + 1) < len) {
if ((len > 2) || conj.empty()) { if ((len > 2) || conj.empty()) {
@ -441,7 +441,7 @@ end:
} }
if ((n + 2 == len) && !conj.empty()) { if ((n + 2 == len) && !conj.empty()) {
buf.put(' '); buf.put(' ');
ostd::range_put_all(buf, conj); buf.get().append(conj);
} }
buf.put(' '); buf.put(' ');
} }
@ -468,8 +468,8 @@ end:
gcs.new_command("listsplice", "ssii", [](auto &cs, auto args, auto &res) { gcs.new_command("listsplice", "ssii", [](auto &cs, auto args, auto &res) {
cs_int offset = std::max(args[2].get_int(), cs_int(0)); cs_int offset = std::max(args[2].get_int(), cs_int(0));
cs_int len = std::max(args[3].get_int(), cs_int(0)); cs_int len = std::max(args[3].get_int(), cs_int(0));
ostd::string_range s = args[0].get_str(); std::string_view s = args[0].get_str();
ostd::string_range vals = args[1].get_str(); std::string_view vals = args[1].get_str();
char const *list = s.data(); char const *list = s.data();
cs_list_parse_state p{s}; cs_list_parse_state p{s};
for (cs_int i = 0; i < offset; ++i) { for (cs_int i = 0; i < offset; ++i) {
@ -477,7 +477,7 @@ end:
break; break;
} }
} }
ostd::string_range quote = p.quoted_item; std::string_view quote = p.quoted_item;
char const *qend = !quote.empty() ? &quote[quote.size()] : list; char const *qend = !quote.empty() ? &quote[quote.size()] : list;
cs_charbuf buf{cs}; cs_charbuf buf{cs};
if (qend > list) { if (qend > list) {
@ -495,8 +495,8 @@ end:
} }
} }
list_find_item(p); list_find_item(p);
if (!p.input.empty()) { if (!p.get_input().empty()) {
switch (p.input.front()) { switch (p.get_input().front()) {
case ')': case ')':
case ']': case ']':
break; break;
@ -504,7 +504,7 @@ end:
if (!buf.empty()) { if (!buf.empty()) {
buf.push_back(' '); buf.push_back(' ');
} }
buf.append(p.input); buf.append(p.get_input());
break; break;
} }
} }
@ -515,8 +515,8 @@ end:
} }
struct ListSortItem { struct ListSortItem {
ostd::string_range str; std::string_view str;
ostd::string_range quote; std::string_view quote;
}; };
struct ListSortFun { struct ListSortFun {
@ -534,7 +534,7 @@ struct ListSortFun {
}; };
static void cs_list_sort( static void cs_list_sort(
cs_state &cs, cs_value &res, ostd::string_range list, cs_state &cs, cs_value &res, std::string_view list,
cs_ident *x, cs_ident *y, cs_bcode *body, cs_bcode *unique cs_ident *x, cs_ident *y, cs_bcode *body, cs_bcode *unique
) { ) {
if (x == y || !x->is_alias() || !y->is_alias()) { if (x == y || !x->is_alias() || !y->is_alias()) {
@ -575,7 +575,7 @@ static void cs_list_sort(
for (size_t i = 1; i < items.size(); i++) { for (size_t i = 1; i < items.size(); i++) {
ListSortItem &item = items[i]; ListSortItem &item = items[i];
if (f(items[i - 1], item)) { if (f(items[i - 1], item)) {
item.quote = nullptr; item.quote = std::string_view{};
} else { } else {
totaluniq += item.quote.size(); totaluniq += item.quote.size();
++nuniq; ++nuniq;
@ -591,7 +591,7 @@ static void cs_list_sort(
for (size_t j = 0; j < i; ++j) { for (size_t j = 0; j < i; ++j) {
ListSortItem &prev = items[j]; ListSortItem &prev = items[j];
if (!prev.quote.empty() && f(item, prev)) { if (!prev.quote.empty() && f(item, prev)) {
item.quote = nullptr; item.quote = std::string_view{};
break; break;
} }
} }

111
src/lib_str.cc
View File

@ -16,8 +16,8 @@ static inline void cs_strgcmp(cs_value_r args, cs_value &res, F cfunc) {
} }
} else { } else {
val = cfunc( val = cfunc(
!args.empty() ? args[0].get_str() : ostd::string_range(), !args.empty() ? args[0].get_str() : std::string_view(),
ostd::string_range() std::string_view()
); );
} }
res.set_int(cs_int(val)); res.set_int(cs_int(val));
@ -25,16 +25,13 @@ static inline void cs_strgcmp(cs_value_r args, cs_value &res, F cfunc) {
void cs_init_lib_string(cs_state &cs) { void cs_init_lib_string(cs_state &cs) {
cs.new_command("strstr", "ss", [](auto &, auto args, auto &res) { cs.new_command("strstr", "ss", [](auto &, auto args, auto &res) {
ostd::string_range a = args[0].get_str(), b = args[1].get_str(); std::string_view a = args[0].get_str(), b = args[1].get_str();
ostd::string_range s = a; auto pos = a.find(b);
for (cs_int i = 0; b.size() <= s.size(); ++i) { if (pos == a.npos) {
if (b == s.slice(0, b.size())) { res.set_int(-1);
res.set_int(i); } else {
return; res.set_int(cs_int(pos));
}
++s;
} }
res.set_int(-1);
}); });
cs.new_command("strlen", "s", [](auto &, auto args, auto &res) { cs.new_command("strlen", "s", [](auto &, auto args, auto &res) {
@ -42,7 +39,7 @@ void cs_init_lib_string(cs_state &cs) {
}); });
cs.new_command("strcode", "si", [](auto &, auto args, auto &res) { cs.new_command("strcode", "si", [](auto &, auto args, auto &res) {
ostd::string_range str = args[0].get_str(); std::string_view str = args[0].get_str();
cs_int i = args[1].get_int(); cs_int i = args[1].get_int();
if (i >= cs_int(str.size())) { if (i >= cs_int(str.size())) {
res.set_int(0); res.set_int(0);
@ -53,11 +50,11 @@ void cs_init_lib_string(cs_state &cs) {
cs.new_command("codestr", "i", [](auto &, auto args, auto &res) { cs.new_command("codestr", "i", [](auto &, auto args, auto &res) {
char const p[2] = { char(args[0].get_int()), '\0' }; char const p[2] = { char(args[0].get_int()), '\0' };
res.set_str(ostd::string_range{static_cast<char const *>(p)}); res.set_str(std::string_view{static_cast<char const *>(p)});
}); });
cs.new_command("strlower", "s", [](auto &ccs, auto args, auto &res) { cs.new_command("strlower", "s", [](auto &ccs, auto args, auto &res) {
auto inps = ostd::string_range{args[0].get_str()}; auto inps = std::string_view{args[0].get_str()};
auto *ics = cs_get_sstate(ccs); auto *ics = cs_get_sstate(ccs);
auto *buf = ics->strman->alloc_buf(inps.size()); auto *buf = ics->strman->alloc_buf(inps.size());
for (auto i: ostd::range(inps.size())) { for (auto i: ostd::range(inps.size())) {
@ -70,7 +67,7 @@ void cs_init_lib_string(cs_state &cs) {
}); });
cs.new_command("strupper", "s", [](auto &ccs, auto args, auto &res) { cs.new_command("strupper", "s", [](auto &ccs, auto args, auto &res) {
auto inps = ostd::string_range{args[0].get_str()}; auto inps = std::string_view{args[0].get_str()};
auto *ics = cs_get_sstate(ccs); auto *ics = cs_get_sstate(ccs);
auto *buf = ics->strman->alloc_buf(inps.size()); auto *buf = ics->strman->alloc_buf(inps.size());
for (auto i: ostd::range(inps.size())) { for (auto i: ostd::range(inps.size())) {
@ -108,16 +105,16 @@ void cs_init_lib_string(cs_state &cs) {
} }
cs_charbuf s{ccs}; cs_charbuf s{ccs};
cs_strref fs = args[0].get_str(); cs_strref fs = args[0].get_str();
ostd::string_range f{fs}; std::string_view f{fs};
while (!f.empty()) { for (auto it = f.begin(); it != f.end(); ++it) {
char c = *f; char c = *it;
++f; ++it;
if ((c == '%') && !f.empty()) { if ((c == '%') && (it != f.end())) {
char ic = *f; char ic = *it;
++f; ++it;
if (ic >= '1' && ic <= '9') { if ((ic >= '1') && (ic <= '9')) {
int i = ic - '0'; int i = ic - '0';
if (size_t(i) < args.size()) { if (std::size_t(i) < args.size()) {
s.append(args[i].get_str()); s.append(args[i].get_str());
} }
} else { } else {
@ -144,89 +141,85 @@ void cs_init_lib_string(cs_state &cs) {
}); });
cs.new_command("substr", "siiN", [](auto &, auto args, auto &res) { cs.new_command("substr", "siiN", [](auto &, auto args, auto &res) {
ostd::string_range s = args[0].get_str(); std::string_view s = args[0].get_str();
cs_int start = args[1].get_int(), count = args[2].get_int(); cs_int start = args[1].get_int(), count = args[2].get_int();
cs_int numargs = args[3].get_int(); cs_int numargs = args[3].get_int();
cs_int len = cs_int(s.size()), offset = std::clamp(start, cs_int(0), len); cs_int len = cs_int(s.size()), offset = std::clamp(start, cs_int(0), len);
res.set_str(ostd::string_range{ res.set_str(std::string_view{
&s[offset], &s[offset],
&s[offset] + ((numargs >= 3) ((numargs >= 3)
? size_t(std::clamp(count, cs_int(0), len - offset)) ? size_t(std::clamp(count, cs_int(0), len - offset))
: size_t(len - offset)) : size_t(len - offset))
}); });
}); });
cs.new_command("strcmp", "s1V", [](auto &, auto args, auto &res) { cs.new_command("strcmp", "s1V", [](auto &, auto args, auto &res) {
cs_strgcmp(args, res, std::equal_to<ostd::string_range>()); cs_strgcmp(args, res, std::equal_to<std::string_view>());
}); });
cs.new_command("=s", "s1V", [](auto &, auto args, auto &res) { cs.new_command("=s", "s1V", [](auto &, auto args, auto &res) {
cs_strgcmp(args, res, std::equal_to<ostd::string_range>()); cs_strgcmp(args, res, std::equal_to<std::string_view>());
}); });
cs.new_command("!=s", "s1V", [](auto &, auto args, auto &res) { cs.new_command("!=s", "s1V", [](auto &, auto args, auto &res) {
cs_strgcmp(args, res, std::not_equal_to<ostd::string_range>()); cs_strgcmp(args, res, std::not_equal_to<std::string_view>());
}); });
cs.new_command("<s", "s1V", [](auto &, auto args, auto &res) { cs.new_command("<s", "s1V", [](auto &, auto args, auto &res) {
cs_strgcmp(args, res, std::less<ostd::string_range>()); cs_strgcmp(args, res, std::less<std::string_view>());
}); });
cs.new_command(">s", "s1V", [](auto &, auto args, auto &res) { cs.new_command(">s", "s1V", [](auto &, auto args, auto &res) {
cs_strgcmp(args, res, std::greater<ostd::string_range>()); cs_strgcmp(args, res, std::greater<std::string_view>());
}); });
cs.new_command("<=s", "s1V", [](auto &, auto args, auto &res) { cs.new_command("<=s", "s1V", [](auto &, auto args, auto &res) {
cs_strgcmp(args, res, std::less_equal<ostd::string_range>()); cs_strgcmp(args, res, std::less_equal<std::string_view>());
}); });
cs.new_command(">=s", "s1V", [](auto &, auto args, auto &res) { cs.new_command(">=s", "s1V", [](auto &, auto args, auto &res) {
cs_strgcmp(args, res, std::greater_equal<ostd::string_range>()); cs_strgcmp(args, res, std::greater_equal<std::string_view>());
}); });
cs.new_command("strreplace", "ssss", [](auto &ccs, auto args, auto &res) { cs.new_command("strreplace", "ssss", [](auto &ccs, auto args, auto &res) {
ostd::string_range s = args[0].get_str(); std::string_view s = args[0].get_str();
ostd::string_range oldval = args[1].get_str(), std::string_view oldval = args[1].get_str(),
newval = args[2].get_str(), newval = args[2].get_str(),
newval2 = args[3].get_str(); newval2 = args[3].get_str();
if (newval2.empty()) { if (newval2.empty()) {
newval2 = newval; newval2 = newval;
} }
if (!oldval.size()) { if (oldval.empty()) {
res.set_str(s); res.set_str(s);
return; return;
} }
cs_charbuf buf{ccs}; cs_charbuf buf{ccs};
for (size_t i = 0;; ++i) { for (size_t i = 0;; ++i) {
ostd::string_range found; std::string_view found;
ostd::string_range trys = s; auto p = s.find(oldval);
for (; oldval.size() <= trys.size(); ++trys) { if (p == s.npos) {
if (trys.slice(0, oldval.size()) == oldval) {
found = trys;
break;
}
}
if (!found.empty()) {
buf.append(s.slice(0, &found[0] - &s[0]));
buf.append((i & 1) ? newval2 : newval);
s = found.slice(oldval.size(), found.size());
} else {
buf.append(s); buf.append(s);
res.set_str(buf.str()); res.set_str(s);
return; return;
} }
buf.append(s.substr(0, p));
buf.append((i & 1) ? newval2 : newval);
buf.append(s.substr(
p + oldval.size(),
s.size() - p - oldval.size()
));
} }
}); });
cs.new_command("strsplice", "ssii", [](auto &ccs, auto args, auto &res) { cs.new_command("strsplice", "ssii", [](auto &ccs, auto args, auto &res) {
ostd::string_range s = args[0].get_str(); std::string_view s = args[0].get_str();
ostd::string_range vals = args[1].get_str(); std::string_view vals = args[1].get_str();
cs_int skip = args[2].get_int(), cs_int skip = args[2].get_int(),
count = args[3].get_int(); count = args[3].get_int();
cs_int offset = std::clamp(skip, cs_int(0), cs_int(s.size())), cs_int offset = std::clamp(skip, cs_int(0), cs_int(s.size())),
len = std::clamp(count, cs_int(0), cs_int(s.size()) - offset); len = std::clamp(count, cs_int(0), cs_int(s.size()) - offset);
cs_charbuf p{ccs}; cs_charbuf p{ccs};
p.reserve(s.size() - len + vals.size()); p.reserve(s.size() - len + vals.size());
if (offset) { if (offset) {
p.append(s.slice(0, offset)); p.append(s.substr(0, offset));
} }
p.append(vals); p.append(vals);
if ((offset + len) < cs_int(s.size())) { if ((offset + len) < cs_int(s.size())) {
p.append(s.slice(offset + len, s.size())); p.append(s.substr(offset + len, s.size() - offset - len));
} }
res.set_str(p.str()); res.set_str(p.str());
}); });

4
tools/edit_fallback.hh
View File

@ -5,7 +5,7 @@
#include <ostd/string.hh> #include <ostd/string.hh>
inline void init_lineedit(cs_state &, ostd::string_range) { inline void init_lineedit(cs_state &, std::string_view) {
} }
inline std::optional<std::string> read_line(cs_state &, cs_svar *pr) { inline std::optional<std::string> read_line(cs_state &, cs_svar *pr) {
@ -13,7 +13,7 @@ inline std::optional<std::string> read_line(cs_state &, cs_svar *pr) {
return ostd::cin.get_line(ostd::appender<std::string>()).get(); return ostd::cin.get_line(ostd::appender<std::string>()).get();
} }
inline void add_history(cs_state &, ostd::string_range) { inline void add_history(cs_state &, std::string_view) {
} }
#endif #endif

10
tools/edit_linenoise.hh
View File

@ -17,16 +17,16 @@
static cs_state *ln_cs = nullptr; static cs_state *ln_cs = nullptr;
inline void ln_complete(char const *buf, linenoiseCompletions *lc) { inline void ln_complete(char const *buf, linenoiseCompletions *lc) {
ostd::string_range cmd = get_complete_cmd(buf); std::string_view cmd = get_complete_cmd(buf);
for (auto id: ln_cs->get_idents()) { for (auto id: ln_cs->get_idents()) {
if (!id->is_command()) { if (!id->is_command()) {
continue; continue;
} }
ostd::string_range idname = id->get_name(); std::string_view idname = id->get_name();
if (idname.size() <= cmd.size()) { if (idname.size() <= cmd.size()) {
continue; continue;
} }
if (idname.slice(0, cmd.size()) == cmd) { if (idname.substr(0, cmd.size()) == cmd) {
linenoiseAddCompletion(lc, idname.data()); linenoiseAddCompletion(lc, idname.data());
} }
} }
@ -51,7 +51,7 @@ inline void ln_hint_free(void *hint) {
delete[] static_cast<char *>(hint); delete[] static_cast<char *>(hint);
} }
inline void init_lineedit(cs_state &cs, ostd::string_range) { inline void init_lineedit(cs_state &cs, std::string_view) {
/* sensible default history size */ /* sensible default history size */
linenoiseHistorySetMaxLen(1000); linenoiseHistorySetMaxLen(1000);
ln_cs = &cs; ln_cs = &cs;
@ -75,7 +75,7 @@ inline std::optional<std::string> read_line(cs_state &, cs_svar *pr) {
return ret; return ret;
} }
inline void add_history(cs_state &, ostd::string_range line) { inline void add_history(cs_state &, std::string_view line) {
/* backed by std::string so it's terminated */ /* backed by std::string so it's terminated */
linenoiseHistoryAdd(line.data()); linenoiseHistoryAdd(line.data());
} }

10
tools/edit_readline.hh
View File

@ -15,7 +15,7 @@
static cs_state *rd_cs = nullptr; static cs_state *rd_cs = nullptr;
inline char *ln_complete_list(char const *buf, int state) { inline char *ln_complete_list(char const *buf, int state) {
static ostd::string_range cmd; static std::string_view cmd;
static ostd::iterator_range<cs_ident **> itr; static ostd::iterator_range<cs_ident **> itr;
if (!state) { if (!state) {
@ -28,11 +28,11 @@ inline char *ln_complete_list(char const *buf, int state) {
if (!id->is_command()) { if (!id->is_command()) {
continue; continue;
} }
ostd::string_range idname = id->get_name(); std::string_view idname = id->get_name();
if (idname.size() <= cmd.size()) { if (idname.size() <= cmd.size()) {
continue; continue;
} }
if (idname.slice(0, cmd.size()) == cmd) { if (idname.substr(0, cmd.size()) == cmd) {
itr.pop_front(); itr.pop_front();
return strdup(idname.data()); return strdup(idname.data());
} }
@ -63,7 +63,7 @@ inline void ln_hint() {
rl_replace_line(old.data(), 0); rl_replace_line(old.data(), 0);
} }
inline void init_lineedit(cs_state &cs, ostd::string_range) { inline void init_lineedit(cs_state &cs, std::string_view) {
rd_cs = &cs; rd_cs = &cs;
rl_attempted_completion_function = ln_complete; rl_attempted_completion_function = ln_complete;
rl_redisplay_function = ln_hint; rl_redisplay_function = ln_hint;
@ -79,7 +79,7 @@ inline std::optional<std::string> read_line(cs_state &, cs_svar *pr) {
return ret; return ret;
} }
inline void add_history(cs_state &, ostd::string_range line) { inline void add_history(cs_state &, std::string_view line) {
/* backed by std::string so it's terminated */ /* backed by std::string so it's terminated */
add_history(line.data()); add_history(line.data());
} }

82
tools/repl.cc
View File

@ -10,7 +10,7 @@
using namespace cscript; using namespace cscript;
ostd::string_range version = "CubeScript 0.0.1"; std::string_view version = "CubeScript 0.0.1";
/* util */ /* util */
@ -28,18 +28,17 @@ static bool stdin_is_tty() {
/* line editing support */ /* line editing support */
inline ostd::string_range get_complete_cmd(ostd::string_range buf) { inline std::string_view get_complete_cmd(std::string_view buf) {
ostd::string_range not_allowed = "\"/;()[] \t\r\n\0"; std::string_view not_allowed = "\"/;()[] \t\r\n\0";
ostd::string_range found = ostd::find_one_of(buf, not_allowed); auto found = buf.find_first_of(not_allowed);
while (!found.empty()) { while (found != buf.npos) {
++found; buf = buf.substr(found + 1, buf.size() - found - 1);
buf = found; found = buf.find_first_of(not_allowed);
found = ostd::find_one_of(found, not_allowed);
} }
return buf; return buf;
} }
inline ostd::string_range get_arg_type(char arg) { inline std::string_view get_arg_type(char arg) {
switch (arg) { switch (arg) {
case 'i': case 'i':
return "int"; return "int";
@ -71,15 +70,15 @@ inline ostd::string_range get_arg_type(char arg) {
return "illegal"; return "illegal";
} }
inline void fill_cmd_args(std::string &writer, ostd::string_range args) { inline void fill_cmd_args(std::string &writer, std::string_view args) {
char variadic = '\0'; char variadic = '\0';
int nrep = 0; int nrep = 0;
if (!args.empty() && ((args.back() == 'V') || (args.back() == 'C'))) { if (!args.empty() && ((args.back() == 'V') || (args.back() == 'C'))) {
variadic = args.back(); variadic = args.back();
args.pop_back(); args.remove_suffix(1);
if (!args.empty() && isdigit(args.back())) { if (!args.empty() && isdigit(args.back())) {
nrep = args.back() - '0'; nrep = args.back() - '0';
args.pop_back(); args.remove_suffix(1);
} }
} }
if (args.empty()) { if (args.empty()) {
@ -96,8 +95,8 @@ inline void fill_cmd_args(std::string &writer, ostd::string_range args) {
if (i != 0) { if (i != 0) {
writer += ", "; writer += ", ";
} }
writer += get_arg_type(*args); writer += get_arg_type(args.front());
++args; args.remove_prefix(1);
} }
} }
if (variadic) { if (variadic) {
@ -128,22 +127,27 @@ inline void fill_cmd_args(std::string &writer, ostd::string_range args) {
} }
} }
inline cs_command *get_hint_cmd(cs_state &cs, ostd::string_range buf) { inline cs_command *get_hint_cmd(cs_state &cs, std::string_view buf) {
ostd::string_range nextchars = "([;"; std::string_view nextchars = "([;";
auto lp = ostd::find_one_of(buf, nextchars); auto lp = buf.find_first_of(nextchars);
if (!lp.empty()) { if (lp != buf.npos) {
cs_command *cmd = get_hint_cmd(cs, buf.slice(1, buf.size())); cs_command *cmd = get_hint_cmd(cs, buf.substr(1, buf.size() - 1));
if (cmd) { if (cmd) {
return cmd; return cmd;
} }
} }
while (!buf.empty() && isspace(buf.front())) { std::size_t nsp = 0;
++buf; for (auto c: buf) {
if (!isspace(c)) {
break;
}
++nsp;
} }
ostd::string_range spaces = " \t\r\n"; buf.remove_prefix(nsp);
ostd::string_range s = ostd::find_one_of(buf, spaces); std::string_view spaces = " \t\r\n";
if (!s.empty()) { auto p = buf.find_first_of(spaces);
buf = buf.slice(0, &s[0] - &buf[0]); if (p != buf.npos) {
buf = buf.substr(0, p);
} }
if (!buf.empty()) { if (!buf.empty()) {
auto cmd = cs.get_ident(buf); auto cmd = cs.get_ident(buf);
@ -158,7 +162,7 @@ inline cs_command *get_hint_cmd(cs_state &cs, ostd::string_range buf) {
/* usage */ /* usage */
void print_usage(ostd::string_range progname, bool err) { void print_usage(std::string_view progname, bool err) {
auto &s = err ? ostd::cerr : ostd::cout; auto &s = err ? ostd::cerr : ostd::cout;
s.writeln( s.writeln(
"Usage: ", progname, " [options] [file]\n" "Usage: ", progname, " [options] [file]\n"
@ -216,8 +220,8 @@ static void repl_print_var(cs_state const &cs, cs_var const &var) {
} }
case cs_ident_type::SVAR: { case cs_ident_type::SVAR: {
auto &sv = static_cast<cs_svar const &>(var); auto &sv = static_cast<cs_svar const &>(var);
auto val = ostd::string_range{sv.get_value()}; auto val = std::string_view{sv.get_value()};
if (ostd::find(val, '"').empty()) { if (val.find('"') == val.npos) {
ostd::writefln("%s = \"%s\"", sv.get_name(), val); ostd::writefln("%s = \"%s\"", sv.get_name(), val);
} else { } else {
ostd::writefln("%s = [%s]", sv.get_name(), val); ostd::writefln("%s = [%s]", sv.get_name(), val);
@ -229,7 +233,7 @@ static void repl_print_var(cs_state const &cs, cs_var const &var) {
} }
} }
static bool do_call(cs_state &cs, ostd::string_range line, bool file = false) { static bool do_call(cs_state &cs, std::string_view line, bool file = false) {
cs_value ret{cs}; cs_value ret{cs};
scs = &cs; scs = &cs;
signal(SIGINT, do_sigint); signal(SIGINT, do_sigint);
@ -244,15 +248,17 @@ static bool do_call(cs_state &cs, ostd::string_range line, bool file = false) {
} catch (cscript::cs_error const &e) { } catch (cscript::cs_error const &e) {
signal(SIGINT, SIG_DFL); signal(SIGINT, SIG_DFL);
scs = nullptr; scs = nullptr;
ostd::string_range terr = e.what(); std::string_view terr = e.what();
auto col = ostd::find(terr, ':'); auto col = terr.find(':');
bool is_lnum = false; bool is_lnum = false;
if (!col.empty()) { if (col != terr.npos) {
is_lnum = ostd::find_if( auto pre = terr.substr(0, col);
terr.slice(0, &col[0] - &terr[0]), auto it = std::find_if(
pre.begin(), pre.end(),
[](auto c) { return !isdigit(c); } [](auto c) { return !isdigit(c); }
).empty(); );
terr = col.slice(2, col.size()); is_lnum = (it == pre.end());
terr = terr.substr(col + 2, terr.size() - col - 2);
} }
if (!file && ((terr == "missing \"]\"") || (terr == "missing \")\""))) { if (!file && ((terr == "missing \"]\"") || (terr == "missing \")\""))) {
return true; return true;
@ -267,7 +273,7 @@ static bool do_call(cs_state &cs, ostd::string_range line, bool file = false) {
signal(SIGINT, SIG_DFL); signal(SIGINT, SIG_DFL);
scs = nullptr; scs = nullptr;
if (ret.get_type() != cs_value_type::NONE) { if (ret.get_type() != cs_value_type::NONE) {
ostd::writeln(ret.get_str()); ostd::writeln(std::string_view{ret.get_str()});
} }
return false; return false;
} }
@ -328,7 +334,7 @@ int main(int argc, char **argv) {
}); });
gcs.new_command("echo", "C", [](auto &, auto args, auto &) { gcs.new_command("echo", "C", [](auto &, auto args, auto &) {
ostd::writeln(ostd::string_range{args[0].get_str()}); ostd::writeln(std::string_view{args[0].get_str()});
}); });
int firstarg = 0; int firstarg = 0;