X-Git-Url: https://git.m6w6.name/?a=blobdiff_plain;f=src%2Fcalc%2Fbasic.h;h=bc35baf1a55ceddac436f473dda67aabccd535c2;hb=cd0567b4052ee24259bc6b8a9858af9d26f3de48;hp=ac021e06a9db5dc4f80d821dcc59622a250472ac;hpb=52ed5940ed0ab3cafd36fbded2e83c92563e7b2b;p=m6w6%2Fext-psi diff --git a/src/calc/basic.h b/src/calc/basic.h index ac021e0..bc35baf 100644 --- a/src/calc/basic.h +++ b/src/calc/basic.h @@ -23,7 +23,6 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. *******************************************************************************/ -#include "php_psi_stdinc.h" #include #include "token.h" @@ -58,6 +57,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; @@ -101,6 +112,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; @@ -144,6 +167,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; @@ -187,6 +222,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; @@ -230,6 +277,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; @@ -273,6 +332,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; @@ -316,6 +387,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; @@ -359,6 +442,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; @@ -376,6 +471,122 @@ 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: + res->i128 = v1->i128 + v2->i8; + return PSI_T_INT128; + case PSI_T_UINT8: + res->i128 = v1->i128 + v2->u8; + return PSI_T_INT128; + case PSI_T_INT16: + res->i128 = v1->i128 + v2->i16; + return PSI_T_INT128; + case PSI_T_UINT16: + res->i128 = v1->i128 + v2->u16; + return PSI_T_INT128; + case PSI_T_INT32: + res->i128 = v1->i128 + v2->i32; + return PSI_T_INT128; + case PSI_T_UINT32: + res->i128 = v1->i128 + v2->u32; + return PSI_T_INT128; + case PSI_T_INT64: + res->i128 = v1->i128 + v2->i64; + return PSI_T_INT128; + 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; + case PSI_T_DOUBLE: + res->dval = v1->i128 + v2->dval; + return PSI_T_DOUBLE; +# if HAVE_LONG_DOUBLE + case PSI_T_LONG_DOUBLE: + res->ldval = v1->i128 + v2->ldval; + return PSI_T_LONG_DOUBLE; +# endif + + default: + assert(0); + break; + } + break; +#endif + +#if HAVE_UINT128 + case PSI_T_UINT128: + switch (t2) { + case PSI_T_INT8: + res->u128 = v1->u128 + v2->i8; + return PSI_T_UINT128; + case PSI_T_UINT8: + res->u128 = v1->u128 + v2->u8; + return PSI_T_UINT128; + case PSI_T_INT16: + res->u128 = v1->u128 + v2->i16; + return PSI_T_UINT128; + case PSI_T_UINT16: + res->u128 = v1->u128 + v2->u16; + return PSI_T_UINT128; + case PSI_T_INT32: + res->u128 = v1->u128 + v2->i32; + return PSI_T_UINT128; + case PSI_T_UINT32: + res->u128 = v1->u128 + v2->u32; + return PSI_T_UINT128; + case PSI_T_INT64: + res->u128 = v1->u128 + v2->i64; + return PSI_T_UINT128; + 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; + case PSI_T_DOUBLE: + res->dval = v1->u128 + v2->dval; + return PSI_T_DOUBLE; +# if HAVE_LONG_DOUBLE + case PSI_T_LONG_DOUBLE: + res->ldval = v1->u128 + v2->ldval; + return PSI_T_LONG_DOUBLE; +# endif + + default: + assert(0); + break; + } + break; +#endif + case PSI_T_FLOAT: switch (t2) { case PSI_T_INT8: @@ -402,6 +613,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; @@ -445,6 +668,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; @@ -489,6 +724,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; @@ -545,6 +792,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; @@ -588,6 +847,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; @@ -631,6 +902,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; @@ -674,6 +957,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; @@ -717,6 +1012,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; @@ -760,6 +1067,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; @@ -803,6 +1122,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; @@ -846,6 +1177,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; @@ -863,6 +1206,122 @@ 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: + res->i128 = v1->i128 - v2->i8; + return PSI_T_INT128; + case PSI_T_UINT8: + res->i128 = v1->i128 - v2->u8; + return PSI_T_INT128; + case PSI_T_INT16: + res->i128 = v1->i128 - v2->i16; + return PSI_T_INT128; + case PSI_T_UINT16: + res->i128 = v1->i128 - v2->u16; + return PSI_T_INT128; + case PSI_T_INT32: + res->i128 = v1->i128 - v2->i32; + return PSI_T_INT128; + case PSI_T_UINT32: + res->i128 = v1->i128 - v2->u32; + return PSI_T_INT128; + case PSI_T_INT64: + res->i128 = v1->i128 - v2->i64; + return PSI_T_INT128; + 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; + case PSI_T_DOUBLE: + res->dval = v1->i128 - v2->dval; + return PSI_T_DOUBLE; +# if HAVE_LONG_DOUBLE + case PSI_T_LONG_DOUBLE: + res->ldval = v1->i128 - v2->ldval; + return PSI_T_LONG_DOUBLE; +# endif + + default: + assert(0); + break; + } + break; +#endif + +#if HAVE_UINT128 + case PSI_T_UINT128: + switch (t2) { + case PSI_T_INT8: + res->u128 = v1->u128 - v2->i8; + return PSI_T_UINT128; + case PSI_T_UINT8: + res->u128 = v1->u128 - v2->u8; + return PSI_T_UINT128; + case PSI_T_INT16: + res->u128 = v1->u128 - v2->i16; + return PSI_T_UINT128; + case PSI_T_UINT16: + res->u128 = v1->u128 - v2->u16; + return PSI_T_UINT128; + case PSI_T_INT32: + res->u128 = v1->u128 - v2->i32; + return PSI_T_UINT128; + case PSI_T_UINT32: + res->u128 = v1->u128 - v2->u32; + return PSI_T_UINT128; + case PSI_T_INT64: + res->u128 = v1->u128 - v2->i64; + return PSI_T_UINT128; + 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; + case PSI_T_DOUBLE: + res->dval = v1->u128 - v2->dval; + return PSI_T_DOUBLE; +# if HAVE_LONG_DOUBLE + case PSI_T_LONG_DOUBLE: + res->ldval = v1->u128 - v2->ldval; + return PSI_T_LONG_DOUBLE; +# endif + + default: + assert(0); + break; + } + break; +#endif + case PSI_T_FLOAT: switch (t2) { case PSI_T_INT8: @@ -889,6 +1348,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; @@ -932,6 +1403,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; @@ -976,6 +1459,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; @@ -1032,6 +1527,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; @@ -1075,6 +1582,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; @@ -1118,6 +1637,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; @@ -1161,6 +1692,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; @@ -1204,6 +1747,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; @@ -1247,6 +1802,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; @@ -1290,6 +1857,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; @@ -1333,6 +1912,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; @@ -1350,6 +1941,122 @@ 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: + res->i128 = v1->i128 * v2->i8; + return PSI_T_INT128; + case PSI_T_UINT8: + res->i128 = v1->i128 * v2->u8; + return PSI_T_INT128; + case PSI_T_INT16: + res->i128 = v1->i128 * v2->i16; + return PSI_T_INT128; + case PSI_T_UINT16: + res->i128 = v1->i128 * v2->u16; + return PSI_T_INT128; + case PSI_T_INT32: + res->i128 = v1->i128 * v2->i32; + return PSI_T_INT128; + case PSI_T_UINT32: + res->i128 = v1->i128 * v2->u32; + return PSI_T_INT128; + case PSI_T_INT64: + res->i128 = v1->i128 * v2->i64; + return PSI_T_INT128; + 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; + case PSI_T_DOUBLE: + res->dval = v1->i128 * v2->dval; + return PSI_T_DOUBLE; +# if HAVE_LONG_DOUBLE + case PSI_T_LONG_DOUBLE: + res->ldval = v1->i128 * v2->ldval; + return PSI_T_LONG_DOUBLE; +# endif + + default: + assert(0); + break; + } + break; +#endif + +#if HAVE_UINT128 + case PSI_T_UINT128: + switch (t2) { + case PSI_T_INT8: + res->u128 = v1->u128 * v2->i8; + return PSI_T_UINT128; + case PSI_T_UINT8: + res->u128 = v1->u128 * v2->u8; + return PSI_T_UINT128; + case PSI_T_INT16: + res->u128 = v1->u128 * v2->i16; + return PSI_T_UINT128; + case PSI_T_UINT16: + res->u128 = v1->u128 * v2->u16; + return PSI_T_UINT128; + case PSI_T_INT32: + res->u128 = v1->u128 * v2->i32; + return PSI_T_UINT128; + case PSI_T_UINT32: + res->u128 = v1->u128 * v2->u32; + return PSI_T_UINT128; + case PSI_T_INT64: + res->u128 = v1->u128 * v2->i64; + return PSI_T_UINT128; + 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; + case PSI_T_DOUBLE: + res->dval = v1->u128 * v2->dval; + return PSI_T_DOUBLE; +# if HAVE_LONG_DOUBLE + case PSI_T_LONG_DOUBLE: + res->ldval = v1->u128 * v2->ldval; + return PSI_T_LONG_DOUBLE; +# endif + + default: + assert(0); + break; + } + break; +#endif + case PSI_T_FLOAT: switch (t2) { case PSI_T_INT8: @@ -1376,6 +2083,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; @@ -1419,6 +2138,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; @@ -1463,6 +2194,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; @@ -1519,6 +2262,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; @@ -1562,6 +2317,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; @@ -1605,6 +2372,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; @@ -1648,6 +2427,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; @@ -1691,6 +2482,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; @@ -1734,6 +2537,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; @@ -1777,6 +2592,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; @@ -1820,6 +2647,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; @@ -1837,6 +2676,122 @@ 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: + res->i128 = v1->i128 / v2->i8; + return PSI_T_INT128; + case PSI_T_UINT8: + res->i128 = v1->i128 / v2->u8; + return PSI_T_INT128; + case PSI_T_INT16: + res->i128 = v1->i128 / v2->i16; + return PSI_T_INT128; + case PSI_T_UINT16: + res->i128 = v1->i128 / v2->u16; + return PSI_T_INT128; + case PSI_T_INT32: + res->i128 = v1->i128 / v2->i32; + return PSI_T_INT128; + case PSI_T_UINT32: + res->i128 = v1->i128 / v2->u32; + return PSI_T_INT128; + case PSI_T_INT64: + res->i128 = v1->i128 / v2->i64; + return PSI_T_INT128; + 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; + case PSI_T_DOUBLE: + res->dval = v1->i128 / v2->dval; + return PSI_T_DOUBLE; +# if HAVE_LONG_DOUBLE + case PSI_T_LONG_DOUBLE: + res->ldval = v1->i128 / v2->ldval; + return PSI_T_LONG_DOUBLE; +# endif + + default: + assert(0); + break; + } + break; +#endif + +#if HAVE_UINT128 + case PSI_T_UINT128: + switch (t2) { + case PSI_T_INT8: + res->u128 = v1->u128 / v2->i8; + return PSI_T_UINT128; + case PSI_T_UINT8: + res->u128 = v1->u128 / v2->u8; + return PSI_T_UINT128; + case PSI_T_INT16: + res->u128 = v1->u128 / v2->i16; + return PSI_T_UINT128; + case PSI_T_UINT16: + res->u128 = v1->u128 / v2->u16; + return PSI_T_UINT128; + case PSI_T_INT32: + res->u128 = v1->u128 / v2->i32; + return PSI_T_UINT128; + case PSI_T_UINT32: + res->u128 = v1->u128 / v2->u32; + return PSI_T_UINT128; + case PSI_T_INT64: + res->u128 = v1->u128 / v2->i64; + return PSI_T_UINT128; + 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; + case PSI_T_DOUBLE: + res->dval = v1->u128 / v2->dval; + return PSI_T_DOUBLE; +# if HAVE_LONG_DOUBLE + case PSI_T_LONG_DOUBLE: + res->ldval = v1->u128 / v2->ldval; + return PSI_T_LONG_DOUBLE; +# endif + + default: + assert(0); + break; + } + break; +#endif + case PSI_T_FLOAT: switch (t2) { case PSI_T_INT8: @@ -1863,6 +2818,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; @@ -1906,6 +2873,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; @@ -1950,6 +2929,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; @@ -2015,6 +3006,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; @@ -2060,6 +3065,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;