xbintsc 0.3.3 → 0.3.5

package/runtime/xt_builtins.c

@@ -8,6 +8,7 @@
 #include "rt_internal.h"
 
 #include <math.h>
+#include <stdio.h>
 #include <stdlib.h>
 #include <string.h>
 
@@ -19,7 +20,9 @@ xt_value xt_object_values(xt_value value) {
   xt_value result = xt_array_new(0, NULL);
   if (!XT_IS_OBJECT(value)) return result;
   xt_object *obj = (xt_object *)XT_GET_PTR(value);
-  for (uint32_t i = 0; i < obj->count; i++) xt_array_push(result, obj->properties[i].value);
+  for (uint32_t i = 0; i < obj->count; i++) {
+    if (XT_IS_STRING(obj->properties[i].key)) xt_array_push(result, obj->properties[i].value);
+  }
   return result;
 }
 
@@ -28,8 +31,9 @@ xt_value xt_object_entries(xt_value value) {
   if (!XT_IS_OBJECT(value)) return result;
   xt_object *obj = (xt_object *)XT_GET_PTR(value);
   for (uint32_t i = 0; i < obj->count; i++) {
+    if (!XT_IS_STRING(obj->properties[i].key)) continue;
     xt_value pair = xt_array_new(0, NULL);
-    xt_array_push(pair, XT_FROM_PTR(XT_TAG_STRING, obj->properties[i].key));
+    xt_array_push(pair, obj->properties[i].key);
     xt_array_push(pair, obj->properties[i].value);
     xt_array_push(result, pair);
   }
@@ -44,7 +48,7 @@ xt_value xt_object_assign(int32_t argc, xt_value *argv) {
     if (!XT_IS_OBJECT(argv[i])) continue;
     xt_object *source = (xt_object *)XT_GET_PTR(argv[i]);
     for (uint32_t j = 0; j < source->count; j++) {
-      xt_object_set(target, XT_FROM_PTR(XT_TAG_STRING, source->properties[j].key), source->properties[j].value);
+      xt_object_set(target, source->properties[j].key, source->properties[j].value);
     }
   }
   return target;
@@ -119,6 +123,140 @@ xt_value xt_is_finite(int32_t argc, xt_value *argv) {
   return xt_bool(!isnan(value) && !isinf(value));
 }
 
+/* ------------------------------------------------------------------------- */
+/* URI encoding / decoding (ECMAScript 19.2.6)                               */
+/* ------------------------------------------------------------------------- */
+
+static _Noreturn void xt_throw_uri_error(const char *message) {
+  char buffer[96];
+  snprintf(buffer, sizeof(buffer), "URIError: %s", message);
+  xt_throw(xt_string_from_cstr(buffer));
+  abort();
+}
+
+static int xt_uri_is_kept(const char *allowed, unsigned char c) {
+  return c < 0x80 && c != 0 && strchr(allowed, (int)c) != NULL;
+}
+
+static xt_value xt_uri_encode(xt_value input, const char *allowed) {
+  xt_string *s = xt_as_string(xt_to_string(input));
+  static const char hex[] = "0123456789ABCDEF";
+  char *out = (char *)malloc((size_t)s->length * 3 + 1);
+  if (!out) {
+    fprintf(stderr, "xbintsc: out of memory\n");
+    abort();
+  }
+  size_t written = 0;
+  for (uint32_t i = 0; i < s->length; i++) {
+    unsigned char c = (unsigned char)s->data[i];
+    if (xt_uri_is_kept(allowed, c)) {
+      out[written++] = (char)c;
+    } else {
+      out[written++] = '%';
+      out[written++] = hex[(c >> 4) & 0xF];
+      out[written++] = hex[c & 0xF];
+    }
+  }
+  xt_value result = xt_string_new(out, written);
+  free(out);
+  return result;
+}
+
+static int xt_hex_value(int 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;
+}
+
+/* Decode percent-escapes as UTF-8. When `component` is false (`decodeURI`),
+ * escapes for reserved characters are copied through unchanged. */
+static xt_value xt_uri_decode(xt_value input, int component) {
+  xt_string *s = xt_as_string(xt_to_string(input));
+  char *out = (char *)malloc((size_t)s->length + 1);
+  if (!out) {
+    fprintf(stderr, "xbintsc: out of memory\n");
+    abort();
+  }
+  size_t written = 0;
+  uint32_t i = 0;
+  while (i < s->length) {
+    unsigned char c = (unsigned char)s->data[i];
+    if (c != '%') {
+      out[written++] = (char)c;
+      i++;
+      continue;
+    }
+    if (i + 2 >= s->length) xt_throw_uri_error("URI malformed");
+    int h1 = xt_hex_value((unsigned char)s->data[i + 1]);
+    int h2 = xt_hex_value((unsigned char)s->data[i + 2]);
+    if (h1 < 0 || h2 < 0) xt_throw_uri_error("URI malformed");
+    unsigned char b = (unsigned char)((h1 << 4) | h2);
+    if (b < 0x80) {
+      if (!component && xt_uri_is_kept(";/?:@&=+$,#", b)) {
+        out[written++] = s->data[i];
+        out[written++] = s->data[i + 1];
+        out[written++] = s->data[i + 2];
+      } else {
+        out[written++] = (char)b;
+      }
+      i += 3;
+      continue;
+    }
+    int extra;
+    if (b >= 0xC2 && b <= 0xDF) extra = 1;
+    else if (b >= 0xE0 && b <= 0xEF) extra = 2;
+    else if (b >= 0xF0 && b <= 0xF4) extra = 3;
+    else xt_throw_uri_error("URI malformed");
+    char seq[4];
+    seq[0] = (char)b;
+    for (int k = 1; k <= extra; k++) {
+      uint32_t pos = i + (uint32_t)k * 3;
+      if (pos + 2 >= s->length) xt_throw_uri_error("URI malformed");
+      if (s->data[pos] != '%') xt_throw_uri_error("URI malformed");
+      int c1 = xt_hex_value((unsigned char)s->data[pos + 1]);
+      int c2 = xt_hex_value((unsigned char)s->data[pos + 2]);
+      if (c1 < 0 || c2 < 0) xt_throw_uri_error("URI malformed");
+      unsigned char cb = (unsigned char)((c1 << 4) | c2);
+      if ((cb & 0xC0) != 0x80) xt_throw_uri_error("URI malformed");
+      seq[k] = (char)cb;
+    }
+    uint32_t codePoint;
+    if (extra == 1) codePoint = ((uint32_t)(b & 0x1F) << 6) | ((uint32_t)seq[1] & 0x3F);
+    else if (extra == 2)
+      codePoint = ((uint32_t)(b & 0x0F) << 12) | (((uint32_t)seq[1] & 0x3F) << 6) | ((uint32_t)seq[2] & 0x3F);
+    else
+      codePoint = ((uint32_t)(b & 0x07) << 18) | (((uint32_t)seq[1] & 0x3F) << 12) |
+                  (((uint32_t)seq[2] & 0x3F) << 6) | ((uint32_t)seq[3] & 0x3F);
+    uint32_t minimum = extra == 1 ? 0x80u : (extra == 2 ? 0x800u : 0x10000u);
+    if (codePoint < minimum || codePoint > 0x10FFFF || (codePoint >= 0xD800 && codePoint <= 0xDFFF))
+      xt_throw_uri_error("URI malformed");
+    for (int k = 0; k <= extra; k++) out[written++] = seq[k];
+    i += (uint32_t)(extra + 1) * 3;
+  }
+  xt_value result = xt_string_new(out, written);
+  free(out);
+  return result;
+}
+
+xt_value xt_encode_uri_component(int32_t argc, xt_value *argv) {
+  return xt_uri_encode(xt_arg_at(argc, argv, 0),
+                       "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789-_.!~*'()");
+}
+
+xt_value xt_encode_uri(int32_t argc, xt_value *argv) {
+  return xt_uri_encode(xt_arg_at(argc, argv, 0),
+                       "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789-_.!~*'();,/?:@&=+$#");
+}
+
+xt_value xt_decode_uri_component(int32_t argc, xt_value *argv) {
+  return xt_uri_decode(xt_arg_at(argc, argv, 0), /* component */ 1);
+}
+
+xt_value xt_decode_uri(int32_t argc, xt_value *argv) {
+  return xt_uri_decode(xt_arg_at(argc, argv, 0), /* component */ 0);
+}
+
 xt_value xt_number_ctor(int32_t argc, xt_value *argv) {
   if (argc == 0) return xt_number(0);
   return xt_number(xt_to_number(argv[0]));
@@ -126,6 +264,7 @@ xt_value xt_number_ctor(int32_t argc, xt_value *argv) {
 
 xt_value xt_string_ctor(int32_t argc, xt_value *argv) {
   if (argc == 0) return xt_string_from_cstr("");
+  if (xt_is_symbol(argv[0])) return xt_symbol_to_string(argv[0]);
   return xt_to_string(argv[0]);
 }
 
@@ -153,18 +292,29 @@ 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_bigint, xt_bigint_ctor)
 XT_BUILTIN_TRAMPOLINE(xt_builtin_value_string, xt_string_ctor)
+XT_BUILTIN_TRAMPOLINE(xt_builtin_value_symbol, xt_symbol)
 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_BUILTIN_TRAMPOLINE(xt_builtin_value_encodeURIComponent, xt_encode_uri_component)
+XT_BUILTIN_TRAMPOLINE(xt_builtin_value_encodeURI, xt_encode_uri)
+XT_BUILTIN_TRAMPOLINE(xt_builtin_value_decodeURIComponent, xt_decode_uri_component)
+XT_BUILTIN_TRAMPOLINE(xt_builtin_value_decodeURI, xt_decode_uri)
 
 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)) {
+    if (xt_is_symbol(key)) {
+      xt_array *array = (xt_array *)XT_GET_PTR(value);
+      if (!XT_IS_OBJECT(array->extra)) return XT_FALSE;
+      return xt_object_has_own(array->extra, key);
+    }
     int32_t index = xt_to_int32(key);
     return xt_bool(index >= 0 && (uint32_t)index < xt_as_array(value)->length);
   }
   if (XT_IS_STRING(value)) {
+    if (xt_is_symbol(key)) return XT_FALSE;
     xt_string *s = xt_as_string(value);
     xt_string *k = xt_as_string(xt_to_string(key));
     if (k->length == 6 && memcmp(k->data, "length", 6) == 0) return XT_TRUE;
@@ -177,9 +327,9 @@ xt_value xt_in(xt_value key, xt_value value) {
 xt_value xt_delete(xt_value value, xt_value key) {
   if (XT_IS_OBJECT(value)) {
     xt_object *obj = (xt_object *)XT_GET_PTR(value);
-    xt_string *k = xt_as_string(xt_to_string(key));
+    xt_value k = xt_to_property_key(key);
     for (uint32_t i = 0; i < obj->count; i++) {
-      if (xt_string_equals(obj->properties[i].key, k)) {
+      if (xt_property_key_equals(obj->properties[i].key, k)) {
         for (uint32_t j = i + 1; j < obj->count; j++) obj->properties[j - 1] = obj->properties[j];
         obj->count--;
         break;
@@ -188,7 +338,7 @@ xt_value xt_delete(xt_value value, xt_value key) {
     return XT_TRUE;
   }
   if (XT_IS_ARRAY(value)) {
-    xt_array_set(value, key, XT_UNDEFINED);
+    if (!xt_is_symbol(key)) xt_array_set(value, key, XT_UNDEFINED);
     return XT_TRUE;
   }
   return XT_TRUE;
@@ -216,6 +366,7 @@ xt_value xt_closure_new(void *fn, int32_t env_count, xt_value *env) {
   function->code = (xt_code_fn)fn;
   function->environment_count = env_count;
   function->arity = -1;
+  function->name = NULL;
   function->properties = NULL;
   function->environment = NULL;
   function->prototype = XT_UNDEFINED;
@@ -236,6 +387,9 @@ xt_value xt_call_with_this(xt_value value, xt_value thisValue, int32_t argc, xt_
     return XT_UNDEFINED;
   }
   xt_function *function = (xt_function *)XT_GET_PTR(value);
+  /* Calling a generator function returns a suspended generator instead of
+   * running the body. */
+  if (function->is_generator) return xt_generator_new(value, thisValue, argc, argv);
   /* The closure value itself is threaded through as `env` so the callee can
    * read its captures with xt_closure_env(env, i). */
   return function->code(thisValue, value, argc, argv);
@@ -248,6 +402,11 @@ xt_value xt_function_set_prototype(xt_value value, xt_value proto) {
   return value;
 }
 
+xt_value xt_function_set_generator(xt_value value) {
+  if (XT_IS_FUNCTION(value)) ((xt_function *)XT_GET_PTR(value))->is_generator = 1;
+  return value;
+}
+
 xt_value xt_function_get_prototype(xt_value value) {
   if (XT_IS_FUNCTION(value)) return ((xt_function *)XT_GET_PTR(value))->prototype;
   return XT_UNDEFINED;
@@ -294,3 +453,12 @@ int32_t xt_closure_arity(xt_value value) {
   return ((xt_function *)XT_GET_PTR(value))->arity;
 }
 
+xt_value xt_function_set_metadata(xt_value value, xt_value name, int32_t arity) {
+  if (XT_IS_FUNCTION(value)) {
+    xt_function *function = (xt_function *)XT_GET_PTR(value);
+    function->arity = arity;
+    function->name = XT_IS_STRING(name) ? xt_as_string(name) : NULL;
+  }
+  return value;
+}
+