xbintsc 0.3.87 → 0.5.20

package/runtime/xt_url.c

@@ -0,0 +1,375 @@
+/*
+ * xbintsc runtime — URLSearchParams.
+ *
+ * The query string is stored as an array of [key, value] pairs under an
+ * internal `__entries` property. Methods are closures on the instance, so the
+ * same object model as the rest of the runtime applies. Values are stored
+ * decoded and encoded with application/x-www-form-urlencoded rules when
+ * serialized (`+` for spaces, percent escapes for everything else).
+ */
+
+#include "rt_internal.h"
+
+#include <ctype.h>
+#include <stdlib.h>
+#include <string.h>
+
+static int xt_url_unreserved(unsigned char c) {
+  return (c >= 'a' && c <= 'z') || (c >= 'A' && c <= 'Z') || (c >= '0' && c <= '9') ||
+         c == '*' || c == '-' || c == '.' || c == '_';
+}
+
+static xt_value xt_url_encode(xt_value value) {
+  xt_value text = xt_to_string(value);
+  xt_string *string = xt_as_string(text);
+  const char *bytes = xt_string_bytes(string);
+  size_t capacity = string->length * 3 + 1;
+  char *out = (char *)malloc(capacity);
+  if (!out) abort();
+  size_t written = 0;
+  for (uint32_t i = 0; i < string->length; i++) {
+    unsigned char c = (unsigned char)bytes[i];
+    if (c == ' ') {
+      out[written++] = '+';
+    } else if (xt_url_unreserved(c)) {
+      out[written++] = (char)c;
+    } else {
+      static const char hex[] = "0123456789ABCDEF";
+      out[written++] = '%';
+      out[written++] = hex[c >> 4];
+      out[written++] = hex[c & 0x0f];
+    }
+  }
+  xt_value result = xt_string_new(out, written);
+  free(out);
+  return result;
+}
+
+static int xt_url_hex(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;
+}
+
+static xt_value xt_url_decode(const char *data, size_t length) {
+  char *out = (char *)malloc(length == 0 ? 1 : length);
+  if (!out) abort();
+  size_t written = 0;
+  for (size_t i = 0; i < length; i++) {
+    char c = data[i];
+    if (c == '+') {
+      out[written++] = ' ';
+    } else if (c == '%' && i + 2 < length) {
+      int high = xt_url_hex(data[i + 1]);
+      int low = xt_url_hex(data[i + 2]);
+      if (high >= 0 && low >= 0) {
+        out[written++] = (char)((high << 4) | low);
+        i += 2;
+      } else {
+        out[written++] = c;
+      }
+    } else {
+      out[written++] = c;
+    }
+  }
+  xt_value result = xt_string_new(out, written);
+  free(out);
+  return result;
+}
+
+static xt_value xt_url_entries(xt_value params) {
+  xt_value entries = xt_get(params, xt_string_from_cstr("__entries"));
+  if (!XT_IS_ARRAY(entries)) {
+    entries = xt_array_new(0, NULL);
+    xt_object_set(params, xt_string_from_cstr("__entries"), entries);
+  }
+  return entries;
+}
+
+static void xt_url_set_size(xt_value params) {
+  xt_array *entries = xt_as_array(xt_url_entries(params));
+  xt_object_set(params, xt_string_from_cstr("size"), xt_number((double)entries->length));
+}
+
+static void xt_url_append_pair(xt_value entries, xt_value key, xt_value value) {
+  xt_value pair = xt_array_new(0, NULL);
+  xt_array_push(pair, key);
+  xt_array_push(pair, value);
+  xt_array_push(entries, pair);
+}
+
+static xt_value xt_url_string_at(xt_value text, size_t start, size_t length) {
+  xt_string *string = xt_as_string(text);
+  const char *bytes = xt_string_bytes(string);
+  return xt_string_new(bytes + start, length);
+}
+
+/* Split a query string on `&`, then each item on the first `=`; decode both
+ * halves and append them. A leading `?` is ignored. */
+static void xt_url_parse_into(xt_value params, xt_value input) {
+  xt_value text = xt_to_string(input);
+  xt_string *string = xt_as_string(text);
+  const char *bytes = xt_string_bytes(string);
+  size_t length = string->length;
+  size_t start = (length > 0 && bytes[0] == '?') ? 1 : 0;
+  xt_value entries = xt_url_entries(params);
+  while (start <= length) {
+    size_t end = start;
+    while (end < length && bytes[end] != '&') end++;
+    if (end > start) {
+      size_t equals = start;
+      while (equals < end && bytes[equals] != '=') equals++;
+      xt_value key = xt_url_decode(bytes + start, equals - start);
+      xt_value value = equals < end ? xt_url_decode(bytes + equals + 1, end - equals - 1)
+                                    : xt_string_from_cstr("");
+      xt_url_append_pair(entries, key, value);
+    }
+    if (end >= length) break;
+    start = end + 1;
+  }
+  xt_url_set_size(params);
+}
+
+static void xt_url_ctor_from_value(xt_value params, xt_value source) {
+  if (source == XT_UNDEFINED) return;
+  if (XT_IS_STRING(source)) {
+    xt_url_parse_into(params, source);
+    return;
+  }
+  if (XT_IS_ARRAY(source)) {
+    xt_value entries = xt_url_entries(params);
+    xt_array *pairs = xt_as_array(source);
+    for (uint32_t i = 0; i < pairs->length; i++) {
+      xt_array *pair = xt_as_array(pairs->items[i]);
+      if (pair && pair->length >= 1) {
+        xt_value value = pair->length >= 2 ? pair->items[1] : xt_string_from_cstr("");
+        xt_url_append_pair(entries, xt_to_string(pair->items[0]), xt_to_string(value));
+      }
+    }
+    xt_url_set_size(params);
+    return;
+  }
+  if (XT_IS_OBJECT(source)) {
+    xt_value existing = xt_get(source, xt_string_from_cstr("__entries"));
+    if (XT_IS_ARRAY(existing)) {
+      xt_value entries = xt_url_entries(params);
+      xt_array *pairs = xt_as_array(existing);
+      for (uint32_t i = 0; i < pairs->length; i++) {
+        xt_array *pair = xt_as_array(pairs->items[i]);
+        if (pair && pair->length >= 2) xt_url_append_pair(entries, pair->items[0], pair->items[1]);
+      }
+      xt_url_set_size(params);
+      return;
+    }
+    xt_value keys = xt_object_keys(source);
+    xt_array *list = xt_as_array(keys);
+    if (!list) return;
+    xt_value entries = xt_url_entries(params);
+    for (uint32_t i = 0; i < list->length; i++) {
+      xt_value key = list->items[i];
+      xt_url_append_pair(entries, xt_to_string(key), xt_to_string(xt_object_get(source, key)));
+    }
+    xt_url_set_size(params);
+  }
+}
+
+/* -- methods -------------------------------------------------------------- */
+
+static xt_value xt_url_method_append(xt_value thisValue, xt_value env, int32_t argc, xt_value *argv) {
+  (void)env;
+  xt_value entries = xt_url_entries(thisValue);
+  xt_url_append_pair(entries, xt_to_string(xt_arg_at(argc, argv, 0)),
+                     xt_to_string(xt_arg_at(argc, argv, 1)));
+  xt_url_set_size(thisValue);
+  return XT_UNDEFINED;
+}
+
+static int xt_url_key_equals(xt_value pair, xt_value key) {
+  xt_array *items = xt_as_array(pair);
+  return items && items->length >= 2 && xt_value_equals(items->items[0], key);
+}
+
+static xt_value xt_url_method_get(xt_value thisValue, xt_value env, int32_t argc, xt_value *argv) {
+  (void)env;
+  xt_value key = xt_to_string(xt_arg_at(argc, argv, 0));
+  xt_array *entries = xt_as_array(xt_url_entries(thisValue));
+  for (uint32_t i = 0; i < entries->length; i++) {
+    if (xt_url_key_equals(entries->items[i], key)) return ((xt_array *)XT_GET_PTR(entries->items[i]))->items[1];
+  }
+  return XT_NULL;
+}
+
+static xt_value xt_url_method_get_all(xt_value thisValue, xt_value env, int32_t argc, xt_value *argv) {
+  (void)env;
+  xt_value key = xt_to_string(xt_arg_at(argc, argv, 0));
+  xt_array *entries = xt_as_array(xt_url_entries(thisValue));
+  xt_value result = xt_array_new(0, NULL);
+  for (uint32_t i = 0; i < entries->length; i++) {
+    if (xt_url_key_equals(entries->items[i], key)) {
+      xt_array_push(result, ((xt_array *)XT_GET_PTR(entries->items[i]))->items[1]);
+    }
+  }
+  return result;
+}
+
+static xt_value xt_url_method_has(xt_value thisValue, xt_value env, int32_t argc, xt_value *argv) {
+  (void)env;
+  xt_value key = xt_to_string(xt_arg_at(argc, argv, 0));
+  xt_array *entries = xt_as_array(xt_url_entries(thisValue));
+  for (uint32_t i = 0; i < entries->length; i++) {
+    if (xt_url_key_equals(entries->items[i], key)) return XT_TRUE;
+  }
+  return XT_FALSE;
+}
+
+static xt_value xt_url_method_delete(xt_value thisValue, xt_value env, int32_t argc, xt_value *argv) {
+  (void)env;
+  xt_value key = xt_to_string(xt_arg_at(argc, argv, 0));
+  xt_array *entries = xt_as_array(xt_url_entries(thisValue));
+  uint32_t write = 0;
+  for (uint32_t read = 0; read < entries->length; read++) {
+    if (!xt_url_key_equals(entries->items[read], key)) entries->items[write++] = entries->items[read];
+  }
+  entries->length = write;
+  xt_url_set_size(thisValue);
+  return XT_UNDEFINED;
+}
+
+static xt_value xt_url_method_set(xt_value thisValue, xt_value env, int32_t argc, xt_value *argv) {
+  (void)env;
+  xt_value key = xt_to_string(xt_arg_at(argc, argv, 0));
+  xt_value value = xt_to_string(xt_arg_at(argc, argv, 1));
+  xt_value entriesValue = xt_url_entries(thisValue);
+  xt_array *entries = xt_as_array(entriesValue);
+  uint32_t write = 0;
+  int replaced = 0;
+  for (uint32_t read = 0; read < entries->length; read++) {
+    if (xt_url_key_equals(entries->items[read], key)) {
+      if (!replaced) {
+        ((xt_array *)XT_GET_PTR(entries->items[read]))->items[1] = value;
+        entries->items[write++] = entries->items[read];
+        replaced = 1;
+      }
+      continue;
+    }
+    entries->items[write++] = entries->items[read];
+  }
+  entries->length = write;
+  if (!replaced) xt_url_append_pair(entriesValue, key, value);
+  xt_url_set_size(thisValue);
+  return XT_UNDEFINED;
+}
+
+static xt_value xt_url_method_sort(xt_value thisValue, xt_value env, int32_t argc, xt_value *argv) {
+  (void)env;
+  (void)argc;
+  (void)argv;
+  xt_array *entries = xt_as_array(xt_url_entries(thisValue));
+  for (uint32_t i = 1; i < entries->length; i++) {
+    xt_value current = entries->items[i];
+    xt_array *currentPair = xt_as_array(current);
+    uint32_t j = i;
+    while (j > 0) {
+      xt_array *previousPair = xt_as_array(entries->items[j - 1]);
+      if (strcmp(xt_string_bytes(xt_as_string(previousPair->items[0])),
+                 xt_string_bytes(xt_as_string(currentPair->items[0]))) <= 0)
+        break;
+      entries->items[j] = entries->items[j - 1];
+      j--;
+    }
+    entries->items[j] = current;
+  }
+  return XT_UNDEFINED;
+}
+
+static xt_value xt_url_method_to_string(xt_value thisValue, xt_value env, int32_t argc, xt_value *argv) {
+  (void)env;
+  (void)argc;
+  (void)argv;
+  xt_array *entries = xt_as_array(xt_url_entries(thisValue));
+  xt_value out = xt_string_from_cstr("");
+  for (uint32_t i = 0; i < entries->length; i++) {
+    xt_array *pair = xt_as_array(entries->items[i]);
+    if (!pair || pair->length < 2) continue;
+    if (i > 0) out = xt_add(out, xt_string_from_cstr("&"));
+    out = xt_add(out, xt_url_encode(pair->items[0]));
+    out = xt_add(out, xt_string_from_cstr("="));
+    out = xt_add(out, xt_url_encode(pair->items[1]));
+  }
+  return out;
+}
+
+static xt_value xt_url_method_for_each(xt_value thisValue, xt_value env, int32_t argc, xt_value *argv) {
+  (void)env;
+  xt_value callback = xt_arg_at(argc, argv, 0);
+  if (!XT_IS_FUNCTION(callback)) return XT_UNDEFINED;
+  xt_array *entries = xt_as_array(xt_url_entries(thisValue));
+  for (uint32_t i = 0; i < entries->length; i++) {
+    xt_array *pair = xt_as_array(entries->items[i]);
+    if (!pair || pair->length < 2) continue;
+    xt_value args[3] = {pair->items[1], pair->items[0], thisValue};
+    xt_closure_call(callback, 3, args);
+  }
+  return XT_UNDEFINED;
+}
+
+static xt_value xt_url_method_keys(xt_value thisValue, xt_value env, int32_t argc, xt_value *argv) {
+  (void)env;
+  (void)argc;
+  (void)argv;
+  xt_array *entries = xt_as_array(xt_url_entries(thisValue));
+  xt_value result = xt_array_new(0, NULL);
+  for (uint32_t i = 0; i < entries->length; i++) {
+    xt_array *pair = xt_as_array(entries->items[i]);
+    if (pair && pair->length >= 1) xt_array_push(result, pair->items[0]);
+  }
+  return result;
+}
+
+static xt_value xt_url_method_values(xt_value thisValue, xt_value env, int32_t argc, xt_value *argv) {
+  (void)env;
+  (void)argc;
+  (void)argv;
+  xt_array *entries = xt_as_array(xt_url_entries(thisValue));
+  xt_value result = xt_array_new(0, NULL);
+  for (uint32_t i = 0; i < entries->length; i++) {
+    xt_array *pair = xt_as_array(entries->items[i]);
+    if (pair && pair->length >= 2) xt_array_push(result, pair->items[1]);
+  }
+  return result;
+}
+
+static xt_value xt_url_method_entries(xt_value thisValue, xt_value env, int32_t argc, xt_value *argv) {
+  (void)env;
+  (void)argc;
+  (void)argv;
+  xt_value result = xt_array_new(0, NULL);
+  xt_array *entries = xt_as_array(xt_url_entries(thisValue));
+  for (uint32_t i = 0; i < entries->length; i++) xt_array_push(result, entries->items[i]);
+  return result;
+}
+
+static void xt_url_install(xt_value params, const char *name, void *fn) {
+  xt_object_set(params, xt_string_from_cstr(name), xt_closure_new(fn, 0, NULL));
+}
+
+xt_value xt_url_search_params_ctor(int32_t argc, xt_value *argv) {
+  xt_value params = xt_object_new();
+  xt_object_set(params, xt_string_from_cstr("__entries"), xt_array_new(0, NULL));
+  xt_object_set(params, xt_string_from_cstr("size"), xt_number(0));
+  xt_url_install(params, "append", (void *)xt_url_method_append);
+  xt_url_install(params, "delete", (void *)xt_url_method_delete);
+  xt_url_install(params, "get", (void *)xt_url_method_get);
+  xt_url_install(params, "getAll", (void *)xt_url_method_get_all);
+  xt_url_install(params, "has", (void *)xt_url_method_has);
+  xt_url_install(params, "set", (void *)xt_url_method_set);
+  xt_url_install(params, "sort", (void *)xt_url_method_sort);
+  xt_url_install(params, "toString", (void *)xt_url_method_to_string);
+  xt_url_install(params, "forEach", (void *)xt_url_method_for_each);
+  xt_url_install(params, "keys", (void *)xt_url_method_keys);
+  xt_url_install(params, "values", (void *)xt_url_method_values);
+  xt_url_install(params, "entries", (void *)xt_url_method_entries);
+  xt_url_ctor_from_value(params, xt_arg_at(argc, argv, 0));
+  return params;
+}

package/runtime/xt_values/arithmetic.inc

@@ -3,7 +3,7 @@
 /* ------------------------------------------------------------------------- */
 
 static void xt_throw_mixed_bigint(void) {
-  xt_throw(xt_string_from_cstr("TypeError: Cannot mix BigInt and other types, use explicit conversions"));
+  xt_throw(xt_error_from_message("TypeError: Cannot mix BigInt and other types, use explicit conversions"));
 }
 
 /* ToPrimitive for the operators: arrays/objects/functions stringify (their
@@ -143,7 +143,7 @@ xt_value xt_shr(xt_value a, xt_value b) {
 
 xt_value xt_ushr(xt_value a, xt_value b) {
   if (XT_IS_BIGINT(a) || XT_IS_BIGINT(b)) {
-    xt_throw(xt_string_from_cstr("TypeError: BigInts have no unsigned right shift, use >> instead"));
+    xt_throw(xt_error_from_message("TypeError: BigInts have no unsigned right shift, use >> instead"));
     return XT_UNDEFINED;
   }
   return xt_number((double)(uint32_t)((uint32_t)xt_to_int32(a) >> (xt_to_int32(b) & 31)));

package/runtime/xt_values/constructors.inc

@@ -10,6 +10,8 @@ xt_value xt_number(double d) { return xt_from_double(d); }
 xt_string *xt_string_alloc(size_t length) {
   xt_string *s = (xt_string *)xt_alloc(sizeof(xt_string), XT_OBJECT_KIND_STRING);
   s->length = (uint32_t)length;
+  s->utf16_length = 0;
+  s->code_point_count = 0;
   /* Keep the terminator in the allocation: many consumers hand `flat` to libc. */
   s->capacity = (uint32_t)length + 1;
   s->flat = (char *)malloc(s->capacity);
@@ -26,6 +28,7 @@ xt_string *xt_string_alloc(size_t length) {
 xt_value xt_string_new(const char *data, size_t len) {
   xt_string *s = xt_string_alloc(len);
   if (len > 0) memcpy(s->flat, data, len);
+  xt_string_finish(s);
   return XT_FROM_PTR(XT_TAG_STRING, s);
 }
 
@@ -44,3 +47,8 @@ int32_t xt_string_length_value(xt_value value) {
   xt_string *s = xt_as_string(value);
   return s ? (int32_t)s->length : -1;
 }
+
+int32_t xt_string_utf16_length_value(xt_value value) {
+  xt_string *s = xt_as_string(value);
+  return s ? (int32_t)xt_string_utf16_length(s) : -1;
+}

package/runtime/xt_values/conversions.inc

@@ -94,7 +94,7 @@ xt_value xt_to_string(xt_value v) {
   }
   if (XT_IS_FUNCTION(v)) return xt_string_from_cstr("function () { [native code] }");
   if (xt_is_symbol(v)) {
-    xt_throw(xt_string_from_cstr("TypeError: Cannot convert a Symbol value to a string"));
+    xt_throw(xt_error_from_message("TypeError: Cannot convert a Symbol value to a string"));
   }
   if (XT_IS_OBJECT(v) &&
       ((xt_object *)XT_GET_PTR(v))->header.kind == XT_OBJECT_KIND_ERROR) {

package/runtime/xt_values/strings.inc

@@ -62,9 +62,13 @@ const char *xt_string_bytes(xt_string *s) {
 
   out[offset] = '\0';
   s->flat = out;
+  s->length = (uint32_t)offset;
   s->capacity = (uint32_t)(total + 1);
   s->left = NULL;
   s->right = NULL;
+  /* A concat boundary can split a surrogate pair; flattening is where the two
+   * halves meet, so normalise and record the UTF-16/code-point view now. */
+  xt_string_finish(s);
   return s->flat;
 }
 
@@ -74,12 +78,22 @@ static xt_value xt_string_concat(xt_string *a, xt_string *b) {
   size_t total = (size_t)a->length + (size_t)b->length;
   if (total <= XT_STRING_CONS_THRESHOLD) {
     xt_string *out = xt_string_alloc(total);
-    memcpy(out->flat, xt_string_bytes(a), a->length);
-    memcpy(out->flat + a->length, xt_string_bytes(b), b->length);
+    const char *aBytes = xt_string_bytes(a);
+    uint32_t aLength = a->length;
+    const char *bBytes = xt_string_bytes(b);
+    uint32_t bLength = b->length;
+    memcpy(out->flat, aBytes, aLength);
+    memcpy(out->flat + aLength, bBytes, bLength);
+    xt_string_finish(out);
     return XT_FROM_PTR(XT_TAG_STRING, out);
   }
   xt_string *out = (xt_string *)xt_alloc(sizeof(xt_string), XT_OBJECT_KIND_STRING);
   out->length = (uint32_t)total;
+  /* UTF-16 length is additive even when the boundary joins a surrogate pair;
+   * the code-point count is not, so leave it to be recomputed after
+   * flattening. */
+  out->utf16_length = xt_string_utf16_length(a) + xt_string_utf16_length(b);
+  out->code_point_count = 0;
   out->capacity = 0;
   out->flat = NULL;
   out->left = a;
@@ -91,6 +105,8 @@ int xt_string_equals(xt_string *a, xt_string *b) {
   /* Interned literals (property names above all) are shared, so identity is the
    * common case and skips the length, flattening and byte comparison entirely. */
   if (a == b) return 1;
+  const char *aBytes = xt_string_bytes(a);
+  const char *bBytes = xt_string_bytes(b);
   if (a->length != b->length) return 0;
-  return memcmp(xt_string_bytes(a), xt_string_bytes(b), a->length) == 0;
+  return memcmp(aBytes, bBytes, a->length) == 0;
 }