visaljs 0.0.0-stage → 0.0.2

package/runtime/include/js_core.def

@@ -0,0 +1,188 @@
+/*
+ * js_core.def — the core built-in methods a program installs only when it names them
+ * (ADR 0014), in V8's order. One line per property:
+ *
+ *   JS_CORE_FN(target, "name", native, length)        a method
+ *   JS_CORE_ACCESSOR(target, "name", getter, setter)   an accessor
+ *   JS_CORE_NUMBER(target, "name", value)              a constant (read-only, fixed)
+ *   JS_CORE_ALIAS(target, "name", "earlier")           the same function as an earlier entry
+ *   JS_CORE_ALIAS_OF(target, "name", from, "earlier")  the same, from an earlier entry on `from`
+ *   JS_CORE_SYMBOL_GETTER(target, symbol, getter)      a well-known-symbol getter (always installed)
+ *   JS_CORE_SYMBOL_ALIAS(target, symbol, "earlier")    a well-known-symbol alias (always installed)
+ *
+ * Included by js_builtins.h (to declare the natives), by runtime/src/core_all.c (every entry,
+ * for the test hosts) and parsed by the compiler (compiler/src/emit/core.ts), which emits the
+ * entries a program names into its C file. No #include guard: it is read several times.
+ */
+
+/* Object (§20.1) */
+JS_CORE_FN(OBJECT, "assign", object_assign, 2)
+JS_CORE_FN(OBJECT, "getOwnPropertyDescriptor", object_get_own_property_descriptor, 2)
+JS_CORE_FN(OBJECT, "getOwnPropertyDescriptors", object_get_own_property_descriptors, 1)
+JS_CORE_FN(OBJECT, "getOwnPropertyNames", object_get_own_property_names, 1)
+JS_CORE_FN(OBJECT, "getOwnPropertySymbols", object_get_own_property_symbols, 1)
+JS_CORE_FN(OBJECT, "hasOwn", object_has_own, 2)
+JS_CORE_FN(OBJECT, "is", object_is, 2)
+JS_CORE_FN(OBJECT, "preventExtensions", object_prevent_extensions, 1)
+JS_CORE_FN(OBJECT, "seal", object_seal, 1)
+JS_CORE_FN(OBJECT, "create", object_create, 2)
+JS_CORE_FN(OBJECT, "defineProperties", object_define_properties, 2)
+JS_CORE_FN(OBJECT, "defineProperty", object_define_property, 3)
+JS_CORE_FN(OBJECT, "freeze", object_freeze, 1)
+JS_CORE_FN(OBJECT, "getPrototypeOf", object_get_prototype_of, 1)
+JS_CORE_FN(OBJECT, "setPrototypeOf", object_set_prototype_of, 2)
+JS_CORE_FN(OBJECT, "isExtensible", object_is_extensible, 1)
+JS_CORE_FN(OBJECT, "isFrozen", object_is_frozen, 1)
+JS_CORE_FN(OBJECT, "isSealed", object_is_sealed, 1)
+JS_CORE_FN(OBJECT, "keys", object_keys, 1)
+JS_CORE_FN(OBJECT, "entries", object_entries, 1)
+JS_CORE_FN(OBJECT, "fromEntries", object_from_entries, 1)
+JS_CORE_FN(OBJECT, "values", object_values, 1)
+JS_CORE_FN(OBJECT, "groupBy", object_group_by, 2)
+JS_CORE_FN(OBJECT_PROTO, "__defineGetter__", object_proto_define_getter, 2)
+JS_CORE_FN(OBJECT_PROTO, "__defineSetter__", object_proto_define_setter, 2)
+JS_CORE_FN(OBJECT_PROTO, "hasOwnProperty", object_proto_has_own_property, 1)
+JS_CORE_FN(OBJECT_PROTO, "__lookupGetter__", object_proto_lookup_getter, 1)
+JS_CORE_FN(OBJECT_PROTO, "__lookupSetter__", object_proto_lookup_setter, 1)
+JS_CORE_FN(OBJECT_PROTO, "isPrototypeOf", object_proto_is_prototype_of, 1)
+JS_CORE_FN(OBJECT_PROTO, "propertyIsEnumerable", object_proto_property_is_enumerable, 1)
+JS_CORE_FN(OBJECT_PROTO, "toString", object_proto_to_string, 0)
+JS_CORE_FN(OBJECT_PROTO, "valueOf", object_proto_value_of, 0)
+JS_CORE_ACCESSOR(OBJECT_PROTO, "__proto__", object_proto_get_proto, object_proto_set_proto)
+JS_CORE_FN(OBJECT_PROTO, "toLocaleString", object_proto_to_locale_string, 0)
+
+/* Array (§23.1) */
+JS_CORE_FN(ARRAY, "isArray", array_is_array, 1)
+JS_CORE_FN(ARRAY, "from", array_from, 1)
+JS_CORE_FN(ARRAY, "of", array_of, 0)
+JS_CORE_FN(ARRAY, "fromAsync", array_from_async, 1)
+JS_CORE_SYMBOL_GETTER(ARRAY, species, array_species)
+JS_CORE_FN(ARRAY_PROTO, "at", array_proto_at, 1)
+JS_CORE_FN(ARRAY_PROTO, "concat", array_proto_concat, 1)
+JS_CORE_FN(ARRAY_PROTO, "copyWithin", array_proto_copy_within, 2)
+JS_CORE_FN(ARRAY_PROTO, "fill", array_proto_fill, 1)
+JS_CORE_FN(ARRAY_PROTO, "find", array_proto_find, 1)
+JS_CORE_FN(ARRAY_PROTO, "findIndex", array_proto_find_index, 1)
+JS_CORE_FN(ARRAY_PROTO, "findLast", array_proto_find_last, 1)
+JS_CORE_FN(ARRAY_PROTO, "findLastIndex", array_proto_find_last_index, 1)
+JS_CORE_FN(ARRAY_PROTO, "lastIndexOf", array_proto_last_index_of, 1)
+JS_CORE_FN(ARRAY_PROTO, "pop", array_proto_pop, 0)
+JS_CORE_FN(ARRAY_PROTO, "push", array_proto_push, 1)
+JS_CORE_FN(ARRAY_PROTO, "reverse", array_proto_reverse, 0)
+JS_CORE_FN(ARRAY_PROTO, "shift", array_proto_shift, 0)
+JS_CORE_FN(ARRAY_PROTO, "unshift", array_proto_unshift, 1)
+JS_CORE_FN(ARRAY_PROTO, "slice", array_proto_slice, 2)
+JS_CORE_FN(ARRAY_PROTO, "sort", array_proto_sort, 1)
+JS_CORE_FN(ARRAY_PROTO, "splice", array_proto_splice, 2)
+JS_CORE_FN(ARRAY_PROTO, "includes", array_proto_includes, 1)
+JS_CORE_FN(ARRAY_PROTO, "indexOf", array_proto_index_of, 1)
+JS_CORE_FN(ARRAY_PROTO, "join", array_proto_join, 1)
+JS_CORE_FN(ARRAY_PROTO, "keys", array_proto_keys, 0)
+JS_CORE_FN(ARRAY_PROTO, "entries", array_proto_entries, 0)
+JS_CORE_FN(ARRAY_PROTO, "values", array_proto_values, 0)
+JS_CORE_FN(ARRAY_PROTO, "forEach", array_proto_for_each, 1)
+JS_CORE_FN(ARRAY_PROTO, "filter", array_proto_filter, 1)
+JS_CORE_FN(ARRAY_PROTO, "flat", array_proto_flat, 0)
+JS_CORE_FN(ARRAY_PROTO, "flatMap", array_proto_flat_map, 1)
+JS_CORE_FN(ARRAY_PROTO, "map", array_proto_map, 1)
+JS_CORE_FN(ARRAY_PROTO, "every", array_proto_every, 1)
+JS_CORE_FN(ARRAY_PROTO, "some", array_proto_some, 1)
+JS_CORE_FN(ARRAY_PROTO, "reduce", array_proto_reduce, 1)
+JS_CORE_FN(ARRAY_PROTO, "reduceRight", array_proto_reduce_right, 1)
+JS_CORE_FN(ARRAY_PROTO, "toReversed", array_proto_to_reversed, 0)
+JS_CORE_FN(ARRAY_PROTO, "toSorted", array_proto_to_sorted, 1)
+JS_CORE_FN(ARRAY_PROTO, "toSpliced", array_proto_to_spliced, 2)
+JS_CORE_FN(ARRAY_PROTO, "with", array_proto_with, 2)
+JS_CORE_FN(ARRAY_PROTO, "toLocaleString", array_proto_to_locale_string, 0)
+JS_CORE_FN(ARRAY_PROTO, "toString", array_proto_to_string, 0)
+JS_CORE_SYMBOL_ALIAS(ARRAY_PROTO, iterator, "values")
+
+/* String (§22.1) */
+JS_CORE_FN(STRING, "fromCharCode", string_from_char_code, 1)
+JS_CORE_FN(STRING, "fromCodePoint", string_from_code_point, 1)
+JS_CORE_FN(STRING, "raw", string_raw, 1)
+JS_CORE_FN(STRING_PROTO, "anchor", string_html_anchor, 1)
+JS_CORE_FN(STRING_PROTO, "at", string_proto_at, 1)
+JS_CORE_FN(STRING_PROTO, "big", string_html_big, 0)
+JS_CORE_FN(STRING_PROTO, "blink", string_html_blink, 0)
+JS_CORE_FN(STRING_PROTO, "bold", string_html_bold, 0)
+JS_CORE_FN(STRING_PROTO, "charAt", string_proto_char_at, 1)
+JS_CORE_FN(STRING_PROTO, "charCodeAt", string_proto_char_code_at, 1)
+JS_CORE_FN(STRING_PROTO, "codePointAt", string_proto_code_point_at, 1)
+JS_CORE_FN(STRING_PROTO, "concat", string_proto_concat, 1)
+JS_CORE_FN(STRING_PROTO, "endsWith", string_proto_ends_with, 1)
+JS_CORE_FN(STRING_PROTO, "fontcolor", string_html_fontcolor, 1)
+JS_CORE_FN(STRING_PROTO, "fontsize", string_html_fontsize, 1)
+JS_CORE_FN(STRING_PROTO, "fixed", string_html_fixed, 0)
+JS_CORE_FN(STRING_PROTO, "includes", string_proto_includes, 1)
+JS_CORE_FN(STRING_PROTO, "indexOf", string_proto_index_of, 1)
+JS_CORE_FN(STRING_PROTO, "isWellFormed", string_proto_is_well_formed, 0)
+JS_CORE_FN(STRING_PROTO, "italics", string_html_italics, 0)
+JS_CORE_FN(STRING_PROTO, "lastIndexOf", string_proto_last_index_of, 1)
+JS_CORE_FN(STRING_PROTO, "link", string_html_link, 1)
+JS_CORE_FN(STRING_PROTO, "localeCompare", string_proto_locale_compare, 1)
+JS_CORE_FN(STRING_PROTO, "match", string_proto_match, 1)
+JS_CORE_FN(STRING_PROTO, "matchAll", string_proto_match_all, 1)
+JS_CORE_FN(STRING_PROTO, "normalize", string_proto_normalize, 0)
+JS_CORE_FN(STRING_PROTO, "padEnd", string_proto_pad_end, 1)
+JS_CORE_FN(STRING_PROTO, "padStart", string_proto_pad_start, 1)
+JS_CORE_FN(STRING_PROTO, "repeat", string_proto_repeat, 1)
+JS_CORE_FN(STRING_PROTO, "replace", string_proto_replace, 2)
+JS_CORE_FN(STRING_PROTO, "replaceAll", string_proto_replace_all, 2)
+JS_CORE_FN(STRING_PROTO, "search", string_proto_search, 1)
+JS_CORE_FN(STRING_PROTO, "slice", string_proto_slice, 2)
+JS_CORE_FN(STRING_PROTO, "small", string_html_small, 0)
+JS_CORE_FN(STRING_PROTO, "split", string_proto_split, 2)
+JS_CORE_FN(STRING_PROTO, "strike", string_html_strike, 0)
+JS_CORE_FN(STRING_PROTO, "sub", string_html_sub, 0)
+JS_CORE_FN(STRING_PROTO, "substr", string_proto_substr, 2)
+JS_CORE_FN(STRING_PROTO, "substring", string_proto_substring, 2)
+JS_CORE_FN(STRING_PROTO, "sup", string_html_sup, 0)
+JS_CORE_FN(STRING_PROTO, "startsWith", string_proto_starts_with, 1)
+JS_CORE_FN(STRING_PROTO, "toString", string_proto_to_string, 0)
+JS_CORE_FN(STRING_PROTO, "toWellFormed", string_proto_to_well_formed, 0)
+JS_CORE_FN(STRING_PROTO, "trim", string_proto_trim, 0)
+JS_CORE_FN(STRING_PROTO, "trimStart", string_proto_trim_start, 0)
+JS_CORE_ALIAS(STRING_PROTO, "trimLeft", "trimStart")
+JS_CORE_FN(STRING_PROTO, "trimEnd", string_proto_trim_end, 0)
+JS_CORE_ALIAS(STRING_PROTO, "trimRight", "trimEnd")
+JS_CORE_FN(STRING_PROTO, "toLocaleLowerCase", string_proto_to_locale_lower_case, 0)
+JS_CORE_FN(STRING_PROTO, "toLocaleUpperCase", string_proto_to_locale_upper_case, 0)
+JS_CORE_FN(STRING_PROTO, "toLowerCase", string_proto_to_lower_case, 0)
+JS_CORE_FN(STRING_PROTO, "toUpperCase", string_proto_to_upper_case, 0)
+JS_CORE_FN(STRING_PROTO, "valueOf", string_proto_value_of, 0)
+
+/* Number (§21.1) */
+JS_CORE_FN(NUMBER, "isFinite", number_is_finite, 1)
+JS_CORE_FN(NUMBER, "isInteger", number_is_integer, 1)
+JS_CORE_FN(NUMBER, "isNaN", number_is_nan, 1)
+JS_CORE_FN(NUMBER, "isSafeInteger", number_is_safe_integer, 1)
+JS_CORE_FN(NUMBER, "parseFloat", number_parse_float, 1)
+JS_CORE_FN(NUMBER, "parseInt", number_parse_int, 2)
+JS_CORE_NUMBER(NUMBER, "MAX_VALUE", 1.7976931348623157e308)
+JS_CORE_NUMBER(NUMBER, "MIN_VALUE", 5e-324)
+JS_CORE_NUMBER(NUMBER, "NaN", NAN)
+JS_CORE_NUMBER(NUMBER, "NEGATIVE_INFINITY", -INFINITY)
+JS_CORE_NUMBER(NUMBER, "POSITIVE_INFINITY", INFINITY)
+JS_CORE_NUMBER(NUMBER, "MAX_SAFE_INTEGER", 9007199254740991.0)
+JS_CORE_NUMBER(NUMBER, "MIN_SAFE_INTEGER", -9007199254740991.0)
+JS_CORE_NUMBER(NUMBER, "EPSILON", 2.220446049250313e-16)
+JS_CORE_FN(NUMBER_PROTO, "toExponential", number_proto_to_exponential, 1)
+JS_CORE_FN(NUMBER_PROTO, "toFixed", number_proto_to_fixed, 1)
+JS_CORE_FN(NUMBER_PROTO, "toPrecision", number_proto_to_precision, 1)
+JS_CORE_FN(NUMBER_PROTO, "toString", number_proto_to_string, 1)
+JS_CORE_FN(NUMBER_PROTO, "valueOf", number_proto_value_of, 0)
+JS_CORE_FN(NUMBER_PROTO, "toLocaleString", number_proto_to_locale_string, 0)
+
+/* The global functions on numbers (§19.2): parseFloat and parseInt are Number's */
+JS_CORE_ALIAS_OF(GLOBAL, "parseFloat", NUMBER, "parseFloat")
+JS_CORE_ALIAS_OF(GLOBAL, "parseInt", NUMBER, "parseInt")
+JS_CORE_FN(GLOBAL, "eval", global_eval, 1)
+JS_CORE_FN(GLOBAL, "isNaN", global_is_nan, 1)
+JS_CORE_FN(GLOBAL, "isFinite", global_is_finite, 1)
+
+/* The URI handling functions (§19.2.6) */
+JS_CORE_FN(GLOBAL, "decodeURI", global_decode_uri, 1)
+JS_CORE_FN(GLOBAL, "decodeURIComponent", global_decode_uri_component, 1)
+JS_CORE_FN(GLOBAL, "encodeURI", global_encode_uri, 1)
+JS_CORE_FN(GLOBAL, "encodeURIComponent", global_encode_uri_component, 1)

package/runtime/include/js_crypto.h

@@ -0,0 +1,58 @@
+/* js_crypto.h — crypto (ADR 0018): node:crypto's host primitives, which node/index.ts lists for
+ * the compiler (generated code declares the ones a program uses), and what the crypto
+ * component shares with them. The primitives are the runtime's, as Web Crypto runs on the same
+ * C (runtime/src/crypto_internal.h). */
+#ifndef JS_CRYPTO_H
+#define JS_CRYPTO_H
+
+#include "js_function.h"
+
+/* A version 4 UUID, lowercase (crypto.randomUUID). */
+JS_WARN_UNUSED JSValue js_crypto_random_uuid(JSContext *ctx);
+
+#define JS_CRYPTO_PRIMITIVE(fn) \
+    JSValue fn(JSContext *ctx, JSValue callee, JSValue this_val, uint32_t argc, const JSValue *argv, JSValue new_target);
+JS_CRYPTO_PRIMITIVE(js_crypto_hash_new)
+JS_CRYPTO_PRIMITIVE(js_crypto_hash_info)
+JS_CRYPTO_PRIMITIVE(js_crypto_hash_copy)
+JS_CRYPTO_PRIMITIVE(js_crypto_hmac_new)
+JS_CRYPTO_PRIMITIVE(js_crypto_digest_update)
+JS_CRYPTO_PRIMITIVE(js_crypto_digest_final)
+JS_CRYPTO_PRIMITIVE(js_crypto_random_fill)
+JS_CRYPTO_PRIMITIVE(js_crypto_host_random_uuid)
+JS_CRYPTO_PRIMITIVE(js_crypto_timing_safe_equal)
+JS_CRYPTO_PRIMITIVE(js_crypto_hashes)
+JS_CRYPTO_PRIMITIVE(js_crypto_pbkdf2)
+JS_CRYPTO_PRIMITIVE(js_crypto_hkdf)
+JS_CRYPTO_PRIMITIVE(js_crypto_scrypt_check)
+JS_CRYPTO_PRIMITIVE(js_crypto_scrypt)
+JS_CRYPTO_PRIMITIVE(js_crypto_cipher_new)
+JS_CRYPTO_PRIMITIVE(js_crypto_cipher_update)
+JS_CRYPTO_PRIMITIVE(js_crypto_cipher_final)
+JS_CRYPTO_PRIMITIVE(js_crypto_cipher_set_aad)
+JS_CRYPTO_PRIMITIVE(js_crypto_cipher_set_auth_tag)
+JS_CRYPTO_PRIMITIVE(js_crypto_cipher_get_auth_tag)
+JS_CRYPTO_PRIMITIVE(js_crypto_cipher_set_padding)
+JS_CRYPTO_PRIMITIVE(js_crypto_cipher_info)
+JS_CRYPTO_PRIMITIVE(js_crypto_ciphers)
+JS_CRYPTO_PRIMITIVE(js_crypto_key_parse)
+JS_CRYPTO_PRIMITIVE(js_crypto_key_export)
+JS_CRYPTO_PRIMITIVE(js_crypto_key_info)
+JS_CRYPTO_PRIMITIVE(js_crypto_key_parts)
+JS_CRYPTO_PRIMITIVE(js_crypto_key_from_parts)
+JS_CRYPTO_PRIMITIVE(js_crypto_key_public)
+JS_CRYPTO_PRIMITIVE(js_crypto_key_equals)
+JS_CRYPTO_PRIMITIVE(js_crypto_key_secret)
+JS_CRYPTO_PRIMITIVE(js_crypto_key_secret_bytes)
+JS_CRYPTO_PRIMITIVE(js_crypto_key_generate)
+JS_CRYPTO_PRIMITIVE(js_crypto_key_handle_of)
+JS_CRYPTO_PRIMITIVE(js_crypto_to_crypto_key)
+JS_CRYPTO_PRIMITIVE(js_crypto_sign)
+JS_CRYPTO_PRIMITIVE(js_crypto_verify)
+JS_CRYPTO_PRIMITIVE(js_crypto_rsa_crypt)
+JS_CRYPTO_PRIMITIVE(js_crypto_ecdh)
+JS_CRYPTO_PRIMITIVE(js_crypto_ec_point)
+JS_CRYPTO_PRIMITIVE(js_crypto_ec_private)
+#undef JS_CRYPTO_PRIMITIVE
+
+#endif /* JS_CRYPTO_H */

package/runtime/include/js_error.h

@@ -0,0 +1,37 @@
+/*
+ * js_error.h — Error objects (ECMAScript §20.5; ADR 0004).
+ *
+ * An error is an ordinary object of class js_class_error (it has [[ErrorData]]).
+ * The js_throw_*_error helpers in js_exception.h create and throw them.
+ */
+#ifndef JS_ERROR_H
+#define JS_ERROR_H
+
+#include "js_function.h"
+
+/* The native errors, in the order of their JS_INTRINSIC_*_PROTOTYPE slots. */
+typedef enum JSErrorKind {
+    JS_ERROR,
+    JS_EVAL_ERROR,
+    JS_RANGE_ERROR,
+    JS_REFERENCE_ERROR,
+    JS_SYNTAX_ERROR,
+    JS_TYPE_ERROR,
+    JS_URI_ERROR,
+    JS_AGGREGATE_ERROR,  /* §20.5.7: its constructor takes the errors first */
+    JS_ERROR_KIND_COUNT
+} JSErrorKind;
+
+extern const JSClass js_class_error;
+
+static inline bool js_is_error(JSValue v) {
+    return js_is_object(v) && js_as_object(v)->shape->cls == &js_class_error;
+}
+
+/* A new error of `kind` in ctx's realm; `message` is a string, or undefined for none. */
+JSValue js_new_error(JSContext *ctx, JSErrorKind kind, JSValue message);
+
+/* Error.prototype.toString on any object: "name: message", either part omitted when empty. */
+JS_WARN_UNUSED JSValue js_error_to_string(JSContext *ctx, JSValue o);
+
+#endif /* JS_ERROR_H */

package/runtime/include/js_exception.h

@@ -0,0 +1,65 @@
+/*
+ * js_exception.h — exception propagation (ADR 0004).
+ *
+ * A function that fails returns JS_EXCEPTION (or < 0 for int results) and
+ * leaves the error in ctx->rt->exception. Callers check and propagate.
+ *
+ * The js_throw_*_error helpers create an Error object of the calling realm
+ * (js_error.h) with the formatted message, and throw it.
+ */
+#ifndef JS_EXCEPTION_H
+#define JS_EXCEPTION_H
+
+#include <assert.h>
+#include <stdbool.h>
+
+#include "jscontext.h"
+
+/* ---- Throwing: set the pending exception, return JS_EXCEPTION ---------- */
+
+/* Prints "jsrt: fatal: <message>" in one write and exits with status 70 (out of memory, broken
+ * invariants). Public for host packages (node/). */
+_Noreturn void js_fatal(const char *fmt, ...);
+
+JS_WARN_UNUSED JSValue js_throw(JSContext *ctx, JSValue error);
+JS_WARN_UNUSED JSValue js_throw_type_error(JSContext *ctx, const char *fmt, ...);
+JS_WARN_UNUSED JSValue js_throw_range_error(JSContext *ctx, const char *fmt, ...);
+JS_WARN_UNUSED JSValue js_throw_reference_error(JSContext *ctx, const char *fmt, ...);
+JS_WARN_UNUSED JSValue js_throw_syntax_error(JSContext *ctx, const char *fmt, ...);
+JS_WARN_UNUSED JSValue js_throw_uri_error(JSContext *ctx, const char *fmt, ...);
+JS_WARN_UNUSED JSValue js_throw_stack_overflow(JSContext *ctx);  /* RangeError: Maximum call stack size exceeded */
+
+/* ---- Catching ---------------------------------------------------------- */
+
+/* Returns the pending error and clears it. A catch or finally calls this first. */
+JSValue js_take_exception(JSContext *ctx);
+
+static inline bool js_has_exception(const JSContext *ctx) {
+    return !js_is_empty(ctx->rt->exception);
+}
+
+/* For hand-written runtime code; generated code writes the check itself. */
+#define JS_RETURN_IF_EXC(v) \
+    do { if (js_is_exception(v)) return JS_EXCEPTION; } while (0)
+
+/* Debug builds: a JS_EXCEPTION received as an argument means a missed check upstream. */
+#define JS_ASSERT_NOT_EXC(v) assert(!js_is_exception(v) && "missed exception check")
+
+/* ---- Stack overflow ---------------------------------------------------- */
+
+#if defined(_MSC_VER) && !defined(__clang__)
+#include <intrin.h>
+#define JS_FRAME_ADDRESS() ((uintptr_t)_AddressOfReturnAddress())
+#else
+#define JS_FRAME_ADDRESS() ((uintptr_t)__builtin_frame_address(0))
+#endif
+
+/* At the entry of every non-leaf generated function, and of runtime code
+ * that recurses on user data. */
+#define JS_CHECK_STACK(ctx)                                                   \
+    do {                                                                      \
+        if (JS_UNLIKELY(JS_FRAME_ADDRESS() < (ctx)->stack_limit))             \
+            return js_throw_stack_overflow(ctx);                              \
+    } while (0)
+
+#endif /* JS_EXCEPTION_H */

package/runtime/include/js_function.h

@@ -0,0 +1,167 @@
+/*
+ * js_function.h — function objects and calls (ADR 0006).
+ *
+ * A function is an object (a JSFunction cell). Every function has a generic
+ * entry with one signature; compiled functions also have a direct entry the
+ * compiler calls when it knows the callee.
+ */
+#ifndef JS_FUNCTION_H
+#define JS_FUNCTION_H
+
+#include "js_object.h"
+
+/* The generic entry (ADR 0006): `this_val` is raw (coercion happens in the
+ * callee); `new_target` is undefined for [[Call]], the constructor for [[Construct]]. */
+typedef JSValue (*JSNativeFn)(JSContext *ctx, JSValue callee, JSValue this_val,
+                              uint32_t argc, const JSValue *argv, JSValue new_target);
+
+/* JSFunction.flags */
+#define JS_FN_STRICT       0x01u
+#define JS_FN_CONSTRUCTOR  0x02u  /* has [[Construct]] */
+#define JS_FN_ORDINARY     0x04u  /* compiled ordinary function: [[Construct]] creates `this` (OrdinaryCreateFromConstructor) */
+#define JS_FN_ARROW        0x08u
+#define JS_FN_CLASS_CTOR   0x10u  /* throws when called without new */
+#define JS_FN_DERIVED      0x20u  /* a derived class constructor: [[Construct]] doesn't create `this` (super() does) */
+#define JS_FN_BOUND        0x40u  /* a bound function (Function.prototype.bind): home_object is the target */
+#define JS_FN_GENERATOR    0x80u  /* function* (ADR 0007): its [[Prototype]] and `prototype` differ */
+#define JS_FN_ASYNC        0x100u /* async function (ADR 0007): [[Prototype]] %AsyncFunction.prototype% */
+#define JS_FN_PROXY        0x200u /* a callable proxy: it runs in its caller's realm */
+
+/* Emitted by the compiler as static const data, one per function in the source. */
+typedef struct JSFunctionInfo {
+    JSNativeFn      generic;
+    const JSString *name;         /* a static string cell */
+    uint32_t        length;       /* params before the first default or rest */
+    uint32_t        flags;        /* JS_FN_* */
+    const JSString *source_text;  /* the module's whole source (static); NULL for builtins */
+    const char     *file;
+    uint32_t        source_start; /* Function.prototype.toString: this function's slice of it */
+    uint32_t        source_length;
+} JSFunctionInfo;
+
+/* A scope's captured variables (ADR 0006, "Closures"): one cell per scope that has
+ * any, linked to the enclosing scope's. Generated code reaches a variable by a static
+ * (depth, slot). Slots start EMPTY (zeroed memory): uninitialized let/const. */
+typedef struct JSEnv {            /* kind = ENV */
+    JSCell         cell;          /* aux = number of slots */
+    struct JSEnv  *parent;        /* NULL at the outermost */
+    JSValue        vars[];
+} JSEnv;
+
+/* The environment in a JSValue: generated code keeps it in an ordinary C local. */
+static inline JSEnv *js_as_env(JSValue v) { return js_is_cell(v) ? (JSEnv *)js_as_cell(v) : NULL; }
+
+/* A new environment of `count` slots (EMPTY) whose parent is `parent` (an environment or undefined). */
+JSValue js_new_env(JSContext *ctx, JSValue parent, uint32_t count);
+/* A copy with the same parent and values: `for (let …)` gives each iteration its own (§14.7.4.4). */
+JSValue js_env_copy(JSContext *ctx, JSValue env);
+
+static inline JSEnv *js_env_up(JSValue env, uint32_t depth) {
+    JSEnv *e = js_as_env(env);
+    while (depth--) e = e->parent;
+    return e;
+}
+static inline JSValue js_env_get(JSValue env, uint32_t depth, uint32_t slot) {
+    return js_env_up(env, depth)->vars[slot];
+}
+static inline void js_env_set(JSContext *ctx, JSValue env, uint32_t depth, uint32_t slot, JSValue v) {
+    JSEnv *e = js_env_up(env, depth);
+    js_store(ctx, &e->cell, &e->vars[slot], v);
+}
+
+typedef struct JSFunction {       /* kind = FUNCTION */
+    JSObject               obj;
+    JSNativeFn             entry;        /* copy of info->generic: one load at call time */
+    const JSFunctionInfo  *info;         /* NULL for builtins created at runtime */
+    struct JSEnv          *env;          /* captured scope (M4), or NULL */
+    JSValue                home_object;  /* methods: where `super` looks (M4) */
+    JSValue                bound_this;   /* arrows: the captured `this`, else EMPTY (M4) */
+    JSContext             *realm;        /* the realm the function was created in (ADR 0011) */
+    uint32_t               flags;
+    uint32_t               pad_;
+} JSFunction;
+
+extern const JSClass js_class_function;
+
+static inline bool js_is_function(JSValue v) {
+    return js_is_cell(v) && js_as_cell(v)->kind == JS_CELL_FUNCTION;
+}
+static inline JSFunction *js_as_function(JSValue v) { return (JSFunction *)js_as_cell(v); }
+
+/* IsCallable / IsConstructor (Proxy and bound functions arrive later). */
+static inline bool js_is_callable(JSValue v) { return js_is_function(v); }
+static inline bool js_is_constructor(JSValue v) {
+    return js_is_function(v) && (js_as_function(v)->flags & JS_FN_CONSTRUCTOR);
+}
+
+/* A function object for compiled code: name and length from `info`. */
+JSValue js_new_function(JSContext *ctx, const JSFunctionInfo *info);
+/* The same, closing over `env` (an environment, or undefined for none). */
+JSValue js_new_closure(JSContext *ctx, const JSFunctionInfo *info, JSValue env);
+/* The environment a closure captured, as a JSValue (undefined if none): for generic entries. */
+static inline JSValue js_function_env(JSValue f) {
+    JSEnv *e = js_as_function(f)->env;
+    return e ? js_cell(&e->cell) : JS_UNDEFINED;
+}
+/* A builtin: `name` is a string, `flags` JS_FN_*. Constructors get no automatic
+ * `prototype`: builtins define theirs. */
+JSValue js_new_native(JSContext *ctx, JSNativeFn fn, JSValue name, uint32_t length, uint32_t flags);
+/* Defines a builtin method `name` on `o` (writable, configurable, not enumerable). */
+JSValue js_define_method(JSContext *ctx, JSObject *o, const char *name, JSNativeFn fn, uint32_t length);
+
+/* [[Call]] and [[Construct]]. `callee_text` names the callee in "x is not a function"
+ * (the source text at a call site; NULL for runtime callers). */
+JS_WARN_UNUSED JSValue js_call(JSContext *ctx, JSValue f, JSValue this_val, uint32_t argc, const JSValue *argv);
+JS_WARN_UNUSED JSValue js_call_site(JSContext *ctx, JSValue f, JSValue this_val, uint32_t argc, const JSValue *argv, const char *callee_text);
+JS_WARN_UNUSED JSValue js_construct(JSContext *ctx, JSValue f, uint32_t argc, const JSValue *argv, JSValue new_target, const char *callee_text);
+/* The same with the arguments in an array (a call with spreads). */
+JS_WARN_UNUSED JSValue js_call_spread(JSContext *ctx, JSValue f, JSValue this_val, JSValue args, const char *callee_text);
+JS_WARN_UNUSED JSValue js_construct_spread(JSContext *ctx, JSValue f, JSValue args, const char *callee_text);
+
+/* GetPrototypeFromConstructor: new_target.prototype, or the intrinsic `fallback`
+ * of new_target's realm if that isn't an object. */
+/* GetFunctionRealm: f's realm (a proxy's target's), ctx for non-functions; NULL with a TypeError for a revoked proxy. */
+JSContext *js_function_realm(JSContext *ctx, JSValue f);
+JS_WARN_UNUSED JSValue js_get_prototype_from_constructor(JSContext *ctx, JSValue new_target, JSIntrinsic fallback);
+/* OrdinaryCreateFromConstructor: an ordinary object with that prototype. */
+JS_WARN_UNUSED JSValue js_create_from_constructor(JSContext *ctx, JSValue new_target, JSIntrinsic fallback);
+
+/* An arguments object (§10.4.4) from the array of actual arguments. `slots` (static,
+ * from the compiler) maps index i < nmapped to its parameter's slot in `env`, UINT32_MAX
+ * for none: a mapped (sloppy) object. NULL: unmapped, with a throwing `callee`. */
+extern const JSClass js_class_arguments;
+JSValue js_new_arguments(JSContext *ctx, JSValue args, JSValue callee, JSValue env, const uint32_t *slots, uint32_t nmapped);
+bool js_is_arguments(JSValue v);
+
+/* ---- Classes (§15.7) and super ----------------------------------------------------- */
+
+/* ClassDefinitionEvaluation steps 5–16: checks the heritage (EMPTY: none), makes the
+ * prototype (inheriting from heritage.prototype), links ctor to the parent class, sets
+ * ctor.prototype and prototype.constructor. Returns the prototype. */
+JS_WARN_UNUSED JSValue js_class_setup(JSContext *ctx, JSValue ctor, JSValue heritage);
+/* A method's [[HomeObject]]: where `super` looks. */
+void js_set_home_object(JSContext *ctx, JSValue fn, JSValue home);
+/* A class method (0), getter (1) or setter (2): not enumerable. */
+void js_define_class_member(JSContext *ctx, JSObject *target, JSValue key, int kind, JSValue fn);
+/* super[key] and super[key] = v, from the function whose home object's prototype holds them. */
+JS_WARN_UNUSED JSValue js_super_get(JSContext *ctx, JSValue callee, JSValue key, JSValue this_val);
+JS_WARN_UNUSED int js_super_set(JSContext *ctx, JSValue callee, JSValue key, JSValue v, JSValue this_val);
+/* super(...args): constructs the constructor's own [[Prototype]] (the parent class). */
+JS_WARN_UNUSED JSValue js_super_construct(JSContext *ctx, JSValue callee, JSValue new_target, uint32_t argc, const JSValue *argv);
+JS_WARN_UNUSED JSValue js_super_construct_spread(JSContext *ctx, JSValue callee, JSValue new_target, JSValue args);
+/* Binding `this` after super(): a ReferenceError if it already was. */
+JS_WARN_UNUSED JSValue js_bind_this(JSContext *ctx, JSValue current, JSValue v);
+/* A derived constructor's `this`: a ReferenceError before super(). */
+JS_WARN_UNUSED JSValue js_check_this(JSContext *ctx, JSValue this_val);
+/* What `return v` in a derived constructor produces: v if an object, else this (if bound). */
+JS_WARN_UNUSED JSValue js_derived_return(JSContext *ctx, JSValue v, JSValue this_val);
+
+/* Function.prototype.bind's result (§10.4.1). */
+JS_WARN_UNUSED JSValue js_bind_function(JSContext *ctx, JSValue target, JSValue bound_this, uint32_t argc, const JSValue *argv);
+
+/* instanceof (InstanceofOperator: @@hasInstance, else OrdinaryHasInstance) and `in`. */
+JS_WARN_UNUSED JSValue js_instanceof(JSContext *ctx, JSValue v, JSValue target);
+JS_WARN_UNUSED JSValue js_ordinary_has_instance(JSContext *ctx, JSValue target, JSValue v);
+JS_WARN_UNUSED JSValue js_in(JSContext *ctx, JSValue key, JSValue obj);
+
+#endif /* JS_FUNCTION_H */