HomePhorge
Diffusion Ant (master) Code

ant/src/silver/ops/comparison.h
8755416ca476master

Last Change
Raw File

comparison.h
View Options

#ifndef SV_COMPARISON_H
#define SV_COMPARISON_H
#include "silver/engine.h"
static inline void sv_op_seq(sv_vm_t *vm, ant_t *js) {
jsval_t r = vm->stack[--vm->sp];
jsval_t l = vm->stack[--vm->sp];
vm->stack[vm->sp++] = mkval(T_BOOL, strict_eq_values(js, l, r));
}
static inline void sv_op_sne(sv_vm_t *vm, ant_t *js) {
jsval_t r = vm->stack[--vm->sp];
jsval_t l = vm->stack[--vm->sp];
vm->stack[vm->sp++] = mkval(T_BOOL, !strict_eq_values(js, l, r));
}
static inline jsval_t sv_abstract_eq(ant_t *js, jsval_t l, jsval_t r) {
uint8_t lt = vtype(l), rt = vtype(r);
if ((lt == T_NULL && rt == T_NULL) || (lt == T_UNDEF && rt == T_UNDEF) ||
(lt == T_UNDEF && rt == T_NULL) || (lt == T_NULL && rt == T_UNDEF))
return mkval(T_BOOL, 1);
if (lt == T_NULL || rt == T_NULL || lt == T_UNDEF || rt == T_UNDEF)
return mkval(T_BOOL, 0);
if (lt == rt)
return mkval(T_BOOL, strict_eq_values(js, l, r));
if ((lt == T_BIGINT && rt == T_NUM) || (lt == T_NUM && rt == T_BIGINT)) {
double num_val = lt == T_NUM ? tod(l) : tod(r);
jsval_t bigint_val = lt == T_BIGINT ? l : r;
if (isfinite(num_val) && num_val == trunc(num_val)) {
bool neg = num_val < 0;
if (neg) num_val = -num_val;
char buf[64];
snprintf(buf, sizeof(buf), "%.0f", num_val);
return mkval(
T_BOOL, bigint_compare(js, bigint_val,
js_mkbigint(js, buf, strlen(buf), neg)) == 0);
}
return mkval(T_BOOL, 0);
}
if (lt == T_BOOL) return sv_abstract_eq(js, tov(vdata(l) ? 1.0 : 0.0), r);
if (rt == T_BOOL) return sv_abstract_eq(js, l, tov(vdata(r) ? 1.0 : 0.0));
if ((lt == T_NUM && rt == T_STR) || (lt == T_STR && rt == T_NUM))
return mkval(T_BOOL, js_to_number(js, l) == js_to_number(js, r));
if (is_object_type(l)) {
jsval_t lp = js_to_primitive(js, l, 0);
if (!is_err(lp)) return sv_abstract_eq(js, lp, r);
}
if (is_object_type(r)) {
jsval_t rp = js_to_primitive(js, r, 0);
if (!is_err(rp)) return sv_abstract_eq(js, l, rp);
}
return mkval(T_BOOL, 0);
}
static inline void sv_op_eq(sv_vm_t *vm, ant_t *js) {
jsval_t r = vm->stack[--vm->sp];
jsval_t l = vm->stack[--vm->sp];
vm->stack[vm->sp++] = sv_abstract_eq(js, l, r);
}
static inline void sv_op_ne(sv_vm_t *vm, ant_t *js) {
jsval_t r = vm->stack[--vm->sp];
jsval_t l = vm->stack[--vm->sp];
jsval_t eq = sv_abstract_eq(js, l, r);
vm->stack[vm->sp++] = mkval(T_BOOL, !vdata(eq));
}
static inline int sv_strcmp(ant_t *js, jsval_t l, jsval_t r) {
jsoff_t n1, off1 = vstr(js, l, &n1);
jsoff_t n2, off2 = vstr(js, r, &n2);
jsoff_t min_len = n1 < n2 ? n1 : n2;
int cmp = memcmp(&js->mem[off1], &js->mem[off2], min_len);
if (cmp == 0) return (n1 < n2) ? -1 : (n1 > n2) ? 1 : 0;
return cmp < 0 ? -1 : 1;
}
static inline void sv_coerce_relational(ant_t *js, jsval_t *l, jsval_t *r) {
if (is_object_type(*l)) {
jsval_t prim = js_to_primitive(js, *l, 2);
if (!is_err(prim)) *l = prim;
}
if (is_object_type(*r)) {
jsval_t prim = js_to_primitive(js, *r, 2);
if (!is_err(prim)) *r = prim;
}
}
static inline jsval_t sv_op_lt(sv_vm_t *vm, ant_t *js) {
jsval_t r = vm->stack[--vm->sp];
jsval_t l = vm->stack[--vm->sp];
sv_coerce_relational(js, &l, &r);
uint8_t lt = vtype(l), rt = vtype(r);
if (lt == T_NUM && rt == T_NUM) {
vm->stack[vm->sp++] = mkval(T_BOOL, tod(l) < tod(r));
return tov(0);
}
if (lt == T_BIGINT && rt == T_BIGINT) {
vm->stack[vm->sp++] = mkval(T_BOOL, bigint_compare(js, l, r) < 0);
return tov(0);
}
if (lt == T_BIGINT || rt == T_BIGINT)
return js_mkerr(js, "Cannot mix BigInt value and other types");
if (lt == T_STR && rt == T_STR) {
vm->stack[vm->sp++] = mkval(T_BOOL, sv_strcmp(js, l, r) < 0);
return tov(0);
}
vm->stack[vm->sp++] = mkval(T_BOOL, js_to_number(js, l) < js_to_number(js, r));
return tov(0);
}
static inline jsval_t sv_op_le(sv_vm_t *vm, ant_t *js) {
jsval_t r = vm->stack[--vm->sp];
jsval_t l = vm->stack[--vm->sp];
sv_coerce_relational(js, &l, &r);
uint8_t lt = vtype(l), rt = vtype(r);
if (lt == T_NUM && rt == T_NUM) {
vm->stack[vm->sp++] = mkval(T_BOOL, tod(l) <= tod(r));
return tov(0);
}
if (lt == T_BIGINT && rt == T_BIGINT) {
vm->stack[vm->sp++] = mkval(T_BOOL, bigint_compare(js, l, r) <= 0);
return tov(0);
}
if (lt == T_BIGINT || rt == T_BIGINT)
return js_mkerr(js, "Cannot mix BigInt value and other types");
if (lt == T_STR && rt == T_STR) {
vm->stack[vm->sp++] = mkval(T_BOOL, sv_strcmp(js, l, r) <= 0);
return tov(0);
}
vm->stack[vm->sp++] = mkval(T_BOOL, js_to_number(js, l) <= js_to_number(js, r));
return tov(0);
}
static inline jsval_t sv_op_gt(sv_vm_t *vm, ant_t *js) {
jsval_t r = vm->stack[--vm->sp];
jsval_t l = vm->stack[--vm->sp];
sv_coerce_relational(js, &l, &r);
uint8_t lt = vtype(l), rt = vtype(r);
if (lt == T_NUM && rt == T_NUM) {
vm->stack[vm->sp++] = mkval(T_BOOL, tod(l) > tod(r));
return tov(0);
}
if (lt == T_BIGINT && rt == T_BIGINT) {
vm->stack[vm->sp++] = mkval(T_BOOL, bigint_compare(js, l, r) > 0);
return tov(0);
}
if (lt == T_BIGINT || rt == T_BIGINT)
return js_mkerr(js, "Cannot mix BigInt value and other types");
if (lt == T_STR && rt == T_STR) {
vm->stack[vm->sp++] = mkval(T_BOOL, sv_strcmp(js, l, r) > 0);
return tov(0);
}
vm->stack[vm->sp++] = mkval(T_BOOL, js_to_number(js, l) > js_to_number(js, r));
return tov(0);
}
static inline jsval_t sv_op_ge(sv_vm_t *vm, ant_t *js) {
jsval_t r = vm->stack[--vm->sp];
jsval_t l = vm->stack[--vm->sp];
sv_coerce_relational(js, &l, &r);
uint8_t lt = vtype(l), rt = vtype(r);
if (lt == T_NUM && rt == T_NUM) {
vm->stack[vm->sp++] = mkval(T_BOOL, tod(l) >= tod(r));
return tov(0);
}
if (lt == T_BIGINT && rt == T_BIGINT) {
vm->stack[vm->sp++] = mkval(T_BOOL, bigint_compare(js, l, r) >= 0);
return tov(0);
}
if (lt == T_BIGINT || rt == T_BIGINT)
return js_mkerr(js, "Cannot mix BigInt value and other types");
if (lt == T_STR && rt == T_STR) {
vm->stack[vm->sp++] = mkval(T_BOOL, sv_strcmp(js, l, r) >= 0);
return tov(0);
}
vm->stack[vm->sp++] = mkval(T_BOOL, js_to_number(js, l) >= js_to_number(js, r));
return tov(0);
}
static inline jsval_t sv_op_instanceof(sv_vm_t *vm, ant_t *js) {
jsval_t r = vm->stack[--vm->sp];
jsval_t l = vm->stack[--vm->sp];
jsval_t res = do_instanceof(js, l, r);
if (!is_err(res)) vm->stack[vm->sp++] = res;
return res;
}
static inline jsval_t sv_op_in(sv_vm_t *vm, ant_t *js) {
jsval_t r = vm->stack[--vm->sp];
jsval_t l = vm->stack[--vm->sp];
jsval_t res = do_in(js, l, r);
if (!is_err(res)) vm->stack[vm->sp++] = res;
return res;
}
static inline void sv_op_is_nullish(sv_vm_t *vm) {
jsval_t v = vm->stack[--vm->sp];
uint8_t t = vtype(v);
vm->stack[vm->sp++] = mkval(T_BOOL, t == T_NULL || t == T_UNDEF);
}
static inline void sv_op_is_undef_or_null(sv_vm_t *vm) {
jsval_t v = vm->stack[--vm->sp];
uint8_t t = vtype(v);
vm->stack[vm->sp++] = mkval(T_BOOL, t == T_NULL || t == T_UNDEF);
}
#endif

Owner Packages

  • No Owners