HomePhorge
Diffusion Ant (master) Code

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

Last Change
Raw File

arithmetic.h
View Options

#ifndef SV_ARITHMETIC_H
#define SV_ARITHMETIC_H
#include <math.h>
#include "tokens.h"
#include "errors.h"
#include "silver/engine.h"
static inline jsval_t sv_op_add(sv_vm_t *vm, ant_t *js) {
jsval_t r = vm->stack[--vm->sp];
jsval_t l = vm->stack[--vm->sp];
if (vtype(l) == T_NUM && vtype(r) == T_NUM) {
vm->stack[vm->sp++] = tov(tod(l) + tod(r));
return tov(0);
}
jsval_t lu = unwrap_primitive(js, l);
jsval_t ru = unwrap_primitive(js, r);
if (vtype(lu) == T_BIGINT && vtype(ru) == T_BIGINT) {
jsval_t res = bigint_add(js, lu, ru);
vm->stack[vm->sp++] = res;
return res;
}
if (vtype(lu) == T_BIGINT || vtype(ru) == T_BIGINT) {
return js_mkerr(js, "Cannot mix BigInt value and other types");
}
if (is_non_numeric(lu) || is_non_numeric(ru) ||
(vtype(lu) == T_STR && vtype(ru) == T_STR)) {
jsval_t l_str = coerce_to_str_concat(js, l);
if (is_err(l_str)) return l_str;
jshdl_t lh = js_root(js, l_str);
jsval_t r_str = coerce_to_str_concat(js, r);
l_str = js_deref(js, lh); js_unroot(js, lh);
if (is_err(r_str)) return r_str;
jsval_t res = do_string_op(js, TOK_PLUS, l_str, r_str);
vm->stack[vm->sp++] = res;
return res;
}
vm->stack[vm->sp++] = tov(js_to_number(js, l) + js_to_number(js, r));
return tov(0);
}
static inline jsval_t sv_op_sub(sv_vm_t *vm, ant_t *js) {
jsval_t r = vm->stack[--vm->sp];
jsval_t l = vm->stack[--vm->sp];
if (vtype(l) == T_NUM && vtype(r) == T_NUM) {
vm->stack[vm->sp++] = tov(tod(l) - tod(r));
return tov(0);
}
if (vtype(l) == T_BIGINT && vtype(r) == T_BIGINT) {
jsval_t res = bigint_sub(js, l, r);
vm->stack[vm->sp++] = res;
return res;
}
if (vtype(l) == T_BIGINT || vtype(r) == T_BIGINT)
return js_mkerr(js, "Cannot mix BigInt value and other types");
vm->stack[vm->sp++] = tov(js_to_number(js, l) - js_to_number(js, r));
return tov(0);
}
static inline jsval_t sv_op_mul(sv_vm_t *vm, ant_t *js) {
jsval_t r = vm->stack[--vm->sp];
jsval_t l = vm->stack[--vm->sp];
if (vtype(l) == T_NUM && vtype(r) == T_NUM) {
vm->stack[vm->sp++] = tov(tod(l) * tod(r));
return tov(0);
}
if (vtype(l) == T_BIGINT && vtype(r) == T_BIGINT) {
jsval_t res = bigint_mul(js, l, r);
vm->stack[vm->sp++] = res;
return res;
}
if (vtype(l) == T_BIGINT || vtype(r) == T_BIGINT)
return js_mkerr(js, "Cannot mix BigInt value and other types");
vm->stack[vm->sp++] = tov(js_to_number(js, l) * js_to_number(js, r));
return tov(0);
}
static inline jsval_t sv_op_div(sv_vm_t *vm, ant_t *js) {
jsval_t r = vm->stack[--vm->sp];
jsval_t l = vm->stack[--vm->sp];
if (vtype(l) == T_NUM && vtype(r) == T_NUM) {
vm->stack[vm->sp++] = tov(tod(l) / tod(r));
return tov(0);
}
if (vtype(l) == T_BIGINT && vtype(r) == T_BIGINT) {
jsval_t res = bigint_div(js, l, r);
vm->stack[vm->sp++] = res;
return res;
}
if (vtype(l) == T_BIGINT || vtype(r) == T_BIGINT)
return js_mkerr(js, "Cannot mix BigInt value and other types");
vm->stack[vm->sp++] = tov(js_to_number(js, l) / js_to_number(js, r));
return tov(0);
}
static inline jsval_t sv_op_mod(sv_vm_t *vm, ant_t *js) {
jsval_t r = vm->stack[--vm->sp];
jsval_t l = vm->stack[--vm->sp];
if (vtype(l) == T_NUM && vtype(r) == T_NUM) {
vm->stack[vm->sp++] = tov(fmod(tod(l), tod(r)));
return tov(0);
}
if (vtype(l) == T_BIGINT && vtype(r) == T_BIGINT) {
jsval_t res = bigint_mod(js, l, r);
vm->stack[vm->sp++] = res;
return res;
}
if (vtype(l) == T_BIGINT || vtype(r) == T_BIGINT)
return js_mkerr(js, "Cannot mix BigInt value and other types");
vm->stack[vm->sp++] = tov(fmod(js_to_number(js, l), js_to_number(js, r)));
return tov(0);
}
static inline jsval_t sv_op_exp(sv_vm_t *vm, ant_t *js) {
jsval_t r = vm->stack[--vm->sp];
jsval_t l = vm->stack[--vm->sp];
if (vtype(l) == T_NUM && vtype(r) == T_NUM) {
vm->stack[vm->sp++] = tov(pow(tod(l), tod(r)));
return tov(0);
}
if (vtype(l) == T_BIGINT && vtype(r) == T_BIGINT) {
jsval_t res = bigint_exp(js, l, r);
vm->stack[vm->sp++] = res;
return res;
}
if (vtype(l) == T_BIGINT || vtype(r) == T_BIGINT)
return js_mkerr(js, "Cannot mix BigInt value and other types");
vm->stack[vm->sp++] = tov(pow(js_to_number(js, l), js_to_number(js, r)));
return tov(0);
}
static inline jsval_t sv_op_neg(sv_vm_t *vm, ant_t *js) {
jsval_t a = vm->stack[--vm->sp];
if (vtype(a) == T_BIGINT) {
jsval_t res = bigint_neg(js, a);
vm->stack[vm->sp++] = res;
return res;
}
if (is_object_type(a)) {
jsval_t prim = js_to_primitive(js, a, 2);
if (is_err(prim)) return prim;
vm->stack[vm->sp++] = tov(-js_to_number(js, prim));
return tov(0);
}
vm->stack[vm->sp++] = tov(-js_to_number(js, a));
return tov(0);
}
static inline jsval_t sv_op_uplus(sv_vm_t *vm, ant_t *js) {
jsval_t a = vm->stack[--vm->sp];
if (vtype(a) == T_BIGINT)
return js_mkerr(js, "Cannot convert a BigInt value to a number");
if (is_object_type(a)) {
jsval_t prim = js_to_primitive(js, a, 2);
if (is_err(prim)) return prim;
vm->stack[vm->sp++] = tov(js_to_number(js, prim));
return tov(0);
}
vm->stack[vm->sp++] = tov(js_to_number(js, a));
return tov(0);
}
static inline void sv_op_inc(sv_vm_t *vm) {
vm->stack[vm->sp - 1] = tov(tod(vm->stack[vm->sp - 1]) + 1.0);
}
static inline void sv_op_dec(sv_vm_t *vm) {
vm->stack[vm->sp - 1] = tov(tod(vm->stack[vm->sp - 1]) - 1.0);
}
static inline void sv_op_post_inc(sv_vm_t *vm) {
jsval_t old = vm->stack[vm->sp - 1];
vm->stack[vm->sp++] = tov(tod(old) + 1.0);
}
static inline void sv_op_post_dec(sv_vm_t *vm) {
jsval_t old = vm->stack[vm->sp - 1];
vm->stack[vm->sp++] = tov(tod(old) - 1.0);
}
static inline void sv_op_inc_local(sv_vm_t *vm, jsval_t *lp, uint8_t *ip) {
uint8_t idx = sv_get_u8(ip + 1);
jsval_t *slot = &lp[idx];
*slot = tov(tod(*slot) + 1.0);
}
static inline void sv_op_dec_local(sv_vm_t *vm, jsval_t *lp, uint8_t *ip) {
uint8_t idx = sv_get_u8(ip + 1);
jsval_t *slot = &lp[idx];
*slot = tov(tod(*slot) - 1.0);
(void)vm;
}
static inline jsval_t sv_op_add_local(sv_vm_t *vm, jsval_t *lp, ant_t *js, uint8_t *ip) {
uint8_t idx = sv_get_u8(ip + 1);
jsval_t *slot = &lp[idx];
jsval_t val = vm->stack[--vm->sp];
if (vtype(*slot) == T_NUM && vtype(val) == T_NUM) {
*slot = tov(tod(*slot) + tod(val));
return tov(0);
}
vm->stack[vm->sp++] = *slot;
vm->stack[vm->sp++] = val;
jsval_t err = sv_op_add(vm, js);
if (is_err(err)) return err;
*slot = vm->stack[--vm->sp];
return tov(0);
}
#endif

Owner Packages

  • No Owners