From 10e51aad0515e80adeb96a47776a2d80e62a98bc Mon Sep 17 00:00:00 2001 From: Michael Wallner Date: Tue, 17 Apr 2018 13:27:05 +0200 Subject: [PATCH] ifdef HAVE_INT128 --- Makefile.frag | 2 +- scripts/_include.php | 4 +- scripts/gen_calc_basic.php | 2 +- scripts/gen_calc_bin.php | 2 +- src/calc/basic.h | 348 +++++++++++++++++++++++++ src/calc/bin.h | 60 +++++ src/calc/bool.h | 24 ++ src/calc/cast.h | 84 +++++++ src/calc/cmp.h | 504 +++++++++++++++++++++++++++++++++++++ src/calc/unary.h | 18 ++ src/marshal.c | 2 +- 11 files changed, 1044 insertions(+), 6 deletions(-) diff --git a/Makefile.frag b/Makefile.frag index 91499f6..1cd17bd 100644 --- a/Makefile.frag +++ b/Makefile.frag @@ -24,7 +24,7 @@ $(PHP_PSI_SRCDIR)/src/parser.c: $(PHP_PSI_SRCDIR)/src/parser.re # trickery needed for relative #line directives cd $(PHP_PSI_SRCDIR) && $(RE2C) -o $(patsubst $(PHP_PSI_SRCDIR)/%,%,$@) $(patsubst $(PHP_PSI_SRCDIR)/%,%,$<) -$(PHP_PSI_SRCDIR)/src/calc/%.h: $(PHP_PSI_SRCDIR)/scripts/gen_calc_%.php +$(PHP_PSI_SRCDIR)/src/calc/%.h: $(PHP_PSI_SRCDIR)/scripts/gen_calc_%.php $(PHP_PSI_SRCDIR)/scripts/_include.php $(PHP_EXECUTABLE) $< >$@ $(PHP_PSI_SRCDIR)/src/calc.h: | $(PHP_PSI_SRCDIR)/src/calc/basic.h $(PHP_PSI_SRCDIR)/src/calc/bin.h $(PHP_PSI_SRCDIR)/src/calc/bool.h $(PHP_PSI_SRCDIR)/src/calc/unary.h $(PHP_PSI_SRCDIR)/src/calc/cast.h $(PHP_PSI_SRCDIR)/src/calc/cmp.h $(PHP_PSI_SRCDIR)/src/calc/oper.h diff --git a/scripts/_include.php b/scripts/_include.php index 67a73ca..f918dab 100644 --- a/scripts/_include.php +++ b/scripts/_include.php @@ -31,8 +31,8 @@ function t_is_int($t) { function t_is_special($t) { switch ($t) { - case "INT128_T": - case "UINT128_T": + case "INT128": + case "UINT128": case "LONG_DOUBLE": return true; default: diff --git a/scripts/gen_calc_basic.php b/scripts/gen_calc_basic.php index 0af83a8..d08c79b 100644 --- a/scripts/gen_calc_basic.php +++ b/scripts/gen_calc_basic.php @@ -127,11 +127,11 @@ static inline token_t psi_calc_mod(token_t t1, impl_val *v1, token_t t2, impl_va case PSI_T_: i2.i64 = v2->; break; - #endif + default: assert(0); diff --git a/scripts/gen_calc_bin.php b/scripts/gen_calc_bin.php index 5ee92a8..6dfece7 100644 --- a/scripts/gen_calc_bin.php +++ b/scripts/gen_calc_bin.php @@ -49,11 +49,11 @@ static inline token_t psi_calc_bin_(token_t t1, impl_val *v1, token case PSI_T_: i2.u64 = v2->; break; - #endif + default: assert(0); diff --git a/src/calc/basic.h b/src/calc/basic.h index ec42112..04660b5 100644 --- a/src/calc/basic.h +++ b/src/calc/basic.h @@ -58,12 +58,18 @@ static inline token_t psi_calc_add(token_t t1, impl_val *v1, token_t t2, impl_va case PSI_T_UINT64: res->i64 = v1->i8 + v2->u64; return PSI_T_INT64; +# if HAVE_INT128 case PSI_T_INT128: res->i128 = v1->i8 + v2->i128; return PSI_T_INT128; +# endif + +# if HAVE_UINT128 case PSI_T_UINT128: res->u128 = v1->i8 + v2->u128; return PSI_T_UINT128; +# endif + case PSI_T_FLOAT: res->fval = v1->i8 + v2->fval; return PSI_T_FLOAT; @@ -107,12 +113,18 @@ static inline token_t psi_calc_add(token_t t1, impl_val *v1, token_t t2, impl_va case PSI_T_UINT64: res->u64 = v1->u8 + v2->u64; return PSI_T_UINT64; +# if HAVE_INT128 case PSI_T_INT128: res->i128 = v1->u8 + v2->i128; return PSI_T_INT128; +# endif + +# if HAVE_UINT128 case PSI_T_UINT128: res->u128 = v1->u8 + v2->u128; return PSI_T_UINT128; +# endif + case PSI_T_FLOAT: res->fval = v1->u8 + v2->fval; return PSI_T_FLOAT; @@ -156,12 +168,18 @@ static inline token_t psi_calc_add(token_t t1, impl_val *v1, token_t t2, impl_va case PSI_T_UINT64: res->i64 = v1->i16 + v2->u64; return PSI_T_INT64; +# if HAVE_INT128 case PSI_T_INT128: res->i128 = v1->i16 + v2->i128; return PSI_T_INT128; +# endif + +# if HAVE_UINT128 case PSI_T_UINT128: res->u128 = v1->i16 + v2->u128; return PSI_T_UINT128; +# endif + case PSI_T_FLOAT: res->fval = v1->i16 + v2->fval; return PSI_T_FLOAT; @@ -205,12 +223,18 @@ static inline token_t psi_calc_add(token_t t1, impl_val *v1, token_t t2, impl_va case PSI_T_UINT64: res->u64 = v1->u16 + v2->u64; return PSI_T_UINT64; +# if HAVE_INT128 case PSI_T_INT128: res->i128 = v1->u16 + v2->i128; return PSI_T_INT128; +# endif + +# if HAVE_UINT128 case PSI_T_UINT128: res->u128 = v1->u16 + v2->u128; return PSI_T_UINT128; +# endif + case PSI_T_FLOAT: res->fval = v1->u16 + v2->fval; return PSI_T_FLOAT; @@ -254,12 +278,18 @@ static inline token_t psi_calc_add(token_t t1, impl_val *v1, token_t t2, impl_va case PSI_T_UINT64: res->i64 = v1->i32 + v2->u64; return PSI_T_INT64; +# if HAVE_INT128 case PSI_T_INT128: res->i128 = v1->i32 + v2->i128; return PSI_T_INT128; +# endif + +# if HAVE_UINT128 case PSI_T_UINT128: res->u128 = v1->i32 + v2->u128; return PSI_T_UINT128; +# endif + case PSI_T_FLOAT: res->fval = v1->i32 + v2->fval; return PSI_T_FLOAT; @@ -303,12 +333,18 @@ static inline token_t psi_calc_add(token_t t1, impl_val *v1, token_t t2, impl_va case PSI_T_UINT64: res->u64 = v1->u32 + v2->u64; return PSI_T_UINT64; +# if HAVE_INT128 case PSI_T_INT128: res->i128 = v1->u32 + v2->i128; return PSI_T_INT128; +# endif + +# if HAVE_UINT128 case PSI_T_UINT128: res->u128 = v1->u32 + v2->u128; return PSI_T_UINT128; +# endif + case PSI_T_FLOAT: res->fval = v1->u32 + v2->fval; return PSI_T_FLOAT; @@ -352,12 +388,18 @@ static inline token_t psi_calc_add(token_t t1, impl_val *v1, token_t t2, impl_va case PSI_T_UINT64: res->i64 = v1->i64 + v2->u64; return PSI_T_INT64; +# if HAVE_INT128 case PSI_T_INT128: res->i128 = v1->i64 + v2->i128; return PSI_T_INT128; +# endif + +# if HAVE_UINT128 case PSI_T_UINT128: res->u128 = v1->i64 + v2->u128; return PSI_T_UINT128; +# endif + case PSI_T_FLOAT: res->fval = v1->i64 + v2->fval; return PSI_T_FLOAT; @@ -401,12 +443,18 @@ static inline token_t psi_calc_add(token_t t1, impl_val *v1, token_t t2, impl_va case PSI_T_UINT64: res->u64 = v1->u64 + v2->u64; return PSI_T_UINT64; +# if HAVE_INT128 case PSI_T_INT128: res->i128 = v1->u64 + v2->i128; return PSI_T_INT128; +# endif + +# if HAVE_UINT128 case PSI_T_UINT128: res->u128 = v1->u64 + v2->u128; return PSI_T_UINT128; +# endif + case PSI_T_FLOAT: res->fval = v1->u64 + v2->fval; return PSI_T_FLOAT; @@ -424,6 +472,7 @@ static inline token_t psi_calc_add(token_t t1, impl_val *v1, token_t t2, impl_va break; } break; +#if HAVE_INT128 case PSI_T_INT128: switch (t2) { case PSI_T_INT8: @@ -450,12 +499,18 @@ static inline token_t psi_calc_add(token_t t1, impl_val *v1, token_t t2, impl_va case PSI_T_UINT64: res->i128 = v1->i128 + v2->u64; return PSI_T_INT128; +# if HAVE_INT128 case PSI_T_INT128: res->i128 = v1->i128 + v2->i128; return PSI_T_INT128; +# endif + +# if HAVE_UINT128 case PSI_T_UINT128: res->u128 = v1->i128 + v2->u128; return PSI_T_UINT128; +# endif + case PSI_T_FLOAT: res->fval = v1->i128 + v2->fval; return PSI_T_FLOAT; @@ -473,6 +528,9 @@ static inline token_t psi_calc_add(token_t t1, impl_val *v1, token_t t2, impl_va break; } break; +#endif + +#if HAVE_UINT128 case PSI_T_UINT128: switch (t2) { case PSI_T_INT8: @@ -499,12 +557,18 @@ static inline token_t psi_calc_add(token_t t1, impl_val *v1, token_t t2, impl_va case PSI_T_UINT64: res->u128 = v1->u128 + v2->u64; return PSI_T_UINT128; +# if HAVE_INT128 case PSI_T_INT128: res->u128 = v1->u128 + v2->i128; return PSI_T_UINT128; +# endif + +# if HAVE_UINT128 case PSI_T_UINT128: res->u128 = v1->u128 + v2->u128; return PSI_T_UINT128; +# endif + case PSI_T_FLOAT: res->fval = v1->u128 + v2->fval; return PSI_T_FLOAT; @@ -522,6 +586,8 @@ static inline token_t psi_calc_add(token_t t1, impl_val *v1, token_t t2, impl_va break; } break; +#endif + case PSI_T_FLOAT: switch (t2) { case PSI_T_INT8: @@ -548,12 +614,18 @@ static inline token_t psi_calc_add(token_t t1, impl_val *v1, token_t t2, impl_va case PSI_T_UINT64: res->fval = v1->fval + v2->u64; return PSI_T_FLOAT; +# if HAVE_INT128 case PSI_T_INT128: res->fval = v1->fval + v2->i128; return PSI_T_FLOAT; +# endif + +# if HAVE_UINT128 case PSI_T_UINT128: res->fval = v1->fval + v2->u128; return PSI_T_FLOAT; +# endif + case PSI_T_FLOAT: res->fval = v1->fval + v2->fval; return PSI_T_FLOAT; @@ -597,12 +669,18 @@ static inline token_t psi_calc_add(token_t t1, impl_val *v1, token_t t2, impl_va case PSI_T_UINT64: res->dval = v1->dval + v2->u64; return PSI_T_DOUBLE; +# if HAVE_INT128 case PSI_T_INT128: res->dval = v1->dval + v2->i128; return PSI_T_DOUBLE; +# endif + +# if HAVE_UINT128 case PSI_T_UINT128: res->dval = v1->dval + v2->u128; return PSI_T_DOUBLE; +# endif + case PSI_T_FLOAT: res->dval = v1->dval + v2->fval; return PSI_T_DOUBLE; @@ -647,12 +725,18 @@ static inline token_t psi_calc_add(token_t t1, impl_val *v1, token_t t2, impl_va case PSI_T_UINT64: res->ldval = v1->ldval + v2->u64; return PSI_T_LONG_DOUBLE; +# if HAVE_INT128 case PSI_T_INT128: res->ldval = v1->ldval + v2->i128; return PSI_T_LONG_DOUBLE; +# endif + +# if HAVE_UINT128 case PSI_T_UINT128: res->ldval = v1->ldval + v2->u128; return PSI_T_LONG_DOUBLE; +# endif + case PSI_T_FLOAT: res->ldval = v1->ldval + v2->fval; return PSI_T_LONG_DOUBLE; @@ -709,12 +793,18 @@ static inline token_t psi_calc_sub(token_t t1, impl_val *v1, token_t t2, impl_va case PSI_T_UINT64: res->i64 = v1->i8 - v2->u64; return PSI_T_INT64; +# if HAVE_INT128 case PSI_T_INT128: res->i128 = v1->i8 - v2->i128; return PSI_T_INT128; +# endif + +# if HAVE_UINT128 case PSI_T_UINT128: res->u128 = v1->i8 - v2->u128; return PSI_T_UINT128; +# endif + case PSI_T_FLOAT: res->fval = v1->i8 - v2->fval; return PSI_T_FLOAT; @@ -758,12 +848,18 @@ static inline token_t psi_calc_sub(token_t t1, impl_val *v1, token_t t2, impl_va case PSI_T_UINT64: res->u64 = v1->u8 - v2->u64; return PSI_T_UINT64; +# if HAVE_INT128 case PSI_T_INT128: res->i128 = v1->u8 - v2->i128; return PSI_T_INT128; +# endif + +# if HAVE_UINT128 case PSI_T_UINT128: res->u128 = v1->u8 - v2->u128; return PSI_T_UINT128; +# endif + case PSI_T_FLOAT: res->fval = v1->u8 - v2->fval; return PSI_T_FLOAT; @@ -807,12 +903,18 @@ static inline token_t psi_calc_sub(token_t t1, impl_val *v1, token_t t2, impl_va case PSI_T_UINT64: res->i64 = v1->i16 - v2->u64; return PSI_T_INT64; +# if HAVE_INT128 case PSI_T_INT128: res->i128 = v1->i16 - v2->i128; return PSI_T_INT128; +# endif + +# if HAVE_UINT128 case PSI_T_UINT128: res->u128 = v1->i16 - v2->u128; return PSI_T_UINT128; +# endif + case PSI_T_FLOAT: res->fval = v1->i16 - v2->fval; return PSI_T_FLOAT; @@ -856,12 +958,18 @@ static inline token_t psi_calc_sub(token_t t1, impl_val *v1, token_t t2, impl_va case PSI_T_UINT64: res->u64 = v1->u16 - v2->u64; return PSI_T_UINT64; +# if HAVE_INT128 case PSI_T_INT128: res->i128 = v1->u16 - v2->i128; return PSI_T_INT128; +# endif + +# if HAVE_UINT128 case PSI_T_UINT128: res->u128 = v1->u16 - v2->u128; return PSI_T_UINT128; +# endif + case PSI_T_FLOAT: res->fval = v1->u16 - v2->fval; return PSI_T_FLOAT; @@ -905,12 +1013,18 @@ static inline token_t psi_calc_sub(token_t t1, impl_val *v1, token_t t2, impl_va case PSI_T_UINT64: res->i64 = v1->i32 - v2->u64; return PSI_T_INT64; +# if HAVE_INT128 case PSI_T_INT128: res->i128 = v1->i32 - v2->i128; return PSI_T_INT128; +# endif + +# if HAVE_UINT128 case PSI_T_UINT128: res->u128 = v1->i32 - v2->u128; return PSI_T_UINT128; +# endif + case PSI_T_FLOAT: res->fval = v1->i32 - v2->fval; return PSI_T_FLOAT; @@ -954,12 +1068,18 @@ static inline token_t psi_calc_sub(token_t t1, impl_val *v1, token_t t2, impl_va case PSI_T_UINT64: res->u64 = v1->u32 - v2->u64; return PSI_T_UINT64; +# if HAVE_INT128 case PSI_T_INT128: res->i128 = v1->u32 - v2->i128; return PSI_T_INT128; +# endif + +# if HAVE_UINT128 case PSI_T_UINT128: res->u128 = v1->u32 - v2->u128; return PSI_T_UINT128; +# endif + case PSI_T_FLOAT: res->fval = v1->u32 - v2->fval; return PSI_T_FLOAT; @@ -1003,12 +1123,18 @@ static inline token_t psi_calc_sub(token_t t1, impl_val *v1, token_t t2, impl_va case PSI_T_UINT64: res->i64 = v1->i64 - v2->u64; return PSI_T_INT64; +# if HAVE_INT128 case PSI_T_INT128: res->i128 = v1->i64 - v2->i128; return PSI_T_INT128; +# endif + +# if HAVE_UINT128 case PSI_T_UINT128: res->u128 = v1->i64 - v2->u128; return PSI_T_UINT128; +# endif + case PSI_T_FLOAT: res->fval = v1->i64 - v2->fval; return PSI_T_FLOAT; @@ -1052,12 +1178,18 @@ static inline token_t psi_calc_sub(token_t t1, impl_val *v1, token_t t2, impl_va case PSI_T_UINT64: res->u64 = v1->u64 - v2->u64; return PSI_T_UINT64; +# if HAVE_INT128 case PSI_T_INT128: res->i128 = v1->u64 - v2->i128; return PSI_T_INT128; +# endif + +# if HAVE_UINT128 case PSI_T_UINT128: res->u128 = v1->u64 - v2->u128; return PSI_T_UINT128; +# endif + case PSI_T_FLOAT: res->fval = v1->u64 - v2->fval; return PSI_T_FLOAT; @@ -1075,6 +1207,7 @@ static inline token_t psi_calc_sub(token_t t1, impl_val *v1, token_t t2, impl_va break; } break; +#if HAVE_INT128 case PSI_T_INT128: switch (t2) { case PSI_T_INT8: @@ -1101,12 +1234,18 @@ static inline token_t psi_calc_sub(token_t t1, impl_val *v1, token_t t2, impl_va case PSI_T_UINT64: res->i128 = v1->i128 - v2->u64; return PSI_T_INT128; +# if HAVE_INT128 case PSI_T_INT128: res->i128 = v1->i128 - v2->i128; return PSI_T_INT128; +# endif + +# if HAVE_UINT128 case PSI_T_UINT128: res->u128 = v1->i128 - v2->u128; return PSI_T_UINT128; +# endif + case PSI_T_FLOAT: res->fval = v1->i128 - v2->fval; return PSI_T_FLOAT; @@ -1124,6 +1263,9 @@ static inline token_t psi_calc_sub(token_t t1, impl_val *v1, token_t t2, impl_va break; } break; +#endif + +#if HAVE_UINT128 case PSI_T_UINT128: switch (t2) { case PSI_T_INT8: @@ -1150,12 +1292,18 @@ static inline token_t psi_calc_sub(token_t t1, impl_val *v1, token_t t2, impl_va case PSI_T_UINT64: res->u128 = v1->u128 - v2->u64; return PSI_T_UINT128; +# if HAVE_INT128 case PSI_T_INT128: res->u128 = v1->u128 - v2->i128; return PSI_T_UINT128; +# endif + +# if HAVE_UINT128 case PSI_T_UINT128: res->u128 = v1->u128 - v2->u128; return PSI_T_UINT128; +# endif + case PSI_T_FLOAT: res->fval = v1->u128 - v2->fval; return PSI_T_FLOAT; @@ -1173,6 +1321,8 @@ static inline token_t psi_calc_sub(token_t t1, impl_val *v1, token_t t2, impl_va break; } break; +#endif + case PSI_T_FLOAT: switch (t2) { case PSI_T_INT8: @@ -1199,12 +1349,18 @@ static inline token_t psi_calc_sub(token_t t1, impl_val *v1, token_t t2, impl_va case PSI_T_UINT64: res->fval = v1->fval - v2->u64; return PSI_T_FLOAT; +# if HAVE_INT128 case PSI_T_INT128: res->fval = v1->fval - v2->i128; return PSI_T_FLOAT; +# endif + +# if HAVE_UINT128 case PSI_T_UINT128: res->fval = v1->fval - v2->u128; return PSI_T_FLOAT; +# endif + case PSI_T_FLOAT: res->fval = v1->fval - v2->fval; return PSI_T_FLOAT; @@ -1248,12 +1404,18 @@ static inline token_t psi_calc_sub(token_t t1, impl_val *v1, token_t t2, impl_va case PSI_T_UINT64: res->dval = v1->dval - v2->u64; return PSI_T_DOUBLE; +# if HAVE_INT128 case PSI_T_INT128: res->dval = v1->dval - v2->i128; return PSI_T_DOUBLE; +# endif + +# if HAVE_UINT128 case PSI_T_UINT128: res->dval = v1->dval - v2->u128; return PSI_T_DOUBLE; +# endif + case PSI_T_FLOAT: res->dval = v1->dval - v2->fval; return PSI_T_DOUBLE; @@ -1298,12 +1460,18 @@ static inline token_t psi_calc_sub(token_t t1, impl_val *v1, token_t t2, impl_va case PSI_T_UINT64: res->ldval = v1->ldval - v2->u64; return PSI_T_LONG_DOUBLE; +# if HAVE_INT128 case PSI_T_INT128: res->ldval = v1->ldval - v2->i128; return PSI_T_LONG_DOUBLE; +# endif + +# if HAVE_UINT128 case PSI_T_UINT128: res->ldval = v1->ldval - v2->u128; return PSI_T_LONG_DOUBLE; +# endif + case PSI_T_FLOAT: res->ldval = v1->ldval - v2->fval; return PSI_T_LONG_DOUBLE; @@ -1360,12 +1528,18 @@ static inline token_t psi_calc_mul(token_t t1, impl_val *v1, token_t t2, impl_va case PSI_T_UINT64: res->i64 = v1->i8 * v2->u64; return PSI_T_INT64; +# if HAVE_INT128 case PSI_T_INT128: res->i128 = v1->i8 * v2->i128; return PSI_T_INT128; +# endif + +# if HAVE_UINT128 case PSI_T_UINT128: res->u128 = v1->i8 * v2->u128; return PSI_T_UINT128; +# endif + case PSI_T_FLOAT: res->fval = v1->i8 * v2->fval; return PSI_T_FLOAT; @@ -1409,12 +1583,18 @@ static inline token_t psi_calc_mul(token_t t1, impl_val *v1, token_t t2, impl_va case PSI_T_UINT64: res->u64 = v1->u8 * v2->u64; return PSI_T_UINT64; +# if HAVE_INT128 case PSI_T_INT128: res->i128 = v1->u8 * v2->i128; return PSI_T_INT128; +# endif + +# if HAVE_UINT128 case PSI_T_UINT128: res->u128 = v1->u8 * v2->u128; return PSI_T_UINT128; +# endif + case PSI_T_FLOAT: res->fval = v1->u8 * v2->fval; return PSI_T_FLOAT; @@ -1458,12 +1638,18 @@ static inline token_t psi_calc_mul(token_t t1, impl_val *v1, token_t t2, impl_va case PSI_T_UINT64: res->i64 = v1->i16 * v2->u64; return PSI_T_INT64; +# if HAVE_INT128 case PSI_T_INT128: res->i128 = v1->i16 * v2->i128; return PSI_T_INT128; +# endif + +# if HAVE_UINT128 case PSI_T_UINT128: res->u128 = v1->i16 * v2->u128; return PSI_T_UINT128; +# endif + case PSI_T_FLOAT: res->fval = v1->i16 * v2->fval; return PSI_T_FLOAT; @@ -1507,12 +1693,18 @@ static inline token_t psi_calc_mul(token_t t1, impl_val *v1, token_t t2, impl_va case PSI_T_UINT64: res->u64 = v1->u16 * v2->u64; return PSI_T_UINT64; +# if HAVE_INT128 case PSI_T_INT128: res->i128 = v1->u16 * v2->i128; return PSI_T_INT128; +# endif + +# if HAVE_UINT128 case PSI_T_UINT128: res->u128 = v1->u16 * v2->u128; return PSI_T_UINT128; +# endif + case PSI_T_FLOAT: res->fval = v1->u16 * v2->fval; return PSI_T_FLOAT; @@ -1556,12 +1748,18 @@ static inline token_t psi_calc_mul(token_t t1, impl_val *v1, token_t t2, impl_va case PSI_T_UINT64: res->i64 = v1->i32 * v2->u64; return PSI_T_INT64; +# if HAVE_INT128 case PSI_T_INT128: res->i128 = v1->i32 * v2->i128; return PSI_T_INT128; +# endif + +# if HAVE_UINT128 case PSI_T_UINT128: res->u128 = v1->i32 * v2->u128; return PSI_T_UINT128; +# endif + case PSI_T_FLOAT: res->fval = v1->i32 * v2->fval; return PSI_T_FLOAT; @@ -1605,12 +1803,18 @@ static inline token_t psi_calc_mul(token_t t1, impl_val *v1, token_t t2, impl_va case PSI_T_UINT64: res->u64 = v1->u32 * v2->u64; return PSI_T_UINT64; +# if HAVE_INT128 case PSI_T_INT128: res->i128 = v1->u32 * v2->i128; return PSI_T_INT128; +# endif + +# if HAVE_UINT128 case PSI_T_UINT128: res->u128 = v1->u32 * v2->u128; return PSI_T_UINT128; +# endif + case PSI_T_FLOAT: res->fval = v1->u32 * v2->fval; return PSI_T_FLOAT; @@ -1654,12 +1858,18 @@ static inline token_t psi_calc_mul(token_t t1, impl_val *v1, token_t t2, impl_va case PSI_T_UINT64: res->i64 = v1->i64 * v2->u64; return PSI_T_INT64; +# if HAVE_INT128 case PSI_T_INT128: res->i128 = v1->i64 * v2->i128; return PSI_T_INT128; +# endif + +# if HAVE_UINT128 case PSI_T_UINT128: res->u128 = v1->i64 * v2->u128; return PSI_T_UINT128; +# endif + case PSI_T_FLOAT: res->fval = v1->i64 * v2->fval; return PSI_T_FLOAT; @@ -1703,12 +1913,18 @@ static inline token_t psi_calc_mul(token_t t1, impl_val *v1, token_t t2, impl_va case PSI_T_UINT64: res->u64 = v1->u64 * v2->u64; return PSI_T_UINT64; +# if HAVE_INT128 case PSI_T_INT128: res->i128 = v1->u64 * v2->i128; return PSI_T_INT128; +# endif + +# if HAVE_UINT128 case PSI_T_UINT128: res->u128 = v1->u64 * v2->u128; return PSI_T_UINT128; +# endif + case PSI_T_FLOAT: res->fval = v1->u64 * v2->fval; return PSI_T_FLOAT; @@ -1726,6 +1942,7 @@ static inline token_t psi_calc_mul(token_t t1, impl_val *v1, token_t t2, impl_va break; } break; +#if HAVE_INT128 case PSI_T_INT128: switch (t2) { case PSI_T_INT8: @@ -1752,12 +1969,18 @@ static inline token_t psi_calc_mul(token_t t1, impl_val *v1, token_t t2, impl_va case PSI_T_UINT64: res->i128 = v1->i128 * v2->u64; return PSI_T_INT128; +# if HAVE_INT128 case PSI_T_INT128: res->i128 = v1->i128 * v2->i128; return PSI_T_INT128; +# endif + +# if HAVE_UINT128 case PSI_T_UINT128: res->u128 = v1->i128 * v2->u128; return PSI_T_UINT128; +# endif + case PSI_T_FLOAT: res->fval = v1->i128 * v2->fval; return PSI_T_FLOAT; @@ -1775,6 +1998,9 @@ static inline token_t psi_calc_mul(token_t t1, impl_val *v1, token_t t2, impl_va break; } break; +#endif + +#if HAVE_UINT128 case PSI_T_UINT128: switch (t2) { case PSI_T_INT8: @@ -1801,12 +2027,18 @@ static inline token_t psi_calc_mul(token_t t1, impl_val *v1, token_t t2, impl_va case PSI_T_UINT64: res->u128 = v1->u128 * v2->u64; return PSI_T_UINT128; +# if HAVE_INT128 case PSI_T_INT128: res->u128 = v1->u128 * v2->i128; return PSI_T_UINT128; +# endif + +# if HAVE_UINT128 case PSI_T_UINT128: res->u128 = v1->u128 * v2->u128; return PSI_T_UINT128; +# endif + case PSI_T_FLOAT: res->fval = v1->u128 * v2->fval; return PSI_T_FLOAT; @@ -1824,6 +2056,8 @@ static inline token_t psi_calc_mul(token_t t1, impl_val *v1, token_t t2, impl_va break; } break; +#endif + case PSI_T_FLOAT: switch (t2) { case PSI_T_INT8: @@ -1850,12 +2084,18 @@ static inline token_t psi_calc_mul(token_t t1, impl_val *v1, token_t t2, impl_va case PSI_T_UINT64: res->fval = v1->fval * v2->u64; return PSI_T_FLOAT; +# if HAVE_INT128 case PSI_T_INT128: res->fval = v1->fval * v2->i128; return PSI_T_FLOAT; +# endif + +# if HAVE_UINT128 case PSI_T_UINT128: res->fval = v1->fval * v2->u128; return PSI_T_FLOAT; +# endif + case PSI_T_FLOAT: res->fval = v1->fval * v2->fval; return PSI_T_FLOAT; @@ -1899,12 +2139,18 @@ static inline token_t psi_calc_mul(token_t t1, impl_val *v1, token_t t2, impl_va case PSI_T_UINT64: res->dval = v1->dval * v2->u64; return PSI_T_DOUBLE; +# if HAVE_INT128 case PSI_T_INT128: res->dval = v1->dval * v2->i128; return PSI_T_DOUBLE; +# endif + +# if HAVE_UINT128 case PSI_T_UINT128: res->dval = v1->dval * v2->u128; return PSI_T_DOUBLE; +# endif + case PSI_T_FLOAT: res->dval = v1->dval * v2->fval; return PSI_T_DOUBLE; @@ -1949,12 +2195,18 @@ static inline token_t psi_calc_mul(token_t t1, impl_val *v1, token_t t2, impl_va case PSI_T_UINT64: res->ldval = v1->ldval * v2->u64; return PSI_T_LONG_DOUBLE; +# if HAVE_INT128 case PSI_T_INT128: res->ldval = v1->ldval * v2->i128; return PSI_T_LONG_DOUBLE; +# endif + +# if HAVE_UINT128 case PSI_T_UINT128: res->ldval = v1->ldval * v2->u128; return PSI_T_LONG_DOUBLE; +# endif + case PSI_T_FLOAT: res->ldval = v1->ldval * v2->fval; return PSI_T_LONG_DOUBLE; @@ -2011,12 +2263,18 @@ static inline token_t psi_calc_div(token_t t1, impl_val *v1, token_t t2, impl_va case PSI_T_UINT64: res->i64 = v1->i8 / v2->u64; return PSI_T_INT64; +# if HAVE_INT128 case PSI_T_INT128: res->i128 = v1->i8 / v2->i128; return PSI_T_INT128; +# endif + +# if HAVE_UINT128 case PSI_T_UINT128: res->u128 = v1->i8 / v2->u128; return PSI_T_UINT128; +# endif + case PSI_T_FLOAT: res->fval = v1->i8 / v2->fval; return PSI_T_FLOAT; @@ -2060,12 +2318,18 @@ static inline token_t psi_calc_div(token_t t1, impl_val *v1, token_t t2, impl_va case PSI_T_UINT64: res->u64 = v1->u8 / v2->u64; return PSI_T_UINT64; +# if HAVE_INT128 case PSI_T_INT128: res->i128 = v1->u8 / v2->i128; return PSI_T_INT128; +# endif + +# if HAVE_UINT128 case PSI_T_UINT128: res->u128 = v1->u8 / v2->u128; return PSI_T_UINT128; +# endif + case PSI_T_FLOAT: res->fval = v1->u8 / v2->fval; return PSI_T_FLOAT; @@ -2109,12 +2373,18 @@ static inline token_t psi_calc_div(token_t t1, impl_val *v1, token_t t2, impl_va case PSI_T_UINT64: res->i64 = v1->i16 / v2->u64; return PSI_T_INT64; +# if HAVE_INT128 case PSI_T_INT128: res->i128 = v1->i16 / v2->i128; return PSI_T_INT128; +# endif + +# if HAVE_UINT128 case PSI_T_UINT128: res->u128 = v1->i16 / v2->u128; return PSI_T_UINT128; +# endif + case PSI_T_FLOAT: res->fval = v1->i16 / v2->fval; return PSI_T_FLOAT; @@ -2158,12 +2428,18 @@ static inline token_t psi_calc_div(token_t t1, impl_val *v1, token_t t2, impl_va case PSI_T_UINT64: res->u64 = v1->u16 / v2->u64; return PSI_T_UINT64; +# if HAVE_INT128 case PSI_T_INT128: res->i128 = v1->u16 / v2->i128; return PSI_T_INT128; +# endif + +# if HAVE_UINT128 case PSI_T_UINT128: res->u128 = v1->u16 / v2->u128; return PSI_T_UINT128; +# endif + case PSI_T_FLOAT: res->fval = v1->u16 / v2->fval; return PSI_T_FLOAT; @@ -2207,12 +2483,18 @@ static inline token_t psi_calc_div(token_t t1, impl_val *v1, token_t t2, impl_va case PSI_T_UINT64: res->i64 = v1->i32 / v2->u64; return PSI_T_INT64; +# if HAVE_INT128 case PSI_T_INT128: res->i128 = v1->i32 / v2->i128; return PSI_T_INT128; +# endif + +# if HAVE_UINT128 case PSI_T_UINT128: res->u128 = v1->i32 / v2->u128; return PSI_T_UINT128; +# endif + case PSI_T_FLOAT: res->fval = v1->i32 / v2->fval; return PSI_T_FLOAT; @@ -2256,12 +2538,18 @@ static inline token_t psi_calc_div(token_t t1, impl_val *v1, token_t t2, impl_va case PSI_T_UINT64: res->u64 = v1->u32 / v2->u64; return PSI_T_UINT64; +# if HAVE_INT128 case PSI_T_INT128: res->i128 = v1->u32 / v2->i128; return PSI_T_INT128; +# endif + +# if HAVE_UINT128 case PSI_T_UINT128: res->u128 = v1->u32 / v2->u128; return PSI_T_UINT128; +# endif + case PSI_T_FLOAT: res->fval = v1->u32 / v2->fval; return PSI_T_FLOAT; @@ -2305,12 +2593,18 @@ static inline token_t psi_calc_div(token_t t1, impl_val *v1, token_t t2, impl_va case PSI_T_UINT64: res->i64 = v1->i64 / v2->u64; return PSI_T_INT64; +# if HAVE_INT128 case PSI_T_INT128: res->i128 = v1->i64 / v2->i128; return PSI_T_INT128; +# endif + +# if HAVE_UINT128 case PSI_T_UINT128: res->u128 = v1->i64 / v2->u128; return PSI_T_UINT128; +# endif + case PSI_T_FLOAT: res->fval = v1->i64 / v2->fval; return PSI_T_FLOAT; @@ -2354,12 +2648,18 @@ static inline token_t psi_calc_div(token_t t1, impl_val *v1, token_t t2, impl_va case PSI_T_UINT64: res->u64 = v1->u64 / v2->u64; return PSI_T_UINT64; +# if HAVE_INT128 case PSI_T_INT128: res->i128 = v1->u64 / v2->i128; return PSI_T_INT128; +# endif + +# if HAVE_UINT128 case PSI_T_UINT128: res->u128 = v1->u64 / v2->u128; return PSI_T_UINT128; +# endif + case PSI_T_FLOAT: res->fval = v1->u64 / v2->fval; return PSI_T_FLOAT; @@ -2377,6 +2677,7 @@ static inline token_t psi_calc_div(token_t t1, impl_val *v1, token_t t2, impl_va break; } break; +#if HAVE_INT128 case PSI_T_INT128: switch (t2) { case PSI_T_INT8: @@ -2403,12 +2704,18 @@ static inline token_t psi_calc_div(token_t t1, impl_val *v1, token_t t2, impl_va case PSI_T_UINT64: res->i128 = v1->i128 / v2->u64; return PSI_T_INT128; +# if HAVE_INT128 case PSI_T_INT128: res->i128 = v1->i128 / v2->i128; return PSI_T_INT128; +# endif + +# if HAVE_UINT128 case PSI_T_UINT128: res->u128 = v1->i128 / v2->u128; return PSI_T_UINT128; +# endif + case PSI_T_FLOAT: res->fval = v1->i128 / v2->fval; return PSI_T_FLOAT; @@ -2426,6 +2733,9 @@ static inline token_t psi_calc_div(token_t t1, impl_val *v1, token_t t2, impl_va break; } break; +#endif + +#if HAVE_UINT128 case PSI_T_UINT128: switch (t2) { case PSI_T_INT8: @@ -2452,12 +2762,18 @@ static inline token_t psi_calc_div(token_t t1, impl_val *v1, token_t t2, impl_va case PSI_T_UINT64: res->u128 = v1->u128 / v2->u64; return PSI_T_UINT128; +# if HAVE_INT128 case PSI_T_INT128: res->u128 = v1->u128 / v2->i128; return PSI_T_UINT128; +# endif + +# if HAVE_UINT128 case PSI_T_UINT128: res->u128 = v1->u128 / v2->u128; return PSI_T_UINT128; +# endif + case PSI_T_FLOAT: res->fval = v1->u128 / v2->fval; return PSI_T_FLOAT; @@ -2475,6 +2791,8 @@ static inline token_t psi_calc_div(token_t t1, impl_val *v1, token_t t2, impl_va break; } break; +#endif + case PSI_T_FLOAT: switch (t2) { case PSI_T_INT8: @@ -2501,12 +2819,18 @@ static inline token_t psi_calc_div(token_t t1, impl_val *v1, token_t t2, impl_va case PSI_T_UINT64: res->fval = v1->fval / v2->u64; return PSI_T_FLOAT; +# if HAVE_INT128 case PSI_T_INT128: res->fval = v1->fval / v2->i128; return PSI_T_FLOAT; +# endif + +# if HAVE_UINT128 case PSI_T_UINT128: res->fval = v1->fval / v2->u128; return PSI_T_FLOAT; +# endif + case PSI_T_FLOAT: res->fval = v1->fval / v2->fval; return PSI_T_FLOAT; @@ -2550,12 +2874,18 @@ static inline token_t psi_calc_div(token_t t1, impl_val *v1, token_t t2, impl_va case PSI_T_UINT64: res->dval = v1->dval / v2->u64; return PSI_T_DOUBLE; +# if HAVE_INT128 case PSI_T_INT128: res->dval = v1->dval / v2->i128; return PSI_T_DOUBLE; +# endif + +# if HAVE_UINT128 case PSI_T_UINT128: res->dval = v1->dval / v2->u128; return PSI_T_DOUBLE; +# endif + case PSI_T_FLOAT: res->dval = v1->dval / v2->fval; return PSI_T_DOUBLE; @@ -2600,12 +2930,18 @@ static inline token_t psi_calc_div(token_t t1, impl_val *v1, token_t t2, impl_va case PSI_T_UINT64: res->ldval = v1->ldval / v2->u64; return PSI_T_LONG_DOUBLE; +# if HAVE_INT128 case PSI_T_INT128: res->ldval = v1->ldval / v2->i128; return PSI_T_LONG_DOUBLE; +# endif + +# if HAVE_UINT128 case PSI_T_UINT128: res->ldval = v1->ldval / v2->u128; return PSI_T_LONG_DOUBLE; +# endif + case PSI_T_FLOAT: res->ldval = v1->ldval / v2->fval; return PSI_T_LONG_DOUBLE; @@ -2671,14 +3007,20 @@ static inline token_t psi_calc_mod(token_t t1, impl_val *v1, token_t t2, impl_va i1.i64 = v1->u64; break; +#if HAVE_INT128 case PSI_T_INT128: i1.i64 = v1->i128; break; +#endif + +#if HAVE_UINT128 case PSI_T_UINT128: i1.i64 = v1->u128; break; +#endif + case PSI_T_FLOAT: i1.i64 = v1->fval; break; @@ -2724,12 +3066,18 @@ static inline token_t psi_calc_mod(token_t t1, impl_val *v1, token_t t2, impl_va case PSI_T_UINT64: i2.i64 = v2->u64; break; +#if HAVE_INT128 case PSI_T_INT128: i2.i64 = v2->i128; break; +#endif + +#if HAVE_UINT128 case PSI_T_UINT128: i2.i64 = v2->u128; break; +#endif + case PSI_T_FLOAT: i2.i64 = v2->fval; break; diff --git a/src/calc/bin.h b/src/calc/bin.h index 772bd98..ab79f21 100644 --- a/src/calc/bin.h +++ b/src/calc/bin.h @@ -65,14 +65,20 @@ static inline token_t psi_calc_bin_lshift(token_t t1, impl_val *v1, token_t t2, i1.u64 = v1->u64; break; +#if HAVE_INT128 case PSI_T_INT128: i1.u64 = v1->i128; break; +#endif + +#if HAVE_UINT128 case PSI_T_UINT128: i1.u64 = v1->u128; break; +#endif + case PSI_T_FLOAT: i1.u64 = v1->fval; break; @@ -118,12 +124,18 @@ static inline token_t psi_calc_bin_lshift(token_t t1, impl_val *v1, token_t t2, case PSI_T_UINT64: i2.u64 = v2->u64; break; +#if HAVE_INT128 case PSI_T_INT128: i2.u64 = v2->i128; break; +#endif + +#if HAVE_UINT128 case PSI_T_UINT128: i2.u64 = v2->u128; break; +#endif + case PSI_T_FLOAT: i2.u64 = v2->fval; break; @@ -182,14 +194,20 @@ static inline token_t psi_calc_bin_rshift(token_t t1, impl_val *v1, token_t t2, i1.u64 = v1->u64; break; +#if HAVE_INT128 case PSI_T_INT128: i1.u64 = v1->i128; break; +#endif + +#if HAVE_UINT128 case PSI_T_UINT128: i1.u64 = v1->u128; break; +#endif + case PSI_T_FLOAT: i1.u64 = v1->fval; break; @@ -235,12 +253,18 @@ static inline token_t psi_calc_bin_rshift(token_t t1, impl_val *v1, token_t t2, case PSI_T_UINT64: i2.u64 = v2->u64; break; +#if HAVE_INT128 case PSI_T_INT128: i2.u64 = v2->i128; break; +#endif + +#if HAVE_UINT128 case PSI_T_UINT128: i2.u64 = v2->u128; break; +#endif + case PSI_T_FLOAT: i2.u64 = v2->fval; break; @@ -299,14 +323,20 @@ static inline token_t psi_calc_bin_and(token_t t1, impl_val *v1, token_t t2, imp i1.u64 = v1->u64; break; +#if HAVE_INT128 case PSI_T_INT128: i1.u64 = v1->i128; break; +#endif + +#if HAVE_UINT128 case PSI_T_UINT128: i1.u64 = v1->u128; break; +#endif + case PSI_T_FLOAT: i1.u64 = v1->fval; break; @@ -352,12 +382,18 @@ static inline token_t psi_calc_bin_and(token_t t1, impl_val *v1, token_t t2, imp case PSI_T_UINT64: i2.u64 = v2->u64; break; +#if HAVE_INT128 case PSI_T_INT128: i2.u64 = v2->i128; break; +#endif + +#if HAVE_UINT128 case PSI_T_UINT128: i2.u64 = v2->u128; break; +#endif + case PSI_T_FLOAT: i2.u64 = v2->fval; break; @@ -416,14 +452,20 @@ static inline token_t psi_calc_bin_xor(token_t t1, impl_val *v1, token_t t2, imp i1.u64 = v1->u64; break; +#if HAVE_INT128 case PSI_T_INT128: i1.u64 = v1->i128; break; +#endif + +#if HAVE_UINT128 case PSI_T_UINT128: i1.u64 = v1->u128; break; +#endif + case PSI_T_FLOAT: i1.u64 = v1->fval; break; @@ -469,12 +511,18 @@ static inline token_t psi_calc_bin_xor(token_t t1, impl_val *v1, token_t t2, imp case PSI_T_UINT64: i2.u64 = v2->u64; break; +#if HAVE_INT128 case PSI_T_INT128: i2.u64 = v2->i128; break; +#endif + +#if HAVE_UINT128 case PSI_T_UINT128: i2.u64 = v2->u128; break; +#endif + case PSI_T_FLOAT: i2.u64 = v2->fval; break; @@ -533,14 +581,20 @@ static inline token_t psi_calc_bin_or(token_t t1, impl_val *v1, token_t t2, impl i1.u64 = v1->u64; break; +#if HAVE_INT128 case PSI_T_INT128: i1.u64 = v1->i128; break; +#endif + +#if HAVE_UINT128 case PSI_T_UINT128: i1.u64 = v1->u128; break; +#endif + case PSI_T_FLOAT: i1.u64 = v1->fval; break; @@ -586,12 +640,18 @@ static inline token_t psi_calc_bin_or(token_t t1, impl_val *v1, token_t t2, impl case PSI_T_UINT64: i2.u64 = v2->u64; break; +#if HAVE_INT128 case PSI_T_INT128: i2.u64 = v2->i128; break; +#endif + +#if HAVE_UINT128 case PSI_T_UINT128: i2.u64 = v2->u128; break; +#endif + case PSI_T_FLOAT: i2.u64 = v2->fval; break; diff --git a/src/calc/bool.h b/src/calc/bool.h index 5fe0ce7..7560021 100644 --- a/src/calc/bool.h +++ b/src/calc/bool.h @@ -62,14 +62,20 @@ static inline token_t psi_calc_bool_or(token_t t1, impl_val *v1, token_t t2, imp if (v1->u64) goto return_true; break; +#if HAVE_INT128 case PSI_T_INT128: if (v1->i128) goto return_true; break; +#endif + +#if HAVE_UINT128 case PSI_T_UINT128: if (v1->u128) goto return_true; break; +#endif + case PSI_T_FLOAT: if (v1->fval) goto return_true; @@ -123,14 +129,20 @@ static inline token_t psi_calc_bool_or(token_t t1, impl_val *v1, token_t t2, imp if (v2->u64) goto return_true; break; +#if HAVE_INT128 case PSI_T_INT128: if (v2->i128) goto return_true; break; +#endif + +#if HAVE_UINT128 case PSI_T_UINT128: if (v2->u128) goto return_true; break; +#endif + case PSI_T_FLOAT: if (v2->fval) goto return_true; @@ -194,14 +206,20 @@ static inline token_t psi_calc_bool_and(token_t t1, impl_val *v1, token_t t2, im if (!v1->u64) goto return_false; break; +#if HAVE_INT128 case PSI_T_INT128: if (!v1->i128) goto return_false; break; +#endif + +#if HAVE_UINT128 case PSI_T_UINT128: if (!v1->u128) goto return_false; break; +#endif + case PSI_T_FLOAT: if (!v1->fval) goto return_false; @@ -255,14 +273,20 @@ static inline token_t psi_calc_bool_and(token_t t1, impl_val *v1, token_t t2, im if (!v2->u64) goto return_false; break; +#if HAVE_INT128 case PSI_T_INT128: if (!v2->i128) goto return_false; break; +#endif + +#if HAVE_UINT128 case PSI_T_UINT128: if (!v2->u128) goto return_false; break; +#endif + case PSI_T_FLOAT: if (!v2->fval) goto return_false; diff --git a/src/calc/cast.h b/src/calc/cast.h index eb93b3b..2d6f3f6 100644 --- a/src/calc/cast.h +++ b/src/calc/cast.h @@ -57,12 +57,18 @@ static inline void psi_calc_cast(token_t in_type, impl_val *in_val, token_t out_ case PSI_T_UINT64: out_val->i8 = in_val->u64; break; +# if HAVE_INT128 case PSI_T_INT128: out_val->i8 = in_val->i128; break; +# endif + +# if HAVE_UINT128 case PSI_T_UINT128: out_val->i8 = in_val->u128; break; +# endif + case PSI_T_FLOAT: out_val->i8 = in_val->fval; break; @@ -106,12 +112,18 @@ static inline void psi_calc_cast(token_t in_type, impl_val *in_val, token_t out_ case PSI_T_UINT64: out_val->u8 = in_val->u64; break; +# if HAVE_INT128 case PSI_T_INT128: out_val->u8 = in_val->i128; break; +# endif + +# if HAVE_UINT128 case PSI_T_UINT128: out_val->u8 = in_val->u128; break; +# endif + case PSI_T_FLOAT: out_val->u8 = in_val->fval; break; @@ -155,12 +167,18 @@ static inline void psi_calc_cast(token_t in_type, impl_val *in_val, token_t out_ case PSI_T_UINT64: out_val->i16 = in_val->u64; break; +# if HAVE_INT128 case PSI_T_INT128: out_val->i16 = in_val->i128; break; +# endif + +# if HAVE_UINT128 case PSI_T_UINT128: out_val->i16 = in_val->u128; break; +# endif + case PSI_T_FLOAT: out_val->i16 = in_val->fval; break; @@ -204,12 +222,18 @@ static inline void psi_calc_cast(token_t in_type, impl_val *in_val, token_t out_ case PSI_T_UINT64: out_val->u16 = in_val->u64; break; +# if HAVE_INT128 case PSI_T_INT128: out_val->u16 = in_val->i128; break; +# endif + +# if HAVE_UINT128 case PSI_T_UINT128: out_val->u16 = in_val->u128; break; +# endif + case PSI_T_FLOAT: out_val->u16 = in_val->fval; break; @@ -253,12 +277,18 @@ static inline void psi_calc_cast(token_t in_type, impl_val *in_val, token_t out_ case PSI_T_UINT64: out_val->i32 = in_val->u64; break; +# if HAVE_INT128 case PSI_T_INT128: out_val->i32 = in_val->i128; break; +# endif + +# if HAVE_UINT128 case PSI_T_UINT128: out_val->i32 = in_val->u128; break; +# endif + case PSI_T_FLOAT: out_val->i32 = in_val->fval; break; @@ -302,12 +332,18 @@ static inline void psi_calc_cast(token_t in_type, impl_val *in_val, token_t out_ case PSI_T_UINT64: out_val->u32 = in_val->u64; break; +# if HAVE_INT128 case PSI_T_INT128: out_val->u32 = in_val->i128; break; +# endif + +# if HAVE_UINT128 case PSI_T_UINT128: out_val->u32 = in_val->u128; break; +# endif + case PSI_T_FLOAT: out_val->u32 = in_val->fval; break; @@ -351,12 +387,18 @@ static inline void psi_calc_cast(token_t in_type, impl_val *in_val, token_t out_ case PSI_T_UINT64: out_val->i64 = in_val->u64; break; +# if HAVE_INT128 case PSI_T_INT128: out_val->i64 = in_val->i128; break; +# endif + +# if HAVE_UINT128 case PSI_T_UINT128: out_val->i64 = in_val->u128; break; +# endif + case PSI_T_FLOAT: out_val->i64 = in_val->fval; break; @@ -400,12 +442,18 @@ static inline void psi_calc_cast(token_t in_type, impl_val *in_val, token_t out_ case PSI_T_UINT64: out_val->u64 = in_val->u64; break; +# if HAVE_INT128 case PSI_T_INT128: out_val->u64 = in_val->i128; break; +# endif + +# if HAVE_UINT128 case PSI_T_UINT128: out_val->u64 = in_val->u128; break; +# endif + case PSI_T_FLOAT: out_val->u64 = in_val->fval; break; @@ -423,6 +471,7 @@ static inline void psi_calc_cast(token_t in_type, impl_val *in_val, token_t out_ break; } break; +#if HAVE_INT128 case PSI_T_INT128: switch (in_type) { case PSI_T_INT8: @@ -449,12 +498,18 @@ static inline void psi_calc_cast(token_t in_type, impl_val *in_val, token_t out_ case PSI_T_UINT64: out_val->i128 = in_val->u64; break; +# if HAVE_INT128 case PSI_T_INT128: out_val->i128 = in_val->i128; break; +# endif + +# if HAVE_UINT128 case PSI_T_UINT128: out_val->i128 = in_val->u128; break; +# endif + case PSI_T_FLOAT: out_val->i128 = in_val->fval; break; @@ -472,6 +527,9 @@ static inline void psi_calc_cast(token_t in_type, impl_val *in_val, token_t out_ break; } break; +#endif + +#if HAVE_UINT128 case PSI_T_UINT128: switch (in_type) { case PSI_T_INT8: @@ -498,12 +556,18 @@ static inline void psi_calc_cast(token_t in_type, impl_val *in_val, token_t out_ case PSI_T_UINT64: out_val->u128 = in_val->u64; break; +# if HAVE_INT128 case PSI_T_INT128: out_val->u128 = in_val->i128; break; +# endif + +# if HAVE_UINT128 case PSI_T_UINT128: out_val->u128 = in_val->u128; break; +# endif + case PSI_T_FLOAT: out_val->u128 = in_val->fval; break; @@ -521,6 +585,8 @@ static inline void psi_calc_cast(token_t in_type, impl_val *in_val, token_t out_ break; } break; +#endif + case PSI_T_FLOAT: switch (in_type) { case PSI_T_INT8: @@ -547,12 +613,18 @@ static inline void psi_calc_cast(token_t in_type, impl_val *in_val, token_t out_ case PSI_T_UINT64: out_val->fval = in_val->u64; break; +# if HAVE_INT128 case PSI_T_INT128: out_val->fval = in_val->i128; break; +# endif + +# if HAVE_UINT128 case PSI_T_UINT128: out_val->fval = in_val->u128; break; +# endif + case PSI_T_FLOAT: out_val->fval = in_val->fval; break; @@ -596,12 +668,18 @@ static inline void psi_calc_cast(token_t in_type, impl_val *in_val, token_t out_ case PSI_T_UINT64: out_val->dval = in_val->u64; break; +# if HAVE_INT128 case PSI_T_INT128: out_val->dval = in_val->i128; break; +# endif + +# if HAVE_UINT128 case PSI_T_UINT128: out_val->dval = in_val->u128; break; +# endif + case PSI_T_FLOAT: out_val->dval = in_val->fval; break; @@ -646,12 +724,18 @@ static inline void psi_calc_cast(token_t in_type, impl_val *in_val, token_t out_ case PSI_T_UINT64: out_val->ldval = in_val->u64; break; +# if HAVE_INT128 case PSI_T_INT128: out_val->ldval = in_val->i128; break; +# endif + +# if HAVE_UINT128 case PSI_T_UINT128: out_val->ldval = in_val->u128; break; +# endif + case PSI_T_FLOAT: out_val->ldval = in_val->fval; break; diff --git a/src/calc/cmp.h b/src/calc/cmp.h index 30bc0c9..5eaa648 100644 --- a/src/calc/cmp.h +++ b/src/calc/cmp.h @@ -57,12 +57,18 @@ static inline token_t psi_calc_cmp_eq(token_t t1, impl_val *v1, token_t t2, impl case PSI_T_UINT64: res->u8 = v1->i8 == v2->u64; break; +# if HAVE_INT128 case PSI_T_INT128: res->u8 = v1->i8 == v2->i128; break; +# endif + +# if HAVE_UINT128 case PSI_T_UINT128: res->u8 = v1->i8 == v2->u128; break; +# endif + case PSI_T_FLOAT: res->u8 = v1->i8 == v2->fval; break; @@ -106,12 +112,18 @@ static inline token_t psi_calc_cmp_eq(token_t t1, impl_val *v1, token_t t2, impl case PSI_T_UINT64: res->u8 = v1->u8 == v2->u64; break; +# if HAVE_INT128 case PSI_T_INT128: res->u8 = v1->u8 == v2->i128; break; +# endif + +# if HAVE_UINT128 case PSI_T_UINT128: res->u8 = v1->u8 == v2->u128; break; +# endif + case PSI_T_FLOAT: res->u8 = v1->u8 == v2->fval; break; @@ -155,12 +167,18 @@ static inline token_t psi_calc_cmp_eq(token_t t1, impl_val *v1, token_t t2, impl case PSI_T_UINT64: res->u8 = v1->i16 == v2->u64; break; +# if HAVE_INT128 case PSI_T_INT128: res->u8 = v1->i16 == v2->i128; break; +# endif + +# if HAVE_UINT128 case PSI_T_UINT128: res->u8 = v1->i16 == v2->u128; break; +# endif + case PSI_T_FLOAT: res->u8 = v1->i16 == v2->fval; break; @@ -204,12 +222,18 @@ static inline token_t psi_calc_cmp_eq(token_t t1, impl_val *v1, token_t t2, impl case PSI_T_UINT64: res->u8 = v1->u16 == v2->u64; break; +# if HAVE_INT128 case PSI_T_INT128: res->u8 = v1->u16 == v2->i128; break; +# endif + +# if HAVE_UINT128 case PSI_T_UINT128: res->u8 = v1->u16 == v2->u128; break; +# endif + case PSI_T_FLOAT: res->u8 = v1->u16 == v2->fval; break; @@ -253,12 +277,18 @@ static inline token_t psi_calc_cmp_eq(token_t t1, impl_val *v1, token_t t2, impl case PSI_T_UINT64: res->u8 = v1->i32 == v2->u64; break; +# if HAVE_INT128 case PSI_T_INT128: res->u8 = v1->i32 == v2->i128; break; +# endif + +# if HAVE_UINT128 case PSI_T_UINT128: res->u8 = v1->i32 == v2->u128; break; +# endif + case PSI_T_FLOAT: res->u8 = v1->i32 == v2->fval; break; @@ -302,12 +332,18 @@ static inline token_t psi_calc_cmp_eq(token_t t1, impl_val *v1, token_t t2, impl case PSI_T_UINT64: res->u8 = v1->u32 == v2->u64; break; +# if HAVE_INT128 case PSI_T_INT128: res->u8 = v1->u32 == v2->i128; break; +# endif + +# if HAVE_UINT128 case PSI_T_UINT128: res->u8 = v1->u32 == v2->u128; break; +# endif + case PSI_T_FLOAT: res->u8 = v1->u32 == v2->fval; break; @@ -351,12 +387,18 @@ static inline token_t psi_calc_cmp_eq(token_t t1, impl_val *v1, token_t t2, impl case PSI_T_UINT64: res->u8 = v1->i64 == v2->u64; break; +# if HAVE_INT128 case PSI_T_INT128: res->u8 = v1->i64 == v2->i128; break; +# endif + +# if HAVE_UINT128 case PSI_T_UINT128: res->u8 = v1->i64 == v2->u128; break; +# endif + case PSI_T_FLOAT: res->u8 = v1->i64 == v2->fval; break; @@ -400,12 +442,18 @@ static inline token_t psi_calc_cmp_eq(token_t t1, impl_val *v1, token_t t2, impl case PSI_T_UINT64: res->u8 = v1->u64 == v2->u64; break; +# if HAVE_INT128 case PSI_T_INT128: res->u8 = v1->u64 == v2->i128; break; +# endif + +# if HAVE_UINT128 case PSI_T_UINT128: res->u8 = v1->u64 == v2->u128; break; +# endif + case PSI_T_FLOAT: res->u8 = v1->u64 == v2->fval; break; @@ -423,6 +471,7 @@ static inline token_t psi_calc_cmp_eq(token_t t1, impl_val *v1, token_t t2, impl break; } break; +#if HAVE_INT128 case PSI_T_INT128: switch (t2) { case PSI_T_INT8: @@ -449,12 +498,18 @@ static inline token_t psi_calc_cmp_eq(token_t t1, impl_val *v1, token_t t2, impl case PSI_T_UINT64: res->u8 = v1->i128 == v2->u64; break; +# if HAVE_INT128 case PSI_T_INT128: res->u8 = v1->i128 == v2->i128; break; +# endif + +# if HAVE_UINT128 case PSI_T_UINT128: res->u8 = v1->i128 == v2->u128; break; +# endif + case PSI_T_FLOAT: res->u8 = v1->i128 == v2->fval; break; @@ -472,6 +527,9 @@ static inline token_t psi_calc_cmp_eq(token_t t1, impl_val *v1, token_t t2, impl break; } break; +#endif + +#if HAVE_UINT128 case PSI_T_UINT128: switch (t2) { case PSI_T_INT8: @@ -498,12 +556,18 @@ static inline token_t psi_calc_cmp_eq(token_t t1, impl_val *v1, token_t t2, impl case PSI_T_UINT64: res->u8 = v1->u128 == v2->u64; break; +# if HAVE_INT128 case PSI_T_INT128: res->u8 = v1->u128 == v2->i128; break; +# endif + +# if HAVE_UINT128 case PSI_T_UINT128: res->u8 = v1->u128 == v2->u128; break; +# endif + case PSI_T_FLOAT: res->u8 = v1->u128 == v2->fval; break; @@ -521,6 +585,8 @@ static inline token_t psi_calc_cmp_eq(token_t t1, impl_val *v1, token_t t2, impl break; } break; +#endif + case PSI_T_FLOAT: switch (t2) { case PSI_T_INT8: @@ -547,12 +613,18 @@ static inline token_t psi_calc_cmp_eq(token_t t1, impl_val *v1, token_t t2, impl case PSI_T_UINT64: res->u8 = v1->fval == v2->u64; break; +# if HAVE_INT128 case PSI_T_INT128: res->u8 = v1->fval == v2->i128; break; +# endif + +# if HAVE_UINT128 case PSI_T_UINT128: res->u8 = v1->fval == v2->u128; break; +# endif + case PSI_T_FLOAT: res->u8 = v1->fval == v2->fval; break; @@ -596,12 +668,18 @@ static inline token_t psi_calc_cmp_eq(token_t t1, impl_val *v1, token_t t2, impl case PSI_T_UINT64: res->u8 = v1->dval == v2->u64; break; +# if HAVE_INT128 case PSI_T_INT128: res->u8 = v1->dval == v2->i128; break; +# endif + +# if HAVE_UINT128 case PSI_T_UINT128: res->u8 = v1->dval == v2->u128; break; +# endif + case PSI_T_FLOAT: res->u8 = v1->dval == v2->fval; break; @@ -646,12 +724,18 @@ static inline token_t psi_calc_cmp_eq(token_t t1, impl_val *v1, token_t t2, impl case PSI_T_UINT64: res->u8 = v1->ldval == v2->u64; break; +# if HAVE_INT128 case PSI_T_INT128: res->u8 = v1->ldval == v2->i128; break; +# endif + +# if HAVE_UINT128 case PSI_T_UINT128: res->u8 = v1->ldval == v2->u128; break; +# endif + case PSI_T_FLOAT: res->u8 = v1->ldval == v2->fval; break; @@ -707,12 +791,18 @@ static inline token_t psi_calc_cmp_ne(token_t t1, impl_val *v1, token_t t2, impl case PSI_T_UINT64: res->u8 = v1->i8 != v2->u64; break; +# if HAVE_INT128 case PSI_T_INT128: res->u8 = v1->i8 != v2->i128; break; +# endif + +# if HAVE_UINT128 case PSI_T_UINT128: res->u8 = v1->i8 != v2->u128; break; +# endif + case PSI_T_FLOAT: res->u8 = v1->i8 != v2->fval; break; @@ -756,12 +846,18 @@ static inline token_t psi_calc_cmp_ne(token_t t1, impl_val *v1, token_t t2, impl case PSI_T_UINT64: res->u8 = v1->u8 != v2->u64; break; +# if HAVE_INT128 case PSI_T_INT128: res->u8 = v1->u8 != v2->i128; break; +# endif + +# if HAVE_UINT128 case PSI_T_UINT128: res->u8 = v1->u8 != v2->u128; break; +# endif + case PSI_T_FLOAT: res->u8 = v1->u8 != v2->fval; break; @@ -805,12 +901,18 @@ static inline token_t psi_calc_cmp_ne(token_t t1, impl_val *v1, token_t t2, impl case PSI_T_UINT64: res->u8 = v1->i16 != v2->u64; break; +# if HAVE_INT128 case PSI_T_INT128: res->u8 = v1->i16 != v2->i128; break; +# endif + +# if HAVE_UINT128 case PSI_T_UINT128: res->u8 = v1->i16 != v2->u128; break; +# endif + case PSI_T_FLOAT: res->u8 = v1->i16 != v2->fval; break; @@ -854,12 +956,18 @@ static inline token_t psi_calc_cmp_ne(token_t t1, impl_val *v1, token_t t2, impl case PSI_T_UINT64: res->u8 = v1->u16 != v2->u64; break; +# if HAVE_INT128 case PSI_T_INT128: res->u8 = v1->u16 != v2->i128; break; +# endif + +# if HAVE_UINT128 case PSI_T_UINT128: res->u8 = v1->u16 != v2->u128; break; +# endif + case PSI_T_FLOAT: res->u8 = v1->u16 != v2->fval; break; @@ -903,12 +1011,18 @@ static inline token_t psi_calc_cmp_ne(token_t t1, impl_val *v1, token_t t2, impl case PSI_T_UINT64: res->u8 = v1->i32 != v2->u64; break; +# if HAVE_INT128 case PSI_T_INT128: res->u8 = v1->i32 != v2->i128; break; +# endif + +# if HAVE_UINT128 case PSI_T_UINT128: res->u8 = v1->i32 != v2->u128; break; +# endif + case PSI_T_FLOAT: res->u8 = v1->i32 != v2->fval; break; @@ -952,12 +1066,18 @@ static inline token_t psi_calc_cmp_ne(token_t t1, impl_val *v1, token_t t2, impl case PSI_T_UINT64: res->u8 = v1->u32 != v2->u64; break; +# if HAVE_INT128 case PSI_T_INT128: res->u8 = v1->u32 != v2->i128; break; +# endif + +# if HAVE_UINT128 case PSI_T_UINT128: res->u8 = v1->u32 != v2->u128; break; +# endif + case PSI_T_FLOAT: res->u8 = v1->u32 != v2->fval; break; @@ -1001,12 +1121,18 @@ static inline token_t psi_calc_cmp_ne(token_t t1, impl_val *v1, token_t t2, impl case PSI_T_UINT64: res->u8 = v1->i64 != v2->u64; break; +# if HAVE_INT128 case PSI_T_INT128: res->u8 = v1->i64 != v2->i128; break; +# endif + +# if HAVE_UINT128 case PSI_T_UINT128: res->u8 = v1->i64 != v2->u128; break; +# endif + case PSI_T_FLOAT: res->u8 = v1->i64 != v2->fval; break; @@ -1050,12 +1176,18 @@ static inline token_t psi_calc_cmp_ne(token_t t1, impl_val *v1, token_t t2, impl case PSI_T_UINT64: res->u8 = v1->u64 != v2->u64; break; +# if HAVE_INT128 case PSI_T_INT128: res->u8 = v1->u64 != v2->i128; break; +# endif + +# if HAVE_UINT128 case PSI_T_UINT128: res->u8 = v1->u64 != v2->u128; break; +# endif + case PSI_T_FLOAT: res->u8 = v1->u64 != v2->fval; break; @@ -1073,6 +1205,7 @@ static inline token_t psi_calc_cmp_ne(token_t t1, impl_val *v1, token_t t2, impl break; } break; +#if HAVE_INT128 case PSI_T_INT128: switch (t2) { case PSI_T_INT8: @@ -1099,12 +1232,18 @@ static inline token_t psi_calc_cmp_ne(token_t t1, impl_val *v1, token_t t2, impl case PSI_T_UINT64: res->u8 = v1->i128 != v2->u64; break; +# if HAVE_INT128 case PSI_T_INT128: res->u8 = v1->i128 != v2->i128; break; +# endif + +# if HAVE_UINT128 case PSI_T_UINT128: res->u8 = v1->i128 != v2->u128; break; +# endif + case PSI_T_FLOAT: res->u8 = v1->i128 != v2->fval; break; @@ -1122,6 +1261,9 @@ static inline token_t psi_calc_cmp_ne(token_t t1, impl_val *v1, token_t t2, impl break; } break; +#endif + +#if HAVE_UINT128 case PSI_T_UINT128: switch (t2) { case PSI_T_INT8: @@ -1148,12 +1290,18 @@ static inline token_t psi_calc_cmp_ne(token_t t1, impl_val *v1, token_t t2, impl case PSI_T_UINT64: res->u8 = v1->u128 != v2->u64; break; +# if HAVE_INT128 case PSI_T_INT128: res->u8 = v1->u128 != v2->i128; break; +# endif + +# if HAVE_UINT128 case PSI_T_UINT128: res->u8 = v1->u128 != v2->u128; break; +# endif + case PSI_T_FLOAT: res->u8 = v1->u128 != v2->fval; break; @@ -1171,6 +1319,8 @@ static inline token_t psi_calc_cmp_ne(token_t t1, impl_val *v1, token_t t2, impl break; } break; +#endif + case PSI_T_FLOAT: switch (t2) { case PSI_T_INT8: @@ -1197,12 +1347,18 @@ static inline token_t psi_calc_cmp_ne(token_t t1, impl_val *v1, token_t t2, impl case PSI_T_UINT64: res->u8 = v1->fval != v2->u64; break; +# if HAVE_INT128 case PSI_T_INT128: res->u8 = v1->fval != v2->i128; break; +# endif + +# if HAVE_UINT128 case PSI_T_UINT128: res->u8 = v1->fval != v2->u128; break; +# endif + case PSI_T_FLOAT: res->u8 = v1->fval != v2->fval; break; @@ -1246,12 +1402,18 @@ static inline token_t psi_calc_cmp_ne(token_t t1, impl_val *v1, token_t t2, impl case PSI_T_UINT64: res->u8 = v1->dval != v2->u64; break; +# if HAVE_INT128 case PSI_T_INT128: res->u8 = v1->dval != v2->i128; break; +# endif + +# if HAVE_UINT128 case PSI_T_UINT128: res->u8 = v1->dval != v2->u128; break; +# endif + case PSI_T_FLOAT: res->u8 = v1->dval != v2->fval; break; @@ -1296,12 +1458,18 @@ static inline token_t psi_calc_cmp_ne(token_t t1, impl_val *v1, token_t t2, impl case PSI_T_UINT64: res->u8 = v1->ldval != v2->u64; break; +# if HAVE_INT128 case PSI_T_INT128: res->u8 = v1->ldval != v2->i128; break; +# endif + +# if HAVE_UINT128 case PSI_T_UINT128: res->u8 = v1->ldval != v2->u128; break; +# endif + case PSI_T_FLOAT: res->u8 = v1->ldval != v2->fval; break; @@ -1357,12 +1525,18 @@ static inline token_t psi_calc_cmp_lt(token_t t1, impl_val *v1, token_t t2, impl case PSI_T_UINT64: res->u8 = v1->i8 < v2->u64; break; +# if HAVE_INT128 case PSI_T_INT128: res->u8 = v1->i8 < v2->i128; break; +# endif + +# if HAVE_UINT128 case PSI_T_UINT128: res->u8 = v1->i8 < v2->u128; break; +# endif + case PSI_T_FLOAT: res->u8 = v1->i8 < v2->fval; break; @@ -1406,12 +1580,18 @@ static inline token_t psi_calc_cmp_lt(token_t t1, impl_val *v1, token_t t2, impl case PSI_T_UINT64: res->u8 = v1->u8 < v2->u64; break; +# if HAVE_INT128 case PSI_T_INT128: res->u8 = v1->u8 < v2->i128; break; +# endif + +# if HAVE_UINT128 case PSI_T_UINT128: res->u8 = v1->u8 < v2->u128; break; +# endif + case PSI_T_FLOAT: res->u8 = v1->u8 < v2->fval; break; @@ -1455,12 +1635,18 @@ static inline token_t psi_calc_cmp_lt(token_t t1, impl_val *v1, token_t t2, impl case PSI_T_UINT64: res->u8 = v1->i16 < v2->u64; break; +# if HAVE_INT128 case PSI_T_INT128: res->u8 = v1->i16 < v2->i128; break; +# endif + +# if HAVE_UINT128 case PSI_T_UINT128: res->u8 = v1->i16 < v2->u128; break; +# endif + case PSI_T_FLOAT: res->u8 = v1->i16 < v2->fval; break; @@ -1504,12 +1690,18 @@ static inline token_t psi_calc_cmp_lt(token_t t1, impl_val *v1, token_t t2, impl case PSI_T_UINT64: res->u8 = v1->u16 < v2->u64; break; +# if HAVE_INT128 case PSI_T_INT128: res->u8 = v1->u16 < v2->i128; break; +# endif + +# if HAVE_UINT128 case PSI_T_UINT128: res->u8 = v1->u16 < v2->u128; break; +# endif + case PSI_T_FLOAT: res->u8 = v1->u16 < v2->fval; break; @@ -1553,12 +1745,18 @@ static inline token_t psi_calc_cmp_lt(token_t t1, impl_val *v1, token_t t2, impl case PSI_T_UINT64: res->u8 = v1->i32 < v2->u64; break; +# if HAVE_INT128 case PSI_T_INT128: res->u8 = v1->i32 < v2->i128; break; +# endif + +# if HAVE_UINT128 case PSI_T_UINT128: res->u8 = v1->i32 < v2->u128; break; +# endif + case PSI_T_FLOAT: res->u8 = v1->i32 < v2->fval; break; @@ -1602,12 +1800,18 @@ static inline token_t psi_calc_cmp_lt(token_t t1, impl_val *v1, token_t t2, impl case PSI_T_UINT64: res->u8 = v1->u32 < v2->u64; break; +# if HAVE_INT128 case PSI_T_INT128: res->u8 = v1->u32 < v2->i128; break; +# endif + +# if HAVE_UINT128 case PSI_T_UINT128: res->u8 = v1->u32 < v2->u128; break; +# endif + case PSI_T_FLOAT: res->u8 = v1->u32 < v2->fval; break; @@ -1651,12 +1855,18 @@ static inline token_t psi_calc_cmp_lt(token_t t1, impl_val *v1, token_t t2, impl case PSI_T_UINT64: res->u8 = v1->i64 < v2->u64; break; +# if HAVE_INT128 case PSI_T_INT128: res->u8 = v1->i64 < v2->i128; break; +# endif + +# if HAVE_UINT128 case PSI_T_UINT128: res->u8 = v1->i64 < v2->u128; break; +# endif + case PSI_T_FLOAT: res->u8 = v1->i64 < v2->fval; break; @@ -1700,12 +1910,18 @@ static inline token_t psi_calc_cmp_lt(token_t t1, impl_val *v1, token_t t2, impl case PSI_T_UINT64: res->u8 = v1->u64 < v2->u64; break; +# if HAVE_INT128 case PSI_T_INT128: res->u8 = v1->u64 < v2->i128; break; +# endif + +# if HAVE_UINT128 case PSI_T_UINT128: res->u8 = v1->u64 < v2->u128; break; +# endif + case PSI_T_FLOAT: res->u8 = v1->u64 < v2->fval; break; @@ -1723,6 +1939,7 @@ static inline token_t psi_calc_cmp_lt(token_t t1, impl_val *v1, token_t t2, impl break; } break; +#if HAVE_INT128 case PSI_T_INT128: switch (t2) { case PSI_T_INT8: @@ -1749,12 +1966,18 @@ static inline token_t psi_calc_cmp_lt(token_t t1, impl_val *v1, token_t t2, impl case PSI_T_UINT64: res->u8 = v1->i128 < v2->u64; break; +# if HAVE_INT128 case PSI_T_INT128: res->u8 = v1->i128 < v2->i128; break; +# endif + +# if HAVE_UINT128 case PSI_T_UINT128: res->u8 = v1->i128 < v2->u128; break; +# endif + case PSI_T_FLOAT: res->u8 = v1->i128 < v2->fval; break; @@ -1772,6 +1995,9 @@ static inline token_t psi_calc_cmp_lt(token_t t1, impl_val *v1, token_t t2, impl break; } break; +#endif + +#if HAVE_UINT128 case PSI_T_UINT128: switch (t2) { case PSI_T_INT8: @@ -1798,12 +2024,18 @@ static inline token_t psi_calc_cmp_lt(token_t t1, impl_val *v1, token_t t2, impl case PSI_T_UINT64: res->u8 = v1->u128 < v2->u64; break; +# if HAVE_INT128 case PSI_T_INT128: res->u8 = v1->u128 < v2->i128; break; +# endif + +# if HAVE_UINT128 case PSI_T_UINT128: res->u8 = v1->u128 < v2->u128; break; +# endif + case PSI_T_FLOAT: res->u8 = v1->u128 < v2->fval; break; @@ -1821,6 +2053,8 @@ static inline token_t psi_calc_cmp_lt(token_t t1, impl_val *v1, token_t t2, impl break; } break; +#endif + case PSI_T_FLOAT: switch (t2) { case PSI_T_INT8: @@ -1847,12 +2081,18 @@ static inline token_t psi_calc_cmp_lt(token_t t1, impl_val *v1, token_t t2, impl case PSI_T_UINT64: res->u8 = v1->fval < v2->u64; break; +# if HAVE_INT128 case PSI_T_INT128: res->u8 = v1->fval < v2->i128; break; +# endif + +# if HAVE_UINT128 case PSI_T_UINT128: res->u8 = v1->fval < v2->u128; break; +# endif + case PSI_T_FLOAT: res->u8 = v1->fval < v2->fval; break; @@ -1896,12 +2136,18 @@ static inline token_t psi_calc_cmp_lt(token_t t1, impl_val *v1, token_t t2, impl case PSI_T_UINT64: res->u8 = v1->dval < v2->u64; break; +# if HAVE_INT128 case PSI_T_INT128: res->u8 = v1->dval < v2->i128; break; +# endif + +# if HAVE_UINT128 case PSI_T_UINT128: res->u8 = v1->dval < v2->u128; break; +# endif + case PSI_T_FLOAT: res->u8 = v1->dval < v2->fval; break; @@ -1946,12 +2192,18 @@ static inline token_t psi_calc_cmp_lt(token_t t1, impl_val *v1, token_t t2, impl case PSI_T_UINT64: res->u8 = v1->ldval < v2->u64; break; +# if HAVE_INT128 case PSI_T_INT128: res->u8 = v1->ldval < v2->i128; break; +# endif + +# if HAVE_UINT128 case PSI_T_UINT128: res->u8 = v1->ldval < v2->u128; break; +# endif + case PSI_T_FLOAT: res->u8 = v1->ldval < v2->fval; break; @@ -2007,12 +2259,18 @@ static inline token_t psi_calc_cmp_gt(token_t t1, impl_val *v1, token_t t2, impl case PSI_T_UINT64: res->u8 = v1->i8 > v2->u64; break; +# if HAVE_INT128 case PSI_T_INT128: res->u8 = v1->i8 > v2->i128; break; +# endif + +# if HAVE_UINT128 case PSI_T_UINT128: res->u8 = v1->i8 > v2->u128; break; +# endif + case PSI_T_FLOAT: res->u8 = v1->i8 > v2->fval; break; @@ -2056,12 +2314,18 @@ static inline token_t psi_calc_cmp_gt(token_t t1, impl_val *v1, token_t t2, impl case PSI_T_UINT64: res->u8 = v1->u8 > v2->u64; break; +# if HAVE_INT128 case PSI_T_INT128: res->u8 = v1->u8 > v2->i128; break; +# endif + +# if HAVE_UINT128 case PSI_T_UINT128: res->u8 = v1->u8 > v2->u128; break; +# endif + case PSI_T_FLOAT: res->u8 = v1->u8 > v2->fval; break; @@ -2105,12 +2369,18 @@ static inline token_t psi_calc_cmp_gt(token_t t1, impl_val *v1, token_t t2, impl case PSI_T_UINT64: res->u8 = v1->i16 > v2->u64; break; +# if HAVE_INT128 case PSI_T_INT128: res->u8 = v1->i16 > v2->i128; break; +# endif + +# if HAVE_UINT128 case PSI_T_UINT128: res->u8 = v1->i16 > v2->u128; break; +# endif + case PSI_T_FLOAT: res->u8 = v1->i16 > v2->fval; break; @@ -2154,12 +2424,18 @@ static inline token_t psi_calc_cmp_gt(token_t t1, impl_val *v1, token_t t2, impl case PSI_T_UINT64: res->u8 = v1->u16 > v2->u64; break; +# if HAVE_INT128 case PSI_T_INT128: res->u8 = v1->u16 > v2->i128; break; +# endif + +# if HAVE_UINT128 case PSI_T_UINT128: res->u8 = v1->u16 > v2->u128; break; +# endif + case PSI_T_FLOAT: res->u8 = v1->u16 > v2->fval; break; @@ -2203,12 +2479,18 @@ static inline token_t psi_calc_cmp_gt(token_t t1, impl_val *v1, token_t t2, impl case PSI_T_UINT64: res->u8 = v1->i32 > v2->u64; break; +# if HAVE_INT128 case PSI_T_INT128: res->u8 = v1->i32 > v2->i128; break; +# endif + +# if HAVE_UINT128 case PSI_T_UINT128: res->u8 = v1->i32 > v2->u128; break; +# endif + case PSI_T_FLOAT: res->u8 = v1->i32 > v2->fval; break; @@ -2252,12 +2534,18 @@ static inline token_t psi_calc_cmp_gt(token_t t1, impl_val *v1, token_t t2, impl case PSI_T_UINT64: res->u8 = v1->u32 > v2->u64; break; +# if HAVE_INT128 case PSI_T_INT128: res->u8 = v1->u32 > v2->i128; break; +# endif + +# if HAVE_UINT128 case PSI_T_UINT128: res->u8 = v1->u32 > v2->u128; break; +# endif + case PSI_T_FLOAT: res->u8 = v1->u32 > v2->fval; break; @@ -2301,12 +2589,18 @@ static inline token_t psi_calc_cmp_gt(token_t t1, impl_val *v1, token_t t2, impl case PSI_T_UINT64: res->u8 = v1->i64 > v2->u64; break; +# if HAVE_INT128 case PSI_T_INT128: res->u8 = v1->i64 > v2->i128; break; +# endif + +# if HAVE_UINT128 case PSI_T_UINT128: res->u8 = v1->i64 > v2->u128; break; +# endif + case PSI_T_FLOAT: res->u8 = v1->i64 > v2->fval; break; @@ -2350,12 +2644,18 @@ static inline token_t psi_calc_cmp_gt(token_t t1, impl_val *v1, token_t t2, impl case PSI_T_UINT64: res->u8 = v1->u64 > v2->u64; break; +# if HAVE_INT128 case PSI_T_INT128: res->u8 = v1->u64 > v2->i128; break; +# endif + +# if HAVE_UINT128 case PSI_T_UINT128: res->u8 = v1->u64 > v2->u128; break; +# endif + case PSI_T_FLOAT: res->u8 = v1->u64 > v2->fval; break; @@ -2373,6 +2673,7 @@ static inline token_t psi_calc_cmp_gt(token_t t1, impl_val *v1, token_t t2, impl break; } break; +#if HAVE_INT128 case PSI_T_INT128: switch (t2) { case PSI_T_INT8: @@ -2399,12 +2700,18 @@ static inline token_t psi_calc_cmp_gt(token_t t1, impl_val *v1, token_t t2, impl case PSI_T_UINT64: res->u8 = v1->i128 > v2->u64; break; +# if HAVE_INT128 case PSI_T_INT128: res->u8 = v1->i128 > v2->i128; break; +# endif + +# if HAVE_UINT128 case PSI_T_UINT128: res->u8 = v1->i128 > v2->u128; break; +# endif + case PSI_T_FLOAT: res->u8 = v1->i128 > v2->fval; break; @@ -2422,6 +2729,9 @@ static inline token_t psi_calc_cmp_gt(token_t t1, impl_val *v1, token_t t2, impl break; } break; +#endif + +#if HAVE_UINT128 case PSI_T_UINT128: switch (t2) { case PSI_T_INT8: @@ -2448,12 +2758,18 @@ static inline token_t psi_calc_cmp_gt(token_t t1, impl_val *v1, token_t t2, impl case PSI_T_UINT64: res->u8 = v1->u128 > v2->u64; break; +# if HAVE_INT128 case PSI_T_INT128: res->u8 = v1->u128 > v2->i128; break; +# endif + +# if HAVE_UINT128 case PSI_T_UINT128: res->u8 = v1->u128 > v2->u128; break; +# endif + case PSI_T_FLOAT: res->u8 = v1->u128 > v2->fval; break; @@ -2471,6 +2787,8 @@ static inline token_t psi_calc_cmp_gt(token_t t1, impl_val *v1, token_t t2, impl break; } break; +#endif + case PSI_T_FLOAT: switch (t2) { case PSI_T_INT8: @@ -2497,12 +2815,18 @@ static inline token_t psi_calc_cmp_gt(token_t t1, impl_val *v1, token_t t2, impl case PSI_T_UINT64: res->u8 = v1->fval > v2->u64; break; +# if HAVE_INT128 case PSI_T_INT128: res->u8 = v1->fval > v2->i128; break; +# endif + +# if HAVE_UINT128 case PSI_T_UINT128: res->u8 = v1->fval > v2->u128; break; +# endif + case PSI_T_FLOAT: res->u8 = v1->fval > v2->fval; break; @@ -2546,12 +2870,18 @@ static inline token_t psi_calc_cmp_gt(token_t t1, impl_val *v1, token_t t2, impl case PSI_T_UINT64: res->u8 = v1->dval > v2->u64; break; +# if HAVE_INT128 case PSI_T_INT128: res->u8 = v1->dval > v2->i128; break; +# endif + +# if HAVE_UINT128 case PSI_T_UINT128: res->u8 = v1->dval > v2->u128; break; +# endif + case PSI_T_FLOAT: res->u8 = v1->dval > v2->fval; break; @@ -2596,12 +2926,18 @@ static inline token_t psi_calc_cmp_gt(token_t t1, impl_val *v1, token_t t2, impl case PSI_T_UINT64: res->u8 = v1->ldval > v2->u64; break; +# if HAVE_INT128 case PSI_T_INT128: res->u8 = v1->ldval > v2->i128; break; +# endif + +# if HAVE_UINT128 case PSI_T_UINT128: res->u8 = v1->ldval > v2->u128; break; +# endif + case PSI_T_FLOAT: res->u8 = v1->ldval > v2->fval; break; @@ -2657,12 +2993,18 @@ static inline token_t psi_calc_cmp_le(token_t t1, impl_val *v1, token_t t2, impl case PSI_T_UINT64: res->u8 = v1->i8 <= v2->u64; break; +# if HAVE_INT128 case PSI_T_INT128: res->u8 = v1->i8 <= v2->i128; break; +# endif + +# if HAVE_UINT128 case PSI_T_UINT128: res->u8 = v1->i8 <= v2->u128; break; +# endif + case PSI_T_FLOAT: res->u8 = v1->i8 <= v2->fval; break; @@ -2706,12 +3048,18 @@ static inline token_t psi_calc_cmp_le(token_t t1, impl_val *v1, token_t t2, impl case PSI_T_UINT64: res->u8 = v1->u8 <= v2->u64; break; +# if HAVE_INT128 case PSI_T_INT128: res->u8 = v1->u8 <= v2->i128; break; +# endif + +# if HAVE_UINT128 case PSI_T_UINT128: res->u8 = v1->u8 <= v2->u128; break; +# endif + case PSI_T_FLOAT: res->u8 = v1->u8 <= v2->fval; break; @@ -2755,12 +3103,18 @@ static inline token_t psi_calc_cmp_le(token_t t1, impl_val *v1, token_t t2, impl case PSI_T_UINT64: res->u8 = v1->i16 <= v2->u64; break; +# if HAVE_INT128 case PSI_T_INT128: res->u8 = v1->i16 <= v2->i128; break; +# endif + +# if HAVE_UINT128 case PSI_T_UINT128: res->u8 = v1->i16 <= v2->u128; break; +# endif + case PSI_T_FLOAT: res->u8 = v1->i16 <= v2->fval; break; @@ -2804,12 +3158,18 @@ static inline token_t psi_calc_cmp_le(token_t t1, impl_val *v1, token_t t2, impl case PSI_T_UINT64: res->u8 = v1->u16 <= v2->u64; break; +# if HAVE_INT128 case PSI_T_INT128: res->u8 = v1->u16 <= v2->i128; break; +# endif + +# if HAVE_UINT128 case PSI_T_UINT128: res->u8 = v1->u16 <= v2->u128; break; +# endif + case PSI_T_FLOAT: res->u8 = v1->u16 <= v2->fval; break; @@ -2853,12 +3213,18 @@ static inline token_t psi_calc_cmp_le(token_t t1, impl_val *v1, token_t t2, impl case PSI_T_UINT64: res->u8 = v1->i32 <= v2->u64; break; +# if HAVE_INT128 case PSI_T_INT128: res->u8 = v1->i32 <= v2->i128; break; +# endif + +# if HAVE_UINT128 case PSI_T_UINT128: res->u8 = v1->i32 <= v2->u128; break; +# endif + case PSI_T_FLOAT: res->u8 = v1->i32 <= v2->fval; break; @@ -2902,12 +3268,18 @@ static inline token_t psi_calc_cmp_le(token_t t1, impl_val *v1, token_t t2, impl case PSI_T_UINT64: res->u8 = v1->u32 <= v2->u64; break; +# if HAVE_INT128 case PSI_T_INT128: res->u8 = v1->u32 <= v2->i128; break; +# endif + +# if HAVE_UINT128 case PSI_T_UINT128: res->u8 = v1->u32 <= v2->u128; break; +# endif + case PSI_T_FLOAT: res->u8 = v1->u32 <= v2->fval; break; @@ -2951,12 +3323,18 @@ static inline token_t psi_calc_cmp_le(token_t t1, impl_val *v1, token_t t2, impl case PSI_T_UINT64: res->u8 = v1->i64 <= v2->u64; break; +# if HAVE_INT128 case PSI_T_INT128: res->u8 = v1->i64 <= v2->i128; break; +# endif + +# if HAVE_UINT128 case PSI_T_UINT128: res->u8 = v1->i64 <= v2->u128; break; +# endif + case PSI_T_FLOAT: res->u8 = v1->i64 <= v2->fval; break; @@ -3000,12 +3378,18 @@ static inline token_t psi_calc_cmp_le(token_t t1, impl_val *v1, token_t t2, impl case PSI_T_UINT64: res->u8 = v1->u64 <= v2->u64; break; +# if HAVE_INT128 case PSI_T_INT128: res->u8 = v1->u64 <= v2->i128; break; +# endif + +# if HAVE_UINT128 case PSI_T_UINT128: res->u8 = v1->u64 <= v2->u128; break; +# endif + case PSI_T_FLOAT: res->u8 = v1->u64 <= v2->fval; break; @@ -3023,6 +3407,7 @@ static inline token_t psi_calc_cmp_le(token_t t1, impl_val *v1, token_t t2, impl break; } break; +#if HAVE_INT128 case PSI_T_INT128: switch (t2) { case PSI_T_INT8: @@ -3049,12 +3434,18 @@ static inline token_t psi_calc_cmp_le(token_t t1, impl_val *v1, token_t t2, impl case PSI_T_UINT64: res->u8 = v1->i128 <= v2->u64; break; +# if HAVE_INT128 case PSI_T_INT128: res->u8 = v1->i128 <= v2->i128; break; +# endif + +# if HAVE_UINT128 case PSI_T_UINT128: res->u8 = v1->i128 <= v2->u128; break; +# endif + case PSI_T_FLOAT: res->u8 = v1->i128 <= v2->fval; break; @@ -3072,6 +3463,9 @@ static inline token_t psi_calc_cmp_le(token_t t1, impl_val *v1, token_t t2, impl break; } break; +#endif + +#if HAVE_UINT128 case PSI_T_UINT128: switch (t2) { case PSI_T_INT8: @@ -3098,12 +3492,18 @@ static inline token_t psi_calc_cmp_le(token_t t1, impl_val *v1, token_t t2, impl case PSI_T_UINT64: res->u8 = v1->u128 <= v2->u64; break; +# if HAVE_INT128 case PSI_T_INT128: res->u8 = v1->u128 <= v2->i128; break; +# endif + +# if HAVE_UINT128 case PSI_T_UINT128: res->u8 = v1->u128 <= v2->u128; break; +# endif + case PSI_T_FLOAT: res->u8 = v1->u128 <= v2->fval; break; @@ -3121,6 +3521,8 @@ static inline token_t psi_calc_cmp_le(token_t t1, impl_val *v1, token_t t2, impl break; } break; +#endif + case PSI_T_FLOAT: switch (t2) { case PSI_T_INT8: @@ -3147,12 +3549,18 @@ static inline token_t psi_calc_cmp_le(token_t t1, impl_val *v1, token_t t2, impl case PSI_T_UINT64: res->u8 = v1->fval <= v2->u64; break; +# if HAVE_INT128 case PSI_T_INT128: res->u8 = v1->fval <= v2->i128; break; +# endif + +# if HAVE_UINT128 case PSI_T_UINT128: res->u8 = v1->fval <= v2->u128; break; +# endif + case PSI_T_FLOAT: res->u8 = v1->fval <= v2->fval; break; @@ -3196,12 +3604,18 @@ static inline token_t psi_calc_cmp_le(token_t t1, impl_val *v1, token_t t2, impl case PSI_T_UINT64: res->u8 = v1->dval <= v2->u64; break; +# if HAVE_INT128 case PSI_T_INT128: res->u8 = v1->dval <= v2->i128; break; +# endif + +# if HAVE_UINT128 case PSI_T_UINT128: res->u8 = v1->dval <= v2->u128; break; +# endif + case PSI_T_FLOAT: res->u8 = v1->dval <= v2->fval; break; @@ -3246,12 +3660,18 @@ static inline token_t psi_calc_cmp_le(token_t t1, impl_val *v1, token_t t2, impl case PSI_T_UINT64: res->u8 = v1->ldval <= v2->u64; break; +# if HAVE_INT128 case PSI_T_INT128: res->u8 = v1->ldval <= v2->i128; break; +# endif + +# if HAVE_UINT128 case PSI_T_UINT128: res->u8 = v1->ldval <= v2->u128; break; +# endif + case PSI_T_FLOAT: res->u8 = v1->ldval <= v2->fval; break; @@ -3307,12 +3727,18 @@ static inline token_t psi_calc_cmp_ge(token_t t1, impl_val *v1, token_t t2, impl case PSI_T_UINT64: res->u8 = v1->i8 >= v2->u64; break; +# if HAVE_INT128 case PSI_T_INT128: res->u8 = v1->i8 >= v2->i128; break; +# endif + +# if HAVE_UINT128 case PSI_T_UINT128: res->u8 = v1->i8 >= v2->u128; break; +# endif + case PSI_T_FLOAT: res->u8 = v1->i8 >= v2->fval; break; @@ -3356,12 +3782,18 @@ static inline token_t psi_calc_cmp_ge(token_t t1, impl_val *v1, token_t t2, impl case PSI_T_UINT64: res->u8 = v1->u8 >= v2->u64; break; +# if HAVE_INT128 case PSI_T_INT128: res->u8 = v1->u8 >= v2->i128; break; +# endif + +# if HAVE_UINT128 case PSI_T_UINT128: res->u8 = v1->u8 >= v2->u128; break; +# endif + case PSI_T_FLOAT: res->u8 = v1->u8 >= v2->fval; break; @@ -3405,12 +3837,18 @@ static inline token_t psi_calc_cmp_ge(token_t t1, impl_val *v1, token_t t2, impl case PSI_T_UINT64: res->u8 = v1->i16 >= v2->u64; break; +# if HAVE_INT128 case PSI_T_INT128: res->u8 = v1->i16 >= v2->i128; break; +# endif + +# if HAVE_UINT128 case PSI_T_UINT128: res->u8 = v1->i16 >= v2->u128; break; +# endif + case PSI_T_FLOAT: res->u8 = v1->i16 >= v2->fval; break; @@ -3454,12 +3892,18 @@ static inline token_t psi_calc_cmp_ge(token_t t1, impl_val *v1, token_t t2, impl case PSI_T_UINT64: res->u8 = v1->u16 >= v2->u64; break; +# if HAVE_INT128 case PSI_T_INT128: res->u8 = v1->u16 >= v2->i128; break; +# endif + +# if HAVE_UINT128 case PSI_T_UINT128: res->u8 = v1->u16 >= v2->u128; break; +# endif + case PSI_T_FLOAT: res->u8 = v1->u16 >= v2->fval; break; @@ -3503,12 +3947,18 @@ static inline token_t psi_calc_cmp_ge(token_t t1, impl_val *v1, token_t t2, impl case PSI_T_UINT64: res->u8 = v1->i32 >= v2->u64; break; +# if HAVE_INT128 case PSI_T_INT128: res->u8 = v1->i32 >= v2->i128; break; +# endif + +# if HAVE_UINT128 case PSI_T_UINT128: res->u8 = v1->i32 >= v2->u128; break; +# endif + case PSI_T_FLOAT: res->u8 = v1->i32 >= v2->fval; break; @@ -3552,12 +4002,18 @@ static inline token_t psi_calc_cmp_ge(token_t t1, impl_val *v1, token_t t2, impl case PSI_T_UINT64: res->u8 = v1->u32 >= v2->u64; break; +# if HAVE_INT128 case PSI_T_INT128: res->u8 = v1->u32 >= v2->i128; break; +# endif + +# if HAVE_UINT128 case PSI_T_UINT128: res->u8 = v1->u32 >= v2->u128; break; +# endif + case PSI_T_FLOAT: res->u8 = v1->u32 >= v2->fval; break; @@ -3601,12 +4057,18 @@ static inline token_t psi_calc_cmp_ge(token_t t1, impl_val *v1, token_t t2, impl case PSI_T_UINT64: res->u8 = v1->i64 >= v2->u64; break; +# if HAVE_INT128 case PSI_T_INT128: res->u8 = v1->i64 >= v2->i128; break; +# endif + +# if HAVE_UINT128 case PSI_T_UINT128: res->u8 = v1->i64 >= v2->u128; break; +# endif + case PSI_T_FLOAT: res->u8 = v1->i64 >= v2->fval; break; @@ -3650,12 +4112,18 @@ static inline token_t psi_calc_cmp_ge(token_t t1, impl_val *v1, token_t t2, impl case PSI_T_UINT64: res->u8 = v1->u64 >= v2->u64; break; +# if HAVE_INT128 case PSI_T_INT128: res->u8 = v1->u64 >= v2->i128; break; +# endif + +# if HAVE_UINT128 case PSI_T_UINT128: res->u8 = v1->u64 >= v2->u128; break; +# endif + case PSI_T_FLOAT: res->u8 = v1->u64 >= v2->fval; break; @@ -3673,6 +4141,7 @@ static inline token_t psi_calc_cmp_ge(token_t t1, impl_val *v1, token_t t2, impl break; } break; +#if HAVE_INT128 case PSI_T_INT128: switch (t2) { case PSI_T_INT8: @@ -3699,12 +4168,18 @@ static inline token_t psi_calc_cmp_ge(token_t t1, impl_val *v1, token_t t2, impl case PSI_T_UINT64: res->u8 = v1->i128 >= v2->u64; break; +# if HAVE_INT128 case PSI_T_INT128: res->u8 = v1->i128 >= v2->i128; break; +# endif + +# if HAVE_UINT128 case PSI_T_UINT128: res->u8 = v1->i128 >= v2->u128; break; +# endif + case PSI_T_FLOAT: res->u8 = v1->i128 >= v2->fval; break; @@ -3722,6 +4197,9 @@ static inline token_t psi_calc_cmp_ge(token_t t1, impl_val *v1, token_t t2, impl break; } break; +#endif + +#if HAVE_UINT128 case PSI_T_UINT128: switch (t2) { case PSI_T_INT8: @@ -3748,12 +4226,18 @@ static inline token_t psi_calc_cmp_ge(token_t t1, impl_val *v1, token_t t2, impl case PSI_T_UINT64: res->u8 = v1->u128 >= v2->u64; break; +# if HAVE_INT128 case PSI_T_INT128: res->u8 = v1->u128 >= v2->i128; break; +# endif + +# if HAVE_UINT128 case PSI_T_UINT128: res->u8 = v1->u128 >= v2->u128; break; +# endif + case PSI_T_FLOAT: res->u8 = v1->u128 >= v2->fval; break; @@ -3771,6 +4255,8 @@ static inline token_t psi_calc_cmp_ge(token_t t1, impl_val *v1, token_t t2, impl break; } break; +#endif + case PSI_T_FLOAT: switch (t2) { case PSI_T_INT8: @@ -3797,12 +4283,18 @@ static inline token_t psi_calc_cmp_ge(token_t t1, impl_val *v1, token_t t2, impl case PSI_T_UINT64: res->u8 = v1->fval >= v2->u64; break; +# if HAVE_INT128 case PSI_T_INT128: res->u8 = v1->fval >= v2->i128; break; +# endif + +# if HAVE_UINT128 case PSI_T_UINT128: res->u8 = v1->fval >= v2->u128; break; +# endif + case PSI_T_FLOAT: res->u8 = v1->fval >= v2->fval; break; @@ -3846,12 +4338,18 @@ static inline token_t psi_calc_cmp_ge(token_t t1, impl_val *v1, token_t t2, impl case PSI_T_UINT64: res->u8 = v1->dval >= v2->u64; break; +# if HAVE_INT128 case PSI_T_INT128: res->u8 = v1->dval >= v2->i128; break; +# endif + +# if HAVE_UINT128 case PSI_T_UINT128: res->u8 = v1->dval >= v2->u128; break; +# endif + case PSI_T_FLOAT: res->u8 = v1->dval >= v2->fval; break; @@ -3896,12 +4394,18 @@ static inline token_t psi_calc_cmp_ge(token_t t1, impl_val *v1, token_t t2, impl case PSI_T_UINT64: res->u8 = v1->ldval >= v2->u64; break; +# if HAVE_INT128 case PSI_T_INT128: res->u8 = v1->ldval >= v2->i128; break; +# endif + +# if HAVE_UINT128 case PSI_T_UINT128: res->u8 = v1->ldval >= v2->u128; break; +# endif + case PSI_T_FLOAT: res->u8 = v1->ldval >= v2->fval; break; diff --git a/src/calc/unary.h b/src/calc/unary.h index 72a82e1..358f65f 100644 --- a/src/calc/unary.h +++ b/src/calc/unary.h @@ -57,12 +57,18 @@ static inline token_t psi_calc_minus(token_t t1, impl_val *v1, token_t t2, impl_ case PSI_T_UINT64: res->u64 = -v1->u64; break; +#if HAVE_INT128 case PSI_T_INT128: res->i128 = -v1->i128; break; +#endif + +#if HAVE_UINT128 case PSI_T_UINT128: res->u128 = -v1->u128; break; +#endif + case PSI_T_FLOAT: res->fval = -v1->fval; break; @@ -113,12 +119,18 @@ static inline token_t psi_calc_bool_not(token_t t1, impl_val *v1, token_t t2, im case PSI_T_UINT64: res->u8 = !v1->u64; break; +#if HAVE_INT128 case PSI_T_INT128: res->u8 = !v1->i128; break; +#endif + +#if HAVE_UINT128 case PSI_T_UINT128: res->u8 = !v1->u128; break; +#endif + case PSI_T_FLOAT: res->u8 = !v1->fval; break; @@ -179,14 +191,20 @@ static inline token_t psi_calc_bin_not(token_t t1, impl_val *v1, token_t t2, imp i1.u64 = v1->u64; break; +#if HAVE_INT128 case PSI_T_INT128: i1.u64 = v1->i128; break; +#endif + +#if HAVE_UINT128 case PSI_T_UINT128: i1.u64 = v1->u128; break; +#endif + case PSI_T_FLOAT: i1.u64 = v1->fval; break; diff --git a/src/marshal.c b/src/marshal.c index 6473eca..d48cb8b 100644 --- a/src/marshal.c +++ b/src/marshal.c @@ -226,6 +226,7 @@ impl_val *psi_let_boolval(impl_val *tmp, struct psi_decl_arg *spec, token_t impl return psi_val_boolval(tmp, real_type, boolval); } +#if HAVE_INT128 static inline char *psi_u128_to_buf(char *buf, unsigned __int128 u128) { for (*buf = 0; u128 > 0; u128 /= 10) { @@ -245,7 +246,6 @@ static inline char *psi_i128_to_buf(char *buf, __int128 i128) return psi_u128_to_buf(buf, i128); } -#if HAVE_INT128 # define RETVAL_LONG_STR(V, s) do {\ char buf[0x30] = {0}; \ if (s && V >= ZEND_LONG_MIN && V <= ZEND_LONG_MAX) { \ -- 2.30.2