xbintsc 0.3.87 → 0.5.20

package/runtime/xt_typed_array/construction.inc

@@ -21,7 +21,7 @@ static xt_value xt_ta_proto(int kind) {
   xt_ta_define(proto, "fill", (void *)xt_ta_method_fill);
   xt_ta_define(proto, "set", (void *)xt_ta_method_set);
   xt_ta_define(proto, "slice", (void *)xt_ta_method_slice);
-  xt_ta_define(proto, "subarray", (void *)xt_ta_method_slice);
+  xt_ta_define(proto, "subarray", (void *)xt_ta_method_subarray);
   xt_ta_define(proto, "join", (void *)xt_ta_method_join);
   xt_ta_define(proto, "toString", (void *)xt_ta_method_to_string);
   xt_ta_define(proto, "toLocaleString", (void *)xt_ta_method_to_string);
@@ -43,18 +43,30 @@ static xt_value xt_ta_proto(int kind) {
   xt_ta_define(proto, "keys", (void *)xt_ta_method_keys);
   xt_ta_define(proto, "values", (void *)xt_ta_method_values);
   xt_ta_define(proto, "entries", (void *)xt_ta_method_entries);
+  xt_value constructor = xt_builtin_constructor(xt_string_from_cstr(xt_ta_names[kind]));
+  if (constructor != XT_UNDEFINED) {
+    xt_object_set(proto, xt_string_from_cstr("constructor"), constructor);
+  }
   return proto;
 }
 
-static xt_value xt_ta_new(int kind, uint32_t length) {
+static xt_value xt_ta_view(int kind, xt_value buffer, uint32_t byteOffset, uint32_t length) {
   xt_value array = xt_object_new_with_proto(xt_ta_proto(kind));
   xt_object_set(array, xt_string_from_cstr("length"), xt_number((double)length));
-  xt_object_set(array, xt_string_from_cstr("byteLength"), xt_number((double)length * xt_ta_bytes[kind]));
-  xt_object_set(array, xt_string_from_cstr("byteOffset"), xt_number(0));
-  for (uint32_t i = 0; i < length; i++) xt_ta_store(array, kind, i, 0);
+  xt_object_set(array, xt_string_from_cstr("byteLength"),
+                xt_number((double)length * xt_ta_bytes[kind]));
+  xt_object_set(array, xt_string_from_cstr("byteOffset"), xt_number((double)byteOffset));
+  xt_object_set(array, xt_ta_buffer_key(), buffer);
+  xt_object_set(array, xt_ta_offset_key(), xt_number((double)byteOffset));
   return array;
 }
 
+static xt_value xt_ta_new(int kind, uint32_t length) {
+  xt_value byteLength = xt_number((double)length * xt_ta_bytes[kind]);
+  xt_value buffer = xt_array_buffer_ctor(1, &byteLength);
+  return xt_ta_view(kind, buffer, 0, length);
+}
+
 /* Length of any value a typed array can be built from, or 0 when it is not
  * array-like (strings/iterables are intentionally not treated as element
  * sources yet). */
@@ -64,7 +76,7 @@ static int xt_ta_length_of(xt_value value, uint32_t *out) {
     return 1;
   }
   if (XT_IS_STRING(value)) {
-    *out = xt_as_string(value)->length;
+    *out = xt_string_code_point_count(xt_as_string(value));
     return 1;
   }
   if (xt_typed_array_kind_of(value) >= 0) {
@@ -86,8 +98,10 @@ static xt_value xt_ta_from_value(int kind, xt_value value, xt_value mapFn, xt_va
   uint32_t length = 0;
   if (!xt_ta_length_of(value, &length)) length = 0;
   xt_value array = xt_ta_new(kind, length);
+  xt_string *sourceString = XT_IS_STRING(value) ? xt_as_string(value) : NULL;
   for (uint32_t i = 0; i < length; i++) {
-    xt_value item = xt_get(value, xt_number((double)i));
+    xt_value item = sourceString ? xt_string_code_point_value(sourceString, (int32_t)i)
+                                 : xt_get(value, xt_number((double)i));
     if (haveMap) {
       xt_value args[3] = {item, xt_number((double)i), array};
       item = xt_call_with_this(mapFn, thisArg, 3, args);
@@ -100,6 +114,28 @@ static xt_value xt_ta_from_value(int kind, xt_value value, xt_value mapFn, xt_va
 static xt_value xt_ta_ctor_impl(int kind, int32_t argc, xt_value *argv) {
   if (argc == 0) return xt_ta_new(kind, 0);
   xt_value argument = argv[0];
+  if (xt_is_array_buffer(argument)) {
+    uint32_t bufferLength = xt_array_buffer_byte_length(argument);
+    double rawOffset = argc > 1 ? xt_to_number(argv[1]) : 0;
+    uint32_t offset = rawOffset > 0 ? (uint32_t)rawOffset : 0;
+    uint32_t width = (uint32_t)xt_ta_bytes[kind];
+    if (offset % width != 0 || offset > bufferLength) {
+      xt_value message = xt_string_from_cstr("start offset is not aligned or out of bounds");
+      xt_throw(xt_range_error_ctor(1, &message));
+    }
+    uint32_t length;
+    if (argc > 2 && argv[2] != XT_UNDEFINED) {
+      double rawLength = xt_to_number(argv[2]);
+      length = rawLength > 0 ? (uint32_t)rawLength : 0;
+    } else {
+      length = (bufferLength - offset) / width;
+    }
+    if (length > (bufferLength - offset) / width) {
+      xt_value message = xt_string_from_cstr("Invalid typed array length");
+      xt_throw(xt_range_error_ctor(1, &message));
+    }
+    return xt_ta_view(kind, argument, offset, length);
+  }
   /* Objects (arrays / typed arrays / array-likes / iterables) are copied
    * element-wise; every other argument is a length via `ToIndex`. */
   if (XT_IS_ARRAY(argument) || XT_IS_OBJECT(argument)) {
@@ -140,3 +176,38 @@ XT_TA_CTOR(i32, XT_TA_I32)
 XT_TA_CTOR(f32, XT_TA_F32)
 XT_TA_CTOR(f64, XT_TA_F64)
 
+/* Dispatch by constructor name, used when a typed-array constructor is a
+ * first-class value (`const T = Uint8Array; new T(4)`). */
+static int xt_ta_kind_from_name(const char *name) {
+  if (!name) return -1;
+  if (strcmp(name, "Uint8Array") == 0) return XT_TA_U8;
+  if (strcmp(name, "Int8Array") == 0) return XT_TA_I8;
+  if (strcmp(name, "Uint8ClampedArray") == 0) return XT_TA_U8C;
+  if (strcmp(name, "Uint16Array") == 0) return XT_TA_U16;
+  if (strcmp(name, "Int16Array") == 0) return XT_TA_I16;
+  if (strcmp(name, "Uint32Array") == 0) return XT_TA_U32;
+  if (strcmp(name, "Int32Array") == 0) return XT_TA_I32;
+  if (strcmp(name, "Float32Array") == 0) return XT_TA_F32;
+  if (strcmp(name, "Float64Array") == 0) return XT_TA_F64;
+  return -1;
+}
+
+xt_value xt_typed_array_ctor_by_name(xt_value nameValue, int32_t argc, xt_value *argv) {
+  int kind = xt_ta_kind_from_name(XT_IS_STRING(nameValue) ? xt_string_data(nameValue) : NULL);
+  if (kind < 0) return XT_UNDEFINED;
+  return xt_ta_ctor_impl(kind, argc, argv);
+}
+
+xt_value xt_typed_array_static_by_name(xt_value nameValue, xt_value method, int32_t argc,
+                                       xt_value *argv) {
+  int kind = xt_ta_kind_from_name(XT_IS_STRING(nameValue) ? xt_string_data(nameValue) : NULL);
+  if (kind < 0) return XT_UNDEFINED;
+  return xt_ta_static_impl(kind, method, argc, argv);
+}
+
+xt_value xt_typed_array_prototype(xt_value nameValue) {
+  int kind = xt_ta_kind_from_name(XT_IS_STRING(nameValue) ? xt_string_data(nameValue) : NULL);
+  if (kind < 0) return XT_UNDEFINED;
+  return xt_ta_proto(kind);
+}
+

package/runtime/xt_typed_array/elements.inc

@@ -53,6 +53,158 @@ int xt_typed_array_kind_of(xt_value value) {
   return -1;
 }
 
+const char *xt_typed_array_name_of(int kind) {
+  if (kind < 0 || kind >= XT_TA_KIND_COUNT) return NULL;
+  return xt_ta_names[kind];
+}
+
+/* -- buffer-backed views -------------------------------------------------- */
+
+/* The backing ArrayBuffer and byte offset live under private symbols, so a
+ * typed array's observable own properties stay `length`/`byteLength`/
+ * `byteOffset` plus `.buffer` (handled in access.inc). */
+static xt_value xt_ta_buffer_key_value = XT_UNDEFINED;
+static xt_value xt_ta_offset_key_value = XT_UNDEFINED;
+
+static xt_value xt_ta_buffer_key(void) {
+  if (!xt_is_symbol(xt_ta_buffer_key_value)) {
+    xt_ta_buffer_key_value = xt_symbol_new(xt_string_from_cstr("__typedArrayBuffer"));
+    xt_gc_add_root(&xt_ta_buffer_key_value);
+  }
+  return xt_ta_buffer_key_value;
+}
+
+static xt_value xt_ta_offset_key(void) {
+  if (!xt_is_symbol(xt_ta_offset_key_value)) {
+    xt_ta_offset_key_value = xt_symbol_new(xt_string_from_cstr("__typedArrayOffset"));
+    xt_gc_add_root(&xt_ta_offset_key_value);
+  }
+  return xt_ta_offset_key_value;
+}
+
+xt_value xt_typed_array_buffer_of(xt_value array) {
+  if (xt_typed_array_kind_of(array) < 0) return XT_UNDEFINED;
+  return xt_object_get(array, xt_ta_buffer_key());
+}
+
+uint32_t xt_typed_array_byte_offset_of(xt_value array) {
+  if (xt_typed_array_kind_of(array) < 0) return 0;
+  return (uint32_t)xt_to_number(xt_object_get(array, xt_ta_offset_key()));
+}
+
+xt_value xt_typed_array_read(xt_value array, uint32_t index) {
+  int kind = xt_typed_array_kind_of(array);
+  if (kind < 0) return XT_UNDEFINED;
+  xt_value buffer = xt_typed_array_buffer_of(array);
+  if (!xt_is_array_buffer(buffer)) {
+    char key[24];
+    snprintf(key, sizeof(key), "%u", index);
+    return xt_object_get_cstr(array, key);
+  }
+  uint32_t width = (uint32_t)xt_ta_bytes[kind];
+  uint32_t offset = xt_typed_array_byte_offset_of(array) + index * width;
+  if (offset + width > xt_array_buffer_byte_length(buffer)) return XT_UNDEFINED;
+  uint8_t raw[8];
+  for (uint32_t i = 0; i < width; i++) raw[i] = xt_array_buffer_get_byte(buffer, offset + i);
+  switch (kind) {
+    case XT_TA_U8:
+      return xt_number((double)raw[0]);
+    case XT_TA_I8:
+      return xt_number((double)(int8_t)raw[0]);
+    case XT_TA_U8C:
+      return xt_number((double)raw[0]);
+    case XT_TA_U16: {
+      uint16_t value;
+      memcpy(&value, raw, sizeof(value));
+      return xt_number((double)value);
+    }
+    case XT_TA_I16: {
+      int16_t value;
+      memcpy(&value, raw, sizeof(value));
+      return xt_number((double)value);
+    }
+    case XT_TA_U32: {
+      uint32_t value;
+      memcpy(&value, raw, sizeof(value));
+      return xt_number((double)value);
+    }
+    case XT_TA_I32: {
+      int32_t value;
+      memcpy(&value, raw, sizeof(value));
+      return xt_number((double)value);
+    }
+    case XT_TA_F32: {
+      float value;
+      memcpy(&value, raw, sizeof(value));
+      return xt_number((double)value);
+    }
+    default: {
+      double value;
+      memcpy(&value, raw, sizeof(value));
+      return xt_number(value);
+    }
+  }
+}
+
+void xt_typed_array_write(xt_value array, uint32_t index, xt_value value) {
+  int kind = xt_typed_array_kind_of(array);
+  if (kind < 0) return;
+  xt_value buffer = xt_typed_array_buffer_of(array);
+  if (!xt_is_array_buffer(buffer)) {
+    char key[24];
+    snprintf(key, sizeof(key), "%u", index);
+    xt_object_set(array, xt_string_from_cstr(key),
+                  xt_number(xt_typed_array_coerce(kind, xt_to_number(value))));
+    return;
+  }
+  uint32_t width = (uint32_t)xt_ta_bytes[kind];
+  uint32_t offset = xt_typed_array_byte_offset_of(array) + index * width;
+  if (offset + width > xt_array_buffer_byte_length(buffer)) return;
+  double coerced = xt_typed_array_coerce(kind, xt_to_number(value));
+  uint8_t raw[8];
+  memset(raw, 0, sizeof(raw));
+  switch (kind) {
+    case XT_TA_U8:
+    case XT_TA_U8C:
+      raw[0] = (uint8_t)coerced;
+      break;
+    case XT_TA_I8:
+      raw[0] = (uint8_t)(int8_t)coerced;
+      break;
+    case XT_TA_U16: {
+      uint16_t stored = (uint16_t)coerced;
+      memcpy(raw, &stored, sizeof(stored));
+      break;
+    }
+    case XT_TA_I16: {
+      int16_t stored = (int16_t)coerced;
+      memcpy(raw, &stored, sizeof(stored));
+      break;
+    }
+    case XT_TA_U32: {
+      uint32_t stored = (uint32_t)coerced;
+      memcpy(raw, &stored, sizeof(stored));
+      break;
+    }
+    case XT_TA_I32: {
+      int32_t stored = (int32_t)coerced;
+      memcpy(raw, &stored, sizeof(stored));
+      break;
+    }
+    case XT_TA_F32: {
+      float stored = (float)coerced;
+      memcpy(raw, &stored, sizeof(stored));
+      break;
+    }
+    default: {
+      double stored = coerced;
+      memcpy(raw, &stored, sizeof(stored));
+      break;
+    }
+  }
+  for (uint32_t i = 0; i < width; i++) xt_array_buffer_set_byte(buffer, offset + i, raw[i]);
+}
+
 /* -- element storage ------------------------------------------------------ */
 
 static uint32_t xt_ta_length(xt_value array) {
@@ -62,12 +214,19 @@ static uint32_t xt_ta_length(xt_value array) {
 }
 
 static xt_value xt_ta_element(xt_value array, uint32_t index) {
+  if (xt_is_array_buffer(xt_typed_array_buffer_of(array))) {
+    return xt_typed_array_read(array, index);
+  }
   char key[24];
   snprintf(key, sizeof(key), "%u", index);
   return xt_object_get_cstr(array, key);
 }
 
 static void xt_ta_store(xt_value array, int kind, uint32_t index, double value) {
+  if (xt_is_array_buffer(xt_typed_array_buffer_of(array))) {
+    xt_typed_array_write(array, index, xt_number(value));
+    return;
+  }
   char key[24];
   snprintf(key, sizeof(key), "%u", index);
   xt_object_set(array, xt_string_from_cstr(key), xt_number(xt_typed_array_coerce(kind, value)));

package/runtime/xt_typed_array/methods.inc

@@ -24,7 +24,7 @@ static xt_value xt_ta_method_set(xt_value self, xt_value env, int32_t argc, xt_v
   if (!xt_ta_length_of(source, &sourceLength)) return XT_UNDEFINED;
   int32_t offset = argc > 1 ? xt_to_int32(argv[1]) : 0;
   if (offset < 0 || offset + (int32_t)sourceLength > (int32_t)xt_ta_length(self)) {
-    xt_throw(xt_string_from_cstr("RangeError: offset is out of bounds"));
+    xt_throw(xt_error_from_message("RangeError: offset is out of bounds"));
     return XT_UNDEFINED;
   }
   for (uint32_t i = 0; i < sourceLength; i++) {
@@ -47,6 +47,20 @@ static xt_value xt_ta_method_slice(xt_value self, xt_value env, int32_t argc, xt
   return out;
 }
 
+static xt_value xt_ta_method_subarray(xt_value self, xt_value env, int32_t argc, xt_value *argv) {
+  (void)env;
+  int kind = xt_typed_array_kind_of(self);
+  if (kind < 0) return XT_UNDEFINED;
+  xt_value buffer = xt_typed_array_buffer_of(self);
+  if (!xt_is_array_buffer(buffer)) return xt_ta_method_slice(self, env, argc, argv);
+  int32_t length = (int32_t)xt_ta_length(self);
+  int32_t start = xt_ta_relative(argc > 0 && argv[0] != XT_UNDEFINED ? xt_to_int32(argv[0]) : 0, length);
+  int32_t end = xt_ta_relative(argc > 1 && argv[1] != XT_UNDEFINED ? xt_to_int32(argv[1]) : length, length);
+  if (end < start) end = start;
+  uint32_t offset = xt_typed_array_byte_offset_of(self) + (uint32_t)start * (uint32_t)xt_ta_bytes[kind];
+  return xt_ta_view(kind, buffer, offset, (uint32_t)(end - start));
+}
+
 static xt_value xt_ta_method_join(xt_value self, xt_value env, int32_t argc, xt_value *argv) {
   (void)env;
   xt_value separator = argc > 0 && argv[0] != XT_UNDEFINED ? xt_to_string(argv[0]) : xt_string_from_cstr(",");
@@ -137,14 +151,16 @@ static xt_value xt_ta_method_filter(xt_value self, xt_value env, int32_t argc, x
   xt_value callback = xt_arg_at(argc, argv, 0);
   xt_value thisArg = xt_arg_at(argc, argv, 1);
   int32_t length = (int32_t)xt_ta_length(self);
-  xt_value out = xt_ta_new(kind, 0);
+  /* A fixed-length buffer cannot grow, so collect matches first and build the
+   * result typed array from that array. */
+  xt_value matches = xt_array_new(0, NULL);
   for (int32_t i = 0; i < length; i++) {
     xt_value args[3] = {xt_ta_element(self, (uint32_t)i), xt_number((double)i), self};
     if (xt_truthy(xt_call_with_this(callback, thisArg, 3, args))) {
-      xt_ta_append(out, kind, xt_ta_element(self, (uint32_t)i));
+      xt_array_push(matches, xt_ta_element(self, (uint32_t)i));
     }
   }
-  return out;
+  return xt_ta_from_value(kind, matches, XT_UNDEFINED, XT_UNDEFINED, 0);
 }
 
 static xt_value xt_ta_method_every(xt_value self, xt_value env, int32_t argc, xt_value *argv) {
@@ -208,7 +224,7 @@ static xt_value xt_ta_method_reduce(xt_value self, xt_value env, int32_t argc, x
     accumulator = xt_ta_element(self, 0);
     index = 1;
   } else {
-    xt_throw(xt_string_from_cstr("TypeError: Reduce of empty array with no initial value"));
+    xt_throw(xt_error_from_message("TypeError: Reduce of empty array with no initial value"));
     return XT_UNDEFINED;
   }
   for (; index < length; index++) {

package/runtime/xt_typed_array.c

@@ -1,16 +1,12 @@
 /*
  * xbintsc runtime - typed arrays.
  *
- * JavaScript TypedArrays are modelled as plain property-bag objects with one
- * numbered property per element plus `length`, `byteLength` and `byteOffset`.
- * Every write is coerced to the array's element type, so
- * `new Uint8Array(2)[0] = 300` stores 44 exactly like ECMAScript and a
- * `Float32Array` round-trips through single precision.
- *
- * There is no shared `ArrayBuffer` backing store: `slice` / `subarray` return
- * independent copies and the `.buffer` property is not exposed. That matches
- * xbintsc's runtime, which has no distinct binary value type (strings are
- * UTF-8 byte arrays and `Buffer` is likewise a property bag).
+ * A TypedArray is a view over an `ArrayBuffer`: its elements live in the
+ * buffer's bytes at `byteOffset`, and `length` / `byteLength` describe the
+ * window. `subarray` shares that buffer; `slice` copies into a new one.
+ * Every write is coerced to the element type, so `new Uint8Array(2)[0] = 300`
+ * stores 44 exactly like ECMAScript and a `Float32Array` round-trips through
+ * single precision.
  */
 
 #include "rt_internal.h"
@@ -34,6 +30,10 @@ enum {
 };
 
 static const int xt_ta_bytes[XT_TA_KIND_COUNT] = {1, 1, 1, 2, 2, 4, 4, 4, 8};
+static const char *const xt_ta_names[XT_TA_KIND_COUNT] = {
+    "Uint8Array", "Int8Array", "Uint8ClampedArray", "Uint16Array", "Int16Array",
+    "Uint32Array", "Int32Array", "Float32Array", "Float64Array",
+};
 
 static xt_value xt_ta_protos[XT_TA_KIND_COUNT];
 
@@ -42,6 +42,7 @@ static xt_value xt_ta_protos[XT_TA_KIND_COUNT];
 static xt_value xt_ta_method_fill(xt_value, xt_value, int32_t, xt_value *);
 static xt_value xt_ta_method_set(xt_value, xt_value, int32_t, xt_value *);
 static xt_value xt_ta_method_slice(xt_value, xt_value, int32_t, xt_value *);
+static xt_value xt_ta_method_subarray(xt_value, xt_value, int32_t, xt_value *);
 static xt_value xt_ta_method_join(xt_value, xt_value, int32_t, xt_value *);
 static xt_value xt_ta_method_to_string(xt_value, xt_value, int32_t, xt_value *);
 static xt_value xt_ta_method_index_of(xt_value, xt_value, int32_t, xt_value *);