From 77f9b4609b853b25543629ff3aba5cbe755e6e96 Mon Sep 17 00:00:00 2001
From: bdemsky <bdemsky@uci.edu>
Date: Tue, 11 Jul 2017 11:12:25 -0700
Subject: [PATCH] Minor formatting issues

---
 src/AST/boolean.c        | 33 ++++++++++------------
 src/AST/boolean.h        |  2 +-
 src/AST/element.c        | 61 ++++++++++++++++++++--------------------
 src/AST/element.h        |  3 +-
 src/AST/function.c       | 11 +++++---
 src/AST/function.h       |  5 ++--
 src/AST/mutableset.c     | 14 ++++-----
 src/AST/order.c          | 41 +++++++++++++--------------
 src/AST/order.h          |  8 +++---
 src/AST/predicate.c      | 40 +++++++++++++-------------
 src/AST/predicate.h      |  5 ++--
 src/AST/set.c            | 54 +++++++++++++++++------------------
 src/AST/set.h            |  9 +++---
 src/AST/table.c          | 29 +++++++++----------
 src/AST/table.h          |  6 ++--
 src/Backend/satencoder.c |  5 ++--
 src/csolver.c            |  2 +-
 17 files changed, 162 insertions(+), 166 deletions(-)

diff --git a/src/AST/boolean.c b/src/AST/boolean.c
index 4fd2c86..428b5e2 100644
--- a/src/AST/boolean.c
+++ b/src/AST/boolean.c
@@ -4,27 +4,24 @@
 #include "element.h"
 #include "order.h"
 
-Boolean* allocBoolean(VarType t) {
-	BooleanVar* tmp=(BooleanVar *) ourmalloc(sizeof (BooleanVar));
-	GETBOOLEANTYPE(tmp)=BOOLEANVAR;
-	tmp->vtype=t;
-	tmp->var=E_NULL;
-	allocInlineDefVectorBoolean(GETBOOLEANPARENTS(tmp));
-	return & tmp->base;
+Boolean* allocBooleanVar(VarType t) {
+	BooleanVar* This=(BooleanVar *) ourmalloc(sizeof (BooleanVar));
+	GETBOOLEANTYPE(This)=BOOLEANVAR;
+	This->vtype=t;
+	This->var=E_NULL;
+	allocInlineDefVectorBoolean(GETBOOLEANPARENTS(This));
+	return & This->base;
 }
 
 Boolean* allocBooleanOrder(Order* order, uint64_t first, uint64_t second) {
-	BooleanOrder* tmp=(BooleanOrder *) ourmalloc(sizeof (BooleanOrder));
-	GETBOOLEANTYPE(tmp)=ORDERCONST;
-	tmp->order=order;
-	tmp->first=first;
-	tmp->second=second;
-	//FIXME: what if client calls this function with the same arguments?
-	//Instead of vector we should keep a hashtable from PAIR->BOOLEANOrder with
-	//asymmetric hash function.  
-	pushVectorBoolean(&order->constraints, &tmp->base);
-	allocInlineDefVectorBoolean(GETBOOLEANPARENTS(tmp));
-	return & tmp -> base;
+	BooleanOrder* This=(BooleanOrder *) ourmalloc(sizeof (BooleanOrder));
+	GETBOOLEANTYPE(This)=ORDERCONST;
+	This->order=order;
+	This->first=first;
+	This->second=second;
+	pushVectorBoolean(&order->constraints, &This->base);
+	allocInlineDefVectorBoolean(GETBOOLEANPARENTS(This));
+	return & This -> base;
 }
 
 Boolean * allocBooleanPredicate(Predicate * predicate, Element ** inputs, uint numInputs){
diff --git a/src/AST/boolean.h b/src/AST/boolean.h
index 7382908..928ba41 100644
--- a/src/AST/boolean.h
+++ b/src/AST/boolean.h
@@ -46,7 +46,7 @@ struct BooleanPredicate {
 	ArrayElement inputs;
 };
 
-Boolean * allocBoolean(VarType t);
+Boolean * allocBooleanVar(VarType t);
 Boolean * allocBooleanOrder(Order * order, uint64_t first, uint64_t second);
 Boolean * allocBooleanPredicate(Predicate * predicate, Element ** inputs, uint numInputs);
 Boolean * allocBooleanLogicArray(CSolver *solver, LogicOp op, Boolean ** array, uint asize);
diff --git a/src/AST/element.c b/src/AST/element.c
index 9fc426c..8855194 100644
--- a/src/AST/element.c
+++ b/src/AST/element.c
@@ -6,45 +6,45 @@
 #include "table.h"
 
 Element *allocElementSet(Set * s) {
-	ElementSet * tmp=(ElementSet *)ourmalloc(sizeof(ElementSet));
-	GETELEMENTTYPE(tmp)= ELEMSET;
-	tmp->set=s;
-	allocInlineDefVectorASTNode(GETELEMENTPARENTS(tmp));
-	initElementEncoding(&tmp->encoding, (Element *) tmp);
-	return &tmp->base;
+	ElementSet * This=(ElementSet *)ourmalloc(sizeof(ElementSet));
+	GETELEMENTTYPE(This)= ELEMSET;
+	This->set=s;
+	allocInlineDefVectorASTNode(GETELEMENTPARENTS(This));
+	initElementEncoding(&This->encoding, (Element *) This);
+	return &This->base;
 }
 
 Element* allocElementFunction(Function * function, Element ** array, uint numArrays, Boolean * overflowstatus){
-	ElementFunction* tmp = (ElementFunction*) ourmalloc(sizeof(ElementFunction));
-	GETELEMENTTYPE(tmp)= ELEMFUNCRETURN;
-	tmp->function=function;
-	tmp->overflowstatus = overflowstatus;
-	allocInlineArrayInitElement(&tmp->inputs, array, numArrays);
-	allocInlineDefVectorASTNode(GETELEMENTPARENTS(tmp));
+	ElementFunction* This = (ElementFunction*) ourmalloc(sizeof(ElementFunction));
+	GETELEMENTTYPE(This)= ELEMFUNCRETURN;
+	This->function=function;
+	This->overflowstatus = overflowstatus;
+	allocInlineArrayInitElement(&This->inputs, array, numArrays);
+	allocInlineDefVectorASTNode(GETELEMENTPARENTS(This));
 	for(uint i=0;i<numArrays;i++)
-		pushVectorASTNode(GETELEMENTPARENTS(array[i]), (ASTNode *) tmp);
-	initElementEncoding(&tmp->domainencoding, (Element *) tmp);
-	initFunctionEncoding(&tmp->functionencoding, (Element *) tmp);
-	return &tmp->base;
+		pushVectorASTNode(GETELEMENTPARENTS(array[i]), (ASTNode *) This);
+	initElementEncoding(&This->domainencoding, (Element *) This);
+	initFunctionEncoding(&This->functionencoding, (Element *) This);
+	return &This->base;
 }
 
 Set* getElementSet(Element* This){
 	switch(GETELEMENTTYPE(This)){
-		case ELEMSET:
-			return ((ElementSet*)This)->set;
-		case ELEMFUNCRETURN:
-			;//Nope is needed for label assignment. i.e. next instruction isn't a statement 
-			Function* func = ((ElementFunction*)This)->function;
-			switch(GETFUNCTIONTYPE(func)){
-				case TABLEFUNC:
-					return ((FunctionTable*)func)->table->range;
-				case OPERATORFUNC:
-					return ((FunctionOperator*)func)->range;
-				default:
-					ASSERT(0);
-			}
+	case ELEMSET:
+		return ((ElementSet*)This)->set;
+	case ELEMFUNCRETURN: {
+		Function* func = ((ElementFunction*)This)->function;
+		switch(GETFUNCTIONTYPE(func)){
+		case TABLEFUNC:
+			return ((FunctionTable*)func)->table->range;
+		case OPERATORFUNC:
+			return ((FunctionOperator*)func)->range;
 		default:
 			ASSERT(0);
+		}
+	}
+	default:
+		ASSERT(0);
 	}
 	ASSERT(0);
 	return NULL;
@@ -65,9 +65,8 @@ void deleteElement(Element *This) {
 		break;
 	}
 	default:
-		;
+		ASSERT(0);
 	}
 	deleteVectorArrayASTNode(GETELEMENTPARENTS(This));
-
 	ourfree(This);
 }
diff --git a/src/AST/element.h b/src/AST/element.h
index 509ee8c..bce0073 100644
--- a/src/AST/element.h
+++ b/src/AST/element.h
@@ -34,6 +34,7 @@ Element * allocElementSet(Set *s);
 Element* allocElementFunction(Function * function, Element ** array, uint numArrays, Boolean * overflowstatus);
 void deleteElement(Element *This);
 Set* getElementSet(Element* This);
+
 static inline ElementEncoding* getElementEncoding(Element* This){
 	switch(GETELEMENTTYPE(This)){
 		case ELEMSET:
@@ -46,9 +47,7 @@ static inline ElementEncoding* getElementEncoding(Element* This){
 	return NULL;
 }
 
-
 static inline FunctionEncoding* getElementFunctionEncoding(ElementFunction* func){
 	return &func->functionencoding;
 }
-
 #endif
diff --git a/src/AST/function.c b/src/AST/function.c
index 61e413b..2530e93 100644
--- a/src/AST/function.c
+++ b/src/AST/function.c
@@ -3,7 +3,7 @@
 #include "set.h"
 
 
-Function* allocFunctionOperator( ArithOp op, Set ** domain, uint numDomain, Set * range,OverFlowBehavior overflowbehavior){
+Function* allocFunctionOperator(ArithOp op, Set ** domain, uint numDomain, Set * range, OverFlowBehavior overflowbehavior) {
 	FunctionOperator* This = (FunctionOperator*) ourmalloc(sizeof(FunctionOperator));
 	GETFUNCTIONTYPE(This)=OPERATORFUNC;
 	allocInlineArrayInitSet(&This->domains, domain, numDomain);
@@ -20,9 +20,9 @@ Function* allocFunctionTable (Table* table){
 	return &This->base;
 }
 
-uint64_t applyFunctionOperator(FunctionOperator* func, uint64_t var1, uint64_t var2, bool* isInRange){
+uint64_t applyFunctionOperator(FunctionOperator* This, uint64_t var1, uint64_t var2) {
 	uint64_t result = 0;
-	switch( func->op){
+	switch(This->op){
 		case ADD:
 			result = var1+ var2;
 			break;
@@ -32,10 +32,13 @@ uint64_t applyFunctionOperator(FunctionOperator* func, uint64_t var1, uint64_t v
 		default:
 			ASSERT(0);
 	}
-	*isInRange = existsInSet(func->range, result);
 	return result;
 }
 
+bool isInRangeFunction(FunctionOperator *This, uint64_t val) {
+	return existsInSet(This->range, val);
+}
+
 void deleteFunction(Function* This){
 	switch(GETFUNCTIONTYPE(This)){
 	case TABLEFUNC:
diff --git a/src/AST/function.h b/src/AST/function.h
index 158a55c..17a3211 100644
--- a/src/AST/function.h
+++ b/src/AST/function.h
@@ -24,9 +24,10 @@ struct FunctionTable {
 	Table* table;
 };
 
-Function* allocFunctionOperator( ArithOp op, Set ** domain, uint numDomain, Set * range,OverFlowBehavior overflowbehavior);
+Function* allocFunctionOperator(ArithOp op, Set ** domain, uint numDomain, Set * range, OverFlowBehavior overflowbehavior);
 Function* allocFunctionTable (Table* table);
-uint64_t applyFunctionOperator(FunctionOperator* func, uint64_t var1, uint64_t var2, bool* isInrange);
+uint64_t applyFunctionOperator(FunctionOperator* This, uint64_t var1, uint64_t var2);
+bool isInRangeFunction(FunctionOperator *This, uint64_t val);
 void deleteFunction(Function* This);
 
 #endif
diff --git a/src/AST/mutableset.c b/src/AST/mutableset.c
index 18f038b..1c893a3 100644
--- a/src/AST/mutableset.c
+++ b/src/AST/mutableset.c
@@ -1,13 +1,13 @@
 #include "mutableset.h"
 
 MutableSet * allocMutableSet(VarType t) {
-	MutableSet * tmp=(MutableSet *)ourmalloc(sizeof(MutableSet));
-	tmp->type=t;
-	tmp->isRange=false;
-	tmp->low=0;
-	tmp->high=0;
-	tmp->members=allocDefVectorInt();
-	return tmp;
+	MutableSet * This=(MutableSet *)ourmalloc(sizeof(MutableSet));
+	This->type=t;
+	This->isRange=false;
+	This->low=0;
+	This->high=0;
+	This->members=allocDefVectorInt();
+	return This;
 }
 
 void addElementMSet(MutableSet * set, uint64_t element) {
diff --git a/src/AST/order.c b/src/AST/order.c
index b1b52e3..7e2b187 100644
--- a/src/AST/order.c
+++ b/src/AST/order.c
@@ -3,35 +3,34 @@
 #include "set.h"
 #include "boolean.h"
 
-
 Order* allocOrder(OrderType type, Set * set){
-	Order* order = (Order*)ourmalloc(sizeof(Order));
-	order->set=set;
-	allocInlineDefVectorBoolean(& order->constraints);
-	order->type=type;
-	allocOrderEncoding(& order->order, order);
-	order->boolsToConstraints = NULL;
-	return order;
+	Order* This = (Order*)ourmalloc(sizeof(Order));
+	This->set=set;
+	allocInlineDefVectorBoolean(& This->constraints);
+	This->type=type;
+	allocOrderEncoding(& This->order, This);
+	This->boolsToConstraints = NULL;
+	return This;
 }
 
-void initializeOrderHashTable(Order* order){
-	order->boolsToConstraints= allocHashTableBoolConst(HT_INITIAL_CAPACITY, HT_DEFAULT_FACTOR);
+void initializeOrderHashTable(Order* This){
+	This->boolsToConstraints= allocHashTableBoolConst(HT_INITIAL_CAPACITY, HT_DEFAULT_FACTOR);
 }
 
-void addOrderConstraint(Order* order, BooleanOrder* constraint){
-	pushVectorBoolean( &order->constraints, (Boolean*) constraint);
+void addOrderConstraint(Order* This, BooleanOrder* constraint){
+	pushVectorBoolean( &This->constraints, (Boolean*) constraint);
 }
 
-void setOrderEncodingType(Order* order, OrderEncodingType type){
-	order->order.type = type;
+void setOrderEncodingType(Order* This, OrderEncodingType type){
+	This->order.type = type;
 }
 
-void deleteOrder(Order* order){
-	deleteVectorArrayBoolean(& order->constraints);
-	deleteOrderEncoding(& order->order);
-	if(order->boolsToConstraints!= NULL) {
-		resetAndDeleteHashTableBoolConst(order->boolsToConstraints);
-		deleteHashTableBoolConst(order->boolsToConstraints);
+void deleteOrder(Order* This){
+	deleteVectorArrayBoolean(& This->constraints);
+	deleteOrderEncoding(& This->order);
+	if(This->boolsToConstraints!= NULL) {
+		resetAndDeleteHashTableBoolConst(This->boolsToConstraints);
+		deleteHashTableBoolConst(This->boolsToConstraints);
 	}
-	ourfree(order);
+	ourfree(This);
 }
diff --git a/src/AST/order.h b/src/AST/order.h
index 67f0d99..dcbfb31 100644
--- a/src/AST/order.h
+++ b/src/AST/order.h
@@ -16,8 +16,8 @@ struct Order {
 };
 
 Order* allocOrder(OrderType type, Set * set);
-void initializeOrderHashTable(Order * order);
-void addOrderConstraint(Order* order, BooleanOrder* constraint);
-void setOrderEncodingType(Order* order, OrderEncodingType type);
-void deleteOrder(Order* order);
+void initializeOrderHashTable(Order * This);
+void addOrderConstraint(Order * This, BooleanOrder * constraint);
+void setOrderEncodingType(Order * This, OrderEncodingType type);
+void deleteOrder(Order * This);
 #endif
diff --git a/src/AST/predicate.c b/src/AST/predicate.c
index 116f152..ce446f2 100644
--- a/src/AST/predicate.c
+++ b/src/AST/predicate.c
@@ -3,29 +3,30 @@
 #include "set.h"
 
 Predicate* allocPredicateOperator(CompOp op, Set ** domain, uint numDomain){
-	PredicateOperator* predicate = ourmalloc(sizeof(PredicateOperator));
-	GETPREDICATETYPE(predicate)=OPERATORPRED;
-	allocInlineArrayInitSet(&predicate->domains, domain, numDomain);
-	predicate->op=op;
-	return &predicate->base;
+	PredicateOperator* This = ourmalloc(sizeof(PredicateOperator));
+	GETPREDICATETYPE(This)=OPERATORPRED;
+	allocInlineArrayInitSet(&This->domains, domain, numDomain);
+	This->op=op;
+	return &This->base;
 }
 
 Predicate* allocPredicateTable(Table* table, UndefinedBehavior undefBehavior){
-	PredicateTable* predicate = ourmalloc(sizeof(PredicateTable));
-	GETPREDICATETYPE(predicate) = TABLEPRED;
-	predicate->table=table;
-	predicate->undefinedbehavior=undefBehavior;
-	return &predicate->base;
+	PredicateTable* This = ourmalloc(sizeof(PredicateTable));
+	GETPREDICATETYPE(This) = TABLEPRED;
+	This->table=table;
+	This->undefinedbehavior=undefBehavior;
+	return &This->base;
 }
 
-void getEqualitySetIntersection(PredicateOperator* predicate, uint* size, uint64_t* result){
-	ASSERT( predicate->op == EQUALS);
+// BRIAN: REVISIT
+void getEqualitySetIntersection(PredicateOperator* This, uint* size, uint64_t* result){
+	ASSERT( This->op == EQUALS);
 	//make sure equality has 2 operands
-	ASSERT(getSizeArraySet( &predicate->domains) == 2);
+	ASSERT(getSizeArraySet( &This->domains) == 2);
 	*size=0;
-	VectorInt* mems1 = getArraySet(&predicate->domains, 0)->members; 
+	VectorInt* mems1 = getArraySet(&This->domains, 0)->members; 
 	uint size1 = getSizeVectorInt(mems1);
-	VectorInt* mems2 = getArraySet(&predicate->domains, 1)->members;
+	VectorInt* mems2 = getArraySet(&This->domains, 1)->members;
 	uint size2 = getSizeVectorInt(mems2);
 	//FIXME:This isn't efficient, if we a hashset datastructure for Set, we
 	// can reduce it to O(n), but for now .... HG
@@ -38,13 +39,12 @@ void getEqualitySetIntersection(PredicateOperator* predicate, uint* size, uint64
 			}
 		}
 	}
-	
 }
 
-void deletePredicate(Predicate* predicate){
-	switch(GETPREDICATETYPE(predicate)) {
+void deletePredicate(Predicate* This){
+	switch(GETPREDICATETYPE(This)) {
 	case OPERATORPRED: {
-		PredicateOperator * operpred=(PredicateOperator *) predicate;
+		PredicateOperator * operpred=(PredicateOperator *) This;
 		deleteInlineArraySet(&operpred->domains);
 		break;
 	}
@@ -53,6 +53,6 @@ void deletePredicate(Predicate* predicate){
 	}
 	}
 	//need to handle freeing array...
-	ourfree(predicate);
+	ourfree(This);
 }
 
diff --git a/src/AST/predicate.h b/src/AST/predicate.h
index 22f33d0..6aaacce 100644
--- a/src/AST/predicate.h
+++ b/src/AST/predicate.h
@@ -23,10 +23,9 @@ struct PredicateTable {
 	UndefinedBehavior undefinedbehavior;
 };
 
-
 Predicate* allocPredicateOperator(CompOp op, Set ** domain, uint numDomain);
 Predicate* allocPredicateTable(Table* table, UndefinedBehavior undefBehavior);
 // size and result will be modified by this function!
-void getEqualitySetIntersection(PredicateOperator* predicate, uint* size, uint64_t* result);
-void deletePredicate(Predicate* predicate);
+void getEqualitySetIntersection(PredicateOperator* This, uint* size, uint64_t* result);
+void deletePredicate(Predicate* This);
 #endif
diff --git a/src/AST/set.c b/src/AST/set.c
index f72bbc3..05aaf91 100644
--- a/src/AST/set.c
+++ b/src/AST/set.c
@@ -2,48 +2,48 @@
 #include <stddef.h>
 
 Set * allocSet(VarType t, uint64_t* elements, uint num) {
-	Set * tmp=(Set *)ourmalloc(sizeof(Set));
-	tmp->type=t;
-	tmp->isRange=false;
-	tmp->low=0;
-	tmp->high=0;
-	tmp->members=allocVectorArrayInt(num, elements);
-	return tmp;
+	Set * This=(Set *)ourmalloc(sizeof(Set));
+	This->type=t;
+	This->isRange=false;
+	This->low=0;
+	This->high=0;
+	This->members=allocVectorArrayInt(num, elements);
+	return This;
 }
 
 Set * allocSetRange(VarType t, uint64_t lowrange, uint64_t highrange) {
-	Set * tmp=(Set *)ourmalloc(sizeof(Set));
-	tmp->type=t;
-	tmp->isRange=true;
-	tmp->low=lowrange;
-	tmp->high=highrange;
-	tmp->members=NULL;
-	return tmp;
+	Set * This=(Set *)ourmalloc(sizeof(Set));
+	This->type=t;
+	This->isRange=true;
+	This->low=lowrange;
+	This->high=highrange;
+	This->members=NULL;
+	return This;
 }
 
-bool existsInSet(Set* set, uint64_t element){
-	if(set->isRange){
-		return element >= set->low && element <= set->high;
+bool existsInSet(Set* This, uint64_t element){
+	if(This->isRange){
+		return element >= This->low && element <= This->high;
 	}else {
-		uint size = getSizeVectorInt(set->members);
+		uint size = getSizeVectorInt(This->members);
 		for(uint i=0; i< size; i++){
-			if(element == getVectorInt(set->members, i))
+			if(element == getVectorInt(This->members, i))
 				return true;
 		}
 		return false;
 	}
 }
 
-uint getSetSize(Set* set){
-	if(set->isRange){
-		return set->high- set->low+1;
+uint getSetSize(Set* This){
+	if(This->isRange){
+		return This->high- This->low+1;
 	}else{
-		return getSizeVectorInt(set->members);
+		return getSizeVectorInt(This->members);
 	}
 }
 
-void deleteSet(Set * set) {
-	if (!set->isRange)
-		deleteVectorInt(set->members);
-	ourfree(set);
+void deleteSet(Set * This) {
+	if (!This->isRange)
+		deleteVectorInt(This->members);
+	ourfree(This);
 }
diff --git a/src/AST/set.h b/src/AST/set.h
index badb28c..5139927 100644
--- a/src/AST/set.h
+++ b/src/AST/set.h
@@ -20,11 +20,10 @@ struct Set {
 	VectorInt * members;
 };
 
-
-Set *allocSet(VarType t, uint64_t * elements, uint num);
+Set * allocSet(VarType t, uint64_t * elements, uint num);
 Set * allocSetRange(VarType t, uint64_t lowrange, uint64_t highrange);
-bool existsInSet(Set* set, uint64_t element);
-uint getSetSize(Set* set);
-void deleteSet(Set *set);
+bool existsInSet(Set * This, uint64_t element);
+uint getSetSize(Set * This);
+void deleteSet(Set * This);
 #endif/* SET_H */
 
diff --git a/src/AST/table.c b/src/AST/table.c
index 2780aca..804d7ac 100644
--- a/src/AST/table.c
+++ b/src/AST/table.c
@@ -5,27 +5,26 @@
 #include "set.h"
 #include "mutableset.h"
 
-
 Table * allocTable(Set **domains, uint numDomain, Set * range){
-	Table* table = (Table*) ourmalloc(sizeof(Table));
-	allocInlineArrayInitSet(&table->domains, domains, numDomain);
-	allocInlineDefVectorTableEntry(&table->entries);
-	table->range =range;
-	return table;
+	Table* This = (Table*) ourmalloc(sizeof(Table));
+	allocInlineArrayInitSet(&This->domains, domains, numDomain);
+	allocInlineDefVectorTableEntry(&This->entries);
+	This->range =range;
+	return This;
 }
 
-void addNewTableEntry(Table* table, uint64_t* inputs, uint inputSize, uint64_t result){
-	ASSERT(getSizeArraySet( &table->domains) == inputSize);
-	pushVectorTableEntry(&table->entries, allocTableEntry(inputs, inputSize, result));
+void addNewTableEntry(Table* This, uint64_t* inputs, uint inputSize, uint64_t result){
+	ASSERT(getSizeArraySet( &This->domains) == inputSize);
+	pushVectorTableEntry(&This->entries, allocTableEntry(inputs, inputSize, result));
 }
 
-void deleteTable(Table* table){
-  deleteInlineArraySet(&table->domains);
-  uint size = getSizeVectorTableEntry(&table->entries);
+void deleteTable(Table* This){
+  deleteInlineArraySet(&This->domains);
+  uint size = getSizeVectorTableEntry(&This->entries);
   for(uint i=0; i<size; i++){
-    deleteTableEntry(getVectorTableEntry(&table->entries, i));
+    deleteTableEntry(getVectorTableEntry(&This->entries, i));
   }
-  deleteVectorArrayTableEntry(&table->entries);
-  ourfree(table);
+  deleteVectorArrayTableEntry(&This->entries);
+  ourfree(This);
 }
 
diff --git a/src/AST/table.h b/src/AST/table.h
index 90f5001..d2df3a4 100644
--- a/src/AST/table.h
+++ b/src/AST/table.h
@@ -10,7 +10,7 @@ struct Table {
 	VectorTableEntry entries;
 };
 
-Table * allocTable(Set **domains, uint numDomain, Set * range);
-void addNewTableEntry(Table* table, uint64_t* inputs, uint inputSize, uint64_t result);
-void deleteTable(Table* table);
+Table * allocTable(Set ** domains, uint numDomain, Set * range);
+void addNewTableEntry(Table * This, uint64_t * inputs, uint inputSize, uint64_t result);
+void deleteTable(Table * This);
 #endif
diff --git a/src/Backend/satencoder.c b/src/Backend/satencoder.c
index ad59903..fede5e4 100644
--- a/src/Backend/satencoder.c
+++ b/src/Backend/satencoder.c
@@ -411,9 +411,10 @@ Edge encodeOperatorElementFunctionSATEncoder(SATEncoder* encoder, ElementFunctio
 		if(isinUseElement(elemEnc1, i)){
 			for( uint j=0; j<elemEnc2->encArraySize; j++){
 				if(isinUseElement(elemEnc2, j)){
-					bool isInRange = false;
 					uint64_t result= applyFunctionOperator((FunctionOperator*)This->function,elemEnc1->encodingArray[i],
-						elemEnc2->encodingArray[j], &isInRange);
+						elemEnc2->encodingArray[j]);
+					bool isInRange = isInRangeFunction((FunctionOperator*)This->function, result);
+
 					//FIXME: instead of getElementValueConstraint, it might be useful to have another function
 					// that doesn't iterate over encodingArray and treats more efficient ...
 					Edge valConstrIn1 = getElementValueConstraint(encoder, elemEnc1->element, elemEnc1->encodingArray[i]);
diff --git a/src/csolver.c b/src/csolver.c
index 8c4f22e..04e3d10 100644
--- a/src/csolver.c
+++ b/src/csolver.c
@@ -106,7 +106,7 @@ Element * getElementVar(CSolver *This, Set * set) {
 }
 
 Boolean * getBooleanVar(CSolver *solver, VarType type) {
-	Boolean* boolean= allocBoolean(type);
+	Boolean* boolean= allocBooleanVar(type);
 	pushVectorBoolean(solver->allBooleans, boolean);
 	return boolean;
 }
-- 
2.34.1