xbintsc 0.3.25 → 0.3.35

package/runtime/xt_fetch/response.inc

@@ -0,0 +1,107 @@
+/* -- Response ------------------------------------------------------------- */
+
+/*
+ * `fetch` resolves with a plain object shaped like a `Response`: the status
+ * fields are own properties, `headers` is a Headers object, and the body is
+ * kept verbatim under `__body`. The body consumers (`text` / `json` /
+ * `arrayBuffer` / `bytes`) return promises, matching the platform API even
+ * though the value is already available.
+ */
+
+static void *xt_response_method_impl(xt_value name);
+static xt_value xt_method_value_for_response(xt_value name);
+
+static xt_value xt_response_body(xt_value response) {
+  xt_value body = xt_object_get_cstr(response, "__body");
+  return XT_IS_STRING(body) ? body : xt_string_from_cstr("");
+}
+
+static xt_value xt_response_method_text(xt_value thisValue, xt_value env, int32_t argc, xt_value *argv) {
+  (void)env;
+  (void)argc;
+  (void)argv;
+  return xt_promise_resolve(xt_response_body(thisValue));
+}
+
+static xt_value xt_response_method_json(xt_value thisValue, xt_value env, int32_t argc, xt_value *argv) {
+  (void)env;
+  (void)argc;
+  (void)argv;
+  xt_value body = xt_response_body(thisValue);
+  return xt_promise_resolve(xt_json_parse(1, &body));
+}
+
+static xt_value xt_response_method_array_buffer(xt_value thisValue, xt_value env, int32_t argc, xt_value *argv) {
+  (void)env;
+  (void)argc;
+  (void)argv;
+  xt_value body = xt_response_body(thisValue);
+  const char *data = xt_string_data(body);
+  int32_t length = xt_string_length_value(body);
+  if (!data || length < 0) length = 0;
+  xt_value bytes = xt_array_new(0, NULL);
+  for (int32_t i = 0; i < length; i++) {
+    xt_array_push(bytes, xt_number((double)(unsigned char)data[i]));
+  }
+  return xt_promise_resolve(bytes);
+}
+
+static xt_value xt_response_method_clone(xt_value thisValue, xt_value env, int32_t argc, xt_value *argv) {
+  (void)env;
+  (void)argc;
+  (void)argv;
+  xt_value clone = xt_object_new();
+  xt_value keys = xt_object_keys(thisValue);
+  int32_t count = (int32_t)xt_to_number(xt_array_length(keys));
+  for (int32_t i = 0; i < count; i++) {
+    xt_value key = xt_array_get(keys, xt_number((double)i));
+    xt_value value = xt_object_get(thisValue, key);
+    if (XT_IS_FUNCTION(value)) {
+      /* Re-use the method implementation with the new receiver. */
+      xt_value name = key;
+      xt_object_set(clone, name, xt_method_value_for_response(name));
+    } else {
+      xt_object_set(clone, key, value);
+    }
+  }
+  return clone;
+}
+
+/* Map a Response method name back to its implementation so `clone()` can copy
+ * the methods without duplicating the dispatch table. */
+static void *xt_response_method_impl(xt_value name) {
+  const char *method = xt_string_data(name);
+  if (!method) return NULL;
+  if (strcmp(method, "text") == 0) return (void *)xt_response_method_text;
+  if (strcmp(method, "json") == 0) return (void *)xt_response_method_json;
+  if (strcmp(method, "arrayBuffer") == 0) return (void *)xt_response_method_array_buffer;
+  if (strcmp(method, "bytes") == 0) return (void *)xt_response_method_array_buffer;
+  if (strcmp(method, "clone") == 0) return (void *)xt_response_method_clone;
+  return NULL;
+}
+
+static xt_value xt_method_value_for_response(xt_value name) {
+  void *impl = xt_response_method_impl(name);
+  return impl ? xt_closure_new(impl, 0, NULL) : XT_UNDEFINED;
+}
+
+static xt_value xt_response_new(xt_value headers, int status, const char *statusText, const char *url,
+                                const char *body, size_t bodyLength) {
+  xt_value response = xt_object_new();
+  xt_object_set(response, xt_string_from_cstr("ok"),
+                (status >= 200 && status < 300) ? XT_TRUE : XT_FALSE);
+  xt_object_set(response, xt_string_from_cstr("status"), xt_number((double)status));
+  xt_object_set(response, xt_string_from_cstr("statusText"), xt_string_from_cstr(statusText ? statusText : ""));
+  xt_object_set(response, xt_string_from_cstr("url"), xt_string_from_cstr(url ? url : ""));
+  xt_object_set(response, xt_string_from_cstr("redirected"), XT_FALSE);
+  xt_object_set(response, xt_string_from_cstr("type"), xt_string_from_cstr("basic"));
+  xt_object_set(response, xt_string_from_cstr("bodyUsed"), XT_FALSE);
+  xt_object_set(response, xt_string_from_cstr("headers"), headers);
+  xt_object_set(response, xt_string_from_cstr("__body"), xt_string_new(body ? body : "", bodyLength));
+  xt_fetch_set_method(response, "text", (void *)xt_response_method_text);
+  xt_fetch_set_method(response, "json", (void *)xt_response_method_json);
+  xt_fetch_set_method(response, "arrayBuffer", (void *)xt_response_method_array_buffer);
+  xt_fetch_set_method(response, "bytes", (void *)xt_response_method_array_buffer);
+  xt_fetch_set_method(response, "clone", (void *)xt_response_method_clone);
+  return response;
+}

package/runtime/xt_fetch/socket.inc

@@ -0,0 +1,72 @@
+/* -- TCP socket helpers --------------------------------------------------- */
+
+/*
+ * `fetch` performs a conventional blocking request/response exchange: connect,
+ * write the request, read until the response is complete (or the peer closes).
+ * The socket carries a receive timeout so a stalled server cannot hang the
+ * program forever; the timeout surfaces as a rejected promise.
+ */
+#define XT_FETCH_TIMEOUT_SECONDS 30
+
+static void xt_fetch_set_timeouts(int fd) {
+#if defined(_WIN32)
+  DWORD ms = (DWORD)XT_FETCH_TIMEOUT_SECONDS * 1000;
+  setsockopt(fd, SOL_SOCKET, SO_RCVTIMEO, (const char *)&ms, (int)sizeof(ms));
+  setsockopt(fd, SOL_SOCKET, SO_SNDTIMEO, (const char *)&ms, (int)sizeof(ms));
+#else
+  struct timeval timeout;
+  timeout.tv_sec = XT_FETCH_TIMEOUT_SECONDS;
+  timeout.tv_usec = 0;
+  setsockopt(fd, SOL_SOCKET, SO_RCVTIMEO, &timeout, sizeof(timeout));
+  setsockopt(fd, SOL_SOCKET, SO_SNDTIMEO, &timeout, sizeof(timeout));
+#endif
+}
+
+static int xt_fetch_connect(const xt_fetch_url *url) {
+  struct addrinfo hints;
+  memset(&hints, 0, sizeof(hints));
+  hints.ai_family = AF_UNSPEC;
+  hints.ai_socktype = SOCK_STREAM;
+  struct addrinfo *result = NULL;
+  if (getaddrinfo(url->host, url->port, &hints, &result) != 0) return -1;
+  int fd = -1;
+  for (struct addrinfo *info = result; info; info = info->ai_next) {
+    int candidate = socket(info->ai_family, info->ai_socktype, info->ai_protocol);
+    if (candidate < 0) continue;
+    if (connect(candidate, info->ai_addr, (xt_fetch_socklen_t)info->ai_addrlen) == 0) {
+      fd = candidate;
+      break;
+    }
+    xt_fetch_close_socket(candidate);
+  }
+  freeaddrinfo(result);
+  if (fd >= 0) xt_fetch_set_timeouts(fd);
+  return fd;
+}
+
+static int xt_fetch_send_all(int fd, const char *data, size_t length) {
+  size_t sent = 0;
+  while (sent < length) {
+#if defined(_WIN32)
+    int written = send(fd, data + sent, (int)(length - sent), 0);
+#else
+    ssize_t written = send(fd, data + sent, length - sent, 0);
+#endif
+    if (written > 0) {
+      sent += (size_t)written;
+      continue;
+    }
+    return -1;
+  }
+  return 0;
+}
+
+/** Receive one chunk; returns the byte count, `0` on close, `-1` on error. */
+static int xt_fetch_recv(int fd, char *buffer, size_t capacity) {
+#if defined(_WIN32)
+  return recv(fd, buffer, (int)capacity, 0);
+#else
+  ssize_t count = recv(fd, buffer, capacity, 0);
+  return count > 2147483647 ? 2147483647 : (int)count;
+#endif
+}

package/runtime/xt_fetch/url.inc

@@ -0,0 +1,108 @@
+/* -- URL parsing ---------------------------------------------------------- */
+
+/*
+ * `fetch` accepts absolute `http://` / `https://` URLs (there is no document
+ * base to resolve relative ones against). The parsed pieces are kept in a
+ * fixed-size struct because `fetch` hands them straight to `getaddrinfo`.
+ */
+typedef struct {
+  int secure;
+  char host[256];
+  char port[8];
+  char path[4096];
+} xt_fetch_url;
+
+/** Parse `url` into `out`. Returns 0 on success, -1 on a malformed URL. */
+static int xt_fetch_parse_url(const char *url, xt_fetch_url *out) {
+  if (!url) return -1;
+  out->secure = 0;
+  const char *cursor = url;
+  if (strncmp(cursor, "http://", 7) == 0) {
+    cursor += 7;
+    snprintf(out->port, sizeof(out->port), "80");
+  } else if (strncmp(cursor, "https://", 8) == 0) {
+    cursor += 8;
+    out->secure = 1;
+    snprintf(out->port, sizeof(out->port), "443");
+  } else {
+    return -1;
+  }
+
+  /* The authority ends at the first `/`, `?` or `#` (or the end of the URL). */
+  const char *authorityEnd = cursor;
+  while (*authorityEnd && *authorityEnd != '/' && *authorityEnd != '?' && *authorityEnd != '#') authorityEnd++;
+
+  /* Drop any `user:password@` prefix. */
+  const char *hostStart = cursor;
+  for (const char *p = cursor; p < authorityEnd; p++) {
+    if (*p == '@') hostStart = p + 1;
+  }
+
+  const char *hostEnd = authorityEnd;
+  const char *portStart = NULL;
+  if (hostStart < authorityEnd && *hostStart == '[') {
+    /* IPv6 literal: `[::1]:8080`. */
+    const char *close = (const char *)memchr(hostStart, ']', (size_t)(authorityEnd - hostStart));
+    if (!close) return -1;
+    hostEnd = close;
+    if (close + 1 < authorityEnd && close[1] == ':') portStart = close + 2;
+    hostStart++;
+  } else {
+    const char *colon = (const char *)memchr(hostStart, ':', (size_t)(authorityEnd - hostStart));
+    if (colon) {
+      hostEnd = colon;
+      portStart = colon + 1;
+    }
+  }
+
+  size_t hostLength = (size_t)(hostEnd - hostStart);
+  if (hostLength == 0 || hostLength >= sizeof(out->host)) return -1;
+  memcpy(out->host, hostStart, hostLength);
+  out->host[hostLength] = '\0';
+
+  if (portStart && portStart < authorityEnd) {
+    size_t portLength = (size_t)(authorityEnd - portStart);
+    if (portLength >= sizeof(out->port)) return -1;
+    memcpy(out->port, portStart, portLength);
+    out->port[portLength] = '\0';
+    for (const char *p = out->port; *p; p++) {
+      if (*p < '0' || *p > '9') return -1;
+    }
+  }
+
+  /* The request target keeps the query string but drops the fragment. */
+  if (*authorityEnd == '\0' || *authorityEnd == '#') {
+    snprintf(out->path, sizeof(out->path), "/");
+  } else {
+    const char *pathEnd = authorityEnd;
+    while (*pathEnd && *pathEnd != '#') pathEnd++;
+    size_t pathLength = (size_t)(pathEnd - authorityEnd);
+    if (pathLength >= sizeof(out->path)) return -1;
+    memcpy(out->path, authorityEnd, pathLength);
+    out->path[pathLength] = '\0';
+  }
+  return 0;
+}
+
+/*
+ * Resolve a `Location` header against the URL just requested. Only absolute
+ * URLs and root-relative paths are supported; anything else is reported as a
+ * failure so the caller can return the 3xx response unchanged.
+ */
+static int xt_fetch_resolve_location(const xt_fetch_url *base, const char *location, char *out, size_t size) {
+  if (strncmp(location, "http://", 7) == 0 || strncmp(location, "https://", 8) == 0) {
+    snprintf(out, size, "%s", location);
+    return 0;
+  }
+  const char *scheme = base->secure ? "https" : "http";
+  if (location[0] == '/') {
+    int defaultPort = base->secure ? 443 : 80;
+    if (atoi(base->port) == defaultPort) {
+      snprintf(out, size, "%s://%s%s", scheme, base->host, location);
+    } else {
+      snprintf(out, size, "%s://%s:%s%s", scheme, base->host, base->port, location);
+    }
+    return 0;
+  }
+  return -1;
+}

package/runtime/xt_fetch.c

@@ -0,0 +1,39 @@
+/*
+ * xbintsc runtime — the global `fetch` API.
+ *
+ * This is a small, dependency-free HTTP/1.1 client exposed as the platform
+ * `fetch` global. The runtime has no event loop (promises are drained
+ * synchronously by `await`), so the request is performed with blocking sockets
+ * and the returned promise is already settled. TLS is not implemented, so only
+ * `http://` URLs are accepted; `https://` rejects with a `TypeError`.
+ *
+ * The implementation is grouped by concern under `xt_fetch/` and `#include`d
+ * here as a single translation unit, following the other runtime modules.
+ */
+
+#include "rt_internal.h"
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+
+#if defined(_WIN32)
+#include <winsock2.h>
+#include <ws2tcpip.h>
+typedef int xt_fetch_socklen_t;
+#define xt_fetch_close_socket closesocket
+#else
+#include <netdb.h>
+#include <sys/socket.h>
+#include <sys/time.h>
+#include <unistd.h>
+typedef socklen_t xt_fetch_socklen_t;
+#define xt_fetch_close_socket close
+#endif
+
+#include "xt_fetch/buffer.inc"
+#include "xt_fetch/url.inc"
+#include "xt_fetch/socket.inc"
+#include "xt_fetch/headers.inc"
+#include "xt_fetch/response.inc"
+#include "xt_fetch/request.inc"

package/runtime/xt_stdlib2/set.inc

@@ -39,7 +39,7 @@ static int xt_is_iterator_state(xt_value value) {
  * any other object with a `Symbol.iterator` method is wrapped. */
 xt_value xt_iter_open(xt_value value) {
   if (XT_IS_ARRAY(value) || XT_IS_STRING(value) || xt_is_map(value) || xt_is_set(value) ||
-      xt_is_generator(value))
+      xt_is_generator(value) || xt_typed_array_kind_of(value) >= 0)
     return value;
   if (XT_IS_OBJECT(value)) {
     xt_value method = xt_object_get(value, xt_symbol_well_known("iterator"));