visaljs 0.0.0-stage → 0.0.2

package/runtime/src/convert.c

@@ -0,0 +1,82 @@
+/* Type conversions (ECMAScript §7.1). */
+#include "js_convert.h"
+
+#include <math.h>
+
+#include "js_atoms.h"
+#include "js_function.h"
+#include "js_symbol.h"
+#include "jsnum.h"
+
+/* ToPrimitive (§7.1.1): the object's @@toPrimitive if it has one, else OrdinaryToPrimitive
+ * (§7.1.1.1): valueOf then toString, or the reverse for strings. */
+JSValue js_to_primitive(JSContext *ctx, JSValue v, JSHint hint) {
+    JS_ASSERT_NOT_EXC(v);
+    if (!js_is_object(v)) return v;
+    JSValue exotic = js_get(ctx, js_as_object(v), JS_SYMBOL(toPrimitive), v);
+    if (js_is_exception(exotic)) return JS_EXCEPTION;
+    if (!js_is_nullish(exotic)) {
+        if (!js_is_callable(exotic)) return js_throw_type_error(ctx, "Symbol.toPrimitive is not a function");
+        JSValue h = hint == JS_HINT_STRING ? JS_ATOM(string) : hint == JS_HINT_NUMBER ? JS_ATOM(number) : JS_ATOM(default);
+        JSValue r = js_call(ctx, exotic, v, 1, &h);
+        if (js_is_exception(r)) return JS_EXCEPTION;
+        if (js_is_object(r)) return js_throw_type_error(ctx, "Cannot convert object to primitive value");
+        return r;
+    }
+    return js_ordinary_to_primitive(ctx, v, hint);
+}
+
+/* OrdinaryToPrimitive (§7.1.1.1): valueOf then toString, or the reverse for strings. */
+JSValue js_ordinary_to_primitive(JSContext *ctx, JSValue v, JSHint hint) {
+    JSValue order[2] = { JS_ATOM(valueOf), JS_ATOM(toString) };
+    if (hint == JS_HINT_STRING) {
+        order[0] = JS_ATOM(toString);
+        order[1] = JS_ATOM(valueOf);
+    }
+    for (int i = 0; i < 2; i++) {
+        JSValue method = js_get(ctx, js_as_object(v), order[i], v);
+        if (js_is_exception(method)) return JS_EXCEPTION;
+        if (!js_is_callable(method)) continue;
+        JSValue r = js_call(ctx, method, v, 0, NULL);
+        if (js_is_exception(r)) return JS_EXCEPTION;
+        if (!js_is_object(r)) return r;
+    }
+    return js_throw_type_error(ctx, "Cannot convert object to primitive value");
+}
+
+JSValue js_to_string(JSContext *ctx, JSValue v) {
+    JS_ASSERT_NOT_EXC(v);
+    if (js_is_string(v)) return v;
+    if (js_is_number(v)) return js_number_to_string(ctx, v);
+    if (js_is_undefined(v)) return JS_ATOM(undefined);
+    if (js_is_null(v)) return JS_ATOM(null);
+    if (js_is_bool(v)) return js_as_bool(v) ? JS_ATOM(true) : JS_ATOM(false);
+    if (js_is_object(v)) {
+        JSValue p = js_to_primitive(ctx, v, JS_HINT_STRING);
+        if (js_is_exception(p)) return JS_EXCEPTION;
+        return js_to_string(ctx, p);
+    }
+    if (js_is_symbol(v)) return js_throw_type_error(ctx, "Cannot convert a Symbol value to a string");
+    if (js_is_bigint(v)) return ctx->rt->bigint->to_string(ctx, v, 10);
+    return js_throw_type_error(ctx, "Cannot convert this value to a string");
+}
+
+int js_to_number(JSContext *ctx, double *out, JSValue v) {
+    JS_ASSERT_NOT_EXC(v);
+    if (js_is_number(v)) *out = js_as_number(v);
+    else if (js_is_string(v)) *out = js_str_to_num(js_string_view(ctx, v));
+    else if (js_is_undefined(v)) *out = NAN;
+    else if (js_is_null(v)) *out = 0;
+    else if (js_is_bool(v)) *out = js_as_bool(v);
+    else if (js_is_object(v)) {
+        JSValue p = js_to_primitive(ctx, v, JS_HINT_NUMBER);
+        if (js_is_exception(p)) return -1;
+        return js_to_number(ctx, out, p);
+    } else {
+        js_discard(js_throw_type_error(ctx, js_is_symbol(v)   ? "Cannot convert a Symbol value to a number"
+                                            : js_is_bigint(v) ? "Cannot convert a BigInt value to a number"
+                                                              : "Cannot convert this value to a number"));
+        return -1;
+    }
+    return 0;
+}

package/runtime/src/core_all.c

@@ -0,0 +1,21 @@
+/* Every core method (js_core.def), for the test hosts and --all-builtins (ADR 0014). Programs
+ * name theirs in their own C file, so this table is only linked when something calls
+ * js_use_all_core. */
+#include <math.h>
+
+#include "js_builtins.h"
+
+static const JSCoreEntry all[] = {
+#define JS_CORE_FN(...) JS_CORE_ENTRY_FN(__VA_ARGS__),
+#define JS_CORE_ACCESSOR(...) JS_CORE_ENTRY_ACCESSOR(__VA_ARGS__),
+#define JS_CORE_NUMBER(...) JS_CORE_ENTRY_NUMBER(__VA_ARGS__),
+#define JS_CORE_ALIAS(...) JS_CORE_ENTRY_ALIAS(__VA_ARGS__),
+#define JS_CORE_ALIAS_OF(...) JS_CORE_ENTRY_ALIAS_OF(__VA_ARGS__),
+#define JS_CORE_SYMBOL_GETTER(...) JS_CORE_ENTRY_SYMBOL_GETTER(__VA_ARGS__),
+#define JS_CORE_SYMBOL_ALIAS(...) JS_CORE_ENTRY_SYMBOL_ALIAS(__VA_ARGS__),
+#include "js_core.def"
+};
+
+void js_use_all_core(JSRuntime *rt) {
+    js_use_core(rt, all, JS_COUNTOF(all));
+}

package/runtime/src/crypto.c

@@ -0,0 +1,116 @@
+/* Web Crypto (W3C Web Cryptography API), the crypto component (ADR 0018), as Node has it: the
+ * `crypto` global (a Crypto: getRandomValues, randomUUID, subtle), SubtleCrypto
+ * (crypto_subtle.c) and CryptoKey (crypto_key.c). Node's errors (ERR_INVALID_THIS,
+ * ERR_MISSING_ARGS, the DOMExceptions) and its WebIDL attributes. */
+#include <stdio.h>
+#include <string.h>
+
+#include "builtins_util.h"
+#include "crypto_internal.h"
+#include "internal.h"
+#include "js_atoms.h"
+#include "js_buffer.h"
+#include "js_convert.h"
+#include "js_crypto.h"
+#include "js_exception.h"
+#include "js_promise.h"
+#include "js_web.h"
+#include "jscontext.h"
+#include "jsstring.h"
+
+static const JSClass crypto_class = { "Crypto", sizeof(JSObject), NULL, NULL, NULL, NULL, NULL, NULL, NULL };
+
+static bool is_crypto(JSValue v) { return js_is_object(v) && js_as_object(v)->shape->cls == &crypto_class; }
+
+BUILTIN(illegal_ctor) {
+    UNUSED_ARGS;
+    return js_throw_node_error(ctx, JS_TYPE_ERROR, "ERR_ILLEGAL_CONSTRUCTOR", "Illegal constructor");
+}
+
+/* WebIDL's argument count check: `Failed to execute 'digest' on 'SubtleCrypto': 2 arguments
+ * required, but only 1 present.` */
+static JSValue throw_missing_args(JSContext *ctx, const char *op, const char *iface, uint32_t need, uint32_t argc) {
+    return js_throw_node_error(ctx, JS_TYPE_ERROR, "ERR_MISSING_ARGS",
+                               "Failed to execute '%s' on '%s': %u argument%s required, but only %u present.", op, iface,
+                               need, need == 1 ? "" : "s", argc);
+}
+
+/* ---- Crypto ------------------------------------------------------------------------------------ */
+
+/* crypto.getRandomValues(typedArray): an integer typed array of at most 65,536 bytes, filled. */
+BUILTIN(get_random_values) {
+    (void)callee, (void)new_target;
+    if (!is_crypto(this_val)) return js_throw_invalid_this(ctx, "Crypto");
+    if (argc < 1) return throw_missing_args(ctx, "getRandomValues", "Crypto", 1, argc);
+    int type = js_typed_array_type(argv[0]);
+    if (type < 0 || type == JS_TA_FLOAT16 || type == JS_TA_FLOAT32 || type == JS_TA_FLOAT64)
+        return js_throw_dom_exception(ctx, "TypeMismatchError", "The data argument must be an integer-type TypedArray");
+    uint8_t *p;
+    size_t n;
+    js_buffer_source_bytes(argv[0], &p, &n);
+    if (n > 65536) return js_throw_dom_exception(ctx, "QuotaExceededError", "The requested length exceeds 65,536 bytes");
+    js_crypto_random(p, n);
+    return argv[0];
+}
+
+/* A version 4 UUID (RFC 9562 §5.4), lowercase. */
+JSValue js_crypto_random_uuid(JSContext *ctx) {
+    uint8_t b[16];
+    js_crypto_random(b, sizeof b);
+    b[6] = (uint8_t)((b[6] & 0x0F) | 0x40);
+    b[8] = (uint8_t)((b[8] & 0x3F) | 0x80);
+    static const char HEX[] = "0123456789abcdef";
+    uint8_t s[36];
+    size_t k = 0;
+    for (int i = 0; i < 16; i++) {
+        if (i == 4 || i == 6 || i == 8 || i == 10) s[k++] = '-';
+        s[k++] = (uint8_t)HEX[b[i] >> 4];
+        s[k++] = (uint8_t)HEX[b[i] & 15];
+    }
+    return js_new_string_latin1(ctx, s, 36);
+}
+
+BUILTIN(random_uuid) {
+    (void)callee, (void)argc, (void)argv, (void)new_target;
+    if (!is_crypto(this_val)) return js_throw_invalid_this(ctx, "Crypto");
+    return js_crypto_random_uuid(ctx);
+}
+
+BUILTIN(crypto_subtle) {
+    UNUSED_ARGS;
+    if (!is_crypto(this_val)) return js_throw_invalid_this(ctx, "Crypto");
+    return ctx->intrinsics[JS_INTRINSIC_SUBTLE_CRYPTO];
+}
+
+BUILTIN(global_crypto) {
+    UNUSED_ARGS;
+    return ctx->intrinsics[JS_INTRINSIC_CRYPTO];
+}
+
+/* ---- Realm ------------------------------------------------------------------------------------- */
+
+static const JSBuiltin crypto_globals[] = {
+    WEBIDL_ATTRIBUTE("crypto", global_crypto, NULL),
+};
+
+static const JSBuiltin crypto_proto[] = {
+    WEBIDL_ATTRIBUTE("subtle", crypto_subtle, NULL),
+    WEBIDL_OPERATION("getRandomValues", get_random_values, 1),
+    WEBIDL_OPERATION("randomUUID", random_uuid, 0),
+};
+
+static void install_crypto(JSContext *ctx, JSObject *global) {
+    JSValue object_proto = ctx->intrinsics[JS_INTRINSIC_OBJECT_PROTOTYPE];
+    js_define_web_class(ctx, global, "Crypto", illegal_ctor, 0, object_proto, JS_INTRINSIC_CRYPTO_PROTOTYPE);
+    JSValue cp = ctx->intrinsics[JS_INTRINSIC_CRYPTO_PROTOTYPE];
+    js_define_builtins(ctx, js_as_object(cp), crypto_proto, JS_COUNTOF(crypto_proto));
+    js_define_data(ctx, js_as_object(cp), JS_SYMBOL(toStringTag), js_new_string_cstr(ctx, "Crypto"), JS_PROP_CONFIGURABLE);
+
+    ctx->intrinsics[JS_INTRINSIC_CRYPTO] = js_object_value(js_alloc_object(ctx, JS_CELL_OBJECT, js_shape_root(ctx, &crypto_class, cp, 0)));
+
+    js_crypto_install_subtle(ctx, global);
+    js_crypto_install_key(ctx, global);
+    js_define_builtins(ctx, global, crypto_globals, JS_COUNTOF(crypto_globals));
+}
+
+const JSComponent js_component_crypto = { "crypto", install_crypto };