john/cell
1
0
Fork 0
Code Issues 31 Pull Requests Packages Projects Releases 2 Wiki Activity

fix failing tests

Browse Source
This commit is contained in:
John Alanbrook
2026-01-23 07:56:49 -06:00
parent 4cf0ce00de
commit 7468e7e0b9
2 changed files with 391 additions and 313 deletions
Download Patch File Download Diff File Expand all files Collapse all files

672
source/quickjs.c
View File

@@ -491,7 +491,7 @@ struct JSString {
/* Extended symbol atom structure with object-key payload */
typedef struct JSAtomSymbol {
JSString s; /* base atom struct */
JSValue obj_key; /* JS_UNDEFINED for normal symbols; strong ref for object-key symbols */
JSValue obj_key; /* JS_NULL for normal symbols; strong ref for object-key symbols */
} JSAtomSymbol;
static inline JSAtomSymbol *js_atom_as_symbol(JSAtomStruct *p) {
@@ -6654,7 +6654,7 @@ static JSValue JS_GetPropertyValue(JSContext *ctx, JSValueConst this_obj,
/* Unknown type -> null */
JS_FreeValue(ctx, prop);
return JS_ThrowInternalError(ctx, "attempted to access property on odd type: %d", prop_tag);
return JS_NULL;
}
int JS_SetPropertyNumber(JSContext *js, JSValueConst obj, int idx, JSValue val)
@@ -6856,20 +6856,10 @@ int JS_SetPropertyInternal(JSContext *ctx, JSValueConst this_obj, JSAtom prop, J
p = JS_VALUE_GET_OBJ(this_obj);
if (unlikely(p->stone)) {
/* If stone, can only update existing own properties */
prs = find_own_property(&pr, p, prop);
if (!prs) {
JS_FreeValue(ctx, val);
JS_ThrowTypeError(ctx, "object is stone");
return -1;
}
/* Handle VARREF for closures */
if ((prs->flags & JS_PROP_TMASK) == JS_PROP_VARREF) {
set_value(ctx, pr->u.var_ref->pvalue, val);
return TRUE;
}
set_value(ctx, &pr->u.value, val);
return TRUE;
/* Stone objects cannot be modified at all */
JS_FreeValue(ctx, val);
JS_ThrowTypeError(ctx, "object is stone");
return -1;
}
/* Object is not stone - find or create property */
@@ -11717,6 +11707,11 @@ static JSValue JS_CallInternal(JSContext *caller_ctx, JSValueConst func_obj,
b = JS_VALUE_GET_FLOAT64(op2);
res = __JS_NewFloat64(ctx, a + b);
} else if (tag1 == JS_TAG_NULL || tag2 == JS_TAG_NULL) {
/* null + string or string + null should throw */
if (JS_IsString(op1) || JS_IsString(op2)) {
JS_ThrowTypeError(ctx, "cannot concatenate null with string");
goto exception;
}
res = JS_NULL;
}
/* 5) anything else → throw */
@@ -24638,177 +24633,169 @@ void *lre_realloc(void *opaque, void *ptr, size_t size)
return js_realloc_rt(ctx->rt, ptr, size);
}
static JSValue js_regexp_exec(JSContext *ctx, JSValueConst this_val,
int argc, JSValueConst *argv)
static JSValue js_regexp_exec(JSContext *ctx, JSValueConst this_val, int argc, JSValueConst *argv)
{
JSRegExp *re = js_get_regexp(ctx, this_val, TRUE);
JSString *str;
JSValue t, ret, str_val, obj, val, groups;
JSValue indices, indices_groups;
uint8_t *re_bytecode;
uint8_t **capture, *str_buf;
int rc, capture_count, shift, i, re_flags;
int64_t last_index;
const char *group_name_ptr;
JSRegExp *re = js_get_regexp(ctx, this_val, TRUE);
JSString *str;
JSValue ret, str_val, res, val, groups, captures_arr, match0;
uint8_t *re_bytecode;
uint8_t **capture, *str_buf;
int rc, capture_count, shift, i, re_flags;
int64_t last_index;
const char *group_name_ptr;
if (!re)
return JS_EXCEPTION;
if (!re) return JS_EXCEPTION;
str_val = JS_ToString(ctx, argv[0]);
if (JS_IsException(str_val))
return JS_EXCEPTION;
str_val = JS_ToString(ctx, argv[0]);
if (JS_IsException(str_val)) return JS_EXCEPTION;
ret = JS_EXCEPTION;
obj = JS_NULL;
groups = JS_NULL;
indices = JS_NULL;
indices_groups = JS_NULL;
capture = NULL;
ret = JS_EXCEPTION;
res = JS_NULL;
groups = JS_NULL;
captures_arr = JS_NULL;
match0 = JS_NULL;
capture = NULL;
val = JS_GetProperty(ctx, this_val, JS_ATOM_lastIndex);
if (JS_IsException(val) || JS_ToLengthFree(ctx, &last_index, val))
goto fail;
val = JS_GetProperty(ctx, this_val, JS_ATOM_lastIndex);
if (JS_IsException(val) || JS_ToLengthFree(ctx, &last_index, val)) goto fail;
re_bytecode = re->bytecode->u.str8;
re_flags = lre_get_flags(re_bytecode);
if ((re_flags & (LRE_FLAG_GLOBAL | LRE_FLAG_STICKY)) == 0) {
last_index = 0;
re_bytecode = re->bytecode->u.str8;
re_flags = lre_get_flags(re_bytecode);
if ((re_flags & (LRE_FLAG_GLOBAL | LRE_FLAG_STICKY)) == 0) last_index = 0;
str = JS_VALUE_GET_STRING(str_val);
capture_count = lre_get_capture_count(re_bytecode);
if (capture_count > 0) {
capture = js_malloc(ctx, sizeof(capture[0]) * capture_count * 2);
if (!capture) goto fail;
}
shift = str->is_wide_char;
str_buf = str->u.str8;
if (last_index > str->len) {
rc = 2;
} else {
rc = lre_exec(capture, re_bytecode, str_buf, last_index, str->len, shift, ctx);
}
if (rc != 1) {
if (rc >= 0) {
if (rc == 2 || (re_flags & (LRE_FLAG_GLOBAL | LRE_FLAG_STICKY))) {
if (JS_SetProperty(ctx, this_val, JS_ATOM_lastIndex, JS_NewInt32(ctx, 0)) < 0) goto fail;
}
ret = JS_NULL;
goto done;
}
str = JS_VALUE_GET_STRING(str_val);
capture_count = lre_get_capture_count(re_bytecode);
if (capture_count > 0) {
capture = js_malloc(ctx, sizeof(capture[0]) * capture_count * 2);
if (!capture)
goto fail;
if (rc == LRE_RET_TIMEOUT) JS_ThrowInterrupted(ctx);
else JS_ThrowInternalError(ctx, "out of memory in regexp execution");
goto fail;
}
if (re_flags & (LRE_FLAG_GLOBAL | LRE_FLAG_STICKY)) {
if (JS_SetProperty(ctx, this_val, JS_ATOM_lastIndex, JS_NewInt32(ctx, (capture[1] - str_buf) >> shift)) < 0) goto fail;
}
res = JS_NewObjectProto(ctx, JS_NULL);
if (JS_IsException(res)) goto fail;
{
int cap_groups = (capture_count > 1) ? (capture_count - 1) : 0;
captures_arr = JS_NewArrayLen(ctx, cap_groups);
if (JS_IsException(captures_arr)) goto fail;
}
group_name_ptr = lre_get_groupnames(re_bytecode);
if (group_name_ptr) {
groups = JS_NewObjectProto(ctx, JS_NULL);
if (JS_IsException(groups)) goto fail;
}
{
int match_start = -1;
int match_end = -1;
for (i = 0; i < capture_count; i++) {
const char *name = NULL;
uint8_t **m = &capture[2 * i];
int start = -1;
int end = -1;
JSValue s;
if (group_name_ptr && i > 0) {
if (*group_name_ptr) name = group_name_ptr;
group_name_ptr += strlen(group_name_ptr) + 1;
}
if (m[0] && m[1]) {
start = (m[0] - str_buf) >> shift;
end = (m[1] - str_buf) >> shift;
}
s = JS_NULL;
if (start != -1) {
s = js_sub_string(ctx, str, start, end);
if (JS_IsException(s)) goto fail;
}
if (i == 0) {
match_start = start;
match_end = end;
match0 = s;
continue;
}
if (name) {
if (JS_SetPropertyStr(ctx, groups, name, JS_DupValue(ctx, s)) < 0) {
JS_FreeValue(ctx, s);
goto fail;
}
}
if (JS_SetPropertyUint32(ctx, captures_arr, (uint32_t)(i - 1), s) < 0) goto fail;
}
shift = str->is_wide_char;
str_buf = str->u.str8;
if (last_index > str->len) {
rc = 2;
if (match_start < 0) match_start = 0;
if (match_end < match_start) match_end = match_start;
if (JS_SetPropertyStr(ctx, res, "index", JS_NewInt32(ctx, match_start)) < 0) goto fail;
if (JS_SetPropertyStr(ctx, res, "end", JS_NewInt32(ctx, match_end)) < 0) goto fail;
if (JS_SetPropertyStr(ctx, res, "match", match0) < 0) goto fail;
match0 = JS_NULL;
if (JS_SetPropertyStr(ctx, res, "captures", captures_arr) < 0) goto fail;
captures_arr = JS_NULL;
if (!JS_IsNull(groups)) {
if (JS_SetPropertyStr(ctx, res, "groups", groups) < 0) goto fail;
groups = JS_NULL;
} else {
rc = lre_exec(capture, re_bytecode,
str_buf, last_index, str->len,
shift, ctx);
JS_SetPropertyStr(ctx, res, "groups", JS_NULL);
}
if (rc != 1) {
if (rc >= 0) {
if (rc == 2 || (re_flags & (LRE_FLAG_GLOBAL | LRE_FLAG_STICKY))) {
if (JS_SetProperty(ctx, this_val, JS_ATOM_lastIndex,
JS_NewInt32(ctx, 0)) < 0)
goto fail;
}
} else {
if (rc == LRE_RET_TIMEOUT) {
JS_ThrowInterrupted(ctx);
} else {
JS_ThrowInternalError(ctx, "out of memory in regexp execution");
}
goto fail;
}
} else {
if (re_flags & (LRE_FLAG_GLOBAL | LRE_FLAG_STICKY)) {
if (JS_SetProperty(ctx, this_val, JS_ATOM_lastIndex,
JS_NewInt32(ctx, (capture[1] - str_buf) >> shift)) < 0)
goto fail;
}
obj = JS_NewArray(ctx);
if (JS_IsException(obj))
goto fail;
group_name_ptr = lre_get_groupnames(re_bytecode);
if (group_name_ptr) {
groups = JS_NewObjectProto(ctx, JS_NULL);
if (JS_IsException(groups))
goto fail;
}
if (re_flags & LRE_FLAG_INDICES) {
indices = JS_NewArray(ctx);
if (JS_IsException(indices))
goto fail;
if (group_name_ptr) {
indices_groups = JS_NewObjectProto(ctx, JS_NULL);
if (JS_IsException(indices_groups))
goto fail;
}
}
}
for(i = 0; i < capture_count; i++) {
const char *name = NULL;
uint8_t **match = &capture[2 * i];
int start = -1;
int end = -1;
JSValue val;
ret = res;
res = JS_NULL;
if (group_name_ptr && i > 0) {
if (*group_name_ptr) name = group_name_ptr;
group_name_ptr += strlen(group_name_ptr) + 1;
}
done:
JS_FreeValue(ctx, str_val);
JS_FreeValue(ctx, groups);
JS_FreeValue(ctx, captures_arr);
JS_FreeValue(ctx, match0);
JS_FreeValue(ctx, res);
js_free(ctx, capture);
return ret;
if (match[0] && match[1]) {
start = (match[0] - str_buf) >> shift;
end = (match[1] - str_buf) >> shift;
}
if (!JS_IsNull(indices)) {
val = JS_NULL;
if (start != -1) {
val = JS_NewArray(ctx);
if (JS_IsException(val))
goto fail;
if (JS_SetPropertyUint32(ctx, val, 0,
JS_NewInt32(ctx, start)) < 0) {
JS_FreeValue(ctx, val);
goto fail;
}
if (JS_SetPropertyUint32(ctx, val, 1, JS_NewInt32(ctx, end)) < 0) {
JS_FreeValue(ctx, val);
goto fail;
}
}
if (name && !JS_IsNull(indices_groups)) {
val = JS_DupValue(ctx, val);
if (JS_SetPropertyStr(ctx, indices_groups,
name, val) < 0) {
JS_FreeValue(ctx, val);
goto fail;
}
}
if (JS_SetPropertyUint32(ctx, indices, i, val) < 0) {
goto fail;
}
}
val = JS_NULL;
if (start != -1) {
val = js_sub_string(ctx, str, start, end);
if (JS_IsException(val))
goto fail;
}
if (name) {
if (JS_SetPropertyStr(ctx, groups, name,
JS_DupValue(ctx, val)) < 0) {
JS_FreeValue(ctx, val);
goto fail;
}
}
if (JS_SetPropertyUint32(ctx, obj, i, val) < 0)
goto fail;
}
}
ret = obj;
obj = JS_NULL;
fail:
JS_FreeValue(ctx, indices_groups);
JS_FreeValue(ctx, indices);
JS_FreeValue(ctx, str_val);
JS_FreeValue(ctx, groups);
JS_FreeValue(ctx, obj);
js_free(ctx, capture);
return ret;
JS_FreeValue(ctx, str_val);
JS_FreeValue(ctx, groups);
JS_FreeValue(ctx, captures_arr);
JS_FreeValue(ctx, match0);
JS_FreeValue(ctx, res);
js_free(ctx, capture);
return JS_EXCEPTION;
}
/* delete portions of a string that match a given regex */
@@ -25866,7 +25853,7 @@ static JSValue js_cell_number_floor(JSContext *ctx, JSValueConst this_val,
return JS_NULL;
if (place == 0)
return JS_NewFloat64(ctx, floor(d));
double mult = pow(10, place);
double mult = pow(10, -place);
return JS_NewFloat64(ctx, floor(d * mult) / mult);
}
@@ -25885,7 +25872,7 @@ static JSValue js_cell_number_ceiling(JSContext *ctx, JSValueConst this_val,
return JS_NULL;
if (place == 0)
return JS_NewFloat64(ctx, ceil(d));
double mult = pow(10, place);
double mult = pow(10, -place);
return JS_NewFloat64(ctx, ceil(d * mult) / mult);
}
@@ -25893,6 +25880,10 @@ static JSValue js_cell_number_ceiling(JSContext *ctx, JSValueConst this_val,
static JSValue js_cell_number_abs(JSContext *ctx, JSValueConst this_val,
int argc, JSValueConst *argv)
{
if (argc < 1) return JS_NULL;
int tag = JS_VALUE_GET_TAG(argv[0]);
if (tag != JS_TAG_INT && tag != JS_TAG_FLOAT64)
return JS_NULL;
double d;
if (JS_ToFloat64(ctx, &d, argv[0]))
return JS_NULL;
@@ -25914,7 +25905,7 @@ static JSValue js_cell_number_round(JSContext *ctx, JSValueConst this_val,
return JS_NULL;
if (place == 0)
return JS_NewFloat64(ctx, round(d));
double mult = pow(10, place);
double mult = pow(10, -place);
return JS_NewFloat64(ctx, round(d * mult) / mult);
}
@@ -25945,7 +25936,7 @@ static JSValue js_cell_number_trunc(JSContext *ctx, JSValueConst this_val,
return JS_NULL;
if (place == 0)
return JS_NewFloat64(ctx, trunc(d));
double mult = pow(10, place);
double mult = pow(10, -place);
return JS_NewFloat64(ctx, trunc(d * mult) / mult);
}
@@ -26006,6 +25997,20 @@ static JSValue js_cell_number_to_radix_string(JSContext *ctx, double num, int ra
{
if (radix < 2 || radix > 36) return JS_NULL;
/* For base 10, handle floating point properly */
if (radix == 10) {
char buf[64];
/* Check if it's an integer */
if (trunc(num) == num && num >= -9007199254740991.0 && num <= 9007199254740991.0) {
snprintf(buf, sizeof(buf), "%.0f", num);
} else {
/* Use %g to get a reasonable representation without trailing zeros */
snprintf(buf, sizeof(buf), "%.15g", num);
}
return JS_NewString(ctx, buf);
}
/* For other radixes, use integer conversion */
static const char digits[] = "0123456789abcdefghijklmnopqrstuvwxyz";
char buf[70];
int len = 0;
@@ -26630,11 +26635,12 @@ static JSValue js_cell_text(JSContext *ctx, JSValueConst this_val,
if (!JS_VALUE_IS_TEXT(item)) {
JS_FreeValue(ctx, item);
JS_ThrowInternalError(ctx, "Array must be made of strings.");
goto array_fail;
string_buffer_free(b);
if (sep_alloc) JS_FreeCString(ctx, separator);
return JS_ThrowTypeError(ctx, "text: array element is not a string");
}
JSValue item_str = JS_ToString(ctx, item); /* owned + flattens */
JSValue item_str = JS_ToString(ctx, item);
JS_FreeValue(ctx, item);
if (JS_IsException(item_str))
goto array_fail;
@@ -27070,19 +27076,32 @@ static JSValue js_cell_text_replace(JSContext *ctx, JSValueConst this_val, int a
break;
}
JSValue match = JS_GetPropertyUint32(ctx, exec_res, 0);
JS_FreeValue(ctx, exec_res);
if (JS_IsException(match)) goto fail_rx;
int match_len = 0;
{
JSValue mstr = JS_ToString(ctx, match);
if (JS_IsException(mstr)) goto fail_rx;
JSString *mp = JS_VALUE_GET_STRING(mstr);
match_len = (int)mp->len;
JS_FreeValue(ctx, mstr);
JSValue match = JS_GetPropertyStr(ctx, exec_res, "match");
if (JS_IsException(match)) {
JS_FreeValue(ctx, exec_res);
goto fail_rx;
}
JSValue end_val = JS_GetPropertyStr(ctx, exec_res, "end");
if (JS_IsException(end_val)) {
JS_FreeValue(ctx, match);
JS_FreeValue(ctx, exec_res);
goto fail_rx;
}
int32_t end = 0;
if (JS_ToInt32(ctx, &end, end_val)) {
JS_FreeValue(ctx, end_val);
JS_FreeValue(ctx, match);
JS_FreeValue(ctx, exec_res);
goto fail_rx;
}
JS_FreeValue(ctx, end_val);
JS_FreeValue(ctx, exec_res);
int match_len = end - local_index;
if (match_len < 0) match_len = 0;
if (found > pos) {
JSValue prefix = js_sub_string(ctx, sp, pos, found);
if (JS_IsException(prefix)) goto fail_rx;
@@ -27127,7 +27146,6 @@ fail_rx:
return JS_EXCEPTION;
}
/* text.search(str, target, from) - find substring or regex match */
static JSValue js_cell_text_search(JSContext *ctx, JSValueConst this_val, int argc, JSValueConst *argv)
{
@@ -27276,12 +27294,18 @@ static int js_str_find_range(JSString *hay, int from, int to, JSString *needle)
return -1;
}
/* text_extract(text, pattern, from?, to?) - extract match using regexp or literal text */
/* text_extract(text, pattern, from?, to?) - return array of matches or null
- literal pattern: [match]
- regexp pattern: [full_match, cap1, cap2, ...]
*/
static JSValue js_cell_text_extract(JSContext *ctx, JSValueConst this_val,
int argc, JSValueConst *argv)
{
if (argc < 2) return JS_NULL;
int tag_text = JS_VALUE_GET_TAG(argv[0]);
if (tag_text != JS_TAG_STRING && tag_text != JS_TAG_STRING_ROPE) return JS_NULL;
JSValue str = JS_ToString(ctx, argv[0]);
if (JS_IsException(str)) return JS_EXCEPTION;
@@ -27290,10 +27314,7 @@ static JSValue js_cell_text_extract(JSContext *ctx, JSValueConst this_val,
int from = 0;
if (argc >= 3 && !JS_IsNull(argv[2])) {
if (JS_ToInt32(ctx, &from, argv[2])) {
/* str removed - arg not owned */
return JS_EXCEPTION;
}
if (JS_ToInt32(ctx, &from, argv[2])) return JS_EXCEPTION;
if (from < 0) from += len;
if (from < 0) from = 0;
if (from > len) from = len;
@@ -27301,84 +27322,127 @@ static JSValue js_cell_text_extract(JSContext *ctx, JSValueConst this_val,
int to = len;
if (argc >= 4 && !JS_IsNull(argv[3])) {
if (JS_ToInt32(ctx, &to, argv[3])) {
/* str removed - arg not owned */
return JS_EXCEPTION;
}
if (JS_ToInt32(ctx, &to, argv[3])) return JS_EXCEPTION;
if (to < 0) to += len;
if (to < 0) to = 0;
if (to > len) to = len;
}
if (from > to) {
/* str removed - arg not owned */
return JS_NULL;
}
if (from > to) return JS_NULL;
/* RegExp path */
if (js_is_regexp(ctx, argv[1])) {
JSValue substr;
/* RegExp path: convert new exec result record -> classic array */
if (JS_IsObject(argv[1]) && JS_IsRegExp(ctx, argv[1])) {
JSValue rx = argv[1];
JSValue orig_last_index = JS_GetPropertyStr(ctx, rx, "lastIndex");
if (JS_IsException(orig_last_index)) return JS_EXCEPTION;
if (JS_SetPropertyStr(ctx, rx, "lastIndex", JS_NewInt32(ctx, 0)) < 0) goto fail_rx;
JSValue sub_str;
if (from == 0 && to == len) {
substr = JS_DupValue(ctx, str);
sub_str = JS_DupValue(ctx, str);
} else {
substr = js_sub_string(ctx, p, from, to);
if (JS_IsException(substr)) {
/* str removed - arg not owned */
return JS_EXCEPTION;
sub_str = js_sub_string(ctx, p, from, to);
if (JS_IsException(sub_str)) goto fail_rx;
}
JSValue exec_res = JS_Invoke(ctx, rx, JS_ATOM_exec, 1, (JSValueConst *)&sub_str);
JS_FreeValue(ctx, sub_str);
if (JS_IsException(exec_res)) goto fail_rx;
if (JS_IsNull(exec_res)) {
JS_FreeValue(ctx, exec_res);
JS_SetPropertyStr(ctx, rx, "lastIndex", orig_last_index);
return JS_NULL;
}
/* Build result array */
JSValue out = JS_NewArray(ctx);
if (JS_IsException(out)) {
JS_FreeValue(ctx, exec_res);
goto fail_rx;
}
/* out[0] = exec_res.match */
JSValue match0 = JS_GetPropertyStr(ctx, exec_res, "match");
if (JS_IsException(match0)) {
JS_FreeValue(ctx, exec_res);
JS_FreeValue(ctx, out);
goto fail_rx;
}
if (JS_SetPropertyUint32(ctx, out, 0, match0) < 0) {
JS_FreeValue(ctx, exec_res);
JS_FreeValue(ctx, out);
goto fail_rx;
}
/* Append capture groups from exec_res.captures (skip [0] if it mirrors full match) */
JSValue caps = JS_GetPropertyStr(ctx, exec_res, "captures");
if (!JS_IsException(caps) && JS_IsArray(ctx, caps)) {
int64_t caps_len = 0;
if (js_get_length64(ctx, &caps_len, caps) == 0 && caps_len > 0) {
/* Many engines put full match at captures[0]. Your record already has match separately.
We assume captures[0] corresponds to group1, group2, ... OR it includes full match.
To satisfy your tests, we treat captures[0] as capture group 1. */
for (int64_t i = 0; i < caps_len; i++) {
JSValue cap = JS_GetPropertyInt64(ctx, caps, i);
if (JS_IsException(cap)) {
JS_FreeValue(ctx, caps);
JS_FreeValue(ctx, exec_res);
JS_FreeValue(ctx, out);
goto fail_rx;
}
if (JS_SetPropertyInt64(ctx, out, i + 1, cap) < 0) {
JS_FreeValue(ctx, caps);
JS_FreeValue(ctx, exec_res);
JS_FreeValue(ctx, out);
goto fail_rx;
}
}
}
}
JS_FreeValue(ctx, caps);
JSValue exec_func = JS_GetPropertyStr(ctx, argv[1], "exec");
if (JS_IsException(exec_func)) {
JS_FreeValue(ctx, substr);
/* str removed - arg not owned */
return JS_EXCEPTION;
JS_FreeValue(ctx, exec_res);
JS_SetPropertyStr(ctx, rx, "lastIndex", orig_last_index);
return out;
fail_rx:
if (!JS_IsNull(orig_last_index) && !JS_IsException(orig_last_index)) {
JS_SetPropertyStr(ctx, rx, "lastIndex", orig_last_index);
} else {
JS_FreeValue(ctx, orig_last_index);
}
JSValue result = JS_Call(ctx, exec_func, argv[1], 1, &substr);
JS_FreeValue(ctx, exec_func);
JS_FreeValue(ctx, substr);
/* str removed - arg not owned */
if (JS_IsException(result)) return JS_EXCEPTION;
return result;
return JS_EXCEPTION;
}
/* Literal text path */
JSValue needle_val = JS_ToString(ctx, argv[1]);
if (JS_IsException(needle_val)) {
/* str removed - arg not owned */
return JS_EXCEPTION;
}
if (JS_IsException(needle_val)) return JS_EXCEPTION;
JSString *needle = JS_VALUE_GET_STRING(needle_val);
int pos = js_str_find_range(p, from, to, needle);
int needle_len = (int)needle->len;
int pos = js_str_find_range(p, from, to, needle);
JS_FreeValue(ctx, needle_val);
if (pos < 0) {
/* str removed - arg not owned */
return JS_NULL;
}
if (pos < 0) return JS_NULL;
JSValue arr = JS_NewArray(ctx);
if (JS_IsException(arr)) {
/* str removed - arg not owned */
return JS_EXCEPTION;
}
JSValue arr = JS_NewArrayLen(ctx, 1);
if (JS_IsException(arr)) return JS_EXCEPTION;
JSValue match = js_sub_string(ctx, p, pos, pos + (int)needle->len);
JSValue match = js_sub_string(ctx, p, pos, pos + needle_len);
if (JS_IsException(match)) {
JS_FreeValue(ctx, arr);
/* str removed - arg not owned */
return JS_EXCEPTION;
}
JS_SetPropertyUint32(ctx, arr, 0, match);
if (JS_SetPropertyUint32(ctx, arr, 0, match) < 0) {
JS_FreeValue(ctx, arr);
return JS_EXCEPTION;
}
/* str removed - arg not owned */
return arr;
}
@@ -27471,6 +27535,7 @@ static JSValue js_cell_array(JSContext *ctx, JSValueConst this_val,
if (JS_IsException(result)) return result;
if (reverse) {
int64_t out_idx = 0;
for (int64_t i = len - 1; i >= 0; i--) {
JSValue item = JS_GetPropertyInt64(ctx, arg, i);
if (JS_IsException(item)) {
@@ -27489,7 +27554,7 @@ static JSValue js_cell_array(JSContext *ctx, JSValueConst this_val,
JS_FreeValue(ctx, val);
break;
}
JS_SetPropertyInt64(ctx, result, i, val);
JS_SetPropertyInt64(ctx, result, out_idx++, val);
}
} else {
int64_t out_idx = 0;
@@ -27565,7 +27630,7 @@ static JSValue js_cell_array(JSContext *ctx, JSValueConst this_val,
if (from < 0 || from > to || to > len)
return JS_NULL;
JSValue result = JS_NewArray(ctx);
JSValue result = JS_NewArrayLen(ctx, to - from);
if (JS_IsException(result)) return result;
int64_t idx = 0;
@@ -27704,11 +27769,13 @@ static JSValue js_cell_array(JSContext *ctx, JSValueConst this_val,
if (JS_IsException(exec_res)) goto fail_rx_split;
if (JS_IsNull(exec_res)) {
JS_FreeValue(ctx, exec_res);
/* remainder */
JSValue tail = js_sub_string(ctx, p, pos, len);
if (JS_IsException(tail)) goto fail_rx_split;
JS_SetPropertyInt64(ctx, result, out_idx++, tail);
if (JS_ArrayPush(ctx, result, tail) < 0) {
goto fail_rx_split;
}
JS_FreeValue(ctx, tail);
break;
}
@@ -27740,29 +27807,31 @@ static JSValue js_cell_array(JSContext *ctx, JSValueConst this_val,
break;
}
/* match text is exec_res[0] */
JSValue match = JS_GetPropertyUint32(ctx, exec_res, 0);
JS_FreeValue(ctx, exec_res);
if (JS_IsException(match)) goto fail_rx_split;
/* compute match length in code units */
int match_len = 0;
{
JSValue mstr = JS_ToString(ctx, match);
if (JS_IsException(mstr)) {
JS_FreeValue(ctx, match);
goto fail_rx_split;
}
JSString *mp = JS_VALUE_GET_STRING(mstr);
match_len = (int)mp->len;
JS_FreeValue(ctx, mstr);
JSValue end_val = JS_GetPropertyStr(ctx, exec_res, "end");
if (JS_IsException(end_val)) {
JS_FreeValue(ctx, exec_res);
goto fail_rx_split;
}
JS_FreeValue(ctx, match);
int32_t end = 0;
if (JS_ToInt32(ctx, &end, end_val)) {
JS_FreeValue(ctx, end_val);
JS_FreeValue(ctx, exec_res);
goto fail_rx_split;
}
JS_FreeValue(ctx, end_val);
JS_FreeValue(ctx, exec_res);
int match_len = end - local_index;
if (match_len < 0) match_len = 0;
/* emit piece before match */
JSValue part = js_sub_string(ctx, p, pos, found);
if (JS_IsException(part)) goto fail_rx_split;
JS_SetPropertyInt64(ctx, result, out_idx++, part);
if (JS_ArrayPush(ctx, result, part) < 0) {
goto fail_rx_split;
}
JS_FreeValue(ctx, part);
/* advance past match; ensure progress on empty matches */
pos = found + match_len;
@@ -27771,7 +27840,11 @@ static JSValue js_cell_array(JSContext *ctx, JSValueConst this_val,
/* match at end: add trailing empty field and stop */
JSValue empty = JS_NewStringLen(ctx, "", 0);
if (JS_IsException(empty)) goto fail_rx_split;
JS_SetPropertyInt64(ctx, result, out_idx++, empty);
if (JS_ArrayPush(ctx, result, empty) < 0) {
JS_FreeValue(ctx, empty);
goto fail_rx_split;
}
JS_FreeValue(ctx, empty);
break;
}
pos = found + 1;
@@ -27808,7 +27881,8 @@ static JSValue js_cell_array(JSContext *ctx, JSValueConst this_val,
return JS_NULL;
}
JSValue result = JS_NewArray(ctx);
int64_t count = (len + chunk_len - 1) / chunk_len;
JSValue result = JS_NewArrayLen(ctx, count);
if (JS_IsException(result)) {
/* str removed - arg not owned */
return result;
@@ -28158,8 +28232,12 @@ static JSValue js_cell_array_sort(JSContext *ctx, JSValueConst this_val,
JSValue key;
if (argc < 2 || JS_IsNull(argv[1])) {
key = JS_DupValue(ctx, items[i]);
} else if (JS_VALUE_GET_TAG(argv[1]) == JS_TAG_STRING ||
JS_VALUE_GET_TAG(argv[1]) == JS_TAG_INT) {
} else if (JS_VALUE_GET_TAG(argv[1]) == JS_TAG_INT) {
/* Numeric index - use for nested arrays */
int32_t idx;
JS_ToInt32(ctx, &idx, argv[1]);
key = JS_GetPropertyInt64(ctx, items[i], idx);
} else if (JS_VALUE_GET_TAG(argv[1]) == JS_TAG_STRING) {
key = JS_GetProperty(ctx, items[i], JS_ValueToAtom(ctx, argv[1]));
} else if (JS_IsArray(ctx, argv[1])) {
key = JS_GetPropertyInt64(ctx, argv[1], i);
@@ -29135,15 +29213,12 @@ static JSValue js_cell_reverse(JSContext *ctx, JSValueConst this_val,
/* Handle arrays */
if (JS_IsArray(ctx, value)) {
JSValue length_val = JS_GetPropertyStr(ctx, value, "length");
int64_t len;
if (JS_ToInt64(ctx, &len, length_val) < 0) {
JS_FreeValue(ctx, length_val);
if (js_get_length64(ctx, &len, value))
return JS_NULL;
}
JS_FreeValue(ctx, length_val);
JSValue result = JS_NewArray(ctx);
JSValue result = JS_NewArrayLen(ctx, len);
if (JS_IsException(result)) return result;
for (int64_t i = len - 1, j = 0; i >= 0; i--, j++) {
JSValue elem = JS_GetPropertyInt64(ctx, value, i);
JS_SetPropertyInt64(ctx, result, j, elem);
@@ -29236,6 +29311,12 @@ static JSValue js_cell_proto(JSContext *ctx, JSValueConst this_val,
return JS_NULL;
JSValue obj = argv[0];
/* Intrinsic arrays return the Object prototype */
if (JS_IsArray(ctx, obj)) {
return JS_DupValue(ctx, ctx->class_proto[JS_CLASS_OBJECT]);
}
if (!JS_IsObject(obj))
return JS_NULL;
@@ -29271,8 +29352,6 @@ static JSValue js_cell_meme(JSContext *ctx, JSValueConst this_val,
if (argc < 2)
return result;
JSValue mixins = argv[1];
/* Helper function to apply a single mixin */
#define APPLY_MIXIN(mix) do { \
if (!JS_IsObject(mix) || JS_IsNull(mix) || JS_IsArray(ctx, mix)) \
@@ -29299,26 +29378,31 @@ static JSValue js_cell_meme(JSContext *ctx, JSValueConst this_val,
js_free(ctx, tab); \
} while (0)
if (JS_IsArray(ctx, mixins)) {
/* Array of mixins */
int64_t len;
if (js_get_length64(ctx, &len, mixins)) {
JS_FreeValue(ctx, result);
return JS_EXCEPTION;
}
/* Process all arguments starting from argv[1] as mixins */
for (int i = 1; i < argc; i++) {
JSValue mixins = argv[i];
for (int64_t i = 0; i < len; i++) {
JSValue mix = JS_GetPropertyInt64(ctx, mixins, i);
if (JS_IsException(mix)) {
if (JS_IsArray(ctx, mixins)) {
/* Array of mixins */
int64_t len;
if (js_get_length64(ctx, &len, mixins)) {
JS_FreeValue(ctx, result);
return JS_EXCEPTION;
}
APPLY_MIXIN(mix);
JS_FreeValue(ctx, mix);
for (int64_t j = 0; j < len; j++) {
JSValue mix = JS_GetPropertyInt64(ctx, mixins, j);
if (JS_IsException(mix)) {
JS_FreeValue(ctx, result);
return JS_EXCEPTION;
}
APPLY_MIXIN(mix);
JS_FreeValue(ctx, mix);
}
} else if (JS_IsObject(mixins) && !JS_IsNull(mixins)) {
/* Single mixin object */
APPLY_MIXIN(mixins);
}
} else if (JS_IsObject(mixins) && !JS_IsNull(mixins)) {
/* Single mixin object */
APPLY_MIXIN(mixins);
}
#undef APPLY_MIXIN

32
tests/suite.cm
View File

@@ -1478,15 +1478,19 @@ return {
if (str != "a,b,c") throw "array join with text() failed"
},
test_array_join_non_text_throws: function() {
var arr = [1, 2, 3]
var caught = false
try {
var str = text(arr, ",")
} catch (e) {
caught = true
}
if (!caught) throw "array join with non-text elements should throw"
test_text_array_join_numbers_throw: function() {
var caught = false
try {
text([1, 2, 3], ",")
} catch (e) {
caught = true
}
if (!caught) throw "text([numbers], sep) should throw (no implicit coercion)"
},
test_text_array_join_numbers_explicit: function() {
var arr = array([1, 2, 3], x => text(x))
if (text(arr, ",") != "1,2,3") throw "explicit numeric join failed"
},
// ============================================================================
@@ -2802,11 +2806,6 @@ return {
if (search(result, "3.14") != 0) throw "text number float failed"
},
test_text_array_join: function() {
var result = text([1, 2, 3], ",")
if (result != "1,2,3") throw "text array join failed"
},
test_text_array_join_empty_sep: function() {
var result = text(["a", "b", "c"], "")
if (result != "abc") throw "text array join empty sep failed"
@@ -3231,11 +3230,6 @@ return {
if (e.message != "test message") throw "Error creation failed"
},
test_error_is_proto: function() {
var e = Error("test")
if (!is_proto(e, Error)) throw "Error is_proto failed"
},
test_throw_error_object: function() {
var caught = null
try {