static void String_ctor(struct v7_c_func_arg *cfa) {
struct v7_val *obj = cfa->called_as_constructor ? cfa->this_obj : cfa->result;
struct v7_val *arg = cfa->args[0];
if (cfa->num_args == 1 && arg->type == V7_TYPE_STR) {
v7_init_str(obj, arg->v.str.buf, arg->v.str.len, 1);
} else {
v7_init_str(obj, NULL, 0, 0);
}
if (cfa->called_as_constructor) {
cfa->this_obj->type = V7_TYPE_OBJ;
cfa->this_obj->proto = &s_prototypes[V7_CLASS_STRING];
cfa->this_obj->ctor = &s_constructors[V7_CLASS_STRING];
}
}
static void Str_charAt(struct v7_c_func_arg *cfa) {
double idx = cfa->num_args > 0 && cfa->args[0]->type == V7_TYPE_NUM ?
cfa->args[0]->v.num : NAN;
const struct v7_string *str = &cfa->this_obj->v.str;
if (!isnan(idx) && cfa->this_obj->type == V7_TYPE_STR &&
fabs(idx) < str->len) {
v7_init_str(cfa->result, &str->buf[(int) idx], 1, 1);
}
}
static void Str_substr(struct v7_c_func_arg *cfa) {
long start = 0;
v7_init_str(cfa->result, NULL, 0, 0);
if (cfa->num_args > 0 && cfa->args[0]->type == V7_TYPE_NUM) {
start = (long) cfa->args[0]->v.num;
}
if (start < 0) {
start += (long) cfa->this_obj->v.str.len;
}
if (start >= 0 && start < (long) cfa->this_obj->v.str.len) {
long n = cfa->this_obj->v.str.len - start;
if (cfa->num_args > 1 && cfa->args[1]->type == V7_TYPE_NUM) {
n = cfa->args[1]->v.num;
}
if (n > 0 && n <= ((long) cfa->this_obj->v.str.len - start)) {
v7_init_str(cfa->result, cfa->this_obj->v.str.buf + start, n, 1);
}
}
}
V7_PRIVATE int cmp(const struct v7_val *a, const struct v7_val *b) {
int res;
double an, bn;
const struct v7_string *as, *bs;
struct v7_val ta = MKOBJ(0), tb = MKOBJ(0);
if (a == NULL || b == NULL) return 1;
if ((a->type == V7_TYPE_UNDEF || a->type == V7_TYPE_NULL) &&
(b->type == V7_TYPE_UNDEF || b->type == V7_TYPE_NULL)) return 0;
if (is_num(a) && is_num(b)) {
v7_init_num(&ta, a->v.num);
v7_init_num(&tb, b->v.num);
a = &ta; b = &tb;
}
if (is_string(a) && is_string(b)) {
v7_init_str(&ta, a->v.str.buf, a->v.str.len, 0);
v7_init_str(&tb, b->v.str.buf, b->v.str.len, 0);
a = &ta; b = &tb;
}
if (a->type != b->type) return 1;
an = a->v.num, bn = b->v.num;
as = &a->v.str, bs = &b->v.str;
switch (a->type) {
case V7_TYPE_NUM:
return (isinf(an) && isinf(bn)) ||
(isnan(an) && isnan(bn)) ? 0 : an - bn;
case V7_TYPE_BOOL:
return an != bn;
case V7_TYPE_STR:
res = memcmp(as->buf, bs->buf, as->len < bs->len ? as->len : bs->len);
return res != 0 ? res : (int) as->len - (int) bs->len;
return as->len != bs->len || memcmp(as->buf, bs->buf, as->len) != 0;
default:
return (int) (a - b);
}
}
V7_PRIVATE enum v7_err String_ctor(struct v7_c_func_arg *cfa) {
#define v7 (cfa->v7) /* Needed for TRY() macro below */
const char *str = NULL;
size_t len = 0;
int own = 0;
struct v7_val *arg = cfa->args[0], *obj = cfa->this_obj;
if (!cfa->called_as_constructor) obj = v7_push_new_object(v7);
if (cfa->num_args > 0) {
TRY(check_str_re_conv(v7, &arg, 0));
str = arg->v.str.buf;
len = arg->v.str.len;
own = 1;
}
v7_init_str(obj, str, len, own);
v7_set_class(obj, V7_CLASS_STRING);
return V7_OK;
#undef v7
}
V7_PRIVATE enum v7_err Str_substr(struct v7_c_func_arg *cfa) {
struct v7_val *result = v7_push_string(cfa->v7, NULL, 0, 0);
long start = 0;
if (cfa->num_args > 0 && cfa->args[0]->type == V7_TYPE_NUM) {
start = (long)cfa->args[0]->v.num;
}
if (start < 0) {
start += (long)cfa->this_obj->v.str.len;
}
if (start >= 0 && start < (long)cfa->this_obj->v.str.len) {
long n = cfa->this_obj->v.str.len - start;
if (cfa->num_args > 1 && cfa->args[1]->type == V7_TYPE_NUM) {
n = cfa->args[1]->v.num;
}
if (n > 0 && n <= ((long)cfa->this_obj->v.str.len - start)) {
v7_init_str(result, cfa->this_obj->v.str.buf + start, n, 1);
}
}
return V7_OK;
}
V7_PRIVATE struct v7_val *v7_mkvv(struct v7 *v7, enum v7_type t, va_list *ap) {
struct v7_val *v = make_value(v7, t);
// TODO: check for make_value() failure
switch (t) {
//case V7_C_FUNC: v->v.c_func = va_arg(*ap, v7_func_t); break;
case V7_TYPE_NUM:
v->v.num = va_arg(*ap, double);
break;
case V7_TYPE_STR: {
char *buf = va_arg(*ap, char *);
unsigned long len = va_arg(*ap, unsigned long);
int own = va_arg(*ap, int);
v7_init_str(v, buf, len, own);
}
break;
default:
break;
}
return v;
}
V7_PRIVATE enum v7_err Str_replace(struct v7_c_func_arg *cfa) {
#define v7 (cfa->v7) /* Needed for TRY() macro below */
struct v7_val *result = v7_push_new_object(v7);
const char *out_str = cfa->this_obj->v.str.buf;
uint8_t own = 1;
size_t out_len = cfa->this_obj->v.str.len;
int old_sp = v7->sp;
if (cfa->num_args > 1) {
const char *const str_end =
cfa->this_obj->v.str.buf + cfa->this_obj->v.str.len;
char *p = cfa->this_obj->v.str.buf;
uint32_t out_sub_num = 0;
struct v7_val *re = cfa->args[0], *str_func = cfa->args[1], *arr = NULL;
struct re_tok out_sub[V7_RE_MAX_REPL_SUB], *ptok = out_sub;
struct Resub loot;
TRY(check_str_re_conv(v7, &re, 1));
TRY(regex_check_prog(re));
if (v7_is_class(str_func, V7_CLASS_FUNCTION)) {
arr = v7_push_new_object(v7);
v7_set_class(arr, V7_CLASS_ARRAY);
TRY(v7_push(v7, str_func));
} else
TRY(check_str_re_conv(v7, &str_func, 0));
out_len = 0;
do {
int i;
if (re_exec(re->v.str.prog, re->fl.fl, p, &loot)) break;
if (p != loot.sub->start) {
ptok->start = p;
ptok->end = loot.sub->start;
ptok++;
out_len += loot.sub->start - p;
out_sub_num++;
}
if (NULL != arr) { /* replace function */
Rune rune;
int old_sp = v7->sp, utf_shift = 0;
struct v7_val *rez_str;
for (i = 0; i < loot.subexpr_num; i++)
v7_push_string(v7, loot.sub[i].start,
loot.sub[i].end - loot.sub[i].start, 1);
for (i = 0; p + i < loot.sub[0].start;
i += chartorune(&rune, p + i), utf_shift++)
;
TRY(push_number(v7, utf_shift));
TRY(v7_push(v7, cfa->this_obj));
rez_str = v7_call(v7, cfa->this_obj, loot.subexpr_num + 2);
TRY(check_str_re_conv(v7, &rez_str, 0));
if (rez_str->v.str.len) {
ptok->start = rez_str->v.str.buf;
ptok->end = rez_str->v.str.buf + rez_str->v.str.len;
ptok++;
out_len += rez_str->v.str.len;
out_sub_num++;
v7_append(v7, arr, rez_str);
}
TRY(inc_stack(v7, old_sp - v7->sp));
} else { /* replace string */
struct Resub newsub;
re_rplc(&loot, p, str_func->v.str.buf, &newsub);
for (i = 0; i < newsub.subexpr_num; i++) {
ptok->start = newsub.sub[i].start;
ptok->end = newsub.sub[i].end;
ptok++;
out_len += newsub.sub[i].end - newsub.sub[i].start;
out_sub_num++;
}
}
p = (char *)loot.sub->end;
} while (re->fl.fl.re_g && p < str_end);
if (p < str_end) {
ptok->start = p;
ptok->end = str_end;
ptok++;
out_len += str_end - p;
out_sub_num++;
}
out_str = malloc(out_len + 1);
CHECK(out_str, V7_OUT_OF_MEMORY);
ptok = out_sub;
p = (char *)out_str;
do {
size_t ln = ptok->end - ptok->start;
memcpy(p, ptok->start, ln);
p += ln;
ptok++;
} while (--out_sub_num);
*p = '\0';
own = 0;
}
TRY(inc_stack(v7, old_sp - v7->sp));
v7_init_str(result, out_str, out_len, own);
result->fl.fl.str_alloc = 1;
return V7_OK;
#undef v7
}
