300 lines
10 KiB
C
300 lines
10 KiB
C
// 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
|