xbintsc 0.3.3 → 0.3.5

package/runtime/xt_regex.h

@@ -7,10 +7,11 @@
  *   literals, '.', '^', '$', '[abc]', '[^abc]', '[a-z]', '*', '+', '?',
  *   alternation '|', groups '(...)', and escapes ('\d', '\w', '\s', ...).
  *
- * Only the boolean "does the pattern match a substring" result is produced;
- * capture groups are not reported (the caller passes nmatch = 0).
- *
- * The implementation is a recursive backtracking matcher over a small AST.
+ * Capturing groups are reported through `regmatch_t` the same way POSIX does:
+ * `pmatch[0]` is the whole match and `pmatch[k]` the k-th group in pattern
+ * order, with unmatched groups left at -1. The implementation is a recursive
+ * backtracking matcher over a small AST; captures are carried on an immutable
+ * chain of stack frames so abandoned search paths are undone automatically.
  * Patterns are tiny, so this is fast enough and keeps the runtime free of an
  * external dependency.
  */
@@ -56,6 +57,7 @@ typedef struct {
   unsigned char ch;
   unsigned char *classbits; /* 256 bits == 32 bytes, for XT_RE_CLASS */
   xt_re_alt *group;         /* for XT_RE_GROUP */
+  int groupIndex;           /* 1-based capture number, for XT_RE_GROUP */
 } xt_re_node;
 
 typedef struct {
@@ -155,6 +157,7 @@ typedef struct {
   const char *s;
   size_t i;
   int error;
+  int groupCount;
 } xt_re_parser;
 
 static void xt_re_free_alt(xt_re_alt *alt);
@@ -293,7 +296,11 @@ static xt_re_node *xt_re_parse_atom(xt_re_parser *p) {
   if (c == '(') {
     xt_re_node *n;
     xt_re_alt *group;
+    int index;
     p->i++;
+    /* Number the group as soon as its '(' is seen so nested groups keep
+     * POSIX/JavaScript numbering (opening-paren order). */
+    index = ++p->groupCount;
     group = xt_re_parse_alt(p);
     if (p->error) return NULL;
     if (p->s[p->i] != ')') {
@@ -308,6 +315,7 @@ static xt_re_node *xt_re_parse_atom(xt_re_parser *p) {
       return NULL;
     }
     n->group = group;
+    n->groupIndex = index;
     return n;
   }
   if (c == '[') return xt_re_parse_class(p);
@@ -388,7 +396,17 @@ typedef struct {
   int icase;
 } xt_re_input;
 
-typedef int (*xt_re_cont)(void *ctx, size_t pos);
+/* One capture on the immutable chain of the current search path. `parent`
+ * points to the captures that were live when the group was entered, so an
+ * abandoned backtrack simply drops the frame instead of restoring it. */
+typedef struct xt_re_cap {
+  const struct xt_re_cap *parent;
+  int index; /* 1-based capture group number */
+  int start;
+  int end;
+} xt_re_cap;
+
+typedef int (*xt_re_cont)(void *ctx, size_t pos, const xt_re_cap *caps);
 
 static void xt_re_free_alt(xt_re_alt *alt);
 
@@ -429,28 +447,54 @@ static int xt_re_class_match(const unsigned char *bits, unsigned char c, int ica
 }
 
 static int xt_re_match_alt(xt_re_alt *alt, const xt_re_input *in, size_t pos,
-                           xt_re_cont cont, void *ctx);
+                           xt_re_cont cont, void *ctx, const xt_re_cap *caps);
+
+/* Resumes the outer continuation once a group's body has matched, recording
+ * where the group ended on the frame it pushed. */
+typedef struct {
+  xt_re_cap *frame;
+  xt_re_cont cont;
+  void *ctx;
+} xt_re_group_state;
+
+static int xt_re_group_next(void *v, size_t pos, const xt_re_cap *caps) {
+  xt_re_group_state *s = (xt_re_group_state *)v;
+  /* `caps` already heads the chain that includes this group's own frame (and
+   * any groups nested inside it), so forward it as-is. */
+  s->frame->end = (int)pos;
+  return s->cont(s->ctx, pos, caps);
+}
 
 static int xt_re_match_atom(xt_re_node *node, const xt_re_input *in, size_t pos,
-                            xt_re_cont cont, void *ctx) {
+                            xt_re_cont cont, void *ctx, const xt_re_cap *caps) {
   switch (node->type) {
     case XT_RE_CHAR:
       if (pos < in->len && xt_re_char_eq(in, (unsigned char)in->text[pos], node->ch))
-        return cont(ctx, pos + 1);
+        return cont(ctx, pos + 1, caps);
       return 0;
     case XT_RE_ANY:
-      if (pos < in->len && in->text[pos] != '\n') return cont(ctx, pos + 1);
+      if (pos < in->len && in->text[pos] != '\n') return cont(ctx, pos + 1, caps);
       return 0;
     case XT_RE_CLASS:
       if (pos < in->len && xt_re_class_match(node->classbits, (unsigned char)in->text[pos], in->icase))
-        return cont(ctx, pos + 1);
+        return cont(ctx, pos + 1, caps);
       return 0;
     case XT_RE_BOL:
-      return pos == 0 ? cont(ctx, pos) : 0;
+      return pos == 0 ? cont(ctx, pos, caps) : 0;
     case XT_RE_EOL:
-      return pos == in->len ? cont(ctx, pos) : 0;
-    case XT_RE_GROUP:
-      return xt_re_match_alt(node->group, in, pos, cont, ctx);
+      return pos == in->len ? cont(ctx, pos, caps) : 0;
+    case XT_RE_GROUP: {
+      xt_re_cap frame;
+      xt_re_group_state state;
+      frame.parent = caps;
+      frame.index = node->groupIndex;
+      frame.start = (int)pos;
+      frame.end = -1;
+      state.frame = &frame;
+      state.cont = cont;
+      state.ctx = ctx;
+      return xt_re_match_alt(node->group, in, pos, xt_re_group_next, &state, &frame);
+    }
     default:
       return 0;
   }
@@ -471,28 +515,28 @@ typedef struct {
   int count;
 } xt_re_repeat_step;
 
-static int xt_re_repeat_try(xt_re_repeat *rep, size_t pos, int count);
+static int xt_re_repeat_try(xt_re_repeat *rep, size_t pos, int count, const xt_re_cap *caps);
 
-static int xt_re_repeat_next(void *v, size_t newpos) {
+static int xt_re_repeat_next(void *v, size_t newpos, const xt_re_cap *caps) {
   xt_re_repeat_step *s = (xt_re_repeat_step *)v;
   if (newpos == s->pos) return 0; /* no progress -> stop to avoid loops */
-  return xt_re_repeat_try(s->rep, newpos, s->count + 1);
+  return xt_re_repeat_try(s->rep, newpos, s->count + 1, caps);
 }
 
-static int xt_re_repeat_try(xt_re_repeat *rep, size_t pos, int count) {
+static int xt_re_repeat_try(xt_re_repeat *rep, size_t pos, int count, const xt_re_cap *caps) {
   if (rep->max < 0 || count < rep->max) {
     xt_re_repeat_step step;
     step.rep = rep;
     step.pos = pos;
     step.count = count;
-    if (xt_re_match_atom(rep->atom, rep->in, pos, xt_re_repeat_next, &step)) return 1;
+    if (xt_re_match_atom(rep->atom, rep->in, pos, xt_re_repeat_next, &step, caps)) return 1;
   }
-  if (count >= rep->min) return rep->cont(rep->ctx, pos);
+  if (count >= rep->min) return rep->cont(rep->ctx, pos, caps);
   return 0;
 }
 
 static int xt_re_match_piece(xt_re_piece *piece, const xt_re_input *in, size_t pos,
-                             xt_re_cont cont, void *ctx) {
+                             xt_re_cont cont, void *ctx, const xt_re_cap *caps) {
   xt_re_repeat rep;
   switch (piece->quant) {
     case XT_RE_Q_STAR:
@@ -502,7 +546,7 @@ static int xt_re_match_piece(xt_re_piece *piece, const xt_re_input *in, size_t p
       rep.max = -1;
       rep.cont = cont;
       rep.ctx = ctx;
-      return xt_re_repeat_try(&rep, pos, 0);
+      return xt_re_repeat_try(&rep, pos, 0, caps);
     case XT_RE_Q_PLUS:
       rep.atom = piece->node;
       rep.in = in;
@@ -510,7 +554,7 @@ static int xt_re_match_piece(xt_re_piece *piece, const xt_re_input *in, size_t p
       rep.max = -1;
       rep.cont = cont;
       rep.ctx = ctx;
-      return xt_re_repeat_try(&rep, pos, 0);
+      return xt_re_repeat_try(&rep, pos, 0, caps);
     case XT_RE_Q_QUEST:
       rep.atom = piece->node;
       rep.in = in;
@@ -518,9 +562,9 @@ static int xt_re_match_piece(xt_re_piece *piece, const xt_re_input *in, size_t p
       rep.max = 1;
       rep.cont = cont;
       rep.ctx = ctx;
-      return xt_re_repeat_try(&rep, pos, 0);
+      return xt_re_repeat_try(&rep, pos, 0, caps);
     default:
-      return xt_re_match_atom(piece->node, in, pos, cont, ctx);
+      return xt_re_match_atom(piece->node, in, pos, cont, ctx, caps);
   }
 }
 
@@ -536,25 +580,25 @@ typedef struct {
   int index;
 } xt_re_concat_step;
 
-static int xt_re_match_concat(xt_re_concat_state *state, int index, size_t pos);
+static int xt_re_match_concat(xt_re_concat_state *state, int index, size_t pos, const xt_re_cap *caps);
 
 /* The continuation for a concat piece resumes matching at the next piece. */
-static int xt_re_concat_next(void *v, size_t pos) {
+static int xt_re_concat_next(void *v, size_t pos, const xt_re_cap *caps) {
   xt_re_concat_step *s = (xt_re_concat_step *)v;
-  return xt_re_match_concat(s->state, s->index + 1, pos);
+  return xt_re_match_concat(s->state, s->index + 1, pos, caps);
 }
 
-static int xt_re_match_concat(xt_re_concat_state *state, int index, size_t pos) {
+static int xt_re_match_concat(xt_re_concat_state *state, int index, size_t pos, const xt_re_cap *caps) {
   xt_re_concat_step step;
-  if (index >= state->concat->count) return state->cont(state->ctx, pos);
+  if (index >= state->concat->count) return state->cont(state->ctx, pos, caps);
   step.state = state;
   step.index = index;
   return xt_re_match_piece(&state->concat->pieces[index], state->in, pos,
-                           xt_re_concat_next, &step);
+                           xt_re_concat_next, &step, caps);
 }
 
 static int xt_re_match_alt(xt_re_alt *alt, const xt_re_input *in, size_t pos,
-                           xt_re_cont cont, void *ctx) {
+                           xt_re_cont cont, void *ctx, const xt_re_cap *caps) {
   int i;
   for (i = 0; i < alt->count; i++) {
     xt_re_concat_state state;
@@ -562,18 +606,34 @@ static int xt_re_match_alt(xt_re_alt *alt, const xt_re_input *in, size_t pos,
     state.in = in;
     state.cont = cont;
     state.ctx = ctx;
-    if (xt_re_match_concat(&state, 0, pos)) return 1;
+    if (xt_re_match_concat(&state, 0, pos, caps)) return 1;
   }
   return 0;
 }
 
 typedef struct {
   size_t end;
+  regmatch_t *pmatch;
+  size_t nmatch;
 } xt_re_match_result;
 
-static int xt_re_record_match(void *ctx, size_t pos) {
+/* Final continuation: records the whole-match end offset and copies every
+ * capture on the successful path into `pmatch`. Walking from the head means
+ * the most recent frame wins, which is what a quantified group such as
+ * `(a)+` should report (its last iteration). */
+static int xt_re_record_match(void *ctx, size_t pos, const xt_re_cap *caps) {
   xt_re_match_result *result = (xt_re_match_result *)ctx;
+  const xt_re_cap *cap;
   result->end = pos;
+  for (cap = caps; cap; cap = cap->parent) {
+    if (cap->index >= 1 && (size_t)cap->index < result->nmatch) {
+      regmatch_t *slot = &result->pmatch[cap->index];
+      if (slot->rm_so < 0) {
+        slot->rm_so = cap->start;
+        slot->rm_eo = cap->end;
+      }
+    }
+  }
   return 1;
 }
 
@@ -587,6 +647,7 @@ static int regcomp(regex_t *preg, const char *pattern, int cflags) {
   p.s = pattern;
   p.i = 0;
   p.error = 0;
+  p.groupCount = 0;
   root = xt_re_parse_alt(&p);
   if (!root || p.error || p.s[p.i] != '\0') {
     if (root) xt_re_free_alt(root);
@@ -601,15 +662,24 @@ static int regexec(const regex_t *preg, const char *string, size_t nmatch,
                    regmatch_t pmatch[], int eflags) {
   xt_re_input in;
   size_t start;
+  size_t i;
   (void)eflags;
   if (!preg || !preg->root || !string) return 1;
+  if (pmatch) {
+    for (i = 0; i < nmatch; i++) {
+      pmatch[i].rm_so = -1;
+      pmatch[i].rm_eo = -1;
+    }
+  }
   in.text = string;
   in.len = strlen(string);
   in.icase = preg->icase;
   for (start = 0; start <= in.len; start++) {
     xt_re_match_result result;
     result.end = 0;
-    if (xt_re_match_alt(preg->root, &in, start, xt_re_record_match, &result)) {
+    result.pmatch = pmatch;
+    result.nmatch = nmatch;
+    if (xt_re_match_alt(preg->root, &in, start, xt_re_record_match, &result, NULL)) {
       if (nmatch > 0 && pmatch) {
         pmatch[0].rm_so = (int)start;
         pmatch[0].rm_eo = (int)result.end;

package/runtime/xt_stdlib/dispatch.inc

@@ -25,10 +25,10 @@ static xt_value xt_array_method(xt_value target, const char *method, int32_t arg
   }
   if (strcmp(method, "reverse") == 0) {
     xt_array *array = xt_as_array(target);
-    for (uint32_t i = 0; i + 1 < array->length; i++, array->length--) {
+    for (uint32_t i = 0; i + 1 < array->length - i; i++) {
       xt_value tmp = array->items[i];
-      array->items[i] = array->items[array->length - 1];
-      array->items[array->length - 1] = tmp;
+      array->items[i] = array->items[array->length - 1 - i];
+      array->items[array->length - 1 - i] = tmp;
     }
     return target;
   }
@@ -45,7 +45,7 @@ static xt_value xt_string_method(xt_value target, const char *method, int32_t ar
   if (strcmp(method, "slice") == 0) return xt_string_slice(target, xt_arg_at(argc, argv, 0), xt_arg_at(argc, argv, 1));
   if (strcmp(method, "substring") == 0) return xt_string_substring(target, xt_arg_at(argc, argv, 0), xt_arg_at(argc, argv, 1));
   if (strcmp(method, "substr") == 0) return xt_string_substr(target, xt_arg_at(argc, argv, 0), xt_arg_at(argc, argv, 1));
-  if (strcmp(method, "split") == 0) return xt_string_split(target, xt_arg_at(argc, argv, 0));
+  if (strcmp(method, "split") == 0) return xt_string_split(target, xt_arg_at(argc, argv, 0), xt_arg_at(argc, argv, 1));
   if (strcmp(method, "toUpperCase") == 0) return xt_string_case(target, 1);
   if (strcmp(method, "toLowerCase") == 0) return xt_string_case(target, 0);
   if (strcmp(method, "trim") == 0) return xt_string_trim(target);
@@ -58,10 +58,208 @@ static xt_value xt_string_method(xt_value target, const char *method, int32_t ar
   return XT_UNDEFINED;
 }
 
+/* Backing trampoline for `fn.bind(thisArg, ...partial)`: the bound target,
+ * `this` value and partial argument array travel in the closure environment. */
+static xt_value xt_bound_invoke(xt_value thisValue, xt_value env, int32_t argc, xt_value *argv) {
+  (void)thisValue;
+  xt_value target = xt_closure_env(env, 0);
+  xt_value boundThis = xt_closure_env(env, 1);
+  xt_value boundArgs = xt_closure_env(env, 2);
+  int32_t boundCount = XT_IS_ARRAY(boundArgs) ? (int32_t)xt_as_array(boundArgs)->length : 0;
+  int32_t total = boundCount + argc;
+  xt_value *combined = total > 0 ? (xt_value *)malloc(sizeof(xt_value) * (size_t)total) : NULL;
+  if (combined) {
+    for (int32_t i = 0; i < boundCount; i++) combined[i] = xt_as_array(boundArgs)->items[i];
+    for (int32_t i = 0; i < argc; i++) combined[boundCount + i] = argv[i];
+  }
+  xt_value result = xt_call_with_this(target, boundThis, total, combined);
+  free(combined);
+  return result;
+}
+
+/* Backing trampoline for first-class built-in method values (`arr.map`,
+ * `"".slice`, `(1).toFixed`). The value is *unbound*, exactly like JavaScript:
+ * the receiver arrives through `this`, so a detached call
+ * (`const f = arr.map; f(cb)`) throws, while `arr.map(cb)` and
+ * `arr.map?.(cb)` (which pass the receiver) work. The method name lives in
+ * environment slot 0. */
+static xt_value xt_method_value_invoke(xt_value thisValue, xt_value env, int32_t argc, xt_value *argv) {
+  xt_value name = xt_closure_env(env, 0);
+  if (thisValue == XT_UNDEFINED || thisValue == XT_NULL) {
+    const char *method = xt_string_data(name);
+    char message[256];
+    snprintf(message, sizeof(message),
+             "TypeError: Cannot read properties of undefined (reading '%s')",
+             method ? method : "method");
+    xt_throw(xt_string_from_cstr(message));
+  }
+  return xt_call_method(thisValue, name, argc, argv);
+}
+
+#define XT_NAME_COUNT(table) (sizeof(table) / sizeof((table)[0]))
+
+typedef struct {
+  const char *name;
+  int32_t arity;
+} xt_method_spec;
+
+static const xt_method_spec XT_ARRAY_METHODS[] = {
+  {"push", 1}, {"pop", 0}, {"shift", 0}, {"unshift", 1}, {"join", 1}, {"slice", 2},
+  {"indexOf", 1}, {"lastIndexOf", 1}, {"includes", 1}, {"concat", 1}, {"forEach", 1},
+  {"map", 1}, {"filter", 1}, {"reduce", 1}, {"reduceRight", 1}, {"reverse", 0},
+  {"at", 1}, {"find", 1}, {"findIndex", 1}, {"findLast", 1}, {"findLastIndex", 1},
+  {"some", 1}, {"every", 1}, {"sort", 1}, {"flat", 0}, {"flatMap", 1}, {"fill", 1},
+  {"copyWithin", 2}, {"splice", 2}, {"toReversed", 0}, {"toSorted", 1}, {"toSpliced", 2},
+  {"with", 2}, {"keys", 0}, {"values", 0}, {"entries", 0}, {"toString", 0},
+  {"toLocaleString", 0},
+};
+
+static const xt_method_spec XT_STRING_METHODS[] = {
+  {"charAt", 1}, {"charCodeAt", 1}, {"codePointAt", 1}, {"indexOf", 1}, {"lastIndexOf", 1},
+  {"includes", 1}, {"slice", 2}, {"substring", 2}, {"substr", 2}, {"split", 2},
+  {"toUpperCase", 0}, {"toLowerCase", 0}, {"trim", 0}, {"trimStart", 0}, {"trimEnd", 0},
+  {"replace", 2}, {"replaceAll", 2}, {"repeat", 1}, {"startsWith", 1}, {"endsWith", 1},
+  {"concat", 1}, {"at", 1}, {"padStart", 1}, {"padEnd", 1}, {"match", 1}, {"search", 1},
+  {"localeCompare", 1}, {"toString", 0}, {"valueOf", 0},
+};
+
+static const xt_method_spec XT_NUMBER_METHODS[] = {
+  {"toFixed", 1}, {"toPrecision", 1}, {"toExponential", 1}, {"toString", 1},
+  {"valueOf", 0}, {"toLocaleString", 0},
+};
+
+static const xt_method_spec XT_FUNCTION_METHODS[] = {
+  {"call", 1}, {"apply", 2}, {"bind", 1}, {"toString", 0},
+};
+
+static const xt_method_spec XT_BIGINT_METHODS[] = {
+  {"toString", 0}, {"toLocaleString", 0}, {"valueOf", 0},
+};
+
+static const xt_method_spec XT_BOOLEAN_METHODS[] = {
+  {"toString", 0}, {"valueOf", 0},
+};
+
+static const xt_method_spec XT_DATE_METHODS[] = {
+  {"getTime", 0}, {"getFullYear", 0}, {"getMonth", 0}, {"getDate", 0}, {"getDay", 0},
+  {"getHours", 0}, {"getMinutes", 0}, {"getSeconds", 0}, {"getMilliseconds", 0},
+  {"getUTCFullYear", 0}, {"getUTCMonth", 0}, {"getUTCDate", 0}, {"getUTCDay", 0},
+  {"getUTCHours", 0}, {"getUTCMinutes", 0}, {"getUTCSeconds", 0}, {"getUTCMilliseconds", 0},
+  {"toISOString", 0}, {"toJSON", 1}, {"toString", 0}, {"valueOf", 0},
+};
+
+static const xt_method_spec XT_MAP_METHODS[] = {
+  {"get", 1}, {"set", 2}, {"has", 1}, {"delete", 1}, {"clear", 0}, {"keys", 0},
+  {"values", 0}, {"entries", 0}, {"forEach", 1},
+};
+
+static const xt_method_spec XT_SET_METHODS[] = {
+  {"add", 1}, {"has", 1}, {"delete", 1}, {"clear", 0}, {"keys", 0}, {"values", 0},
+  {"entries", 0}, {"forEach", 1},
+};
+
+static const xt_method_spec XT_REGEXP_METHODS[] = {
+  {"test", 1}, {"exec", 1}, {"toString", 0},
+};
+
+static const xt_method_spec XT_PROMISE_METHODS[] = {
+  {"then", 2}, {"catch", 1}, {"finally", 1},
+};
+
+static const xt_method_spec XT_ERROR_METHODS[] = {
+  {"toString", 0},
+};
+
+static const xt_method_spec XT_GENERATOR_METHODS[] = {
+  {"next", 1}, {"return", 1}, {"throw", 1},
+};
+
+static const xt_method_spec XT_SYMBOL_METHODS[] = {
+  {"toString", 0}, {"valueOf", 0},
+};
+
+static int xt_method_lookup(const xt_method_spec *specs, size_t count, const char *method, int32_t *arity) {
+  for (size_t i = 0; i < count; i++) {
+    if (strcmp(method, specs[i].name) == 0) {
+      if (arity) *arity = specs[i].arity;
+      return 1;
+    }
+  }
+  return 0;
+}
+
+xt_value xt_method_value(xt_value target, xt_value name) {
+  if (!XT_IS_STRING(name)) return XT_UNDEFINED;
+  const char *method = xt_string_data(name);
+  if (!method) return XT_UNDEFINED;
+  int32_t arity = 0;
+  int known = 0;
+  if (XT_IS_ARRAY(target)) {
+    known = xt_method_lookup(XT_ARRAY_METHODS, XT_NAME_COUNT(XT_ARRAY_METHODS), method, &arity);
+  } else if (XT_IS_STRING(target)) {
+    known = xt_method_lookup(XT_STRING_METHODS, XT_NAME_COUNT(XT_STRING_METHODS), method, &arity);
+  } else if (XT_IS_FUNCTION(target)) {
+    known = xt_method_lookup(XT_FUNCTION_METHODS, XT_NAME_COUNT(XT_FUNCTION_METHODS), method, &arity);
+  } else if (XT_IS_BIGINT(target)) {
+    known = xt_method_lookup(XT_BIGINT_METHODS, XT_NAME_COUNT(XT_BIGINT_METHODS), method, &arity);
+  } else if (XT_IS_NUMBER(target)) {
+    known = xt_method_lookup(XT_NUMBER_METHODS, XT_NAME_COUNT(XT_NUMBER_METHODS), method, &arity);
+  } else if (target == XT_TRUE || target == XT_FALSE) {
+    known = xt_method_lookup(XT_BOOLEAN_METHODS, XT_NAME_COUNT(XT_BOOLEAN_METHODS), method, &arity);
+  } else if (XT_IS_OBJECT(target)) {
+    int kind = ((xt_object *)XT_GET_PTR(target))->header.kind;
+    if (kind == XT_OBJECT_KIND_DATE) {
+      known = xt_method_lookup(XT_DATE_METHODS, XT_NAME_COUNT(XT_DATE_METHODS), method, &arity);
+    } else if (kind == XT_OBJECT_KIND_MAP) {
+      known = xt_method_lookup(XT_MAP_METHODS, XT_NAME_COUNT(XT_MAP_METHODS), method, &arity);
+    } else if (kind == XT_OBJECT_KIND_SET) {
+      known = xt_method_lookup(XT_SET_METHODS, XT_NAME_COUNT(XT_SET_METHODS), method, &arity);
+    } else if (kind == XT_OBJECT_KIND_REGEXP) {
+      known = xt_method_lookup(XT_REGEXP_METHODS, XT_NAME_COUNT(XT_REGEXP_METHODS), method, &arity);
+    } else if (kind == XT_OBJECT_KIND_PROMISE) {
+      known = xt_method_lookup(XT_PROMISE_METHODS, XT_NAME_COUNT(XT_PROMISE_METHODS), method, &arity);
+    } else if (kind == XT_OBJECT_KIND_ERROR) {
+      known = xt_method_lookup(XT_ERROR_METHODS, XT_NAME_COUNT(XT_ERROR_METHODS), method, &arity);
+    } else if (kind == XT_OBJECT_KIND_GENERATOR) {
+      known = xt_method_lookup(XT_GENERATOR_METHODS, XT_NAME_COUNT(XT_GENERATOR_METHODS), method, &arity);
+    } else if (kind == XT_OBJECT_KIND_SYMBOL) {
+      known = xt_method_lookup(XT_SYMBOL_METHODS, XT_NAME_COUNT(XT_SYMBOL_METHODS), method, &arity);
+    }
+  }
+  if (!known) return XT_UNDEFINED;
+  xt_value env[1];
+  env[0] = name;
+  xt_value closure = xt_closure_new((void *)xt_method_value_invoke, 1, env);
+  xt_function_set_metadata(closure, name, arity);
+  return closure;
+}
+
 xt_value xt_call_method(xt_value target, xt_value name, int32_t argc, xt_value *argv) {
+  /* A symbol-named method (`obj[Symbol.iterator]()`) is never a built-in, so
+   * resolve it as an ordinary property and call it with `target` as `this`. */
+  if (xt_is_symbol(name)) {
+    if (target == XT_UNDEFINED || target == XT_NULL) {
+      xt_throw(xt_string_from_cstr("TypeError: Cannot read properties of null (reading a Symbol)"));
+    }
+    xt_value fn = xt_get(target, name);
+    if (XT_IS_FUNCTION(fn)) return xt_call_with_this(fn, target, argc, argv);
+    return XT_UNDEFINED;
+  }
   const char *method = xt_string_data(name);
   if (!method) return XT_UNDEFINED;
+  if (target == XT_UNDEFINED || target == XT_NULL) {
+    const char *base = target == XT_NULL ? "null" : "undefined";
+    char message[256];
+    snprintf(message, sizeof(message),
+             "TypeError: Cannot read properties of %s (reading '%s')", base, method);
+    xt_throw(xt_string_from_cstr(message));
+  }
   int handled = 0;
+  if (xt_is_symbol(target)) {
+    if (strcmp(method, "toString") == 0) return xt_symbol_to_string(target);
+    if (strcmp(method, "valueOf") == 0) return target;
+    return XT_UNDEFINED;
+  }
   if (XT_IS_OBJECT(target)) {
     xt_object *obj = (xt_object *)XT_GET_PTR(target);
     int kind = obj->header.kind;
@@ -69,6 +267,14 @@ xt_value xt_call_method(xt_value target, xt_value name, int32_t argc, xt_value *
       xt_value result = xt_promise_method(target, method, argc, argv, &handled);
       if (handled) return result;
     }
+    if (kind == XT_OBJECT_KIND_ERROR && strcmp(method, "toString") == 0) {
+      return xt_error_to_string(target);
+    }
+    if (kind == XT_OBJECT_KIND_GENERATOR) {
+      if (strcmp(method, "next") == 0) return xt_generator_next(target, xt_arg_at(argc, argv, 0));
+      if (strcmp(method, "throw") == 0) return xt_generator_throw(target, xt_arg_at(argc, argv, 0));
+      if (strcmp(method, "return") == 0) return xt_generator_return(target, xt_arg_at(argc, argv, 0));
+    }
     if (kind != XT_OBJECT_KIND_OBJECT && kind != XT_OBJECT_KIND_FUNCTION) {
       xt_value result = xt_ext_container_method(target, method, argc, argv, &handled);
       if (handled) return result;
@@ -85,8 +291,48 @@ xt_value xt_call_method(xt_value target, xt_value name, int32_t argc, xt_value *
     return XT_UNDEFINED;
   }
   if (XT_IS_FUNCTION(target)) {
+    /* Function prototype methods, resolved before the property bag. */
+    if (strcmp(method, "call") == 0) {
+      return xt_call_with_this(target, xt_arg_at(argc, argv, 0),
+                               argc > 0 ? argc - 1 : 0, argc > 0 ? argv + 1 : NULL);
+    }
+    if (strcmp(method, "apply") == 0) {
+      xt_value thisArg = xt_arg_at(argc, argv, 0);
+      xt_value args = xt_arg_at(argc, argv, 1);
+      if (XT_IS_ARRAY(args)) {
+        xt_array *array = xt_as_array(args);
+        return xt_call_with_this(target, thisArg, (int32_t)array->length, array->items);
+      }
+      return xt_call_with_this(target, thisArg, 0, NULL);
+    }
+    if (strcmp(method, "bind") == 0) {
+      xt_value env[3];
+      env[0] = target;
+      env[1] = xt_arg_at(argc, argv, 0);
+      env[2] = argc > 1 ? xt_array_new(argc - 1, argv + 1) : xt_array_new(0, NULL);
+      xt_value bound = xt_closure_new((void *)xt_bound_invoke, 3, env);
+      /* Bound functions report `name` as "bound <target>" and reduce `length`
+       * by the number of pre-bound arguments, like the specification. */
+      xt_function *targetFn = (xt_function *)XT_GET_PTR(target);
+      const char *base = targetFn->name ? targetFn->name->data : "";
+      char boundName[256];
+      snprintf(boundName, sizeof(boundName), "bound %s", base);
+      int32_t prebound = argc > 1 ? argc - 1 : 0;
+      int32_t arity = targetFn->arity >= 0 ? targetFn->arity - prebound : 0;
+      if (arity < 0) arity = 0;
+      xt_function_set_metadata(bound, xt_string_from_cstr(boundName), arity);
+      return bound;
+    }
     xt_value fn = xt_object_get(target, name);
     if (XT_IS_FUNCTION(fn)) return xt_call_with_this(fn, target, argc, argv);
+    if (strcmp(method, "toString") == 0) {
+      /* Source text is not retained; report a native-style representation. */
+      xt_function *self = (xt_function *)XT_GET_PTR(target);
+      const char *selfName = self->name ? self->name->data : "";
+      char buffer[256];
+      snprintf(buffer, sizeof(buffer), "function %s() { [native code] }", selfName);
+      return xt_string_from_cstr(buffer);
+    }
     {
       char message[256];
       snprintf(message, sizeof(message), "TypeError: function has no callable method '%s'", method);
@@ -112,5 +358,10 @@ xt_value xt_call_method(xt_value target, xt_value name, int32_t argc, xt_value *
     xt_value result = xt_ext_number_method(target, method, argc, argv, &handled);
     if (handled) return result;
   }
+  if (target == XT_TRUE || target == XT_FALSE) {
+    if (strcmp(method, "toString") == 0) return target == XT_TRUE ? xt_string_from_cstr("true") : xt_string_from_cstr("false");
+    if (strcmp(method, "valueOf") == 0) return target;
+    return XT_UNDEFINED;
+  }
   return XT_UNDEFINED;
 }

package/runtime/xt_stdlib/strings.inc

@@ -76,10 +76,12 @@ static xt_value xt_string_substr(xt_value value, xt_value startValue, xt_value l
   return xt_string_new(s->data + start, (size_t)length);
 }
 
-static xt_value xt_string_split(xt_value value, xt_value separatorValue) {
+static xt_value xt_string_split(xt_value value, xt_value separatorValue, xt_value limitValue) {
   xt_value result = xt_array_new(0, NULL);
   xt_string *s = xt_as_string(value);
   if (!s) return result;
+  int64_t limit = limitValue == XT_UNDEFINED ? 0x7fffffff : (int64_t)xt_to_int32(limitValue);
+  if (limit <= 0) return result;
   if (separatorValue == XT_UNDEFINED) {
     xt_array_push(result, value);
     return result;
@@ -87,20 +89,22 @@ static xt_value xt_string_split(xt_value value, xt_value separatorValue) {
   xt_string *sep = xt_as_string(xt_to_string(separatorValue));
   if (sep->length == 0) {
     for (uint32_t i = 0; i < s->length; i++) xt_array_push(result, xt_string_new(s->data + i, 1));
-    return result;
-  }
-  uint32_t start = 0;
-  uint32_t i = 0;
-  while (i + sep->length <= s->length) {
-    if (memcmp(s->data + i, sep->data, sep->length) == 0) {
-      xt_array_push(result, xt_string_new(s->data + start, i - start));
-      i += sep->length;
-      start = i;
-    } else {
-      i++;
+  } else {
+    uint32_t start = 0;
+    uint32_t i = 0;
+    while (i + sep->length <= s->length) {
+      if (memcmp(s->data + i, sep->data, sep->length) == 0) {
+        xt_array_push(result, xt_string_new(s->data + start, i - start));
+        i += sep->length;
+        start = i;
+      } else {
+        i++;
+      }
     }
+    xt_array_push(result, xt_string_new(s->data + start, s->length - start));
   }
-  xt_array_push(result, xt_string_new(s->data + start, s->length - start));
+  xt_array *array = xt_as_array(result);
+  if ((int64_t)array->length > limit) array->length = (uint32_t)limit;
   return result;
 }