@suchipi/quickjs 0.8.1 → 0.10.0

package/build/aarch64-unknown-linux-musl/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-unknown-linux-musl/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-unknown-linux-musl/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-unknown-linux-musl/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-unknown-linux-musl/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-unknown-linux-musl/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-unknown-linux-musl/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-unknown-linux-musl/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-unknown-linux-musl/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-unknown-linux-musl/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-unknown-linux-musl/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-unknown-linux-musl/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-unknown-linux-musl/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 */