xbintsc 0.2.4 → 0.2.6

package/runtime/xt_builtins.c

@@ -100,6 +100,29 @@ xt_value xt_boolean_ctor(int32_t argc, xt_value *argv) {
   return xt_bool(xt_truthy(argv[0]));
 }
 
+/*
+ * Builtin function values. Global constructors like `Boolean` are usually
+ * called directly, but JavaScript also allows passing them around
+ * (`arr.filter(Boolean)`). These trampolines adapt the uniform `(argc, argv)`
+ * builtin ABI to the closure ABI so the codegen can wrap them with
+ * `xt_closure_new`.
+ */
+#define XT_BUILTIN_TRAMPOLINE(name, target)                            \
+  xt_value name(xt_value thisValue, xt_value env, int32_t argc,        \
+                xt_value *argv) {                                      \
+    (void)thisValue;                                                   \
+    (void)env;                                                         \
+    return target(argc, argv);                                         \
+  }
+
+XT_BUILTIN_TRAMPOLINE(xt_builtin_value_boolean, xt_boolean_ctor)
+XT_BUILTIN_TRAMPOLINE(xt_builtin_value_number, xt_number_ctor)
+XT_BUILTIN_TRAMPOLINE(xt_builtin_value_string, xt_string_ctor)
+XT_BUILTIN_TRAMPOLINE(xt_builtin_value_parseInt, xt_parse_int)
+XT_BUILTIN_TRAMPOLINE(xt_builtin_value_parseFloat, xt_parse_float)
+XT_BUILTIN_TRAMPOLINE(xt_builtin_value_isNaN, xt_is_nan)
+XT_BUILTIN_TRAMPOLINE(xt_builtin_value_isFinite, xt_is_finite)
+
 xt_value xt_in(xt_value key, xt_value value) {
   if (XT_IS_OBJECT(value)) return xt_object_has(value, key);
   if (XT_IS_ARRAY(value)) {

package/runtime/xt_containers.c

@@ -63,16 +63,40 @@ xt_property *xt_object_find_property(xt_object *obj, xt_string *key) {
   return obj ? xt_object_find(obj, key) : NULL;
 }
 
+static int xt_key_is_prototype(xt_value key) {
+  xt_string *k = xt_as_string(xt_to_string(key));
+  return k && k->length == 9 && memcmp(k->data, "prototype", 9) == 0;
+}
+
 xt_value xt_object_get(xt_value value, xt_value key) {
+  /* A function's `.prototype` lives in a dedicated field (set by
+     `xt_function_set_prototype`), not in its property bag. Expose it as a
+     normal property so `Class.prototype` returns the object instances use. */
+  if (XT_IS_FUNCTION(value) && xt_key_is_prototype(key)) {
+    return ((xt_function *)XT_GET_PTR(value))->prototype;
+  }
   xt_object *obj = xt_as_object(value);
   if (!obj) return XT_UNDEFINED;
+  /* Only plain objects (and function property bags) use the `xt_object`
+     layout. Containers such as Map/Set/Date/RegExp/Promise/Array must not be
+     interpreted as property tables, or property lookup reads past the end of
+     their real representation. */
+  if (obj->header.kind != XT_OBJECT_KIND_OBJECT) return XT_UNDEFINED;
   xt_value keyString = xt_to_string(key);
   xt_string *k = xt_as_string(keyString);
   /* Walk the prototype chain like JavaScript property lookup. */
   xt_object *cur = obj;
   while (cur) {
     xt_property *prop = xt_object_find(cur, k);
-    if (prop) return prop->value;
+    if (prop) {
+      /* Invoke accessors with the original receiver as `this`, so getters
+         inherited from a prototype still see the instance. */
+      if (prop->getter != XT_UNDEFINED && XT_IS_FUNCTION(prop->getter)) {
+        return xt_call_with_this(prop->getter, value, 0, NULL);
+      }
+      if (prop->getter != XT_UNDEFINED) return XT_UNDEFINED;
+      return prop->value;
+    }
     if (!XT_IS_OBJECT(cur->prototype)) break;
     cur = (xt_object *)XT_GET_PTR(cur->prototype);
   }
@@ -80,22 +104,82 @@ xt_value xt_object_get(xt_value value, xt_value key) {
 }
 
 xt_value xt_object_set(xt_value value, xt_value key, xt_value newValue) {
+  if (XT_IS_FUNCTION(value) && xt_key_is_prototype(key)) {
+    return xt_function_set_prototype(value, newValue);
+  }
   xt_object *obj = xt_as_object(value);
   if (!obj) return newValue;
+  if (obj->header.kind != XT_OBJECT_KIND_OBJECT) return newValue;
   if (obj->frozen) return newValue;
   xt_value keyString = xt_to_string(key);
-  xt_property *prop = xt_object_find(obj, xt_as_string(keyString));
+  xt_string *k = xt_as_string(keyString);
+  xt_property *prop = xt_object_find(obj, k);
   if (prop) {
+    if (prop->setter != XT_UNDEFINED) {
+      if (XT_IS_FUNCTION(prop->setter)) {
+        xt_value argument = newValue;
+        xt_call_with_this(prop->setter, value, 1, &argument);
+      }
+      return newValue;
+    }
+    if (prop->getter != XT_UNDEFINED) return newValue; /* accessor without setter */
     prop->value = newValue;
     return newValue;
   }
+  /* No own property: an inherited accessor still intercepts the assignment
+     (JavaScript assigns through prototype setters instead of shadowing). */
+  xt_object *ancestor = XT_IS_OBJECT(obj->prototype) ? (xt_object *)XT_GET_PTR(obj->prototype) : NULL;
+  while (ancestor) {
+    xt_property *inherited = xt_object_find(ancestor, k);
+    if (inherited) {
+      if (inherited->setter != XT_UNDEFINED) {
+        if (XT_IS_FUNCTION(inherited->setter)) {
+          xt_value argument = newValue;
+          xt_call_with_this(inherited->setter, value, 1, &argument);
+        }
+        return newValue;
+      }
+      if (inherited->getter != XT_UNDEFINED) return newValue; /* getter-only accessor */
+      break; /* plain inherited data property: create an own shadowing property */
+    }
+    ancestor = XT_IS_OBJECT(ancestor->prototype) ? (xt_object *)XT_GET_PTR(ancestor->prototype) : NULL;
+  }
   xt_object_reserve(obj, obj->count + 1);
-  obj->properties[obj->count].key = xt_as_string(keyString);
+  obj->properties[obj->count].key = k;
   obj->properties[obj->count].value = newValue;
+  obj->properties[obj->count].getter = XT_UNDEFINED;
+  obj->properties[obj->count].setter = XT_UNDEFINED;
   obj->count++;
   return newValue;
 }
 
+static xt_property *xt_object_ensure_property(xt_object *obj, xt_value keyString) {
+  xt_property *prop = xt_object_find(obj, xt_as_string(keyString));
+  if (prop) return prop;
+  xt_object_reserve(obj, obj->count + 1);
+  prop = &obj->properties[obj->count];
+  prop->key = xt_as_string(keyString);
+  prop->value = XT_UNDEFINED;
+  prop->getter = XT_UNDEFINED;
+  prop->setter = XT_UNDEFINED;
+  obj->count++;
+  return prop;
+}
+
+xt_value xt_object_define_getter(xt_value value, xt_value key, xt_value getter) {
+  xt_object *obj = xt_as_object(value);
+  if (!obj) return value;
+  xt_object_ensure_property(obj, xt_to_string(key))->getter = getter;
+  return value;
+}
+
+xt_value xt_object_define_setter(xt_value value, xt_value key, xt_value setter) {
+  xt_object *obj = xt_as_object(value);
+  if (!obj) return value;
+  xt_object_ensure_property(obj, xt_to_string(key))->setter = setter;
+  return value;
+}
+
 xt_value xt_object_get_prototype(xt_value value) {
   xt_object *obj = xt_as_object(value);
   if (obj) return obj->prototype;
@@ -248,21 +332,47 @@ xt_value xt_array_length(xt_value value) {
 }
 
 xt_value xt_array_spread(xt_value target, xt_value source) {
-  if (!XT_IS_ARRAY(target) || !XT_IS_ARRAY(source)) return target;
-  xt_array *dst = (xt_array *)XT_GET_PTR(target);
-  xt_array *src = (xt_array *)XT_GET_PTR(source);
-  xt_array_reserve(dst, dst->length + src->length);
-  for (uint32_t i = 0; i < src->length; i++) dst->items[dst->length++] = src->items[i];
+  if (!XT_IS_ARRAY(target)) return target;
+  if (XT_IS_ARRAY(source)) {
+    xt_array *dst = (xt_array *)XT_GET_PTR(target);
+    xt_array *src = (xt_array *)XT_GET_PTR(source);
+    xt_array_reserve(dst, dst->length + src->length);
+    for (uint32_t i = 0; i < src->length; i++) dst->items[dst->length++] = src->items[i];
+    return target;
+  }
+  /* Spreading a string/Map/Set iterates exactly like `for...of`. */
+  int32_t n = xt_to_int32(xt_iter_length(source));
+  for (int32_t i = 0; i < n; i++) {
+    xt_array_push(target, xt_iter_value(source, xt_number((double)i)));
+  }
   return target;
 }
 
+int32_t xt_array_size(xt_value value) {
+  if (!XT_IS_ARRAY(value)) return 0;
+  return (int32_t)((xt_array *)XT_GET_PTR(value))->length;
+}
+
+xt_value *xt_array_items(xt_value value) {
+  if (!XT_IS_ARRAY(value)) return NULL;
+  return ((xt_array *)XT_GET_PTR(value))->items;
+}
+
 
 /* ------------------------------------------------------------------------- */
 /* Generic member access                                                     */
 /* ------------------------------------------------------------------------- */
 
 xt_value xt_get(xt_value target, xt_value key) {
-  if (XT_IS_ARRAY(target)) return xt_array_get(target, key);
+  if (XT_IS_ARRAY(target)) {
+    /* `arr.length` must read the array's length, never an element. */
+    if (XT_IS_STRING(key)) {
+      xt_string *k = xt_as_string(key);
+      if (k->length == 6 && memcmp(k->data, "length", 6) == 0)
+        return xt_number((double)((xt_array *)XT_GET_PTR(target))->length);
+    }
+    return xt_array_get(target, key);
+  }
   if (XT_IS_FUNCTION(target)) return xt_object_get(target, key);
   if (XT_IS_OBJECT(target)) {
     /* Map/Set expose `.size`; promises, dates and regexps have their own
@@ -277,6 +387,7 @@ xt_value xt_get(xt_value target, xt_value key) {
         }
       }
     }
+    if (obj->header.kind == XT_OBJECT_KIND_REGEXP) return xt_regexp_get_property(target, key);
     return xt_object_get(target, key);
   }
   if (XT_IS_STRING(target)) {
@@ -294,7 +405,22 @@ xt_value xt_get(xt_value target, xt_value key) {
 }
 
 xt_value xt_set(xt_value target, xt_value key, xt_value value) {
-  if (XT_IS_ARRAY(target)) return xt_array_set(target, key, value);
+  if (XT_IS_ARRAY(target)) {
+    /* Assigning `arr.length` truncates or extends the array. */
+    if (XT_IS_STRING(key)) {
+      xt_string *k = xt_as_string(key);
+      if (k->length == 6 && memcmp(k->data, "length", 6) == 0) {
+        xt_array *array = (xt_array *)XT_GET_PTR(target);
+        int32_t n = xt_to_int32(value);
+        if (n < 0) n = 0;
+        xt_array_reserve(array, (uint32_t)n);
+        for (uint32_t j = array->length; j < (uint32_t)n; j++) array->items[j] = XT_UNDEFINED;
+        array->length = (uint32_t)n;
+        return value;
+      }
+    }
+    return xt_array_set(target, key, value);
+  }
   if (XT_IS_FUNCTION(target)) return xt_object_set(target, key, value);
   if (XT_IS_OBJECT(target)) return xt_object_set(target, key, value);
   return value;

package/runtime/xt_io.c

@@ -69,6 +69,59 @@ void xt_set_program_args(int32_t argc, char **argv) {
   xt_program_argv = argv;
 }
 
+/*
+ * `import.meta` support. The compiler resolves module URLs at build time, but
+ * a self-hosted binary only knows where *it* lives, so `import.meta.url` is the
+ * executable's own `file://` URL (and `dirname`/`filename` its path parts).
+ * This lets the compiler locate an adjacent `runtime/` directory at run time.
+ */
+static xt_value xt_file_url(const char *path) {
+  char url[4300];
+  size_t j = 0;
+  const char *prefix = "file://";
+  for (; *prefix; prefix++) url[j++] = *prefix;
+#if defined(_WIN32)
+  url[j++] = '/';
+#endif
+  for (const char *p = path; *p && j < sizeof(url) - 1; p++) url[j++] = (*p == '\\') ? '/' : *p;
+  url[j] = 0;
+  return xt_string_from_cstr(url);
+}
+
+xt_value xt_import_meta(xt_value name) {
+  const char *prop = xt_string_data(name);
+  const char *raw = (xt_program_argv && xt_program_argv[0]) ? xt_program_argv[0] : "";
+  char resolved[4096];
+  resolved[0] = 0;
+  if (raw[0]) {
+#if defined(_WIN32)
+    if (_fullpath(resolved, raw, sizeof(resolved)) == NULL) resolved[0] = 0;
+#else
+    if (realpath(raw, resolved) == NULL) resolved[0] = 0;
+#endif
+  }
+  const char *abs = resolved[0] ? resolved : raw;
+  if (prop && strcmp(prop, "dirname") == 0) {
+    char dir[4096];
+    size_t n = strlen(abs);
+    if (n >= sizeof(dir)) n = sizeof(dir) - 1;
+    memcpy(dir, abs, n);
+    dir[n] = 0;
+    char *slash = strrchr(dir, '/');
+#if defined(_WIN32)
+    char *back = strrchr(dir, '\\');
+    if (back && (!slash || back > slash)) slash = back;
+#endif
+    if (slash) {
+      if (slash == dir) slash[1] = 0;
+      else *slash = 0;
+    }
+    return xt_string_from_cstr(dir);
+  }
+  if (prop && strcmp(prop, "filename") == 0) return xt_string_from_cstr(abs);
+  return xt_file_url(abs);
+}
+
 void *xt_try_enter(void) {
   xt_try_frame *frame = (xt_try_frame *)calloc(1, sizeof(xt_try_frame));
   if (!frame) abort();

package/runtime/xt_regex.h

@@ -567,9 +567,13 @@ static int xt_re_match_alt(xt_re_alt *alt, const xt_re_input *in, size_t pos,
   return 0;
 }
 
-static int xt_re_accept(void *ctx, size_t pos) {
-  (void)ctx;
-  (void)pos;
+typedef struct {
+  size_t end;
+} xt_re_match_result;
+
+static int xt_re_record_match(void *ctx, size_t pos) {
+  xt_re_match_result *result = (xt_re_match_result *)ctx;
+  result->end = pos;
   return 1;
 }
 
@@ -597,15 +601,21 @@ 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;
-  (void)nmatch;
-  (void)pmatch;
   (void)eflags;
   if (!preg || !preg->root || !string) return 1;
   in.text = string;
   in.len = strlen(string);
   in.icase = preg->icase;
   for (start = 0; start <= in.len; start++) {
-    if (xt_re_match_alt(preg->root, &in, start, xt_re_accept, NULL)) return 0;
+    xt_re_match_result result;
+    result.end = 0;
+    if (xt_re_match_alt(preg->root, &in, start, xt_re_record_match, &result)) {
+      if (nmatch > 0 && pmatch) {
+        pmatch[0].rm_so = (int)start;
+        pmatch[0].rm_eo = (int)result.end;
+      }
+      return 0;
+    }
   }
   return 1;
 }

package/runtime/xt_stdlib.c

@@ -327,6 +327,7 @@ static xt_value xt_string_trim(xt_value value) {
 }
 
 static xt_value xt_string_replace(xt_value value, xt_value searchValue, xt_value replacementValue) {
+  if (xt_is_regexp(searchValue)) return xt_regexp_replace(value, searchValue, replacementValue);
   xt_string *s = xt_as_string(value);
   if (!s) return value;
   xt_string *search = xt_as_string(xt_to_string(searchValue));
@@ -456,13 +457,21 @@ xt_value xt_call_method(xt_value target, xt_value name, int32_t argc, xt_value *
     if (XT_IS_FUNCTION(fn)) return xt_call_with_this(fn, target, argc, argv);
     xt_value result = xt_ext_object_method(target, method, argc, argv, &handled);
     if (handled) return result;
-    xt_throw(xt_string_from_cstr("TypeError: target does not have a callable property of that name"));
+    {
+      char message[256];
+      snprintf(message, sizeof(message), "TypeError: object has no callable method '%s'", method);
+      xt_throw(xt_string_from_cstr(message));
+    }
     return XT_UNDEFINED;
   }
   if (XT_IS_FUNCTION(target)) {
     xt_value fn = xt_object_get(target, name);
     if (XT_IS_FUNCTION(fn)) return xt_call_with_this(fn, target, argc, argv);
-    xt_throw(xt_string_from_cstr("TypeError: target does not have a callable property of that name"));
+    {
+      char message[256];
+      snprintf(message, sizeof(message), "TypeError: function has no callable method '%s'", method);
+      xt_throw(xt_string_from_cstr(message));
+    }
     return XT_UNDEFINED;
   }
   if (XT_IS_ARRAY(target)) {

package/runtime/xt_stdlib2.c

@@ -294,6 +294,7 @@ static xt_value xt_string_at(xt_value value, xt_value indexValue) {
 }
 
 static xt_value xt_string_replace_all(xt_value value, xt_value searchValue, xt_value replacementValue) {
+  if (xt_is_regexp(searchValue)) return xt_regexp_replace(value, searchValue, replacementValue);
   xt_string *s = xt_as_string(value);
   if (!s) return value;
   xt_string *search = xt_as_string(xt_to_string(searchValue));
@@ -856,6 +857,35 @@ int32_t xt_set_size(xt_value value) {
   return (int32_t)((xt_set_object *)XT_GET_PTR(value))->count;
 }
 
+/* -- for...of iteration --------------------------------------------------- */
+
+/* `for...of` lowers to a length check plus an index lookup. Arrays and strings
+   index directly; Maps yield `[key, value]` pairs and Sets yield their values. */
+xt_value xt_iter_length(xt_value value) {
+  if (xt_is_map(value)) return xt_number((double)xt_map_size(value));
+  if (xt_is_set(value)) return xt_number((double)xt_set_size(value));
+  return xt_array_length(value);
+}
+
+xt_value xt_iter_value(xt_value value, xt_value index) {
+  if (xt_is_map(value)) {
+    xt_map *map = (xt_map *)XT_GET_PTR(value);
+    int64_t i = (int64_t)xt_to_int32(index);
+    if (i < 0 || i >= (int64_t)map->count) return XT_UNDEFINED;
+    xt_value pair = xt_array_new(0, NULL);
+    xt_array_push(pair, map->keys[i]);
+    xt_array_push(pair, map->values[i]);
+    return pair;
+  }
+  if (xt_is_set(value)) {
+    xt_set_object *set = (xt_set_object *)XT_GET_PTR(value);
+    int64_t i = (int64_t)xt_to_int32(index);
+    if (i < 0 || i >= (int64_t)set->count) return XT_UNDEFINED;
+    return set->values[i];
+  }
+  return xt_get(value, index);
+}
+
 static int32_t xt_set_index(xt_set_object *set, xt_value key) {
   for (uint32_t i = 0; i < set->count; i++) if (xt_value_equals(set->values[i], key)) return (int32_t)i;
   return -1;
@@ -1016,18 +1046,232 @@ xt_value xt_regexp_ctor(int32_t argc, xt_value *argv) {
   return XT_FROM_PTR(XT_TAG_OBJECT, regexp);
 }
 
-static xt_value xt_regexp_test(xt_value target, xt_value input) {
-  xt_regexp *regexp = (xt_regexp *)XT_GET_PTR(target);
+xt_value xt_error_ctor(int32_t argc, xt_value *argv) {
+  xt_value error = xt_object_new();
+  xt_value name = xt_arg_at(argc, argv, 1);
+  xt_value message = xt_arg_at(argc, argv, 0);
+  xt_object_set(error, xt_string_from_cstr("name"),
+                name == XT_UNDEFINED ? xt_string_from_cstr("Error") : name);
+  xt_object_set(error, xt_string_from_cstr("message"),
+                message == XT_UNDEFINED ? xt_string_from_cstr("") : message);
+  return error;
+}
+
+/* `super(message)` inside a subclass of the builtin `Error`: initialize the
+ * already-allocated instance instead of creating a fresh object. */
+xt_value xt_error_init(xt_value thisValue, int32_t argc, xt_value *argv) {
+  xt_value name = xt_arg_at(argc, argv, 1);
+  xt_value message = xt_arg_at(argc, argv, 0);
+  xt_object_set(thisValue, xt_string_from_cstr("name"),
+                name == XT_UNDEFINED ? xt_string_from_cstr("Error") : name);
+  xt_object_set(thisValue, xt_string_from_cstr("message"),
+                message == XT_UNDEFINED ? xt_string_from_cstr("") : message);
+  return thisValue;
+}
+
+/* Compile `regexp` and search `input` starting at byte offset `start`.
+ * Returns 1 and fills `matchStart`/`matchEnd` (absolute offsets into `input`)
+ * when a match is found, otherwise 0. */
+
+static int xt_regex_hex_digit(char c) {
+  if (c >= '0' && c <= '9') return c - '0';
+  if (c >= 'a' && c <= 'f') return c - 'a' + 10;
+  if (c >= 'A' && c <= 'F') return c - 'A' + 10;
+  return -1;
+}
+
+/* JavaScript regexes use escapes POSIX ERE does not understand (`\r`, `\n`,
+ * `\d`, `\w`, `\s`, `(?:...)`, ...). Rewrite the common ones into their POSIX
+ * equivalents before handing the pattern to the engine. Returns a malloc'd,
+ * NUL-terminated string the caller must free. */
+static char *xt_regexp_translate_js(const char *pattern) {
+  size_t length = strlen(pattern);
+  size_t capacity = length * 16 + 16;
+  char *out = (char *)malloc(capacity);
+  if (!out) abort();
+  size_t written = 0;
+  for (size_t i = 0; i < length; i++) {
+    char c = pattern[i];
+    const char *replacement = NULL;
+    char literal = 0;
+    int consume = 0;
+    if (c == '\\') {
+      char next = (i + 1 < length) ? pattern[i + 1] : '\0';
+      switch (next) {
+        case 'r': literal = '\r'; consume = 1; break;
+        case 'n': literal = '\n'; consume = 1; break;
+        case 't': literal = '\t'; consume = 1; break;
+        case 'f': literal = '\f'; consume = 1; break;
+        case 'v': literal = '\v'; consume = 1; break;
+        case 'd': replacement = "[0-9]"; consume = 1; break;
+        case 'D': replacement = "[^0-9]"; consume = 1; break;
+        case 'w': replacement = "[A-Za-z0-9_]"; consume = 1; break;
+        case 'W': replacement = "[^A-Za-z0-9_]"; consume = 1; break;
+        case 's': replacement = "[ \t\n\r\f\v]"; consume = 1; break;
+        case 'S': replacement = "[^ \t\n\r\f\v]"; consume = 1; break;
+        case 'x': {
+          int hi = (i + 2 < length) ? xt_regex_hex_digit(pattern[i + 2]) : -1;
+          int lo = (i + 3 < length) ? xt_regex_hex_digit(pattern[i + 3]) : -1;
+          if (hi >= 0 && lo >= 0) { literal = (char)(hi * 16 + lo); consume = 3; }
+          break;
+        }
+        default: break;
+      }
+    } else if (c == '(' && i + 2 < length && pattern[i + 1] == '?' && pattern[i + 2] == ':') {
+      /* POSIX ERE has no non-capturing groups; a capturing group matches the
+       * same text, only the capture bookkeeping differs. */
+      literal = '(';
+      consume = 2;
+    }
+    if (replacement) {
+      size_t addition = strlen(replacement);
+      if (written + addition + 1 > capacity) { capacity = (written + addition) * 2 + 16; out = (char *)realloc(out, capacity); if (!out) abort(); }
+      memcpy(out + written, replacement, addition);
+      written += addition;
+    } else if (consume || literal) {
+      if (written + 2 > capacity) { capacity = capacity * 2 + 16; out = (char *)realloc(out, capacity); if (!out) abort(); }
+      out[written++] = literal;
+    } else {
+      if (written + 2 > capacity) { capacity = capacity * 2 + 16; out = (char *)realloc(out, capacity); if (!out) abort(); }
+      out[written++] = c;
+    }
+    i += (size_t)consume;
+  }
+  out[written] = '\0';
+  return out;
+}
+
+int xt_regexp_find(xt_value regexpValue, xt_value input, int32_t start, int32_t *matchStart, int32_t *matchEnd) {
+  xt_regexp *regexp = (xt_regexp *)XT_GET_PTR(regexpValue);
   xt_string *pattern = xt_as_string(regexp->source);
   xt_string *text = xt_as_string(xt_to_string(input));
+  if (!pattern || !text) return 0;
+  if (start < 0) start = 0;
+  if ((uint32_t)start > text->length) return 0;
   int flags = REG_EXTENDED;
   xt_string *f = xt_as_string(regexp->flags);
   if (f) for (uint32_t i = 0; i < f->length; i++) if (f->data[i] == 'i') flags |= REG_ICASE;
+  char *translated = xt_regexp_translate_js(pattern->data);
+  if (!translated) return 0;
   regex_t compiled;
-  if (!pattern || !text || regcomp(&compiled, pattern->data, flags) != 0) return XT_FALSE;
-  int ok = regexec(&compiled, text->data, 0, NULL, 0) == 0;
+  if (regcomp(&compiled, translated, flags) != 0) {
+    free(translated);
+    return 0;
+  }
+  free(translated);
+  regmatch_t match;
+  match.rm_so = 0;
+  match.rm_eo = 0;
+  int ok = regexec(&compiled, text->data + start, 1, &match, 0) == 0;
   regfree(&compiled);
-  return xt_bool(ok);
+  if (!ok) return 0;
+  if (matchStart) *matchStart = start + (int32_t)match.rm_so;
+  if (matchEnd) *matchEnd = start + (int32_t)match.rm_eo;
+  return 1;
+}
+
+static int xt_regexp_is_global(xt_value regexpValue) {
+  xt_regexp *regexp = (xt_regexp *)XT_GET_PTR(regexpValue);
+  xt_string *f = xt_as_string(regexp->flags);
+  if (!f) return 0;
+  for (uint32_t i = 0; i < f->length; i++) if (f->data[i] == 'g') return 1;
+  return 0;
+}
+
+static xt_value xt_regexp_test(xt_value target, xt_value input) {
+  return xt_bool(xt_regexp_find(target, input, 0, NULL, NULL));
+}
+
+/* JavaScript-style match object: `[0]` is the matched text, `index` is the
+ * match offset and `input` is the searched string. */
+xt_value xt_regexp_exec(xt_value target, xt_value input) {
+  int32_t start = 0;
+  int32_t end = 0;
+  if (!xt_regexp_find(target, input, 0, &start, &end)) return XT_NULL;
+  xt_value textValue = xt_to_string(input);
+  xt_string *text = xt_as_string(textValue);
+  xt_value out = xt_object_new();
+  xt_object_set(out, xt_string_from_cstr("0"), xt_string_new(text->data + start, (int64_t)(end - start)));
+  xt_object_set(out, xt_string_from_cstr("index"), xt_number((double)start));
+  xt_object_set(out, xt_string_from_cstr("input"), textValue);
+  xt_object_set(out, xt_string_from_cstr("length"), xt_number(1));
+  return out;
+}
+
+/* `String.prototype.replace`/`replaceAll` with a RegExp search value. */
+xt_value xt_regexp_replace(xt_value value, xt_value regexpValue, xt_value replacementValue) {
+  xt_string *text = xt_as_string(xt_to_string(value));
+  if (!text) return value;
+  xt_string *replacement = xt_as_string(xt_to_string(replacementValue));
+  if (!replacement) return value;
+  int global = xt_regexp_is_global(regexpValue);
+  size_t capacity = text->length + replacement->length + 16;
+  char *out = (char *)malloc(capacity);
+  if (!out) abort();
+  size_t length = 0;
+  int32_t cursor = 0;
+  int replaced = 0;
+  for (;;) {
+    int32_t start = 0;
+    int32_t end = 0;
+    if (!xt_regexp_find(regexpValue, value, cursor, &start, &end)) break;
+    size_t prefix = (size_t)(start - cursor);
+    size_t needed = length + prefix + replacement->length + 2;
+    if (needed > capacity) {
+      capacity = needed * 2;
+      out = (char *)realloc(out, capacity);
+      if (!out) abort();
+    }
+    memcpy(out + length, text->data + cursor, prefix);
+    length += prefix;
+    memcpy(out + length, replacement->data, replacement->length);
+    length += replacement->length;
+    replaced = 1;
+    if (end > start) {
+      cursor = end;
+    } else {
+      /* Zero-width match: copy one byte so the scan always progresses. */
+      if (cursor >= (int32_t)text->length) break;
+      out[length++] = text->data[cursor++];
+    }
+    if (!global) break;
+  }
+  if (!replaced) {
+    free(out);
+    return value;
+  }
+  size_t tail = text->length - (size_t)cursor;
+  if (length + tail + 1 > capacity) {
+    capacity = length + tail + 1;
+    out = (char *)realloc(out, capacity);
+    if (!out) abort();
+  }
+  memcpy(out + length, text->data + cursor, tail);
+  length += tail;
+  xt_value result = xt_string_new(out, (int64_t)length);
+  free(out);
+  return result;
+}
+
+/* Property access (`re.source`, `re.flags`, `re.global`, ...). */
+xt_value xt_regexp_get_property(xt_value target, xt_value key) {
+  xt_regexp *regexp = (xt_regexp *)XT_GET_PTR(target);
+  if (!XT_IS_STRING(key)) return XT_UNDEFINED;
+  xt_string *k = xt_as_string(key);
+  xt_string *f = xt_as_string(regexp->flags);
+  int flag = 0;
+  if (k->length == 6 && memcmp(k->data, "source", 6) == 0) return regexp->source;
+  if (k->length == 5 && memcmp(k->data, "flags", 5) == 0) return regexp->flags;
+  if (k->length == 9 && memcmp(k->data, "lastIndex", 9) == 0) return xt_number(0);
+  if (k->length == 6 && memcmp(k->data, "global", 6) == 0) flag = 'g';
+  else if (k->length == 10 && memcmp(k->data, "ignoreCase", 10) == 0) flag = 'i';
+  else if (k->length == 9 && memcmp(k->data, "multiline", 9) == 0) flag = 'm';
+  else if (k->length == 6 && memcmp(k->data, "sticky", 6) == 0) flag = 'y';
+  if (flag) {
+    if (f) for (uint32_t i = 0; i < f->length; i++) if (f->data[i] == flag) return XT_TRUE;
+    return XT_FALSE;
+  }
+  return XT_UNDEFINED;
 }
 
 xt_value xt_ext_container_method(xt_value target, const char *method, int32_t argc, xt_value *argv, int *handled) {
@@ -1039,14 +1283,7 @@ xt_value xt_ext_container_method(xt_value target, const char *method, int32_t ar
     xt_regexp *regexp = (xt_regexp *)obj;
     *handled = 1;
     if (strcmp(method, "test") == 0) return xt_regexp_test(target, xt_arg_at(argc, argv, 0));
-    if (strcmp(method, "exec") == 0) {
-      if (xt_truthy(xt_regexp_test(target, xt_arg_at(argc, argv, 0)))) {
-        xt_value out = xt_array_new(0, NULL);
-        xt_array_push(out, xt_arg_at(argc, argv, 0));
-        return out;
-      }
-      return XT_NULL;
-    }
+    if (strcmp(method, "exec") == 0) return xt_regexp_exec(target, xt_arg_at(argc, argv, 0));
     if (strcmp(method, "toString") == 0) {
       xt_value out = xt_string_from_cstr("/");
       out = xt_add(out, regexp->source);

package/runtime/xt_values.c

@@ -117,7 +117,8 @@ int xt_truthy(xt_value v) {
   if (v == XT_UNDEFINED || v == XT_NULL) return 0;
   if (v == XT_FALSE) return 0;
   if (v == XT_TRUE) return 1;
-  return 1; /* objects, arrays, functions and non-empty strings are truthy */
+  if (XT_IS_STRING(v)) return xt_as_string(v)->length != 0;
+  return 1; /* objects, arrays and functions are truthy */
 }
 
 double xt_to_number(xt_value v) {