Minor formatting issues

diff --git a/src/AST/boolean.c b/src/AST/boolean.c
index 4fd2c8615be473a2b3499fd28ee555514c340fad..428b5e2fe6b24456a97b2179638087ba314159f8 100644 (file)
--- 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 7382908c3075f30eb730f563ce5d56ea22ec300e..928ba41bc78fec2d252e5bb0b6da2cb559752dba 100644 (file)
--- 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 9fc426c1fb686f544f7d20608b258ac8becad41c..8855194e934edac8c9a6912fbb07ad39781bfd11 100644 (file)
--- 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 509ee8c3d34566c21faf9f4e8d78d2fca84f6e4d..bce0073f3826a84d14ccf6907ae0dba506171aa9 100644 (file)
--- 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 61e413b88ebdf1ce42553288b4a1a0495bdc5c29..2530e93663494e1c391815441abd1d27fa3b2412 100644 (file)
--- 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 158a55c9059f0650b2dbab700af63434781ea844..17a32112d0f636cee89a41205c0e79ea2cd42639 100644 (file)
--- 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 18f038b420548738fffcc945d1f8eb50305dbf5a..1c893a394aa9a83b1b46277232969de0fc6bab90 100644 (file)
--- 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 b1b52e3e82df9fc52b4e5099a5f646a041eecec3..7e2b1877c426af69421278e7bcf394763245e5e9 100644 (file)
--- 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 67f0d9928b5406e0df0b2bbd0fcf21e4b169f3c1..dcbfb313bc492de84302f84d3e96ecdf2dd0e63b 100644 (file)
--- 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 116f152673cd3a2d23239a09d46c497b512a9c91..ce446f2af23ee5cce2183550a0eb5fc4ec204c85 100644 (file)
--- 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 22f33d0e2e4bacaac23a6f22ac608e475d36c72c..6aaacce08de5c292ac5c363dd91b46ec40fa57e3 100644 (file)
--- 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 f72bbc33fbce11e11d9b1f317bc3c001e794614f..05aaf910e3cca2343b66895689da59db1432138c 100644 (file)
--- 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 badb28c4b6a165ce2e048fd7b4618ad41a3a4e5c..5139927e690e759592ab18ab5d326f090e0fffca 100644 (file)
--- 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 2780aca127e2725a5bb5d9f37fdbde224d376e0f..804d7ac8be9dc094fba4a41dd80f4c54e3bbd6b0 100644 (file)
--- 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 90f50015071d9c701c9c76310602ee0da1813de4..d2df3a4d62b132aa0c54762b955562b53a5d7825 100644 (file)
--- 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 ad59903889b0bedfa2de8c8b8970dcea8ea51e7e..fede5e4cb3262594ca528b039d0eb31c88f0081f 100644 (file)
--- 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 8c4f22e079a4a651d7806e46d72a4a807d792c93..04e3d1070fe75fd917a599399ea0e95eac668ae3 100644 (file)
--- 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;
 }