Broken site based impl

2026-10-03 14:06:24 +00:00
parent 23a2c3bc46
commit 44498b32a9
39 changed files with 4250 additions and 1750 deletions
@@ -0,0 +1,299 @@
+// any_t: a value of any kind, and JS's operators on it
+#pragma once
+
+#include "number.h"
+
+// A value of any kind. An object in it is the pointer to its cell, so it keeps
+// its identity. A field can also hold absent
+
+typedef enum {
+    JSRT_KIND_ABSENT,
+    JSRT_KIND_UNDEFINED,
+    JSRT_KIND_NULL,
+    JSRT_KIND_BOOL,
+    JSRT_KIND_INT,
+    JSRT_KIND_FLOAT,
+    JSRT_KIND_STRING,
+    JSRT_KIND_OBJECT,
+} jsrt_kind;
+
+typedef struct {
+    jsrt_kind kind;
+    union {
+        bool b;
+        int32_t i;
+        double f;
+        string_t s;
+        void *o;
+    } as;
+} any_t;
+
+// Box a value. A pointer that is a sentinel (NULL, JSRT_UNDEFINED,
+// JSRT_ABSENT) boxes as null, undefined or absent
+any_t __any_undefined(void);
+any_t __any_null(void);
+any_t __any_absent(void);
+any_t __any_from_bool(bool b);
+any_t __any_from_int(int32_t n);
+any_t __any_from_float(double x);
+any_t __any_from_string(string_t s);
+any_t __any_from_object(void *o);
+
+// Unbox a value. A value of another kind throws. A string or an object unboxes
+// null, undefined and absent to their sentinels
+bool __any_as_bool(any_t a);
+int32_t __any_as_int(any_t a);
+double __any_as_float(any_t a);       // an int too
+string_t __any_as_string(any_t a);
+void *__any_as_object(any_t a);
+
+// The kind of a value
+bool __any_is_absent(any_t a);
+bool __any_is_undefined(any_t a);
+bool __any_is_null(any_t a);
+bool __any_is_nullish(any_t a);       // undefined or null
+bool __any_is_boolean(any_t a);
+bool __any_is_number(any_t a);
+bool __any_is_string(any_t a);
+bool __any_is_object(any_t a);        // a fn too
+bool __any_is_function(any_t a);
+
+// JS's operators, with JS's conversions
+any_t __any_add(any_t a, any_t b);
+any_t __any_sub(any_t a, any_t b);
+any_t __any_mul(any_t a, any_t b);
+any_t __any_div(any_t a, any_t b);
+any_t __any_mod(any_t a, any_t b);
+any_t __any_pow(any_t a, any_t b);
+any_t __any_neg(any_t a);
+any_t __any_plus(any_t a);            // ToNumber
+any_t __any_inc(any_t a);
+any_t __any_dec(any_t a);
+
+bool __any_lt(any_t a, any_t b);
+bool __any_lte(any_t a, any_t b);
+bool __any_gt(any_t a, any_t b);
+bool __any_gte(any_t a, any_t b);
+bool __any_eq(any_t a, any_t b);
+bool __any_neq(any_t a, any_t b);
+bool __any_strict_eq(any_t a, any_t b);
+bool __any_strict_neq(any_t a, any_t b);
+
+// JS's abstract operations
+bool __any_truthy(any_t a);           // ToBoolean
+int32_t __any_to_int32(any_t a);      // ToInt32
+string_t __any_to_string(any_t a);    // ToString
+string_t __any_typeof(any_t a);
+
+#ifdef JSRT_IMPLEMENTATION
+#include <math.h>
+
+// ── any: boxing ──
+
+any_t __any_undefined(void) { return (any_t){ .kind = JSRT_KIND_UNDEFINED }; }
+any_t __any_null(void) { return (any_t){ .kind = JSRT_KIND_NULL }; }
+any_t __any_absent(void) { return (any_t){ .kind = JSRT_KIND_ABSENT }; }
+any_t __any_from_bool(bool b) { return (any_t){ .kind = JSRT_KIND_BOOL, .as.b = b }; }
+any_t __any_from_int(int32_t n) { return (any_t){ .kind = JSRT_KIND_INT, .as.i = n }; }
+any_t __any_from_float(double x) { return (any_t){ .kind = JSRT_KIND_FLOAT, .as.f = x }; }
+
+// A pointer that can be a sentinel, as the kind it stands for, else as `kind`
+static any_t jsrt_from_ptr(void *p, jsrt_kind kind) {
+    if (p == NULL) return __any_null();
+    if (p == JSRT_UNDEFINED) return __any_undefined();
+    if (p == JSRT_ABSENT) return __any_absent();
+    return (any_t){ .kind = kind, .as.o = p };
+}
+
+any_t __any_from_string(string_t s) { return jsrt_from_ptr(s, JSRT_KIND_STRING); }
+any_t __any_from_object(void *o) { return jsrt_from_ptr(o, JSRT_KIND_OBJECT); }
+
+bool __any_as_bool(any_t a) {
+    if (a.kind != JSRT_KIND_BOOL) jsrt_type_error();
+    return a.as.b;
+}
+
+double __any_as_float(any_t a) {
+    if (a.kind == JSRT_KIND_INT) return a.as.i;
+    if (a.kind != JSRT_KIND_FLOAT) jsrt_type_error();
+    return a.as.f;
+}
+
+int32_t __any_as_int(any_t a) {
+    return a.kind == JSRT_KIND_INT ? a.as.i : (int32_t)__any_as_float(a);
+}
+
+// A pointer of kind `kind`, or the sentinel of a nullish or absent value
+static void *jsrt_as_ptr(any_t a, jsrt_kind kind) {
+    switch (a.kind) {
+    case JSRT_KIND_NULL: return NULL;
+    case JSRT_KIND_UNDEFINED: return JSRT_UNDEFINED;
+    case JSRT_KIND_ABSENT: return JSRT_ABSENT;
+    default:
+        if (a.kind != kind) jsrt_type_error();
+        return a.as.o;
+    }
+}
+
+string_t __any_as_string(any_t a) { return jsrt_as_ptr(a, JSRT_KIND_STRING); }
+void *__any_as_object(any_t a) { return jsrt_as_ptr(a, JSRT_KIND_OBJECT); }
+
+// ── any: kinds ──
+
+bool __any_is_absent(any_t a) { return a.kind == JSRT_KIND_ABSENT; }
+bool __any_is_undefined(any_t a) { return a.kind == JSRT_KIND_UNDEFINED || a.kind == JSRT_KIND_ABSENT; }
+bool __any_is_null(any_t a) { return a.kind == JSRT_KIND_NULL; }
+bool __any_is_nullish(any_t a) { return __any_is_undefined(a) || __any_is_null(a); }
+bool __any_is_boolean(any_t a) { return a.kind == JSRT_KIND_BOOL; }
+bool __any_is_number(any_t a) { return a.kind == JSRT_KIND_INT || a.kind == JSRT_KIND_FLOAT; }
+bool __any_is_string(any_t a) { return a.kind == JSRT_KIND_STRING; }
+bool __any_is_object(any_t a) { return a.kind == JSRT_KIND_OBJECT; }
+
+bool __any_is_function(any_t a) {
+    return a.kind == JSRT_KIND_OBJECT && jsrt_fn_sites[((jsrt_header *)a.as.o)->site];
+}
+
+// ── any: abstract operations ──
+
+// ToNumber. An object would call its `valueOf` or `toString` first, which the
+// runtime cannot do, so it gives NaN
+static double jsrt_to_number(any_t a) {
+    switch (a.kind) {
+    case JSRT_KIND_NULL: return 0;
+    case JSRT_KIND_BOOL: return a.as.b;
+    case JSRT_KIND_INT: return a.as.i;
+    case JSRT_KIND_FLOAT: return a.as.f;
+    case JSRT_KIND_STRING: return __native_string_to_number(a.as.s);
+    default: return NAN;
+    }
+}
+
+bool __any_truthy(any_t a) {
+    switch (a.kind) {
+    case JSRT_KIND_BOOL: return a.as.b;
+    case JSRT_KIND_INT: return a.as.i != 0;
+    case JSRT_KIND_FLOAT: return a.as.f != 0 && !isnan(a.as.f);
+    case JSRT_KIND_STRING: return a.as.s->length != 0;
+    case JSRT_KIND_OBJECT: return true;
+    default: return false;
+    }
+}
+
+int32_t __any_to_int32(any_t a) {
+    double x = jsrt_to_number(a);
+
+    if (isnan(x) || isinf(x)) {
+        return 0;
+    }
+
+    x = fmod(trunc(x), 4294967296.0);
+    return (int32_t)(uint32_t)(int64_t)(x < 0 ? x + 4294967296.0 : x);
+}
+
+// ToString. An object would call its `toString`, which the runtime cannot do
+string_t __any_to_string(any_t a) {
+    switch (a.kind) {
+    case JSRT_KIND_UNDEFINED: case JSRT_KIND_ABSENT: return jsrt_string_lit("undefined");
+    case JSRT_KIND_NULL: return jsrt_string_lit("null");
+    case JSRT_KIND_BOOL: return jsrt_string_lit(a.as.b ? "true" : "false");
+    case JSRT_KIND_INT: return __native_number_to_string(a.as.i);
+    case JSRT_KIND_FLOAT: return __native_number_to_string(a.as.f);
+    case JSRT_KIND_STRING: return a.as.s;
+    default: return jsrt_string_lit(__any_is_function(a) ? "function" : "[object Object]");
+    }
+}
+
+string_t __any_typeof(any_t a) {
+    switch (a.kind) {
+    case JSRT_KIND_UNDEFINED: case JSRT_KIND_ABSENT: return jsrt_string_lit("undefined");
+    case JSRT_KIND_BOOL: return jsrt_string_lit("boolean");
+    case JSRT_KIND_INT: case JSRT_KIND_FLOAT: return jsrt_string_lit("number");
+    case JSRT_KIND_STRING: return jsrt_string_lit("string");
+    case JSRT_KIND_OBJECT: return jsrt_string_lit(__any_is_function(a) ? "function" : "object");
+    default: return jsrt_string_lit("object");
+    }
+}
+
+// ── any: operators ──
+
+any_t __any_add(any_t a, any_t b) {
+    // An object becomes a string (see `__any_to_string`), so it concatenates
+    bool strings = a.kind == JSRT_KIND_STRING || b.kind == JSRT_KIND_STRING
+        || a.kind == JSRT_KIND_OBJECT || b.kind == JSRT_KIND_OBJECT;
+
+    if (strings) {
+        return __any_from_string(__native_string_concat(__any_to_string(a), __any_to_string(b)));
+    }
+
+    return __any_from_float(jsrt_to_number(a) + jsrt_to_number(b));
+}
+
+any_t __any_sub(any_t a, any_t b) { return __any_from_float(jsrt_to_number(a) - jsrt_to_number(b)); }
+any_t __any_mul(any_t a, any_t b) { return __any_from_float(jsrt_to_number(a) * jsrt_to_number(b)); }
+any_t __any_div(any_t a, any_t b) { return __any_from_float(jsrt_to_number(a) / jsrt_to_number(b)); }
+any_t __any_mod(any_t a, any_t b) { return __any_from_float(fmod(jsrt_to_number(a), jsrt_to_number(b))); }
+any_t __any_pow(any_t a, any_t b) { return __any_from_float(pow(jsrt_to_number(a), jsrt_to_number(b))); }
+any_t __any_neg(any_t a) { return __any_from_float(-jsrt_to_number(a)); }
+any_t __any_plus(any_t a) { return __any_from_float(jsrt_to_number(a)); }
+any_t __any_inc(any_t a) { return __any_from_float(jsrt_to_number(a) + 1); }
+any_t __any_dec(any_t a) { return __any_from_float(jsrt_to_number(a) - 1); }
+
+// ── any: comparisons ──
+
+// Two strings compare by code units. Anything else compares as numbers, where
+// NaN makes every comparison false
+bool __any_lt(any_t a, any_t b) {
+    bool strings = a.kind == JSRT_KIND_STRING && b.kind == JSRT_KIND_STRING;
+    return strings ? jsrt_string_cmp(a.as.s, b.as.s) < 0 : jsrt_to_number(a) < jsrt_to_number(b);
+}
+
+bool __any_lte(any_t a, any_t b) {
+    bool strings = a.kind == JSRT_KIND_STRING && b.kind == JSRT_KIND_STRING;
+    return strings ? jsrt_string_cmp(a.as.s, b.as.s) <= 0 : jsrt_to_number(a) <= jsrt_to_number(b);
+}
+
+bool __any_gt(any_t a, any_t b) { return __any_lt(b, a); }
+bool __any_gte(any_t a, any_t b) { return __any_lte(b, a); }
+
+bool __any_strict_eq(any_t a, any_t b) {
+    if (__any_is_number(a) && __any_is_number(b)) {
+        return jsrt_to_number(a) == jsrt_to_number(b);
+    }
+
+    if (__any_is_undefined(a) || __any_is_undefined(b)) {
+        return __any_is_undefined(a) && __any_is_undefined(b);
+    }
+
+    if (a.kind != b.kind) {
+        return false;
+    }
+
+    switch (a.kind) {
+    case JSRT_KIND_NULL: return true;
+    case JSRT_KIND_BOOL: return a.as.b == b.as.b;
+    case JSRT_KIND_STRING: return jsrt_string_eq(a.as.s, b.as.s);
+    default: return a.as.o == b.as.o;
+    }
+}
+
+bool __any_strict_neq(any_t a, any_t b) { return !__any_strict_eq(a, b); }
+
+// Undefined and null equal each other and nothing else. Values of one kind,
+// and objects, compare as `===` does. Other primitives compare as numbers
+bool __any_eq(any_t a, any_t b) {
+    if (__any_is_nullish(a) || __any_is_nullish(b)) {
+        return __any_is_nullish(a) && __any_is_nullish(b);
+    }
+
+    bool same = a.kind == b.kind || (__any_is_number(a) && __any_is_number(b));
+
+    if (same || a.kind == JSRT_KIND_OBJECT || b.kind == JSRT_KIND_OBJECT) {
+        return __any_strict_eq(a, b);
+    }
+
+    return jsrt_to_number(a) == jsrt_to_number(b);
+}
+
+bool __any_neq(any_t a, any_t b) { return !__any_eq(a, b); }
+
+#endif // JSRT_IMPLEMENTATION