flush

[m6w6/ext-psi] / src / calc / cmp.h

diff --git a/src/calc/cmp.h b/src/calc/cmp.h
index 30bc0c9eccb5785463002a48880a0efb002731c7..6bb67de192d8457c26fe32fa7ceda8fd2135fe81 100644 (file)
--- a/src/calc/cmp.h
+++ b/src/calc/cmp.h
@@ -23,7 +23,6 @@
  OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 *******************************************************************************/
 
-#include "php_psi_stdinc.h"
 #include <assert.h>
 
 #include "token.h"
@@ -57,12 +56,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 +111,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 +166,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 +221,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 +276,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 +331,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 +386,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 +441,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 +470,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 +497,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 +526,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 +555,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 +584,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 +612,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 +667,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 +723,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 +790,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 +845,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 +900,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 +955,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 +1010,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 +1065,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 +1120,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 +1175,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 +1204,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 +1231,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 +1260,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 +1289,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 +1318,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 +1346,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 +1401,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 +1457,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 +1524,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 +1579,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 +1634,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 +1689,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 +1744,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 +1799,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 +1854,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 +1909,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 +1938,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 +1965,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 +1994,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 +2023,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 +2052,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 +2080,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 +2135,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 +2191,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 +2258,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 +2313,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 +2368,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 +2423,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 +2478,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 +2533,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 +2588,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 +2643,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 +2672,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 +2699,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 +2728,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 +2757,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 +2786,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 +2814,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 +2869,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 +2925,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 +2992,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 +3047,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 +3102,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 +3157,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 +3212,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 +3267,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 +3322,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 +3377,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 +3406,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 +3433,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 +3462,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 +3491,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 +3520,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 +3548,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 +3603,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 +3659,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 +3726,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 +3781,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 +3836,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 +3891,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 +3946,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 +4001,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 +4056,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 +4111,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 +4140,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 +4167,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 +4196,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 +4225,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 +4254,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 +4282,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 +4337,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 +4393,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;