xbintsc 0.1.8 → 0.1.10

package/runtime/ext_node/fs/fs_ops.c

@@ -0,0 +1,342 @@
+/*
+ * Node.js `fs` filesystem operations for xbintsc.
+ *
+ * Covers the synchronous, non-descriptor half of the module:
+ *     existsSync, readdirSync, mkdirSync, rmSync, unlinkSync, rmdirSync,
+ *     renameSync, copyFileSync, realpathSync, statSync, lstatSync
+ *
+ * Error handling is intentionally Node-compatible in spirit but not in
+ * mechanics: xbintsc has no try/catch that can catch native errors yet, so
+ * failures print to stderr and return `undefined` (or `false` for
+ * `existsSync`) instead of throwing `ENOENT`-style exceptions.
+ */
+
+#include "rt.h"
+#include "fs_common.h"
+
+#include <dirent.h>
+#include <errno.h>
+#include <sys/stat.h>
+#include <sys/types.h>
+#include <unistd.h>
+
+#if defined(_WIN32)
+#include <direct.h>
+#define xt_fs_mkdir_one(path) _mkdir(path)
+#define xt_fs_rmdir_one(path) _rmdir(path)
+#else
+#define xt_fs_mkdir_one(path) mkdir(path, 0777)
+#define xt_fs_rmdir_one(path) rmdir(path)
+#endif
+
+/* ------------------------------------------------------------------------- */
+/* existsSync                                                                */
+/* ------------------------------------------------------------------------- */
+
+xt_value xt_node_exists(int32_t argc, xt_value *argv) {
+  if (argc < 1) return xt_bool(0);
+  const char *path = xt_string_data(xt_to_string(argv[0]));
+  if (!path) return xt_bool(0);
+  return xt_bool(access(path, F_OK) == 0);
+}
+
+/* ------------------------------------------------------------------------- */
+/* readdirSync                                                               */
+/* ------------------------------------------------------------------------- */
+
+xt_value xt_node_read_dir(int32_t argc, xt_value *argv) {
+  if (argc < 1) return xt_undefined();
+  const char *path = xt_string_data(xt_to_string(argv[0]));
+  if (!path) return xt_undefined();
+
+  DIR *dir = opendir(path);
+  if (!dir) {
+    xt_fs_error("open directory", path);
+    return xt_undefined();
+  }
+
+  size_t count = 0;
+  size_t capacity = 16;
+  xt_value *items = (xt_value *)malloc(sizeof(xt_value) * capacity);
+  if (!items) {
+    closedir(dir);
+    return xt_undefined();
+  }
+
+  struct dirent *entry;
+  while ((entry = readdir(dir)) != NULL) {
+    if (strcmp(entry->d_name, ".") == 0 || strcmp(entry->d_name, "..") == 0) continue;
+    if (count == capacity) {
+      capacity *= 2;
+      xt_value *grown = (xt_value *)realloc(items, sizeof(xt_value) * capacity);
+      if (!grown) break;
+      items = grown;
+    }
+    items[count++] = xt_string_from_cstr(entry->d_name);
+  }
+  closedir(dir);
+
+  xt_value result = xt_array_new((int32_t)count, items);
+  free(items);
+  return result;
+}
+
+/* ------------------------------------------------------------------------- */
+/* mkdirSync                                                                 */
+/* ------------------------------------------------------------------------- */
+
+/* True when the second argument asks for recursive creation. */
+static int xt_fs_recursive(xt_value options) {
+  if (!xt_truthy(options)) return 0;
+  if (XT_IS_OBJECT(options)) return xt_truthy(xt_object_get_cstr(options, "recursive"));
+  return 1;
+}
+
+static int xt_fs_mkdir_recursive(const char *path) {
+  size_t length = strlen(path);
+  char *copy = (char *)malloc(length + 1);
+  if (!copy) return -1;
+  memcpy(copy, path, length + 1);
+
+  while (length > 1 && copy[length - 1] == '/') copy[--length] = '\0';
+  for (size_t i = 1; i <= length; i++) {
+    if (copy[i] != '/' && copy[i] != '\0') continue;
+    char saved = copy[i];
+    copy[i] = '\0';
+    if (xt_fs_mkdir_one(copy) != 0 && errno != EEXIST) {
+      free(copy);
+      return -1;
+    }
+    copy[i] = saved;
+  }
+  free(copy);
+  return 0;
+}
+
+xt_value xt_node_mkdir(int32_t argc, xt_value *argv) {
+  if (argc < 1) return xt_undefined();
+  const char *path = xt_string_data(xt_to_string(argv[0]));
+  if (!path) return xt_undefined();
+
+  if (argc > 1 && xt_fs_recursive(argv[1])) {
+    if (xt_fs_mkdir_recursive(path) != 0) xt_fs_error("create directory", path);
+    return xt_undefined();
+  }
+  if (xt_fs_mkdir_one(path) != 0 && errno != EEXIST) xt_fs_error("create directory", path);
+  return xt_undefined();
+}
+
+/* ------------------------------------------------------------------------- */
+/* rmSync / unlinkSync / rmdirSync                                           */
+/* ------------------------------------------------------------------------- */
+
+static int xt_fs_remove_recursive(const char *path) {
+  struct stat info;
+  if (lstat(path, &info) != 0) return -1;
+  if (!S_ISDIR(info.st_mode)) return remove(path);
+
+  DIR *dir = opendir(path);
+  if (!dir) return -1;
+  struct dirent *entry;
+  while ((entry = readdir(dir)) != NULL) {
+    if (strcmp(entry->d_name, ".") == 0 || strcmp(entry->d_name, "..") == 0) continue;
+    size_t size = strlen(path) + strlen(entry->d_name) + 2;
+    char *child = (char *)malloc(size);
+    if (!child) continue;
+    snprintf(child, size, "%s/%s", path, entry->d_name);
+    xt_fs_remove_recursive(child);
+    free(child);
+  }
+  closedir(dir);
+  return xt_fs_rmdir_one(path);
+}
+
+xt_value xt_node_rm(int32_t argc, xt_value *argv) {
+  if (argc < 1) return xt_undefined();
+  const char *path = xt_string_data(xt_to_string(argv[0]));
+  if (!path) return xt_undefined();
+
+  int recursive = argc > 1 && xt_fs_recursive(argv[1]);
+  int status = recursive ? xt_fs_remove_recursive(path) : remove(path);
+  if (status != 0) xt_fs_error("remove", path);
+  return xt_undefined();
+}
+
+xt_value xt_node_unlink(int32_t argc, xt_value *argv) {
+  if (argc < 1) return xt_undefined();
+  const char *path = xt_string_data(xt_to_string(argv[0]));
+  if (!path) return xt_undefined();
+  if (remove(path) != 0) xt_fs_error("remove file", path);
+  return xt_undefined();
+}
+
+xt_value xt_node_rmdir(int32_t argc, xt_value *argv) {
+  if (argc < 1) return xt_undefined();
+  const char *path = xt_string_data(xt_to_string(argv[0]));
+  if (!path) return xt_undefined();
+  if (xt_fs_rmdir_one(path) != 0) xt_fs_error("remove directory", path);
+  return xt_undefined();
+}
+
+/* ------------------------------------------------------------------------- */
+/* renameSync / copyFileSync / realpathSync                                  */
+/* ------------------------------------------------------------------------- */
+
+xt_value xt_node_rename(int32_t argc, xt_value *argv) {
+  if (argc < 2) return xt_undefined();
+  const char *from = xt_string_data(xt_to_string(argv[0]));
+  const char *to = xt_string_data(xt_to_string(argv[1]));
+  if (!from || !to) return xt_undefined();
+  if (rename(from, to) != 0) xt_fs_error("rename", from);
+  return xt_undefined();
+}
+
+xt_value xt_node_copy_file(int32_t argc, xt_value *argv) {
+  if (argc < 2) return xt_undefined();
+  const char *from = xt_string_data(xt_to_string(argv[0]));
+  const char *to = xt_string_data(xt_to_string(argv[1]));
+  if (!from || !to) return xt_undefined();
+
+  FILE *source = fopen(from, "rb");
+  if (!source) {
+    xt_fs_error("open", from);
+    return xt_undefined();
+  }
+  FILE *destination = fopen(to, "wb");
+  if (!destination) {
+    fclose(source);
+    xt_fs_error("open", to);
+    return xt_undefined();
+  }
+
+  char buffer[8192];
+  size_t read;
+  while ((read = fread(buffer, 1, sizeof(buffer), source)) > 0) fwrite(buffer, 1, read, destination);
+  fclose(source);
+  fclose(destination);
+  return xt_undefined();
+}
+
+xt_value xt_node_realpath(int32_t argc, xt_value *argv) {
+  if (argc < 1) return xt_undefined();
+  const char *path = xt_string_data(xt_to_string(argv[0]));
+  if (!path) return xt_undefined();
+#if defined(_WIN32)
+  char resolved[_MAX_PATH];
+  if (_fullpath(resolved, path, _MAX_PATH) == NULL) {
+    xt_fs_error("resolve", path);
+    return xt_undefined();
+  }
+  return xt_string_from_cstr(resolved);
+#else
+  char *resolved = realpath(path, NULL);
+  if (!resolved) {
+    xt_fs_error("resolve", path);
+    return xt_undefined();
+  }
+  xt_value result = xt_string_from_cstr(resolved);
+  free(resolved);
+  return result;
+#endif
+}
+
+/* ------------------------------------------------------------------------- */
+/* statSync / lstatSync                                                      */
+/* ------------------------------------------------------------------------- */
+
+/*
+ * Stats methods (`isFile`, `isDirectory`, ...) are native closures capturing
+ * the raw mode; the closure environment carries `[mode, methodName]`.
+ */
+static xt_value xt_fs_stat_method(xt_value thisValue, xt_value env, int32_t argc, xt_value *argv) {
+  (void)thisValue;
+  (void)argc;
+  (void)argv;
+  unsigned int mode = (unsigned int)xt_to_number(xt_closure_env(env, 0));
+  const char *method = xt_string_data(xt_closure_env(env, 1));
+  if (!method) return xt_bool(0);
+  int result = 0;
+  if (strcmp(method, "isFile") == 0) result = S_ISREG(mode);
+  else if (strcmp(method, "isDirectory") == 0) result = S_ISDIR(mode);
+  else if (strcmp(method, "isSymbolicLink") == 0) result = S_ISLNK(mode);
+  else if (strcmp(method, "isFIFO") == 0) result = S_ISFIFO(mode);
+  else if (strcmp(method, "isSocket") == 0) result = S_ISSOCK(mode);
+  else if (strcmp(method, "isBlockDevice") == 0) result = S_ISBLK(mode);
+  else if (strcmp(method, "isCharacterDevice") == 0) result = S_ISCHR(mode);
+  return xt_bool(result);
+}
+
+static void xt_fs_define_stat_method(xt_value object, const char *name, unsigned int mode) {
+  xt_value env[2];
+  env[0] = xt_number((double)mode);
+  env[1] = xt_string_from_cstr(name);
+  xt_value fn = xt_closure_new((void *)xt_fs_stat_method, 2, env);
+  xt_object_set(object, xt_string_from_cstr(name), fn);
+}
+
+static double xt_fs_seconds_ms(long seconds, long nanoseconds) {
+  return (double)seconds * 1000.0 + (double)nanoseconds / 1000000.0;
+}
+
+static xt_value xt_node_stat_result(const struct stat *info) {
+  xt_value object = xt_object_new();
+  xt_object_set(object, xt_string_from_cstr("size"), xt_number((double)info->st_size));
+  xt_object_set(object, xt_string_from_cstr("mode"), xt_number((double)info->st_mode));
+  xt_object_set(object, xt_string_from_cstr("uid"), xt_number((double)info->st_uid));
+  xt_object_set(object, xt_string_from_cstr("gid"), xt_number((double)info->st_gid));
+  xt_object_set(object, xt_string_from_cstr("dev"), xt_number((double)info->st_dev));
+  xt_object_set(object, xt_string_from_cstr("ino"), xt_number((double)info->st_ino));
+  xt_object_set(object, xt_string_from_cstr("nlink"), xt_number((double)info->st_nlink));
+  xt_object_set(object, xt_string_from_cstr("rdev"), xt_number((double)info->st_rdev));
+#if defined(__APPLE__)
+  xt_object_set(object, xt_string_from_cstr("blocks"), xt_number((double)info->st_blocks));
+  xt_object_set(object, xt_string_from_cstr("blksize"), xt_number((double)info->st_blksize));
+  xt_object_set(object, xt_string_from_cstr("mtimeMs"),
+                xt_number(xt_fs_seconds_ms(info->st_mtimespec.tv_sec, info->st_mtimespec.tv_nsec)));
+  xt_object_set(object, xt_string_from_cstr("atimeMs"),
+                xt_number(xt_fs_seconds_ms(info->st_atimespec.tv_sec, info->st_atimespec.tv_nsec)));
+  xt_object_set(object, xt_string_from_cstr("ctimeMs"),
+                xt_number(xt_fs_seconds_ms(info->st_ctimespec.tv_sec, info->st_ctimespec.tv_nsec)));
+#elif defined(_WIN32)
+  xt_object_set(object, xt_string_from_cstr("mtimeMs"), xt_number((double)info->st_mtime * 1000.0));
+  xt_object_set(object, xt_string_from_cstr("atimeMs"), xt_number((double)info->st_atime * 1000.0));
+  xt_object_set(object, xt_string_from_cstr("ctimeMs"), xt_number((double)info->st_ctime * 1000.0));
+#else
+  xt_object_set(object, xt_string_from_cstr("blocks"), xt_number((double)info->st_blocks));
+  xt_object_set(object, xt_string_from_cstr("blksize"), xt_number((double)info->st_blksize));
+  xt_object_set(object, xt_string_from_cstr("mtimeMs"),
+                xt_number(xt_fs_seconds_ms(info->st_mtim.tv_sec, info->st_mtim.tv_nsec)));
+  xt_object_set(object, xt_string_from_cstr("atimeMs"),
+                xt_number(xt_fs_seconds_ms(info->st_atim.tv_sec, info->st_atim.tv_nsec)));
+  xt_object_set(object, xt_string_from_cstr("ctimeMs"),
+                xt_number(xt_fs_seconds_ms(info->st_ctim.tv_sec, info->st_ctim.tv_nsec)));
+#endif
+
+  unsigned int mode = (unsigned int)info->st_mode;
+  xt_fs_define_stat_method(object, "isFile", mode);
+  xt_fs_define_stat_method(object, "isDirectory", mode);
+  xt_fs_define_stat_method(object, "isSymbolicLink", mode);
+  xt_fs_define_stat_method(object, "isFIFO", mode);
+  xt_fs_define_stat_method(object, "isSocket", mode);
+  xt_fs_define_stat_method(object, "isBlockDevice", mode);
+  xt_fs_define_stat_method(object, "isCharacterDevice", mode);
+  return object;
+}
+
+static xt_value xt_node_stat_common(int32_t argc, xt_value *argv, int followLinks) {
+  if (argc < 1) return xt_undefined();
+  const char *path = xt_string_data(xt_to_string(argv[0]));
+  if (!path) return xt_undefined();
+
+  struct stat info;
+  int status = followLinks ? stat(path, &info) : lstat(path, &info);
+  if (status != 0) {
+    xt_fs_error("stat", path);
+    return xt_undefined();
+  }
+  return xt_node_stat_result(&info);
+}
+
+xt_value xt_node_stat(int32_t argc, xt_value *argv) { return xt_node_stat_common(argc, argv, 1); }
+
+xt_value xt_node_lstat(int32_t argc, xt_value *argv) { return xt_node_stat_common(argc, argv, 0); }

package/runtime/ext_node/fs/read_file.c

@@ -1,15 +1,19 @@
 /*
- * Node.js `fs` module for xbintsc.
+ * Node.js `fs.readFileSync` for xbintsc.
  *
  * Compiled and linked only when the `node` extension is registered. Following
- * the runtime calling convention, every builtin is:
+ * the runtime calling convention, the builtin is:
  *     xt_value fn(int32_t argc, xt_value *argv)
+ *
+ * `readFileSync(path[, options])` reads a file and returns its contents as a
+ * string. `options` may be an encoding string or an object with an `encoding`
+ * property; `"utf8"` (the default), `"ascii"`, `"latin1"` and `"binary"` return
+ * the raw bytes, while `"hex"` and `"base64"` return encoded strings. There is
+ * no `Buffer` type yet, so binary reads always come back as text.
  */
 
 #include "rt.h"
-
-#include <stdio.h>
-#include <stdlib.h>
+#include "fs_common.h"
 
 xt_value xt_node_read_text_file(int32_t argc, xt_value *argv) {
   if (argc < 1) return xt_undefined();
@@ -37,7 +41,9 @@ xt_value xt_node_read_text_file(int32_t argc, xt_value *argv) {
   size_t read = fread(buffer, 1, (size_t)size, file);
   fclose(file);
   buffer[read] = '\0';
-  xt_value result = xt_string_new(buffer, read);
+
+  const char *encoding = argc > 1 ? xt_fs_encoding(argv[1]) : NULL;
+  xt_value result = xt_fs_encode_bytes((const unsigned char *)buffer, read, encoding);
   free(buffer);
   return result;
 }

package/runtime/ext_node/fs/write_file.c

@@ -0,0 +1,47 @@
+/*
+ * Node.js `fs.writeFileSync` / `fs.appendFileSync` for xbintsc.
+ *
+ * `writeFileSync(path, data[, options])` truncates the file before writing;
+ * `appendFileSync(path, data[, options])` appends. `data` is converted to a
+ * string with the usual JS rules and `options` selects an encoding:
+ * `"hex"`/`"base64"` decode the string, everything else writes its UTF-8 bytes.
+ */
+
+#include "rt.h"
+#include "fs_common.h"
+
+static xt_value xt_node_write_common(int32_t argc, xt_value *argv, const char *mode) {
+  if (argc < 2) return xt_undefined();
+  xt_value pathValue = xt_to_string(argv[0]);
+  const char *path = xt_string_data(pathValue);
+  if (!path) return xt_undefined();
+
+  xt_value dataValue = xt_to_string(argv[1]);
+  const char *text = xt_string_data(dataValue);
+  int32_t length = xt_string_length_value(dataValue);
+  if (!text || length < 0) return xt_undefined();
+
+  const char *encoding = argc > 2 ? xt_fs_encoding(argv[2]) : NULL;
+  size_t byteLength = 0;
+  unsigned char *bytes = xt_fs_decode_text(text, (size_t)length, encoding, &byteLength);
+  if (!bytes) return xt_undefined();
+
+  FILE *file = fopen(path, mode);
+  if (!file) {
+    fprintf(stderr, "xbintsc: cannot open '%s'\n", path);
+    free(bytes);
+    return xt_undefined();
+  }
+  if (byteLength > 0) fwrite(bytes, 1, byteLength, file);
+  fclose(file);
+  free(bytes);
+  return xt_undefined();
+}
+
+xt_value xt_node_write_file(int32_t argc, xt_value *argv) {
+  return xt_node_write_common(argc, argv, "wb");
+}
+
+xt_value xt_node_append_file(int32_t argc, xt_value *argv) {
+  return xt_node_write_common(argc, argv, "ab");
+}

package/runtime/ext_node/os/os.c

@@ -0,0 +1,165 @@
+/*
+ * Node.js `os` module for xbintsc.
+ *
+ * Exposed through namespace dispatch: `os.<name>()` lowers to
+ * `xt_os_static(<name>, argc, argv)`. Implemented: platform, arch, type,
+ * release, endianness, homedir, tmpdir, hostname, totalmem, freemem.
+ */
+
+#include "rt.h"
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+
+#if defined(_WIN32)
+#include <windows.h>
+#else
+#include <sys/utsname.h>
+#include <unistd.h>
+#endif
+
+static const char *xt_os_platform(void) {
+#if defined(_WIN32)
+  return "win32";
+#elif defined(__APPLE__)
+  return "darwin";
+#elif defined(__linux__)
+  return "linux";
+#elif defined(__FreeBSD__)
+  return "freebsd";
+#else
+  return "unknown";
+#endif
+}
+
+static const char *xt_os_type(void) {
+#if defined(_WIN32)
+  return "Windows_NT";
+#elif defined(__APPLE__)
+  return "Darwin";
+#elif defined(__linux__)
+  return "Linux";
+#elif defined(__FreeBSD__)
+  return "FreeBSD";
+#else
+  return "Unknown";
+#endif
+}
+
+static const char *xt_os_arch(void) {
+#if defined(__x86_64__) || defined(_M_X64)
+  return "x64";
+#elif defined(__aarch64__) || defined(_M_ARM64)
+  return "arm64";
+#elif defined(__i386__) || defined(_M_IX86)
+  return "ia32";
+#elif defined(__arm__)
+  return "arm";
+#else
+  return "unknown";
+#endif
+}
+
+static xt_value xt_os_string(const char *value) {
+  return value ? xt_string_from_cstr(value) : xt_undefined();
+}
+
+static xt_value xt_os_totalmem(void) {
+#if defined(_WIN32)
+  MEMORYSTATUSEX status;
+  status.dwLength = sizeof(status);
+  if (GlobalMemoryStatusEx(&status)) return xt_number((double)status.ullTotalPhys);
+  return xt_number(0);
+#else
+  long pages = sysconf(_SC_PHYS_PAGES);
+  long pageSize = sysconf(_SC_PAGESIZE);
+  if (pages <= 0 || pageSize <= 0) return xt_number(0);
+  return xt_number((double)pages * (double)pageSize);
+#endif
+}
+
+static xt_value xt_os_freemem(void) {
+#if defined(_WIN32)
+  MEMORYSTATUSEX status;
+  status.dwLength = sizeof(status);
+  if (GlobalMemoryStatusEx(&status)) return xt_number((double)status.ullAvailPhys);
+  return xt_number(0);
+#elif defined(_SC_AVPHYS_PAGES)
+  long pages = sysconf(_SC_AVPHYS_PAGES);
+  long pageSize = sysconf(_SC_PAGESIZE);
+  if (pages <= 0 || pageSize <= 0) return xt_number(0);
+  return xt_number((double)pages * (double)pageSize);
+#else
+  /* macOS exposes free memory through Mach APIs only; report total memory. */
+  return xt_os_totalmem();
+#endif
+}
+
+xt_value xt_os_static(xt_value name, int32_t argc, xt_value *argv) {
+  const char *method = xt_string_data(name);
+  if (!method) return xt_undefined();
+  (void)argc;
+  (void)argv;
+
+  if (strcmp(method, "platform") == 0) return xt_string_from_cstr(xt_os_platform());
+  if (strcmp(method, "type") == 0) return xt_string_from_cstr(xt_os_type());
+  if (strcmp(method, "arch") == 0) return xt_string_from_cstr(xt_os_arch());
+  if (strcmp(method, "endianness") == 0) {
+#if defined(__BYTE_ORDER__) && defined(__ORDER_BIG_ENDIAN__) && __BYTE_ORDER__ == __ORDER_BIG_ENDIAN__
+    return xt_string_from_cstr("BE");
+#else
+    return xt_string_from_cstr("LE");
+#endif
+  }
+  if (strcmp(method, "homedir") == 0) {
+#if defined(_WIN32)
+    return xt_os_string(getenv("USERPROFILE"));
+#else
+    return xt_os_string(getenv("HOME"));
+#endif
+  }
+  if (strcmp(method, "tmpdir") == 0) {
+#if defined(_WIN32)
+    const char *temp = getenv("TEMP");
+    return xt_os_string(temp ? temp : "C:\\Windows\\Temp");
+#else
+    const char *temp = getenv("TMPDIR");
+    return xt_os_string(temp ? temp : "/tmp");
+#endif
+  }
+  if (strcmp(method, "hostname") == 0) {
+    char buffer[256];
+    if (gethostname(buffer, sizeof(buffer)) != 0) return xt_undefined();
+    buffer[sizeof(buffer) - 1] = '\0';
+    return xt_string_from_cstr(buffer);
+  }
+  if (strcmp(method, "release") == 0) {
+#if defined(_WIN32)
+    return xt_string_from_cstr("0.0.0");
+#else
+    struct utsname info;
+    if (uname(&info) != 0) return xt_undefined();
+    return xt_string_from_cstr(info.release);
+#endif
+  }
+  if (strcmp(method, "totalmem") == 0) return xt_os_totalmem();
+  if (strcmp(method, "freemem") == 0) return xt_os_freemem();
+  if (strcmp(method, "cpus") == 0) {
+    /* No per-core details yet; report the logical processor count as length. */
+    long processors = sysconf(_SC_NPROCESSORS_ONLN);
+    if (processors <= 0) processors = 1;
+    xt_value *items = (xt_value *)malloc(sizeof(xt_value) * (size_t)processors);
+    if (!items) return xt_array_new(0, NULL);
+    for (long i = 0; i < processors; i++) {
+      xt_value info = xt_object_new();
+      xt_object_set(info, xt_string_from_cstr("model"), xt_string_from_cstr("unknown"));
+      xt_object_set(info, xt_string_from_cstr("speed"), xt_number(0));
+      items[i] = info;
+    }
+    xt_value result = xt_array_new((int32_t)processors, items);
+    free(items);
+    return result;
+  }
+  return xt_undefined();
+}