@suchipi/quickjs 0.8.1 → 0.10.0

package/README.md

@@ -55,11 +55,10 @@ Fork of the fantastic QuickJS engine by Fabrice Bellard, with many changes.
 - `os.{S_IRWXU,S_IRUSR,S_IWUSR,S_IXUSR,S_IRWXG,S_IRGRP,S_IWGRP,S_IXGRP,S_IRWXO,S_IROTH,S_IWOTH,S_IXOTH}` added, for working with file modes.
 - `"b"` mode flag is now allowed in `std.fdopen`.
 - `std.strftime` added (wrapper for libc `strftime`).
-- Added `std.getuid`, `std.geteuid`, `std.getgid`, and `std.getegid` (wrappers for the libc functions of the same names).
+- Added `std.getuid`, `std.geteuid`, `std.getgid`, `std.getegid`, and `std.getpwuid` (wrappers for the libc/posix functions of the same names).
 - Most module-loading-related code was moved into `quickjs-modulesys`.
 - `setTimeout` and `clearTimeout` are now available as globals (previously they were only available as exports).
 - `setInterval` and `clearInterval` are added, available as globals.
-- `String.dedent` added (template tag function, like the proposed [String.dedent](https://github.com/tc39/proposal-string-dedent)).
 - Several C-side helper functions were moved out of quickjs-libc and into quickjs-utils.
 - Most module-related code (setting import.meta, etc) was moved into quickjs-modulesys.
 - Added `std.setExitCode`, `std.getExitCode`, and made `std.exit`'s parameter optional. The value passed to `std.setExitCode` will be used when the process exits normally, or when `std.exit` is called without any arguments. `std.setExitCode`, `std.getExitCode`, and `std.exit` throw if called from a thread other than the main thread (ie. a Worker).
@@ -126,6 +125,8 @@ This module contains APIs related to engine internals like script execution, mod
 
 - `.js` extensions can now be omitted from import specifiers; they're optional.
 - If your import specifier points to a folder, it will attempt to load `index.js` from that folder.
+- Synchronous import function added (`importModule`), which provides the same module record object you would get via dynamic (async) import.
+- JS api for using the engine's configured module name normalization function was added (`resolveModule`).
 - Adds the global `require`, a CommonJS-like synchronous module loading function.
   - The `require` function is not fully CommonJS-compliant; for instance, `require.main` is not present. `require.resolve` is, though.
 - Adds `import.meta.require`
@@ -136,7 +137,7 @@ This module contains APIs related to engine internals like script execution, mod
 - Makes the module loader's resolution and loading behavior configurable
   - The module "quickjs:engine" exports an object called `ModuleDelegate`.
   - You can specify additional implicit import specifier extensions by adding to the `ModuleDelegate.searchExtensions` array.
-  - You can transform any file prior to evaluating it as a module by adding a function to the `ModuleDelegate.compilers` object. Useful for compile-to-ts languages like TypeScript, Coffeescript, etc.
+  - You can transform any file prior to evaluating it as a module by adding a function to the `ModuleDelegate.compilers` object. Useful for compile-to-js languages like TypeScript, Coffeescript, etc.
   - You can override module name normalization (aka module resolution) by replacing the `ModuleDelegate.resolve` function.
     - Note that you must handle `ModuleDelegate.searchExtensions` yourself in your replacement implementation.
   - You can override the method used to load modules by replacing the `ModuleDelegate.read` function.
@@ -148,8 +149,6 @@ This module contains APIs related to engine internals like script execution, mod
 - New `isModuleNamespace` function lets users identify module namespace objects
 - New `defineBuiltinModule` function lets users add their own builtin modules
 - When using `require` to load a module which contains an export named `__cjsExports`, the value of the `__cjsExports` property will be returned from `require` instead of the usual module namespace object. This can be leveraged by users configuring the module loader to add some CommonJS <-> ESM interop. Note, however, that dynamic import and `"quickjs:engine"`'s `importModule` always receive the usual module namespace object.
-- Synchronous import function added (`importModule`), which provides the same module record object you would get via dynamic (async) import.
-- JS api for using the engine's configured module name normalization function was added (`resolveModule`).
 
 ### Changes to project organization
 
@@ -157,7 +156,7 @@ This module contains APIs related to engine internals like script execution, mod
 - Ninja is used instead of make. Ninja build config is generated via `.ninja.js` files which get loaded into [@suchipi/shinobi](https://github.com/suchipi/shinobi).
 - Line endings have been made consistent and trailing whitespace has been removed
 - The tests are authored in a new format which leverages jest snapshot testing.
-- Some parts of `quickjs-libc` were moved into `quickjs-modulesys` and `quickjs-libengine`.
+- Some parts of `quickjs-libc` were moved into `quickjs-modulesys` and `quickjs-engine`.
 - The `eval_*` functions that were duplicated in each of the programs (`eval_buf`, `eval_file`, and `eval_binary`) were deduplicated and moved into `quickjs-modulesys`.
 
 ### More target OSes/runtimes
@@ -206,6 +205,10 @@ To compile binaries for Linux, macOS, iOS, and Windows (using Docker):
 Or, to compile binaries for just your own unix system:
 
 - Make sure you have both [Ninja](https://ninja-build.org/) and [Node.js](https://nodejs.org/) installed. I use Ninja 1.10.1 and Node.js 18.18.0, but it should work with most versions of both of those.
+- Make sure you have [bash](https://www.gnu.org/software/bash/) 4 or higher.
+
+  > Almost all modern Linux systems have bash 5, but macOS still has bash 3. To get a newer version of bash on macOS, install either [Homebrew](https://brew.sh/) or [MacPorts](https://www.macports.org/) (your preference), then run `brew install bash` or `sudo port install bash`, respectively. You may also need to ensure your shell's [PATH environment variable](https://superuser.com/a/284351) is set correctly; running `which bash` should print the location of the _newer_ bash binary, installed by Homebrew/MacPorts.
+
 - Clone the repo and cd to its folder
 - Run `meta/build.sh`
 - Build artifacts will be placed in the `build` folder. You're probably most interested in stuff in the `build/bin` and `build/lib` folders.

package/build/aarch64-apple-darwin/bin/file-to-bytecode.js

@@ -3,9 +3,9 @@
 // Simple script which reads in a file, converts it to bytecode, and writes out
 // the bytecode to a new file.
 
-/// <reference path="../quickjs/quickjs.d.ts" />
-/// <reference path="../quickjs-libc/quickjs-libc.d.ts" />
-/// <reference path="../quickjs-libbytecode/quickjs-libbytecode.d.ts" />
+/// <reference path="../../quickjs/quickjs.d.ts" />
+/// <reference path="../../builtin-modules/quickjs-libc/quickjs-libc.d.ts" />
+/// <reference path="../../builtin-modules/quickjs-bytecode/quickjs-bytecode.d.ts" />
 
 import * as std from "quickjs:std";
 import * as Bytecode from "quickjs:bytecode";

package/build/aarch64-apple-darwin/include/quickjs-bytecode.h

@@ -0,0 +1,8 @@
+#ifndef QUICKJS_BYTECODE_H
+#define QUICKJS_BYTECODE_H
+
+#include "quickjs.h"
+
+JSModuleDef *js_init_module_bytecode(JSContext *ctx, const char *module_name);
+
+#endif /* ifndef QUICKJS_BYTECODE_H */

package/build/aarch64-apple-darwin/include/quickjs-context.h

@@ -0,0 +1,8 @@
+#ifndef QUICKJS_CONTEXT_H
+#define QUICKJS_CONTEXT_H
+
+#include "quickjs.h"
+
+JSModuleDef *js_init_module_context(JSContext *ctx, const char *module_name);
+
+#endif /* ifndef QUICKJS_CONTEXT_H */

package/build/aarch64-apple-darwin/include/quickjs-encoding.h

@@ -0,0 +1,8 @@
+#ifndef QUICKJS_ENCODING_H
+#define QUICKJS_ENCODING_H
+
+#include "quickjs.h"
+
+JSModuleDef *js_init_module_encoding(JSContext *ctx, const char *module_name);
+
+#endif /* ifndef QUICKJS_ENCODING_H */

package/build/aarch64-apple-darwin/include/quickjs-engine.h

@@ -0,0 +1,8 @@
+#ifndef QUICKJS_ENGINE_H
+#define QUICKJS_ENGINE_H
+
+#include "quickjs.h"
+
+JSModuleDef *js_init_module_engine(JSContext *ctx, const char *module_name);
+
+#endif /* ifndef QUICKJS_ENGINE_H */

package/build/aarch64-apple-darwin/include/quickjs-full-init.h

@@ -0,0 +1,19 @@
+#ifndef QUICKJS_FULL_INIT_H
+#define QUICKJS_FULL_INIT_H
+
+#include "quickjs.h"
+#include "quickjs-print.h"
+#include "quickjs-inspect.h"
+#include "quickjs-intervals.h"
+#include "quickjs-libc.h"
+#include "quickjs-bytecode.h"
+#include "quickjs-context.h"
+#include "quickjs-pointer.h"
+#include "quickjs-modulesys.h"
+#include "quickjs-engine.h"
+#include "quickjs-encoding.h"
+
+/* returns 0 on success, nonzero on failure */
+int quickjs_full_init(JSContext *ctx);
+
+#endif /* ifndef QUICKJS_FULL_INIT_H */

package/build/aarch64-apple-darwin/include/quickjs-inspect.h

@@ -0,0 +1,9 @@
+#ifndef QUICKJS_INSPECT_H
+#define QUICKJS_INSPECT_H
+
+#include "quickjs.h"
+
+/* Adds 'inspect' global */
+int js_inspect_add_inspect_global(JSContext *ctx);
+
+#endif /* ifndef QUICKJS_INSPECT_H */

package/build/aarch64-apple-darwin/include/quickjs-intervals.h

@@ -0,0 +1,9 @@
+#ifndef QUICKJS_INTERVALS_H
+#define QUICKJS_INTERVALS_H
+
+#include "quickjs.h"
+
+/* Adds 'setInterval' and 'clearInterval' globals */
+int js_intervals_add_setInterval_clearInterval_globals(JSContext *ctx);
+
+#endif /* ifndef QUICKJS_INTERVALS_H */

package/build/aarch64-apple-darwin/include/quickjs-libc.h

@@ -0,0 +1,65 @@
+/*
+ * QuickJS C library
+ *
+ * Copyright (c) 2017-2018 Fabrice Bellard
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in
+ * all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
+ * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+ * THE SOFTWARE.
+ */
+#ifndef QUICKJS_LIBC_H
+#define QUICKJS_LIBC_H
+
+#include <stdio.h>
+#include <stdlib.h>
+
+#include "quickjs.h"
+
+#ifdef __cplusplus
+extern "C"
+{
+#endif
+
+  JSModuleDef *js_init_module_std(JSContext *ctx, const char *module_name);
+  JSModuleDef *js_init_module_os(JSContext *ctx, const char *module_name);
+
+  /*
+    Creates 'scriptArgs' and 'setTimeout'.
+  */
+  void js_std_add_helpers(JSContext *ctx, int argc, char **argv);
+
+  /* Creates 'scriptArgs' global */
+  void js_std_add_scriptArgs(JSContext *ctx, int argc, char **argv);
+
+  /* Creates 'setTimeout' and 'clearTimeout' globals */
+  void js_std_add_timeout(JSContext *ctx);
+
+  JS_BOOL js_std_is_main_thread(JSRuntime *rt);
+  void js_std_interrupt_handler_start(JSContext *ctx);
+  void js_std_interrupt_handler_finish(JSContext *ctx, JSValue ret);
+
+  /* returns the exit status code */
+  int js_std_loop(JSContext *ctx);
+  void js_std_init_handlers(JSRuntime *rt);
+  void js_std_free_handlers(JSRuntime *rt);
+  void js_std_set_worker_new_context_func(JSContext *(*func)(JSRuntime *rt));
+
+#ifdef __cplusplus
+} /* extern "C" { */
+#endif
+
+#endif /* QUICKJS_LIBC_H */

package/build/aarch64-apple-darwin/include/quickjs-modulesys.h

@@ -0,0 +1,68 @@
+#ifndef QUICKJS_MODULESYS_H
+#define QUICKJS_MODULESYS_H
+
+#include "quickjs.h"
+
+typedef struct QJMS_State QJMS_State;
+
+/*
+  initialize and register the module loader system.
+  call both this (once per runtime) AND QJMS_InitContext (once per context).
+*/
+void QJMS_InitState(JSRuntime *rt);
+
+/*
+  initialize and register the module loader system.
+  call both this (once per context) AND QJMS_InitState (once per runtime).
+*/
+void QJMS_InitContext(JSContext *ctx);
+
+/* free resources allocated by the module loader system */
+void QJMS_FreeState(JSRuntime *rt);
+
+/*
+  Affects the value of import.meta.main.
+*/
+void QJMS_SetMainModule(JSRuntime *rt, const char *module_name);
+
+/*
+  Check if import.meta.main would be true for this module.
+*/
+JS_BOOL QJMS_IsMainModule(JSRuntime *rt, const char *module_name);
+
+/* initializes the import.meta object for the provided module function */
+int QJMS_SetModuleImportMeta(JSContext *ctx, JSValueConst func_val);
+
+/*
+  returns 0 on success, nonzero on error.
+  in case of error, prints error to stderr before returning.
+*/
+int QJMS_EvalBuf(JSContext *ctx, const void *buf, int buf_len,
+                 const char *filename, int eval_flags);
+
+/*
+  module can be -1 for autodetect.
+  returns 0 on success, nonzero on error.
+  in case of error, prints error to stderr before returning.
+*/
+int QJMS_EvalFile(JSContext *ctx, const char *filename, int module);
+
+/*
+  returns 0 on success, nonzero on error.
+  in case of error, prints error to stderr before returning.
+*/
+int QJMS_EvalBinary(JSContext *ctx, const uint8_t *buf, size_t buf_len,
+                    int load_only);
+
+/* the internal behavior of the 'require' function, exposed as a C API */
+JSValue QJMS_Require(JSContext *ctx, JSValueConst specifier);
+JSValue QJMS_Require2(JSContext *ctx, JSValueConst specifier, JSValueConst basename);
+
+/* the internal behavior of the 'require.resolve' function, exposed as a C API */
+JSValue QJMS_RequireResolve(JSContext *ctx, JSValueConst specifier_val);
+JSValue QJMS_RequireResolve2(JSContext *ctx, JSValueConst specifier_val, JSAtom basename_atom);
+
+/* returns an object like { require: Function, ModuleDelegate: Object } */
+JSValue QJMS_GetModuleLoaderInternals(JSContext *ctx);
+
+#endif /* ifndef QUICKJS_MODULESYS_H */

package/build/aarch64-apple-darwin/include/quickjs-pointer.h

@@ -0,0 +1,9 @@
+#ifndef QUICKJS_POINTER_H
+#define QUICKJS_POINTER_H
+
+#include "quickjs.h"
+
+JSModuleDef *js_init_module_pointer(JSContext *ctx, const char *module_name);
+JSValue js_new_pointer(JSContext *ctx, void *value);
+
+#endif /* ifndef QUICKJS_POINTER_H */

package/build/aarch64-apple-darwin/include/quickjs-print.h

@@ -0,0 +1,9 @@
+#ifndef QUICKJS_PRINT_H
+#define QUICKJS_PRINT_H
+
+#include "quickjs.h"
+
+void js_print_add_print_global(JSContext *ctx);
+void js_print_add_console_global(JSContext *ctx);
+
+#endif /* ifndef QUICKJS_PRINT_H */

package/build/aarch64-apple-darwin/include/quickjs-utils.h

@@ -0,0 +1,49 @@
+#ifndef QUICKJS_UTILS_H
+#define QUICKJS_UTILS_H
+
+#include "quickjs.h"
+
+typedef struct QJUForEachPropertyState
+{
+  uint32_t len;
+  uint32_t i;
+  JSPropertyEnum *tab;
+  JSAtom key;
+  JSValue val;
+} QJUForEachPropertyState;
+
+/* free using QJU_FreeForEachPropertyState */
+QJUForEachPropertyState *QJU_NewForEachPropertyState(JSContext *ctx, JSValue obj, int flags);
+
+// put a block after this invocation; it will be run once per property
+#define QJU_ForEachProperty(ctx, state) \
+  for (state->i = 0; state->i < state->len; state->i++)
+
+// fills in `state` with data for the current property.
+// return value will be JS_EXCEPTION if an exception was thrown, or JS_UNDEFINED otherwise.
+// you must JS_DupValue `state->val` if you wanna keep it around.
+JSValue QJU_ForEachProperty_Read(JSContext *ctx, JSValue obj, QJUForEachPropertyState *state);
+
+void QJU_FreeForEachPropertyState(JSContext *ctx, QJUForEachPropertyState *state);
+
+/* reads the contents of the file at `filename` into a buffer. */
+uint8_t *QJU_ReadFile(JSContext *ctx, size_t *pbuf_len, const char *filename);
+
+/*
+prints `exception_val` to `f`. If `exception_val` is an Error,
+it gets printed nicely.
+*/
+void QJU_PrintError(JSContext *ctx, FILE *f, JSValueConst exception_val);
+
+/*
+prints the context's current exception to `f`.
+this calls JS_GetException, so the exception will be cleared.
+*/
+void QJU_PrintException(JSContext *ctx, FILE *f);
+
+/* an unhandled promise rejection handler suitable for passing into JS_SetHostPromiseRejectionTracker */
+void QJU_PrintPromiseRejection(JSContext *ctx, JSValueConst promise,
+                               JSValueConst reason, JS_BOOL is_handled,
+                               void *opaque);
+
+#endif /* ifndef QUICKJS_UTILS_H */