~lbnz/xr0: drop binary op

10 files changed, 132 insertions(+), 70 deletions(-)

M include/ast.h
M include/value.h
M src/ast/ast.c
M src/ast/expr/expr.c
M src/ast/expr/expr.h
M src/ast/expr/verify.c
M src/ast/stmt/verify.c
M src/object/object.c
M src/state/block.c
M src/value/value.c

M include/ast.h => include/ast.h +23 -15

@@ 75,22 75,29 @@ ast_expr_unary_isdereference(struct ast_expr *);
 struct ast_expr *
 ast_expr_unary_operand(struct ast_expr *);
 
-enum ast_binary_operator {
-	BINARY_OP_EQ	= 1 << 0,
-	BINARY_OP_NE	= 1 << 1,
+struct ast_expr *
+ast_expr_eq_create(struct ast_expr *, struct ast_expr *);
 
-	BINARY_OP_LT	= 1 << 2,
-	BINARY_OP_GT	= 1 << 3,
-	BINARY_OP_LE	= 1 << 4,
-	BINARY_OP_GE	= 1 << 5,
+struct ast_expr *
+ast_expr_ne_create(struct ast_expr *, struct ast_expr *);
 
-	BINARY_OP_ADDITION	= 1 << 6,
-	BINARY_OP_SUBTRACTION	= 1 << 7,
-};
+struct ast_expr *
+ast_expr_lt_create(struct ast_expr *, struct ast_expr *);
+
+struct ast_expr *
+ast_expr_gt_create(struct ast_expr *, struct ast_expr *);
+
+struct ast_expr *
+ast_expr_le_create(struct ast_expr *, struct ast_expr *);
 
 struct ast_expr *
-ast_expr_binary_create(struct ast_expr *e1, enum ast_binary_operator,
-		struct ast_expr *e2);
+ast_expr_ge_create(struct ast_expr *, struct ast_expr *);
+
+struct ast_expr *
+ast_expr_sum_create(struct ast_expr *, struct ast_expr *);
+
+struct ast_expr *
+ast_expr_difference_create(struct ast_expr *, struct ast_expr *);
 
 struct ast_expr *
 ast_expr_binary_e1(struct ast_expr *);


@@ 98,9 105,6 @@ ast_expr_binary_e1(struct ast_expr *);
 struct ast_expr *
 ast_expr_binary_e2(struct ast_expr *);
 
-enum ast_binary_operator
-ast_expr_binary_op(struct ast_expr *);
-
 struct ast_expr *
 ast_expr_assignment_create(struct ast_expr *root, struct ast_expr *value);
 


@@ 148,6 152,8 @@ ast_expr_rangedecide(struct ast_expr *, struct ast_expr *lw,
 struct error *
 ast_expr_exec(struct ast_expr *, struct state *);
 
+struct lvalue;
+
 struct lvalue *
 ast_expr_lvalue(struct ast_expr *, struct state *);
 


@@ 498,6 504,8 @@ struct error;
 struct error *
 ast_function_verify(struct ast_function *, struct externals *);
 
+struct result;
+
 struct result *
 ast_function_absexec(struct ast_function *, struct state *state);

M include/value.h => include/value.h +1 -1

@@ 84,7 84,7 @@ value_references(struct value *, struct location *, struct state *);
 enum ast_binary_operator;
 
 bool
-value_compare(struct value *v1, enum ast_binary_operator, struct value *v2);
+value_equal(struct value *v1, struct value *v2);
 
 enum number_value_type {
 	NUMBER_VALUE_CONSTANT,

M src/ast/ast.c => src/ast/ast.c +0 -2

@@ 137,5 137,3 @@ lvalue_object(struct lvalue *l)
 {
 	return l->obj;
 }
-
-

M src/ast/expr/expr.c => src/ast/expr/expr.c +48 -0

@@ 371,6 371,54 @@ ast_expr_binary_create(struct ast_expr *e1, enum ast_binary_operator op,
 }
 
 struct ast_expr *
+ast_expr_eq_create(struct ast_expr *e1, struct ast_expr *e2)
+{
+	return ast_expr_binary_create(e1, BINARY_OP_EQ, e2);
+}
+
+struct ast_expr *
+ast_expr_ne_create(struct ast_expr *e1, struct ast_expr *e2)
+{
+	return ast_expr_binary_create(e1, BINARY_OP_NE, e2);
+}
+
+struct ast_expr *
+ast_expr_lt_create(struct ast_expr *e1, struct ast_expr *e2)
+{
+	return ast_expr_binary_create(e1, BINARY_OP_LT, e2);
+}
+
+struct ast_expr *
+ast_expr_gt_create(struct ast_expr *e1, struct ast_expr *e2)
+{
+	return ast_expr_binary_create(e1, BINARY_OP_GT, e2);
+}
+
+struct ast_expr *
+ast_expr_le_create(struct ast_expr *e1, struct ast_expr *e2)
+{
+	return ast_expr_binary_create(e1, BINARY_OP_LE, e2);
+}
+
+struct ast_expr *
+ast_expr_ge_create(struct ast_expr *e1, struct ast_expr *e2)
+{
+	return ast_expr_binary_create(e1, BINARY_OP_GE, e2);
+}
+
+struct ast_expr *
+ast_expr_sum_create(struct ast_expr *e1, struct ast_expr *e2)
+{
+	return ast_expr_binary_create(e1, BINARY_OP_ADDITION, e2);
+}
+
+struct ast_expr *
+ast_expr_difference_create(struct ast_expr *e1, struct ast_expr *e2)
+{
+	return ast_expr_binary_create(e1, BINARY_OP_SUBTRACTION, e2);
+}
+
+struct ast_expr *
 ast_expr_binary_e1(struct ast_expr *expr)
 {
 	assert(expr->kind == EXPR_BINARY);

M src/ast/expr/expr.h => src/ast/expr/expr.h +16 -1

@@ 42,7 42,18 @@ struct ast_expr {
 			UNARY_OP_BANG			= 1 << 5,
 		} unary_op;
 		struct {
-			enum ast_binary_operator op;
+			enum ast_binary_operator {
+				BINARY_OP_EQ	= 1 << 0,
+				BINARY_OP_NE	= 1 << 1,
+
+				BINARY_OP_LT	= 1 << 2,
+				BINARY_OP_GT	= 1 << 3,
+				BINARY_OP_LE	= 1 << 4,
+				BINARY_OP_GE	= 1 << 5,
+
+				BINARY_OP_ADDITION	= 1 << 6,
+				BINARY_OP_SUBTRACTION	= 1 << 7,
+			} op;
 			struct ast_expr *e1, *e2;
 		} binary;
 		struct ast_expr *assignment_value;


@@ 52,4 63,8 @@ struct ast_expr {
 enum ast_expr_kind
 ast_expr_kind(struct ast_expr *);
 
+struct ast_expr *
+ast_expr_binary_create(struct ast_expr *e1, enum ast_binary_operator,
+		struct ast_expr *e2);
+
 #endif

M src/ast/expr/verify.c => src/ast/expr/verify.c +16 -0

@@ 231,6 231,9 @@ struct result *
 ast_expr_eval(struct ast_expr *expr, struct state *state);
 
 static bool
+value_compare(struct value *, enum ast_binary_operator, struct value *);
+
+static bool
 expr_binary_decide(struct ast_expr *expr, struct state *state)
 {
 	struct result *root = ast_expr_eval(ast_expr_binary_e1(expr), state),


@@ 245,6 248,19 @@ expr_binary_decide(struct ast_expr *expr, struct state *state)
 	);
 }
 
+static bool
+value_compare(struct value *v1, enum ast_binary_operator op, struct value *v2)
+{
+	switch (op) {
+	case BINARY_OP_EQ:
+		return value_equal(v1, v2);
+	case BINARY_OP_NE:
+		return !value_compare(v1, BINARY_OP_EQ, v2);
+	default:
+		assert(false);
+	}
+}
+
 /* ast_expr_eval */
 
 static struct result *

M src/ast/stmt/verify.c => src/ast/stmt/verify.c +0 -1

@@ 242,7 242,6 @@ stmt_jump_exec(struct ast_stmt *stmt, struct state *state)
 }
 
 
-
 static struct result *
 iter_absexec(struct ast_stmt *stmt, struct state *state);

M src/object/object.c => src/object/object.c +24 -26

@@ 208,9 208,8 @@ object_lower(struct object *obj)
 struct ast_expr *
 object_upper(struct object *obj)
 {
-	return ast_expr_binary_create(
+	return ast_expr_sum_create(
 		ast_expr_copy(obj->offset),
-		BINARY_OP_ADDITION,
 		object_size(obj)
 	);
 }


@@ 222,11 221,11 @@ object_contains(struct object *obj, struct ast_expr *offset, struct state *s)
 			*up = object_upper(obj),
 			*of = offset;
 
-	struct ast_expr *e1 = ast_expr_binary_create(
-		ast_expr_copy(lw), BINARY_OP_LE, ast_expr_copy(of)
+	struct ast_expr *e1 = ast_expr_le_create(
+		ast_expr_copy(lw), ast_expr_copy(of)
 	);
-	struct ast_expr *e2 = ast_expr_binary_create(
-		ast_expr_copy(of), BINARY_OP_LT, ast_expr_copy(up)
+	struct ast_expr *e2 = ast_expr_lt_create(
+		ast_expr_copy(of), ast_expr_copy(up)
 	);
 	ast_expr_destroy(up);
 	


@@ 253,12 252,12 @@ object_contains_upperincl(struct object *obj, struct ast_expr *offset,
 
 	return
 		/* lw ≤ of */
-		state_eval(s, ast_expr_binary_create(lw, BINARY_OP_LE, of))
+		state_eval(s, ast_expr_le_create(lw, of))
 
 		&&
 
 		/* of ≤ up */
-		state_eval(s, ast_expr_binary_create(of, BINARY_OP_LE, up));
+		state_eval(s, ast_expr_le_create(of, up));
 }
 
 bool


@@ 267,7 266,7 @@ object_isempty(struct object *obj, struct state *s)
 	struct ast_expr *lw = obj->offset,
 			*up = object_upper(obj);
 
-	return state_eval(s, ast_expr_binary_create(lw, BINARY_OP_EQ, up));
+	return state_eval(s, ast_expr_eq_create(lw, up));
 }
 
 bool


@@ 276,7 275,7 @@ object_contig_precedes(struct object *before, struct object *after,
 {
 	struct ast_expr *lw = object_upper(before),
 			*up = after->offset;
-	return state_eval(s, ast_expr_binary_create(lw, BINARY_OP_EQ, up));
+	return state_eval(s, ast_expr_eq_create(lw, up));
 }
 
 bool


@@ 285,12 284,12 @@ object_issingular(struct object *obj, struct state *s)
 	struct ast_expr *lw = obj->offset,
 			*up = object_upper(obj);
 
-	struct ast_expr *lw_succ = ast_expr_binary_create(
-		lw, BINARY_OP_ADDITION, ast_expr_constant_create(1)
+	struct ast_expr *lw_succ = ast_expr_sum_create(
+		lw, ast_expr_constant_create(1)
 	);
 
 	/* lw + 1 == up */
-	return state_eval(s, ast_expr_binary_create(lw_succ, BINARY_OP_EQ, up));
+	return state_eval(s, ast_expr_eq_create(lw_succ, up));
 }
 
 struct object *


@@ 299,14 298,14 @@ object_upto(struct object *obj, struct ast_expr *excl_up, struct state *s)
 	struct ast_expr *lw = obj->offset,
 			*up = object_upper(obj);
 
-	struct ast_expr *prop0 = ast_expr_binary_create(
-		ast_expr_copy(lw), BINARY_OP_LE, ast_expr_copy(excl_up)
+	struct ast_expr *prop0 = ast_expr_le_create(
+		ast_expr_copy(lw), ast_expr_copy(excl_up)
 	);
-	struct ast_expr *prop1 = ast_expr_binary_create(
-		ast_expr_copy(lw), BINARY_OP_EQ, ast_expr_copy(excl_up)
+	struct ast_expr *prop1 = ast_expr_eq_create(
+		ast_expr_copy(lw), ast_expr_copy(excl_up)
 	);
-	struct ast_expr *prop2 = ast_expr_binary_create(
-		ast_expr_copy(up), BINARY_OP_EQ, ast_expr_copy(excl_up)
+	struct ast_expr *prop2 = ast_expr_eq_create(
+		ast_expr_copy(up), ast_expr_copy(excl_up)
 	);
 
 	bool e0 = state_eval(s, prop0),


@@ 333,7 332,7 @@ object_upto(struct object *obj, struct ast_expr *excl_up, struct state *s)
 	return object_range_create(
 		ast_expr_copy(obj->offset),
 		range_create(
-			ast_expr_binary_create(excl_up, BINARY_OP_SUBTRACTION, lw),
+			ast_expr_difference_create(excl_up, lw),
 			value_as_ptr(state_alloc(s))
 		)
 	);


@@ 345,11 344,11 @@ object_from(struct object *obj, struct ast_expr *incl_lw, struct state *s)
 	struct ast_expr *lw = obj->offset,
 			*up = object_upper(obj);
 
-	struct ast_expr *prop0 = ast_expr_binary_create(
-		ast_expr_copy(incl_lw), BINARY_OP_GE, ast_expr_copy(up)
+	struct ast_expr *prop0 = ast_expr_ge_create(
+		ast_expr_copy(incl_lw), ast_expr_copy(up)
 	);
-	struct ast_expr *prop1 = ast_expr_binary_create(
-		ast_expr_copy(incl_lw), BINARY_OP_EQ, ast_expr_copy(lw)
+	struct ast_expr *prop1 = ast_expr_eq_create(
+		ast_expr_copy(incl_lw), ast_expr_copy(lw)
 	);
 
 	bool e0 = state_eval(s, prop0),


@@ 374,9 373,8 @@ object_from(struct object *obj, struct ast_expr *incl_lw, struct state *s)
 	return object_range_create(
 		ast_expr_copy(incl_lw),
 		range_create(
-			ast_expr_binary_create(
+			ast_expr_difference_create(
 				up,
-				BINARY_OP_SUBTRACTION,
 				ast_expr_copy(incl_lw)
 			),
 			value_as_ptr(state_alloc(s))

M src/state/block.c => src/state/block.c +4 -8

@@ 85,9 85,8 @@ block_observe(struct block *b, struct ast_expr *offset, struct state *s,
 
 	/* range around observand at offset */
 	struct ast_expr *lw = ast_expr_copy(offset);
-	struct ast_expr *up = ast_expr_binary_create(
+	struct ast_expr *up = ast_expr_sum_create(
 		ast_expr_copy(offset),
-		BINARY_OP_ADDITION,
 		ast_expr_constant_create(1)
 	);
  


@@ 141,9 140,8 @@ block_range_alloc(struct block *b, struct ast_expr *lw, struct ast_expr *up,
 		object_range_create(
 			ast_expr_copy(lw),
 			range_create(
-				ast_expr_binary_create(
+				ast_expr_difference_create(
 					ast_expr_copy(up),
-					BINARY_OP_SUBTRACTION,
 					ast_expr_copy(lw)
 				),
 				heap_newblock(heap)


@@ 204,10 202,8 @@ hack_first_object_is_exactly_bounds(struct block *b, struct ast_expr *lw,
 		return false;
 	}
 
-	struct ast_expr *same_lw =
-		ast_expr_binary_create(lw, BINARY_OP_EQ, object_lower(obj)),
-			*same_up =
-		ast_expr_binary_create(up, BINARY_OP_EQ, object_upper(obj));
+	struct ast_expr *same_lw = ast_expr_eq_create(lw, object_lower(obj)),
+			*same_up = ast_expr_eq_create(up, object_upper(obj));
 
 	return state_eval(s, same_lw) && state_eval(s, same_up);
 }

M src/value/value.c => src/value/value.c +0 -16

@@ 440,22 440,6 @@ struct_references(struct value *v, struct location *loc, struct state *s)
 }
 
 bool
-value_equal(struct value *v1, struct value *v2);
-
-bool
-value_compare(struct value *v1, enum ast_binary_operator op, struct value *v2)
-{
-	switch (op) {
-	case BINARY_OP_EQ:
-		return value_equal(v1, v2);
-	case BINARY_OP_NE:
-		return !value_compare(v1, BINARY_OP_EQ, v2);
-	default:
-		assert(false);
-	}
-}
-
-bool
 number_equal(struct number *n1, struct number *n2);
 
 bool