Operator constant folding rewrite almost complete, just need to track down why two...
authorDale Weiler <killfieldengine@gmail.com>
Wed, 31 Jul 2013 15:49:45 +0000 (15:49 +0000)
committerDale Weiler <killfieldengine@gmail.com>
Wed, 31 Jul 2013 15:49:45 +0000 (15:49 +0000)
fold.c
lexer.h
parser.c

diff --git a/fold.c b/fold.c
index d7de3ae85458a19eeb223d0740fac85bad791f99..662601bc0ab61a8c91478f6d38cc46e5a8c8c4a9 100644 (file)
--- a/fold.c
+++ b/fold.c
  * 
  * This file is thus, split into two parts.
  */
-static GMQCC_INLINE bool fold_possible(const ast_value *val) {
-    return  ast_istype((ast_expression*)val, ast_value) &&
-            val->hasvalue && (val->cvq == CV_CONST)     &&
-            ((ast_expression*)val)->vtype != TYPE_FUNCTION; /* why not for functions? */
-}
-
-#define isfloatonly(X)  (((ast_expression*)(X))->vtype == TYPE_FLOAT)
-#define isvectoronly(X) (((ast_expression*)(X))->vtype == TYPE_VECTOR)
-#define isstringonly(X) (((ast_expression*)(X))->vtype == TYPE_STRING)
-#define isfloat(X)      (isfloatonly (X) && fold_possible(X))
-#define isvector(X)     (isvectoronly(X) && fold_possible(X))
-#define isstring(X)     (isstringonly(X) && fold_possible(X))
-#define isfloats(X,Y)   (isfloat     (X) && isfloat (Y))
-#define isvectors(X,Y)  (isvector    (X) && isvector(Y))
-/*#define isstrings(X,Y)  (isstring    (X) && isstring(Y))*/
+
+#define isfloat(X)      (((ast_expression*)(X))->vtype == TYPE_FLOAT)
+#define isvector(X)     (((ast_expression*)(X))->vtype == TYPE_VECTOR)
+#define isstring(X)     (((ast_expression*)(X))->vtype == TYPE_STRING)
+#define isfloats(X,Y)   (isfloat  (X) && isfloat (Y))
+#define isvectors(X,Y)  (isvector (X) && isvector(Y))
 
 /*
  * Implementation of basic vector math for vec3_t, for trivial constant
@@ -75,14 +66,6 @@ static GMQCC_INLINE vec3_t vec3_sub(vec3_t a, vec3_t b) {
     return out;
 }
 
-static GMQCC_INLINE vec3_t vec3_not(vec3_t a) {
-    vec3_t out;
-    out.x = !a.x;
-    out.y = !a.y;
-    out.z = !a.z;
-    return out;
-}
-
 static GMQCC_INLINE vec3_t vec3_neg(vec3_t a) {
     vec3_t out;
     out.x = -a.x;
@@ -133,10 +116,54 @@ static GMQCC_INLINE vec3_t vec3_create(float x, float y, float z) {
     return out;
 }
 
+static GMQCC_INLINE qcfloat_t vec3_notf(vec3_t a) {
+    return (!a.x && !a.y && !a.z);
+}
+
 static GMQCC_INLINE bool vec3_pbool(vec3_t a) {
     return (a.x && a.y && a.z);
 }
 
+static GMQCC_INLINE bool fold_can_1(const ast_value *val) {
+    return  (ast_istype((ast_expression*)val, ast_value) && val->hasvalue && val->cvq == CV_CONST && ((ast_expression*)val)->vtype != TYPE_FUNCTION);
+}
+
+static GMQCC_INLINE bool fold_can_2(const ast_value *v1, const ast_value *v2) {
+    return fold_can_1(v1) && fold_can_1(v2);
+}
+
+static lex_ctx_t fold_ctx(fold_t *fold) {
+    lex_ctx_t ctx;
+    if (fold->parser->lex)
+        return parser_ctx(fold->parser);
+
+    memset(&ctx, 0, sizeof(ctx));
+    return ctx;
+}
+
+static GMQCC_INLINE bool fold_immediate_true(fold_t *fold, ast_value *v) {
+    switch (v->expression.vtype) {
+        case TYPE_FLOAT:
+            return !!v->constval.vfloat;
+        case TYPE_INTEGER:
+            return !!v->constval.vint;
+        case TYPE_VECTOR: 
+            if (OPTS_FLAG(CORRECT_LOGIC))
+                return vec3_pbool(v->constval.vvec);
+            return !!v->constval.vvec.x;
+        case TYPE_STRING:
+            if (!v->constval.vstring)
+                return false;
+            if (OPTS_FLAG(TRUE_EMPTY_STRINGS))
+                return true;
+            return !!v->constval.vstring[0];
+        default:
+            compile_error(fold_ctx(fold), "internal error: fold_immediate_true on invalid type");
+            break;
+    }
+    return !!v->constval.vfunc;
+}
+
 #define fold_immvalue_float(E)  ((E)->constval.vfloat)
 #define fold_immvalue_vector(E) ((E)->constval.vvec)
 #define fold_immvalue_string(E) ((E)->constval.vstring)
@@ -200,15 +227,6 @@ void fold_cleanup(fold_t *fold) {
     mem_d(fold);
 }
 
-static lex_ctx_t fold_ctx(fold_t *fold) {
-    lex_ctx_t ctx;
-    if (fold->parser->lex)
-        return parser_ctx(fold->parser);
-
-    memset(&ctx, 0, sizeof(ctx));
-    return ctx;
-}
-
 ast_expression *fold_constgen_float(fold_t *fold, qcfloat_t value) {
     ast_value  *out = NULL;
     size_t      i;
@@ -274,7 +292,8 @@ ast_expression *fold_constgen_string(fold_t *fold, const char *str, bool transla
     return (ast_expression*)out;
 }
 
-static GMQCC_INLINE ast_expression *fold_op_mul_vec(fold_t *fold, vec3_t *vec, ast_value *sel, const char *set) {
+
+static GMQCC_INLINE ast_expression *fold_op_mul_vec(fold_t *fold, vec3_t vec, ast_value *sel, const char *set) {
     /*
      * vector-component constant folding works by matching the component sets
      * to eliminate expensive operations on whole-vectors (3 components at runtime).
@@ -294,9 +313,9 @@ static GMQCC_INLINE ast_expression *fold_op_mul_vec(fold_t *fold, vec3_t *vec, a
      * Of course more work needs to be done to generate the correct index for the ast_member_new
      * call, which is no problem: set[0]-'x' suffices that job.
      */
-    qcfloat_t x = (&vec->x)[set[0]-'x'];
-    qcfloat_t y = (&vec->x)[set[1]-'x'];
-    qcfloat_t z = (&vec->x)[set[2]-'x'];
+    qcfloat_t x = (&vec.x)[set[0]-'x'];
+    qcfloat_t y = (&vec.x)[set[1]-'x'];
+    qcfloat_t z = (&vec.x)[set[2]-'x'];
 
     if (!y && !z) {
         ast_expression *out;
@@ -307,106 +326,204 @@ static GMQCC_INLINE ast_expression *fold_op_mul_vec(fold_t *fold, vec3_t *vec, a
         if (!x != -1)
             return (ast_expression*)ast_binary_new(fold_ctx(fold), INSTR_MUL_F, fold_constgen_float(fold, x), out);
     }
+    return NULL;
+}
+
+
+static GMQCC_INLINE ast_expression *fold_op_neg(fold_t *fold, ast_value *a) {
+    if (isfloat(a)) {
+        if (fold_can_1(a))
+            return fold_constgen_float(fold, -fold_immvalue_float(a));
+    } else if (isvector(a)) {
+        if (fold_can_1(a))
+            return fold_constgen_vector(fold, vec3_neg(fold_immvalue_vector(a)));
+    }
+    return NULL;
+}
+
+static GMQCC_INLINE ast_expression *fold_op_not(fold_t *fold, ast_value *a) {
+    if (isfloat(a)) {
+        if (fold_can_1(a))
+            return fold_constgen_float(fold, !fold_immvalue_float(a));
+    } else if (isvector(a)) {
+        if (fold_can_1(a))
+            return fold_constgen_float(fold, vec3_notf(fold_immvalue_vector(a)));
+    } else if (isstring(a)) {
+        if (fold_can_1(a)) {
+            if (OPTS_FLAG(TRUE_EMPTY_STRINGS))
+                return fold_constgen_float(fold, !fold_immvalue_string(a));
+            else
+                return fold_constgen_float(fold, !fold_immvalue_string(a) || !*fold_immvalue_string(a));
+        }
+    }
+    return NULL;
+}
 
+static GMQCC_INLINE ast_expression *fold_op_add(fold_t *fold, ast_value *a, ast_value *b) {
+    if (isfloat(a)) {
+        if (fold_can_2(a, b))
+            return fold_constgen_float(fold, fold_immvalue_float(a) + fold_immvalue_float(b));
+    } else if (isvector(a)) {
+        if (fold_can_2(a, b))
+            return fold_constgen_vector(fold, vec3_add(fold_immvalue_vector(a), fold_immvalue_vector(b)));
+    }
     return NULL;
 }
 
+static GMQCC_INLINE ast_expression *fold_op_sub(fold_t *fold, ast_value *a, ast_value *b) {
+    if (isfloat(a)) {
+        if (fold_can_2(a, b))
+            return fold_constgen_float(fold, fold_immvalue_float(a) - fold_immvalue_float(b));
+    } else if (isvector(a)) {
+        if (fold_can_2(a, b))
+            return fold_constgen_vector(fold, vec3_sub(fold_immvalue_vector(a), fold_immvalue_vector(b)));
+    }
+    return NULL;
+}
 
 static GMQCC_INLINE ast_expression *fold_op_mul(fold_t *fold, ast_value *a, ast_value *b) {
-    if (isfloatonly(a)) {
-        return (fold_possible(a) && fold_possible(b))
-                    ? fold_constgen_vector(fold, vec3_mulvf(fold_immvalue_vector(b), fold_immvalue_float(a))) /* a=float,  b=vector */
-                    : NULL;                                                                                   /* cannot fold them   */
-    } else if (isfloats(a, b)) {
-        return fold_constgen_float(fold, fold_immvalue_float(a) * fold_immvalue_float(b));                    /* a=float,  b=float  */
-    } else if (isvectoronly(a)) {
-        if (isfloat(b) && fold_possible(a))
-            return fold_constgen_vector(fold, vec3_mulvf(fold_immvalue_vector(a), fold_immvalue_float(b)));   /* a=vector, b=float  */
-        else if (isvector(b)) {
-            /*
-             * if we made it here the two ast values are both vectors. However because vectors are represented as
-             * three float values, constant folding can still occur within reason of the individual const-qualification
-             * of the components the vector is composed of.
-             */
-            if (fold_possible(a) && fold_possible(b))
+    if (isfloat(a)) {
+        if (isfloat(b) && fold_can_2(a, b))
+            return fold_constgen_vector(fold, vec3_mulvf(fold_immvalue_vector(b), fold_immvalue_float(a)));
+        else if (fold_can_2(a, b))
+            return fold_constgen_float(fold, fold_immvalue_float(a) * fold_immvalue_float(b));
+    } else if (isvector(a)) {
+        if (isfloat(b) && fold_can_2(a, b)) {
+            return fold_constgen_vector(fold, vec3_mulvf(fold_immvalue_vector(a), fold_immvalue_float(b)));
+        } else {
+            if (fold_can_2(a, b)) {
                 return fold_constgen_float(fold, vec3_mulvv(fold_immvalue_vector(a), fold_immvalue_vector(b)));
-            else if (OPTS_OPTIMIZATION(OPTIM_VECTOR_COMPONENTS) && fold_possible(a)) {
-                vec3_t          vec = fold_immvalue_vector(a);
+            } else if (OPTS_OPTIMIZATION(OPTIM_VECTOR_COMPONENTS) && fold_can_1(a)) {
                 ast_expression *out;
-                if ((out = fold_op_mul_vec(fold, &vec, b, "xyz"))) return out;
-                if ((out = fold_op_mul_vec(fold, &vec, b, "yxz"))) return out;
-                if ((out = fold_op_mul_vec(fold, &vec, b, "zxy"))) return out;
-                return NULL;
-            } else if (OPTS_OPTIMIZATION(OPTIM_VECTOR_COMPONENTS) && fold_possible(b)) {
-                vec3_t          vec = fold_immvalue_vector(b);
+                if ((out = fold_op_mul_vec(fold, fold_immvalue_vector(a), b, "xyz"))) return out;
+                if ((out = fold_op_mul_vec(fold, fold_immvalue_vector(a), b, "yxz"))) return out;
+                if ((out = fold_op_mul_vec(fold, fold_immvalue_vector(a), b, "zxy"))) return out;
+            } else if (OPTS_OPTIMIZATION(OPTIM_VECTOR_COMPONENTS) && fold_can_1(b)) {
                 ast_expression *out;
-                if ((out = fold_op_mul_vec(fold, &vec, a, "xyz"))) return out;
-                if ((out = fold_op_mul_vec(fold, &vec, a, "yxz"))) return out;
-                if ((out = fold_op_mul_vec(fold, &vec, a, "zxy"))) return out;
-                return NULL;
+                if ((out = fold_op_mul_vec(fold, fold_immvalue_vector(b), a, "xyz"))) return out;
+                if ((out = fold_op_mul_vec(fold, fold_immvalue_vector(b), a, "yxz"))) return out;
+                if ((out = fold_op_mul_vec(fold, fold_immvalue_vector(b), a, "zxy"))) return out;
             }
         }
     }
     return NULL;
 }
 
-static GMQCC_INLINE bool fold_immediate_true(fold_t *fold, ast_value *v) {
-    switch (v->expression.vtype) {
-        case TYPE_FLOAT:   return !!v->constval.vfloat;
-        case TYPE_INTEGER: return !!v->constval.vint;
-        case TYPE_VECTOR:  return OPTS_FLAG(CORRECT_LOGIC) ? vec3_pbool(v->constval.vvec) : !!v->constval.vvec.x;
-        case TYPE_STRING:
-            if (!v->constval.vstring)
-                return false;
-            if (OPTS_FLAG(TRUE_EMPTY_STRINGS))
-                return true;
-            return !!v->constval.vstring[0];
-        default:
-            compile_error(fold_ctx(fold), "internal error: fold_immediate_true on invalid type");
-            break;
+static GMQCC_INLINE ast_expression *fold_op_div(fold_t *fold, ast_value *a, ast_value *b) {
+    if (isfloat(a)) {
+        if (fold_can_2(a, b))
+            return fold_constgen_float(fold, fold_immvalue_float(a) / fold_immvalue_float(b));
+    } else if (isvector(a)) {
+        if (fold_can_2(a, b))
+            return fold_constgen_vector(fold, vec3_mulvf(fold_immvalue_vector(a), 1.0f / fold_immvalue_float(b)));
+        else if (fold_can_1(b))
+            return fold_constgen_float (fold, 1.0f / fold_immvalue_float(b));
     }
-    return !!v->constval.vfunc;
+    return NULL;
 }
 
-static GMQCC_INLINE ast_expression *fold_op_div(fold_t *fold, ast_value *a, ast_value *b) {
-    if (isfloatonly(a)) {
-        return (fold_possible(a) && fold_possible(b))
-                    ? fold_constgen_float(fold, fold_immvalue_float(a) / fold_immvalue_float(b))
-                    : NULL;
-    }
+static GMQCC_INLINE ast_expression *fold_op_mod(fold_t *fold, ast_value *a, ast_value *b) {
+    if (fold_can_2(a, b))
+        return fold_constgen_float(fold, (qcfloat_t)(((qcint_t)fold_immvalue_float(a)) % ((qcint_t)fold_immvalue_float(b))));
+    return NULL;
+}
 
-    if (isvectoronly(a)) {
-        if (fold_possible(a) && fold_possible(b))
-            return fold_constgen_vector(fold, vec3_mulvf(fold_immvalue_vector(a), 1.0f / fold_immvalue_float(b)));
-        else if (fold_possible(b))
-            return fold_constgen_float (fold, 1.0f / fold_immvalue_float(b));
+static GMQCC_INLINE ast_expression *fold_op_bor(fold_t *fold, ast_value *a, ast_value *b) {
+    if (fold_can_2(a, b))
+        return fold_constgen_float(fold, (qcfloat_t)(((qcint_t)fold_immvalue_float(a)) | ((qcint_t)fold_immvalue_float(b))));
+    return NULL;
+}
+
+static GMQCC_INLINE ast_expression *fold_op_band(fold_t *fold, ast_value *a, ast_value *b) {
+    if (fold_can_2(a, b))
+        return fold_constgen_float(fold, (qcfloat_t)(((qcint_t)fold_immvalue_float(a)) & ((qcint_t)fold_immvalue_float(b))));
+    return NULL;
+}
+
+static GMQCC_INLINE ast_expression *fold_op_xor(fold_t *fold, ast_value *a, ast_value *b) {
+    if (isfloat(a)) {
+        if (fold_can_2(a, b))
+            return fold_constgen_float(fold, (qcfloat_t)(((qcint_t)fold_immvalue_float(a)) ^ ((qcint_t)fold_immvalue_float(b))));
+    } else {
+        if (isvector(b)) {
+            if (fold_can_2(a, b))
+                return fold_constgen_vector(fold, vec3_xor(fold_immvalue_vector(a), fold_immvalue_vector(b)));
+        } else {
+            if (fold_can_2(a, b))
+                return fold_constgen_vector(fold, vec3_xorvf(fold_immvalue_vector(a), fold_immvalue_float(b)));
+        }
     }
     return NULL;
 }
 
-static GMQCC_INLINE ast_expression *fold_op_andor(fold_t *fold, ast_value *a, ast_value *b, bool isor) {
-    if (fold_possible(a) && fold_possible(b)) {
+static GMQCC_INLINE ast_expression *fold_op_lshift(fold_t *fold, ast_value *a, ast_value *b) {
+    if (fold_can_2(a, b) && isfloats(a, b))
+        return fold_constgen_float(fold, (qcfloat_t)((qcuint_t)(fold_immvalue_float(a)) << (qcuint_t)(fold_immvalue_float(b))));
+    return NULL;
+}
+
+static GMQCC_INLINE ast_expression *fold_op_rshift(fold_t *fold, ast_value *a, ast_value *b) {
+    if (fold_can_2(a, b) && isfloats(a, b))
+        return fold_constgen_float(fold, (qcfloat_t)((qcuint_t)(fold_immvalue_float(a)) >> (qcuint_t)(fold_immvalue_float(b))));
+    return NULL;
+}
+
+static GMQCC_INLINE ast_expression *fold_op_andor(fold_t *fold, ast_value *a, ast_value *b, float or) {
+    if (fold_can_2(a, b)) {
         if (OPTS_FLAG(PERL_LOGIC)) {
-            if (fold_immediate_true(fold, b))
+            if (fold_immediate_true(fold, a))
                 return (ast_expression*)b;
         } else {
-            return ((isor) ? (fold_immediate_true(fold, a) || fold_immediate_true(fold, b))
-                           : (fold_immediate_true(fold, a) && fold_immediate_true(fold, b)))
-                                 ? (ast_expression*)fold->imm_float[1]  /* 1.0f */
-                                 : (ast_expression*)fold->imm_float[0]; /* 0.0f */
+            return fold_constgen_float (
+                fold, 
+                ((or) ? (fold_immediate_true(fold, a) || fold_immediate_true(fold, b))
+                      : (fold_immediate_true(fold, a) && fold_immediate_true(fold, b)))
+                            ? 1.0f
+                            : 0.0f
+            );
         }
     }
     return NULL;
 }
 
+static GMQCC_INLINE ast_expression *fold_op_tern(fold_t *fold, ast_value *a, ast_value *b, ast_value *c) {
+    if (fold_can_1(a)) {
+        return fold_immediate_true(fold, a)
+                    ? (ast_expression*)b
+                    : (ast_expression*)c;
+    }
+    return NULL;
+}
+
+static GMQCC_INLINE ast_expression *fold_op_exp(fold_t *fold, ast_value *a, ast_value *b) {
+    if (fold_can_2(a, b))
+        return fold_constgen_float(fold, (qcfloat_t)powf(fold_immvalue_float(a), fold_immvalue_float(b)));
+    return NULL;
+}
+
 static GMQCC_INLINE ast_expression *fold_op_lteqgt(fold_t *fold, ast_value *a, ast_value *b) {
-    if (!isfloats(a, b))
-        return NULL;
+    if (fold_can_2(a,b)) {
+        if (fold_immvalue_float(a) <  fold_immvalue_float(b)) return (ast_expression*)fold->imm_float[2];
+        if (fold_immvalue_float(a) == fold_immvalue_float(b)) return (ast_expression*)fold->imm_float[0];
+        if (fold_immvalue_float(a) >  fold_immvalue_float(b)) return (ast_expression*)fold->imm_float[1];
+    }
+    return NULL;
+}
 
-    if (fold_immvalue_float(a)  < fold_immvalue_float(b)) return (ast_expression*)fold->imm_float[2];/* -1 */
-    if (fold_immvalue_float(a) == fold_immvalue_float(b)) return (ast_expression*)fold->imm_float[0];/* 0  */
-    if (fold_immvalue_float(a)  > fold_immvalue_float(b)) return (ast_expression*)fold->imm_float[1];/* 1  */
+static GMQCC_INLINE ast_expression *fold_op_cmp(fold_t *fold, ast_value *a, ast_value *b, bool ne) {
+    if (fold_can_2(a, b)) {
+        return fold_constgen_float(
+                    fold,
+                    (ne) ? (fold_immvalue_float(a) != fold_immvalue_float(b))
+                         : (fold_immvalue_float(a) == fold_immvalue_float(b))
+                );
+    }
+    return NULL;
+}
 
+static GMQCC_INLINE ast_expression *fold_op_bnot(fold_t *fold, ast_value *a) {
+    if (fold_can_1(a))
+        return fold_constgen_float(fold, ~((qcint_t)fold_immvalue_float(a)));
     return NULL;
 }
 
@@ -422,67 +539,34 @@ ast_expression *fold_op(fold_t *fold, const oper_info *info, ast_expression **op
     switch(info->operands) {
         case 3: if(!c) return NULL;
         case 2: if(!b) return NULL;
+        case 1:
+        if(!a) {
+            compile_error(fold_ctx(fold), "interal error: fold_op no operands to fold\n");
+            return NULL;
+        }
     }
 
     switch(info->id) {
-        case opid2('-', 'P'):
-            return isfloat (a)             ? fold_constgen_float (fold, fold_immvalue_float(a))
-                 : isvector(a)             ? fold_constgen_vector(fold, vec3_neg(fold_immvalue_vector(a)))
-                 : NULL;
-        case opid2('!', 'P'):
-            return isfloat (a)             ? fold_constgen_float (fold, !fold_immvalue_float(a))
-                 : isvector(a)             ? fold_constgen_vector(fold, vec3_not(fold_immvalue_vector(a)))
-                 : isstring(a)             ? fold_constgen_float (fold, !fold_immvalue_string(a) || OPTS_FLAG(TRUE_EMPTY_STRINGS) ? 0 : !*fold_immvalue_string(a))
-                 : NULL;
-        case opid1('+'):
-            return isfloats(a,b)           ? fold_constgen_float (fold, fold_immvalue_float(a) + fold_immvalue_float(b))
-                 : isvectors(a,b)          ? fold_constgen_vector(fold, vec3_add(fold_immvalue_vector(a), fold_immvalue_vector(b)))
-                 : NULL;
-        case opid1('-'):
-            return isfloats(a,b)           ? fold_constgen_float (fold, fold_immvalue_float(a) - fold_immvalue_float(b))
-                 : isvectors(a,b)          ? fold_constgen_vector(fold, vec3_sub(fold_immvalue_vector(a), fold_immvalue_vector(b)))
-                 : NULL;
-        case opid1('%'):
-            return isfloats(a,b)           ? fold_constgen_float (fold, (qcfloat_t)(((qcint_t)fold_immvalue_float(a)) % ((qcint_t)fold_immvalue_float(b))))
-                 : NULL;
-        case opid1('|'):
-            return isfloats(a,b)           ? fold_constgen_float (fold, (qcfloat_t)(((qcint_t)fold_immvalue_float(a)) | ((qcint_t)fold_immvalue_float(b))))
-                 : NULL;
-        case opid1('&'):
-            return isfloats(a,b)           ? fold_constgen_float (fold, (qcfloat_t)(((qcint_t)fold_immvalue_float(a)) & ((qcint_t)fold_immvalue_float(b))))
-                 : NULL;
-        case opid1('^'):
-            return isfloats(a,b)           ? fold_constgen_float (fold, (qcfloat_t)(((qcint_t)fold_immvalue_float(a)) ^ ((qcint_t)fold_immvalue_float(b))))
-                 : isvectors(a,b)          ? fold_constgen_vector(fold, vec3_xor  (fold_immvalue_vector(a), fold_immvalue_vector(b)))
-                 : isvector(a)&&isfloat(b) ? fold_constgen_vector(fold, vec3_xorvf(fold_immvalue_vector(a), fold_immvalue_float (b)))
-                 : NULL;
-        case opid2('<','<'):
-            return isfloats(a,b)           ? fold_constgen_float (fold, (qcfloat_t)(((qcuint_t)(fold_immvalue_float(a)) << ((qcuint_t)fold_immvalue_float(b)))))
-                 : NULL;
-        case opid2('>','>'):
-            return isfloats(a,b)           ? fold_constgen_float (fold, (qcfloat_t)(((qcuint_t)(fold_immvalue_float(a)) >> ((qcuint_t)fold_immvalue_float(b)))))
-                 : NULL;
-        case opid2('*','*'):
-            return isfloats(a,b)           ? fold_constgen_float (fold, (qcfloat_t)powf(fold_immvalue_float(a), fold_immvalue_float(b)))
-                 : NULL;
-        case opid2('!','='):
-            return isfloats(a,b)           ? fold_constgen_float (fold, fold_immvalue_float(a) != fold_immvalue_float(b))
-                 : NULL;
-        case opid2('=','='):
-            return isfloats(a,b)           ? fold_constgen_float (fold, fold_immvalue_float(a) == fold_immvalue_float(b))
-                 : NULL;
-        case opid2('~','P'):
-            return isfloat(a)              ? fold_constgen_float (fold, ~(qcint_t)fold_immvalue_float(a))
-                 : NULL;
-
-        case opid1('*'):         return fold_op_mul  (fold, a, b);
-        case opid1('/'):         return fold_op_div  (fold, a, b);
-        case opid2('|','|'):     return fold_op_andor(fold, a, b, true);
-        case opid2('&','&'):     return fold_op_andor(fold, a, b, false);
-        case opid3('<','=','>'): return fold_op_lteqgt(fold, a, b);
-        case opid2('?',':'):
-            /* TODO: seperate function for this case */
-            return NULL;
+        case opid2('-', 'P'):    return fold_op_neg    (fold, a);
+        case opid2('!', 'P'):    return fold_op_not    (fold, a);
+        case opid1('+'):         return fold_op_add    (fold, a, b);
+        case opid1('-'):         return fold_op_sub    (fold, a, b);
+        case opid1('*'):         return fold_op_mul    (fold, a, b);
+        case opid1('/'):         return fold_op_div    (fold, a, b);
+        case opid1('%'):         return fold_op_mod    (fold, a, b);
+        case opid1('|'):         return fold_op_bor    (fold, a, b);
+        case opid1('&'):         return fold_op_band   (fold, a, b);
+        case opid1('^'):         return fold_op_xor    (fold, a, b);
+        case opid2('<','<'):     return fold_op_lshift (fold, a, b);
+        case opid2('>','>'):     return fold_op_rshift (fold, a, b);
+        case opid2('|','|'):     return fold_op_andor  (fold, a, b, true);
+        case opid2('&','&'):     return fold_op_andor  (fold, a, b, false);
+        case opid2('?',':'):     return fold_op_tern   (fold, a, b, c);
+        case opid2('*','*'):     return fold_op_exp    (fold, a, b);
+        case opid3('<','=','>'): return fold_op_lteqgt (fold, a, b);
+        case opid2('!','='):     return fold_op_cmp    (fold, a, b, true);
+        case opid2('=','='):     return fold_op_cmp    (fold, a, b, false);
+        case opid2('~','P'):     return fold_op_bnot   (fold, a);
     }
     return NULL;
 }
diff --git a/lexer.h b/lexer.h
index f490d2a1b538618bb3ed307d78d0aa94316ecd17..c8c6bfea0772da0ccf56e7862c803d745ad338ef 100644 (file)
--- a/lexer.h
+++ b/lexer.h
@@ -209,10 +209,10 @@ static const oper_info c_operators[] = {
     { "<=",  2, opid2('<','='),     ASSOC_LEFT,  10, 0,         false},
     { ">=",  2, opid2('>','='),     ASSOC_LEFT,  10, 0,         false},
 
-    { "==",  2, opid2('=','='),     ASSOC_LEFT,  9,  0,         false},
-    { "!=",  2, opid2('!','='),     ASSOC_LEFT,  9,  0,         false},
+    { "==",  2, opid2('=','='),     ASSOC_LEFT,  9,  0,         true},
+    { "!=",  2, opid2('!','='),     ASSOC_LEFT,  9,  0,         true},
 
-    { "&",   2, opid1('&'),         ASSOC_LEFT,  8,  0,         true},
+    { "&",   2, opid1('&'),         ASSOC_LEFT,  8,  0,         false},
 
     { "^",   2, opid1('^'),         ASSOC_LEFT,  7,  0,         true},
 
@@ -228,7 +228,7 @@ static const oper_info c_operators[] = {
     { "+=",  2, opid2('+','='),     ASSOC_RIGHT, 2,  0,         false},
     { "-=",  2, opid2('-','='),     ASSOC_RIGHT, 2,  0,         false},
     { "*=",  2, opid2('*','='),     ASSOC_RIGHT, 2,  0,         false},
-    { "/=",  2, opid2('/','='),     ASSOC_RIGHT, 2,  0,         true},
+    { "/=",  2, opid2('/','='),     ASSOC_RIGHT, 2,  0,         false},
     { "%=",  2, opid2('%','='),     ASSOC_RIGHT, 2,  0,         false},
     { ">>=", 2, opid3('>','>','='), ASSOC_RIGHT, 2,  0,         false},
     { "<<=", 2, opid3('<','<','='), ASSOC_RIGHT, 2,  0,         false},
@@ -252,9 +252,9 @@ static const oper_info fte_operators[] = {
     { "(",   0, opid1('('),         ASSOC_LEFT,  15, 0,         false}, /* function call */
     { "[",   2, opid1('['),         ASSOC_LEFT,  15, 0,         false}, /* array subscript */
 
-    { "!",   1, opid2('!', 'P'),    ASSOC_RIGHT, 14, OP_PREFIX, true},
+    { "!",   1, opid2('!', 'P'),    ASSOC_RIGHT, 14, OP_PREFIX, false},
     { "+",   1, opid2('+','P'),     ASSOC_RIGHT, 14, OP_PREFIX, false},
-    { "-",   1, opid2('-','P'),     ASSOC_RIGHT, 14, OP_PREFIX, true},
+    { "-",   1, opid2('-','P'),     ASSOC_RIGHT, 14, OP_PREFIX, false},
     { "++",  1, opid3('+','+','P'), ASSOC_RIGHT, 14, OP_PREFIX, false},
     { "--",  1, opid3('-','-','P'), ASSOC_RIGHT, 14, OP_PREFIX, false},
 
@@ -273,8 +273,8 @@ static const oper_info fte_operators[] = {
     { ">",   2, opid1('>'),         ASSOC_LEFT,  10, 0,         false},
     { "<=",  2, opid2('<','='),     ASSOC_LEFT,  10, 0,         false},
     { ">=",  2, opid2('>','='),     ASSOC_LEFT,  10, 0,         false},
-    { "==",  2, opid2('=','='),     ASSOC_LEFT,  10, 0,         false},
-    { "!=",  2, opid2('!','='),     ASSOC_LEFT,  10, 0,         false},
+    { "==",  2, opid2('=','='),     ASSOC_LEFT,  10, 0,         true},
+    { "!=",  2, opid2('!','='),     ASSOC_LEFT,  10, 0,         true},
 
     { "?",   3, opid2('?',':'),     ASSOC_RIGHT, 9,  0,         true},
 
@@ -282,7 +282,7 @@ static const oper_info fte_operators[] = {
     { "+=",  2, opid2('+','='),     ASSOC_RIGHT, 8,  0,         false},
     { "-=",  2, opid2('-','='),     ASSOC_RIGHT, 8,  0,         false},
     { "*=",  2, opid2('*','='),     ASSOC_RIGHT, 8,  0,         false},
-    { "/=",  2, opid2('/','='),     ASSOC_RIGHT, 8,  0,         true},
+    { "/=",  2, opid2('/','='),     ASSOC_RIGHT, 8,  0,         false},
     { "%=",  2, opid2('%','='),     ASSOC_RIGHT, 8,  0,         false},
     { "&=",  2, opid2('&','='),     ASSOC_RIGHT, 8,  0,         false},
     { "|=",  2, opid2('|','='),     ASSOC_RIGHT, 8,  0,         false},
@@ -320,14 +320,14 @@ static const oper_info qcc_operators[] = {
     { ">",   2, opid1('>'),         ASSOC_LEFT,  10, 0,         false},
     { "<=",  2, opid2('<','='),     ASSOC_LEFT,  10, 0,         false},
     { ">=",  2, opid2('>','='),     ASSOC_LEFT,  10, 0,         false},
-    { "==",  2, opid2('=','='),     ASSOC_LEFT,  10, 0,         false},
-    { "!=",  2, opid2('!','='),     ASSOC_LEFT,  10, 0,         false},
+    { "==",  2, opid2('=','='),     ASSOC_LEFT,  10, 0,         true},
+    { "!=",  2, opid2('!','='),     ASSOC_LEFT,  10, 0,         true},
 
     { "=",   2, opid1('='),         ASSOC_RIGHT, 8,  0,         false},
     { "+=",  2, opid2('+','='),     ASSOC_RIGHT, 8,  0,         false},
     { "-=",  2, opid2('-','='),     ASSOC_RIGHT, 8,  0,         false},
     { "*=",  2, opid2('*','='),     ASSOC_RIGHT, 8,  0,         false},
-    { "/=",  2, opid2('/','='),     ASSOC_RIGHT, 8,  0,         true},
+    { "/=",  2, opid2('/','='),     ASSOC_RIGHT, 8,  0,         false},
     { "%=",  2, opid2('%','='),     ASSOC_RIGHT, 8,  0,         false},
     { "&=",  2, opid2('&','='),     ASSOC_RIGHT, 8,  0,         false},
     { "|=",  2, opid2('|','='),     ASSOC_RIGHT, 8,  0,         false},
index e7c7816605a637913b96694072091f2edfb80342..bfa7105151428ab0167296976150e6b9f8cf351c 100644 (file)
--- a/parser.c
+++ b/parser.c
@@ -355,8 +355,8 @@ static bool parser_sy_apply_operator(parser_t *parser, shunt *sy)
               exprs[0]->vtype != T)
 
     /* preform any constant folding on operator usage first */
-    if ((out = fold_op(parser->fold, op, exprs)))
-        goto complete;
+    /*if ((out = fold_op(parser->fold, op, exprs)))*/
+    /*goto complete;*/
 
     switch (op->id)
     {
@@ -452,49 +452,53 @@ static bool parser_sy_apply_operator(parser_t *parser, shunt *sy)
             out = exprs[0];
             break;
         case opid2('-','P'):
-            switch (exprs[0]->vtype) {
-                case TYPE_FLOAT:
-                    out = (ast_expression*)ast_binary_new(ctx, INSTR_SUB_F,
-                                                              (ast_expression*)parser->fold->imm_float[0],
-                                                              exprs[0]);
-                    break;
-                case TYPE_VECTOR:
-                    out = (ast_expression*)ast_binary_new(ctx, INSTR_SUB_V,
-                                                              (ast_expression*)parser->fold->imm_vector[0],
-                                                              exprs[0]);
-                    break;
-                default:
-                compile_error(ctx, "invalid types used in expression: cannot negate type %s",
-                              type_name[exprs[0]->vtype]);
-                return false;
+            if (!(out = fold_op(parser->fold, op, exprs))) {
+                switch (exprs[0]->vtype) {
+                    case TYPE_FLOAT:
+                        out = (ast_expression*)ast_binary_new(ctx, INSTR_SUB_F,
+                                                                  (ast_expression*)parser->fold->imm_float[0],
+                                                                  exprs[0]);
+                        break;
+                    case TYPE_VECTOR:
+                        out = (ast_expression*)ast_binary_new(ctx, INSTR_SUB_V,
+                                                                  (ast_expression*)parser->fold->imm_vector[0],
+                                                                  exprs[0]);
+                        break;
+                    default:
+                    compile_error(ctx, "invalid types used in expression: cannot negate type %s",
+                                  type_name[exprs[0]->vtype]);
+                    return false;
+                }
             }
             break;
 
         case opid2('!','P'):
-            switch (exprs[0]->vtype) {
-                case TYPE_FLOAT:
-                    out = (ast_expression*)ast_unary_new(ctx, INSTR_NOT_F, exprs[0]);
-                    break;
-                case TYPE_VECTOR:
-                    out = (ast_expression*)ast_unary_new(ctx, INSTR_NOT_V, exprs[0]);
-                    break;
-                case TYPE_STRING:
-                    if (OPTS_FLAG(TRUE_EMPTY_STRINGS))
+            if (!(out = fold_op(parser->fold, op, exprs))) {
+                switch (exprs[0]->vtype) {
+                    case TYPE_FLOAT:
                         out = (ast_expression*)ast_unary_new(ctx, INSTR_NOT_F, exprs[0]);
-                    else
-                        out = (ast_expression*)ast_unary_new(ctx, INSTR_NOT_S, exprs[0]);
-                    break;
-                /* we don't constant-fold NOT for these types */
-                case TYPE_ENTITY:
-                    out = (ast_expression*)ast_unary_new(ctx, INSTR_NOT_ENT, exprs[0]);
-                    break;
-                case TYPE_FUNCTION:
-                    out = (ast_expression*)ast_unary_new(ctx, INSTR_NOT_FNC, exprs[0]);
-                    break;
-                default:
-                compile_error(ctx, "invalid types used in expression: cannot logically negate type %s",
-                              type_name[exprs[0]->vtype]);
-                return false;
+                        break;
+                    case TYPE_VECTOR:
+                        out = (ast_expression*)ast_unary_new(ctx, INSTR_NOT_V, exprs[0]);
+                        break;
+                    case TYPE_STRING:
+                        if (OPTS_FLAG(TRUE_EMPTY_STRINGS))
+                            out = (ast_expression*)ast_unary_new(ctx, INSTR_NOT_F, exprs[0]);
+                        else
+                            out = (ast_expression*)ast_unary_new(ctx, INSTR_NOT_S, exprs[0]);
+                        break;
+                    /* we don't constant-fold NOT for these types */
+                    case TYPE_ENTITY:
+                        out = (ast_expression*)ast_unary_new(ctx, INSTR_NOT_ENT, exprs[0]);
+                        break;
+                    case TYPE_FUNCTION:
+                        out = (ast_expression*)ast_unary_new(ctx, INSTR_NOT_FNC, exprs[0]);
+                        break;
+                    default:
+                    compile_error(ctx, "invalid types used in expression: cannot logically negate type %s",
+                                  type_name[exprs[0]->vtype]);
+                    return false;
+                }
             }
             break;
 
@@ -507,42 +511,46 @@ static bool parser_sy_apply_operator(parser_t *parser, shunt *sy)
                               type_name[exprs[1]->vtype]);
                 return false;
             }
-            switch (exprs[0]->vtype) {
-                case TYPE_FLOAT:
-                    out = (ast_expression*)ast_binary_new(ctx, INSTR_ADD_F, exprs[0], exprs[1]);
-                    break;
-                case TYPE_VECTOR:
-                    out = (ast_expression*)ast_binary_new(ctx, INSTR_ADD_V, exprs[0], exprs[1]);
-                    break;
-                default:
-                    compile_error(ctx, "invalid types used in expression: cannot add type %s and %s",
-                                  type_name[exprs[0]->vtype],
-                                  type_name[exprs[1]->vtype]);
-                    return false;
-            };
+            if (!(out = fold_op(parser->fold, op, exprs))) {
+                switch (exprs[0]->vtype) {
+                    case TYPE_FLOAT:
+                        out = (ast_expression*)ast_binary_new(ctx, INSTR_ADD_F, exprs[0], exprs[1]);
+                        break;
+                    case TYPE_VECTOR:
+                        out = (ast_expression*)ast_binary_new(ctx, INSTR_ADD_V, exprs[0], exprs[1]);
+                        break;
+                    default:
+                        compile_error(ctx, "invalid types used in expression: cannot add type %s and %s",
+                                      type_name[exprs[0]->vtype],
+                                      type_name[exprs[1]->vtype]);
+                        return false;
+                }
+            }
             break;
         case opid1('-'):
-            if (exprs[0]->vtype != exprs[1]->vtype ||
-                (exprs[0]->vtype != TYPE_VECTOR && exprs[0]->vtype != TYPE_FLOAT) )
+            if  (exprs[0]->vtype != exprs[1]->vtype ||
+                (exprs[0]->vtype != TYPE_VECTOR && exprs[0]->vtype != TYPE_FLOAT))
             {
                 compile_error(ctx, "invalid types used in expression: cannot subtract type %s from %s",
                               type_name[exprs[1]->vtype],
                               type_name[exprs[0]->vtype]);
                 return false;
             }
-            switch (exprs[0]->vtype) {
-                case TYPE_FLOAT:
-                    out = (ast_expression*)ast_binary_new(ctx, INSTR_SUB_F, exprs[0], exprs[1]);
-                    break;
-                case TYPE_VECTOR:
-                    out = (ast_expression*)ast_binary_new(ctx, INSTR_SUB_V, exprs[0], exprs[1]);
-                    break;
-                default:
-                    compile_error(ctx, "invalid types used in expression: cannot subtract type %s from %s",
-                                  type_name[exprs[1]->vtype],
-                                  type_name[exprs[0]->vtype]);
-                    return false;
-            };
+            if (!(out = fold_op(parser->fold, op, exprs))) {
+                switch (exprs[0]->vtype) {
+                    case TYPE_FLOAT:
+                        out = (ast_expression*)ast_binary_new(ctx, INSTR_SUB_F, exprs[0], exprs[1]);
+                        break;
+                    case TYPE_VECTOR:
+                        out = (ast_expression*)ast_binary_new(ctx, INSTR_SUB_V, exprs[0], exprs[1]);
+                        break;
+                    default:
+                        compile_error(ctx, "invalid types used in expression: cannot subtract type %s from %s",
+                                      type_name[exprs[1]->vtype],
+                                      type_name[exprs[0]->vtype]);
+                        return false;
+                }
+            }
             break;
         case opid1('*'):
             if (exprs[0]->vtype != exprs[1]->vtype &&
@@ -557,25 +565,27 @@ static bool parser_sy_apply_operator(parser_t *parser, shunt *sy)
                               type_name[exprs[0]->vtype]);
                 return false;
             }
-            switch (exprs[0]->vtype) {
-                case TYPE_FLOAT:
-                    if (exprs[1]->vtype == TYPE_VECTOR)
-                        out = (ast_expression*)ast_binary_new(ctx, INSTR_MUL_FV, exprs[0], exprs[1]);
-                    else
-                        out = (ast_expression*)ast_binary_new(ctx, INSTR_MUL_F, exprs[0], exprs[1]);
-                    break;
-                case TYPE_VECTOR:
-                    if (exprs[1]->vtype == TYPE_FLOAT)
-                        out = (ast_expression*)ast_binary_new(ctx, INSTR_MUL_VF, exprs[0], exprs[1]);
-                    else
-                        out = (ast_expression*)ast_binary_new(ctx, INSTR_MUL_V, exprs[0], exprs[1]);
-                    break;
-                default:
-                    compile_error(ctx, "invalid types used in expression: cannot multiply types %s and %s",
-                                  type_name[exprs[1]->vtype],
-                                  type_name[exprs[0]->vtype]);
-                    return false;
-            };
+            if (!(out = fold_op(parser->fold, op, exprs))) {
+                switch (exprs[0]->vtype) {
+                    case TYPE_FLOAT:
+                        if (exprs[1]->vtype == TYPE_VECTOR)
+                            out = (ast_expression*)ast_binary_new(ctx, INSTR_MUL_FV, exprs[0], exprs[1]);
+                        else
+                            out = (ast_expression*)ast_binary_new(ctx, INSTR_MUL_F, exprs[0], exprs[1]);
+                        break;
+                    case TYPE_VECTOR:
+                        if (exprs[1]->vtype == TYPE_FLOAT)
+                            out = (ast_expression*)ast_binary_new(ctx, INSTR_MUL_VF, exprs[0], exprs[1]);
+                        else
+                            out = (ast_expression*)ast_binary_new(ctx, INSTR_MUL_V, exprs[0], exprs[1]);
+                        break;
+                    default:
+                        compile_error(ctx, "invalid types used in expression: cannot multiply types %s and %s",
+                                      type_name[exprs[1]->vtype],
+                                      type_name[exprs[0]->vtype]);
+                        return false;
+                }
+            }
             break;
         case opid1('/'):
             if (exprs[1]->vtype != TYPE_FLOAT) {
@@ -584,16 +594,18 @@ static bool parser_sy_apply_operator(parser_t *parser, shunt *sy)
                 compile_error(ctx, "invalid types used in expression: cannot divide types %s and %s", ty1, ty2);
                 return false;
             }
-            if (exprs[0]->vtype == TYPE_FLOAT) 
-                out = (ast_expression*)ast_binary_new(ctx, INSTR_DIV_F, exprs[0], exprs[1]);
-            else if (exprs[0]->vtype == TYPE_VECTOR)
-                out = (ast_expression*)ast_binary_new(ctx, INSTR_MUL_VF, exprs[0], out);
-            else
-            {
-                ast_type_to_string(exprs[0], ty1, sizeof(ty1));
-                ast_type_to_string(exprs[1], ty2, sizeof(ty2));
-                compile_error(ctx, "invalid types used in expression: cannot divide types %s and %s", ty1, ty2);
-                return false;
+            if (!(out = fold_op(parser->fold, op, exprs))) {
+                if (exprs[0]->vtype == TYPE_FLOAT) 
+                    out = (ast_expression*)ast_binary_new(ctx, INSTR_DIV_F, exprs[0], exprs[1]);
+                else if (exprs[0]->vtype == TYPE_VECTOR)
+                    out = (ast_expression*)ast_binary_new(ctx, INSTR_MUL_VF, exprs[0], out);
+                else /* TODO stot */
+                {
+                    ast_type_to_string(exprs[0], ty1, sizeof(ty1));
+                    ast_type_to_string(exprs[1], ty2, sizeof(ty2));
+                    compile_error(ctx, "invalid types used in expression: cannot divide types %s and %s", ty1, ty2);
+                    return false;
+                }
             }
             break;
 
@@ -603,7 +615,7 @@ static bool parser_sy_apply_operator(parser_t *parser, shunt *sy)
                     type_name[exprs[0]->vtype],
                     type_name[exprs[1]->vtype]);
                 return false;
-            } else {
+            } else if (!(out = fold_op(parser->fold, op, exprs))) {
                 /* generate a call to __builtin_mod */
                 ast_expression *mod  = intrin_func(parser, "mod");
                 ast_call       *call = NULL;
@@ -629,9 +641,10 @@ static bool parser_sy_apply_operator(parser_t *parser, shunt *sy)
                               type_name[exprs[1]->vtype]);
                 return false;
             }
-            out = (ast_expression*)ast_binary_new(ctx,
-                (op->id == opid1('|') ? INSTR_BITOR : INSTR_BITAND),
-                exprs[0], exprs[1]);
+            if (!(out = fold_op(parser->fold, op, exprs)))
+                out = (ast_expression*)ast_binary_new(ctx,
+                    (op->id == opid1('|') ? INSTR_BITOR : INSTR_BITAND),
+                    exprs[0], exprs[1]);
             break;
         case opid1('^'):
             /*
@@ -681,62 +694,65 @@ static bool parser_sy_apply_operator(parser_t *parser, shunt *sy)
                 return false;
             }
 
-            /*
-             * IF the first expression is float, the following will be too
-             * since scalar ^ vector is not allowed.
-             */
-            if (exprs[0]->vtype == TYPE_FLOAT) {
-                ast_binary *expr = ast_binary_new(
-                    ctx,
-                    INSTR_SUB_F,
-                    (ast_expression*)parser->fold->imm_float[2],
-                    (ast_expression*)ast_binary_new(
-                        ctx,
-                        INSTR_BITAND,
-                        exprs[0],
-                        exprs[1]
-                    )
-                );
-                expr->refs = AST_REF_NONE;
-
-                out = (ast_expression*)
-                    ast_binary_new(
+            if (!(out = fold_op(parser->fold, op, exprs))) {
+                /*
+                 * IF the first expression is float, the following will be too
+                 * since scalar ^ vector is not allowed.
+                 */
+                if (exprs[0]->vtype == TYPE_FLOAT) {
+                    ast_binary *expr = ast_binary_new(
                         ctx,
-                        INSTR_BITAND,
+                        INSTR_SUB_F,
+                        (ast_expression*)parser->fold->imm_float[2],
                         (ast_expression*)ast_binary_new(
                             ctx,
-                            INSTR_BITOR,
+                            INSTR_BITAND,
                             exprs[0],
                             exprs[1]
-                        ),
-                        (ast_expression*)expr
+                        )
                     );
-            } else {
-                /*
-                 * The first is a vector: vector is allowed to xor with vector and
-                 * with scalar, branch here for the second operand.
-                 */
-                if (exprs[1]->vtype == TYPE_VECTOR) {
+                    expr->refs = AST_REF_NONE;
+
+                    out = (ast_expression*)
+                        ast_binary_new(
+                            ctx,
+                            INSTR_BITAND,
+                            (ast_expression*)ast_binary_new(
+                                ctx,
+                                INSTR_BITOR,
+                                exprs[0],
+                                exprs[1]
+                            ),
+                            (ast_expression*)expr
+                        );
+                } else {
                     /*
-                     * Xor all the values of the vector components against the
-                     * vectors components in question.
+                     * The first is a vector: vector is allowed to xor with vector and
+                     * with scalar, branch here for the second operand.
                      */
-                    compile_error(ast_ctx(exprs[0]), "Not Yet Implemented: bit-xor for vector against vector");
-                    return false;
-                } else {
-                    compile_error(ast_ctx(exprs[0]), "Not Yet Implemented: bit-xor for vector against float");
-                    return false;
+                    if (exprs[1]->vtype == TYPE_VECTOR) {
+                        /*
+                         * Xor all the values of the vector components against the
+                         * vectors components in question.
+                         */
+                        compile_error(ast_ctx(exprs[0]), "Not Yet Implemented: bit-xor for vector against vector");
+                        return false;
+                    } else {
+                        compile_error(ast_ctx(exprs[0]), "Not Yet Implemented: bit-xor for vector against float");
+                        return false;
+                    }
                 }
             }
-
             break;
 
         case opid2('<','<'):
         case opid2('>','>'):
         case opid3('<','<','='):
         case opid3('>','>','='):
-            compile_error(ast_ctx(exprs[0]), "Not Yet Implemented: bit-shifts");
-            return false;
+            if(!(out = fold_op(parser->fold, op, exprs))) {
+                compile_error(ast_ctx(exprs[0]), "Not Yet Implemented: bit-shifts");
+                return false;
+            }
 
         case opid2('|','|'):
             generated_op += 1; /* INSTR_OR */
@@ -748,31 +764,33 @@ static bool parser_sy_apply_operator(parser_t *parser, shunt *sy)
                 compile_error(ctx, "invalid types for logical operation with -fperl-logic: %s and %s", ty1, ty2);
                 return false;
             }
-            for (i = 0; i < 2; ++i) {
-                if (OPTS_FLAG(CORRECT_LOGIC) && exprs[i]->vtype == TYPE_VECTOR) {
-                    out = (ast_expression*)ast_unary_new(ctx, INSTR_NOT_V, exprs[i]);
-                    if (!out) break;
-                    out = (ast_expression*)ast_unary_new(ctx, INSTR_NOT_F, out);
-                    if (!out) break;
-                    exprs[i] = out; out = NULL;
-                    if (OPTS_FLAG(PERL_LOGIC)) {
-                        /* here we want to keep the right expressions' type */
-                        break;
+            if (!(out = fold_op(parser->fold, op, exprs))) {
+                for (i = 0; i < 2; ++i) {
+                    if (OPTS_FLAG(CORRECT_LOGIC) && exprs[i]->vtype == TYPE_VECTOR) {
+                        out = (ast_expression*)ast_unary_new(ctx, INSTR_NOT_V, exprs[i]);
+                        if (!out) break;
+                        out = (ast_expression*)ast_unary_new(ctx, INSTR_NOT_F, out);
+                        if (!out) break;
+                        exprs[i] = out; out = NULL;
+                        if (OPTS_FLAG(PERL_LOGIC)) {
+                            /* here we want to keep the right expressions' type */
+                            break;
+                        }
                     }
-                }
-                else if (OPTS_FLAG(FALSE_EMPTY_STRINGS) && exprs[i]->vtype == TYPE_STRING) {
-                    out = (ast_expression*)ast_unary_new(ctx, INSTR_NOT_S, exprs[i]);
-                    if (!out) break;
-                    out = (ast_expression*)ast_unary_new(ctx, INSTR_NOT_F, out);
-                    if (!out) break;
-                    exprs[i] = out; out = NULL;
-                    if (OPTS_FLAG(PERL_LOGIC)) {
-                        /* here we want to keep the right expressions' type */
-                        break;
+                    else if (OPTS_FLAG(FALSE_EMPTY_STRINGS) && exprs[i]->vtype == TYPE_STRING) {
+                        out = (ast_expression*)ast_unary_new(ctx, INSTR_NOT_S, exprs[i]);
+                        if (!out) break;
+                        out = (ast_expression*)ast_unary_new(ctx, INSTR_NOT_F, out);
+                        if (!out) break;
+                        exprs[i] = out; out = NULL;
+                        if (OPTS_FLAG(PERL_LOGIC)) {
+                            /* here we want to keep the right expressions' type */
+                            break;
+                        }
                     }
                 }
+                out = (ast_expression*)ast_binary_new(ctx, generated_op, exprs[0], exprs[1]);
             }
-            out = (ast_expression*)ast_binary_new(ctx, generated_op, exprs[0], exprs[1]);
             break;
 
         case opid2('?',':'):
@@ -787,7 +805,8 @@ static bool parser_sy_apply_operator(parser_t *parser, shunt *sy)
                 compile_error(ctx, "operands of ternary expression must have the same type, got %s and %s", ty1, ty2);
                 return false;
             }
-            out = (ast_expression*)ast_ternary_new(ctx, exprs[0], exprs[1], exprs[2]);
+            if (!(out = fold_op(parser->fold, op, exprs)))
+                out = (ast_expression*)ast_ternary_new(ctx, exprs[0], exprs[1], exprs[2]);
             break;
 
         case opid2('*', '*'):
@@ -796,9 +815,8 @@ static bool parser_sy_apply_operator(parser_t *parser, shunt *sy)
                 ast_type_to_string(exprs[1], ty2, sizeof(ty2));
                 compile_error(ctx, "invalid types used in exponentiation: %s and %s",
                     ty1, ty2);
-
                 return false;
-            } else {
+            } else if (!(out = fold_op(parser->fold, op, exprs))) {
                 ast_call *gencall = ast_call_new(parser_ctx(parser), intrin_func(parser, "pow"));
                 vec_push(gencall->params, exprs[0]);
                 vec_push(gencall->params, exprs[1]);
@@ -814,7 +832,7 @@ static bool parser_sy_apply_operator(parser_t *parser, shunt *sy)
                     ty1, ty2);
 
                 return false;
-            } else {
+            } else if (!(out = fold_op(parser->fold, op, exprs))) {
                 ast_binary *eq = ast_binary_new(ctx, INSTR_EQ_F, exprs[0], exprs[1]);
 
                 eq->refs = AST_REF_NONE;
@@ -854,7 +872,8 @@ static bool parser_sy_apply_operator(parser_t *parser, shunt *sy)
                               type_name[exprs[1]->vtype]);
                 return false;
             }
-            out = (ast_expression*)ast_binary_new(ctx, generated_op, exprs[0], exprs[1]);
+            if (!(out = fold_op(parser->fold, op, exprs)))
+                out = (ast_expression*)ast_binary_new(ctx, generated_op, exprs[0], exprs[1]);
             break;
         case opid2('!', '='):
             if (exprs[0]->vtype != exprs[1]->vtype) {
@@ -863,7 +882,8 @@ static bool parser_sy_apply_operator(parser_t *parser, shunt *sy)
                               type_name[exprs[1]->vtype]);
                 return false;
             }
-            out = (ast_expression*)ast_binary_new(ctx, type_ne_instr[exprs[0]->vtype], exprs[0], exprs[1]);
+            if (!(out = fold_op(parser->fold, op, exprs)))
+                out = (ast_expression*)ast_binary_new(ctx, type_ne_instr[exprs[0]->vtype], exprs[0], exprs[1]);
             break;
         case opid2('=', '='):
             if (exprs[0]->vtype != exprs[1]->vtype) {
@@ -872,7 +892,8 @@ static bool parser_sy_apply_operator(parser_t *parser, shunt *sy)
                               type_name[exprs[1]->vtype]);
                 return false;
             }
-            out = (ast_expression*)ast_binary_new(ctx, type_eq_instr[exprs[0]->vtype], exprs[0], exprs[1]);
+            if (!(out = fold_op(parser->fold, op, exprs)))
+                out = (ast_expression*)ast_binary_new(ctx, type_eq_instr[exprs[0]->vtype], exprs[0], exprs[1]);
             break;
 
         case opid1('='):
@@ -1133,11 +1154,12 @@ static bool parser_sy_apply_operator(parser_t *parser, shunt *sy)
                 compile_error(ast_ctx(exprs[0]), "invalid type for bit not: %s", ty1);
                 return false;
             }
-            out = (ast_expression*)ast_binary_new(ctx, INSTR_SUB_F, (ast_expression*)parser->fold->imm_float[2], exprs[0]);
+            if (!(out = fold_op(parser->fold, op, exprs)))
+                out = (ast_expression*)ast_binary_new(ctx, INSTR_SUB_F, (ast_expression*)parser->fold->imm_float[2], exprs[0]);
             break;
     }
 #undef NotSameType
-complete:
+/*complete:*/
     if (!out) {
         compile_error(ctx, "failed to apply operator %s", op->op);
         return false;