From 4221735881b9d1cd53ef410d9448efd2d12a51ad Mon Sep 17 00:00:00 2001 From: bdemsky Date: Wed, 16 Aug 2017 18:11:51 -0700 Subject: [PATCH] Big Tabbing Change --- src/AST/boolean.c | 74 ++-- src/AST/boolean.h | 22 +- src/AST/element.c | 46 +- src/AST/element.h | 40 +- src/AST/function.c | 42 +- src/AST/function.h | 14 +- src/AST/mutableset.c | 16 +- src/AST/mutableset.h | 4 +- src/AST/order.c | 28 +- src/AST/order.h | 14 +- src/AST/predicate.c | 36 +- src/AST/predicate.h | 10 +- src/AST/rewriter.c | 106 ++--- src/AST/rewriter.h | 4 +- src/AST/set.c | 50 +-- src/AST/set.h | 14 +- src/AST/table.c | 40 +- src/AST/table.h | 12 +- src/AST/tableentry.c | 10 +- src/AST/tableentry.h | 4 +- src/Backend/cnfexpr.c | 412 ++++++++--------- src/Backend/cnfexpr.h | 20 +- src/Backend/constraint.c | 710 +++++++++++++++--------------- src/Backend/constraint.h | 86 ++-- src/Backend/inc_solver.c | 100 ++--- src/Backend/inc_solver.h | 36 +- src/Backend/orderpair.c | 6 +- src/Backend/orderpair.h | 12 +- src/Backend/satelemencoder.c | 114 ++--- src/Backend/satelemencoder.h | 18 +- src/Backend/satencoder.c | 148 +++---- src/Backend/satencoder.h | 20 +- src/Backend/satfuncopencoder.c | 184 ++++---- src/Backend/satfuncopencoder.h | 10 +- src/Backend/satfunctableencoder.c | 360 +++++++-------- src/Backend/satfunctableencoder.h | 8 +- src/Backend/satorderencoder.c | 78 ++-- src/Backend/satorderencoder.h | 8 +- src/Backend/sattranslator.c | 94 ++-- src/Backend/sattranslator.h | 18 +- src/Collections/array.h | 86 ++-- src/Collections/hashset.h | 128 +++--- src/Collections/hashtable.h | 74 ++-- src/Collections/structs.c | 44 +- src/Collections/structs.h | 10 +- src/Collections/vector.h | 116 ++--- src/Encoders/elementencoding.c | 32 +- src/Encoders/elementencoding.h | 16 +- src/Encoders/functionencoding.c | 12 +- src/Encoders/functionencoding.h | 8 +- src/Encoders/naiveencoder.c | 68 +-- src/Encoders/naiveencoder.h | 10 +- src/Encoders/orderedge.c | 6 +- src/Encoders/orderedge.h | 24 +- src/Encoders/orderencoder.c | 206 ++++----- src/Encoders/orderencoder.h | 36 +- src/Encoders/orderencoding.c | 6 +- src/Encoders/orderencoding.h | 2 +- src/Encoders/ordergraph.c | 78 ++-- src/Encoders/ordergraph.h | 24 +- src/Encoders/ordernode.c | 16 +- src/Encoders/ordernode.h | 16 +- src/Encoders/polarityassignment.c | 118 ++--- src/Encoders/polarityassignment.h | 16 +- src/Test/buildconstraintstest.c | 54 +-- src/Test/cnftest.c | 42 +- src/Test/elemequalsattest.c | 36 +- src/Test/elemequalunsattest.c | 30 +- src/Test/funcencodingtest.c | 86 ++-- src/Test/logicopstest.c | 32 +- src/Test/ltelemconsttest.c | 26 +- src/Test/ordertest.c | 28 +- src/Test/tablefuncencodetest.c | 54 +-- src/Test/tablepredicencodetest.c | 64 +-- src/common.h | 18 +- src/csolver.c | 154 +++---- src/csolver.h | 76 ++-- src/mymemory.h | 16 +- 78 files changed, 2448 insertions(+), 2448 deletions(-) diff --git a/src/AST/boolean.c b/src/AST/boolean.c index 3ce75e4..2987217 100644 --- a/src/AST/boolean.c +++ b/src/AST/boolean.c @@ -4,49 +4,49 @@ #include "element.h" #include "order.h" -Boolean* allocBooleanVar(VarType t) { - BooleanVar* This=(BooleanVar *) ourmalloc(sizeof (BooleanVar)); - GETBOOLEANTYPE(This)=BOOLEANVAR; +Boolean *allocBooleanVar(VarType t) { + BooleanVar *This = (BooleanVar *) ourmalloc(sizeof (BooleanVar)); + GETBOOLEANTYPE(This) = BOOLEANVAR; GETBOOLEANVALUE(This) = BV_UNDEFINED; GETBOOLEANPOLARITY(This) = P_UNDEFINED; - This->vtype=t; - This->var=E_NULL; + This->vtype = t; + This->var = E_NULL; initDefVectorBoolean(GETBOOLEANPARENTS(This)); - return & This->base; + return &This->base; } -Boolean* allocBooleanOrder(Order* order, uint64_t first, uint64_t second) { - BooleanOrder* This=(BooleanOrder *) ourmalloc(sizeof (BooleanOrder)); - GETBOOLEANTYPE(This)=ORDERCONST; +Boolean *allocBooleanOrder(Order *order, uint64_t first, uint64_t second) { + BooleanOrder *This = (BooleanOrder *) ourmalloc(sizeof (BooleanOrder)); + GETBOOLEANTYPE(This) = ORDERCONST; GETBOOLEANVALUE(This) = BV_UNDEFINED; GETBOOLEANPOLARITY(This) = P_UNDEFINED; - This->order=order; - This->first=first; - This->second=second; + This->order = order; + This->first = first; + This->second = second; pushVectorBooleanOrder(&order->constraints, This); initDefVectorBoolean(GETBOOLEANPARENTS(This)); - return & This -> base; + return &This->base; } -Boolean * allocBooleanPredicate(Predicate * predicate, Element ** inputs, uint numInputs, Boolean* undefinedStatus){ - BooleanPredicate* This = (BooleanPredicate*) ourmalloc(sizeof(BooleanPredicate)); - GETBOOLEANTYPE(This)= PREDICATEOP; +Boolean *allocBooleanPredicate(Predicate *predicate, Element **inputs, uint numInputs, Boolean *undefinedStatus) { + BooleanPredicate *This = (BooleanPredicate *) ourmalloc(sizeof(BooleanPredicate)); + GETBOOLEANTYPE(This) = PREDICATEOP; GETBOOLEANVALUE(This) = BV_UNDEFINED; GETBOOLEANPOLARITY(This) = P_UNDEFINED; - This->predicate=predicate; + This->predicate = predicate; initArrayInitElement(&This->inputs, inputs, numInputs); initDefVectorBoolean(GETBOOLEANPARENTS(This)); - for(uint i=0;iencoding, (Boolean *) This); This->undefStatus = undefinedStatus; - return & This->base; + return &This->base; } -Boolean * allocBooleanLogicArray(CSolver *solver, LogicOp op, Boolean ** array, uint asize){ - BooleanLogic * This = ourmalloc(sizeof(BooleanLogic)); +Boolean *allocBooleanLogicArray(CSolver *solver, LogicOp op, Boolean **array, uint asize) { + BooleanLogic *This = ourmalloc(sizeof(BooleanLogic)); GETBOOLEANTYPE(This) = LOGICOP; GETBOOLEANVALUE(This) = BV_UNDEFINED; GETBOOLEANPOLARITY(This) = P_UNDEFINED; @@ -54,24 +54,24 @@ Boolean * allocBooleanLogicArray(CSolver *solver, LogicOp op, Boolean ** array, initDefVectorBoolean(GETBOOLEANPARENTS(This)); initArrayInitBoolean(&This->inputs, array, asize); pushVectorBoolean(solver->allBooleans, (Boolean *) This); - return & This->base; + return &This->base; } -void deleteBoolean(Boolean * This) { - switch(GETBOOLEANTYPE(This)){ - case PREDICATEOP:{ - BooleanPredicate *bp=(BooleanPredicate *)This; - deleteInlineArrayElement(& bp->inputs ); - deleteFunctionEncoding(& bp->encoding); - break; - } - case LOGICOP:{ - BooleanLogic* bl = (BooleanLogic*) This; - deleteInlineArrayBoolean(&bl->inputs); - break; - } - default: - break; +void deleteBoolean(Boolean *This) { + switch (GETBOOLEANTYPE(This)) { + case PREDICATEOP: { + BooleanPredicate *bp = (BooleanPredicate *)This; + deleteInlineArrayElement(&bp->inputs ); + deleteFunctionEncoding(&bp->encoding); + break; + } + case LOGICOP: { + BooleanLogic *bl = (BooleanLogic *) This; + deleteInlineArrayBoolean(&bl->inputs); + break; + } + default: + break; } deleteVectorArrayBoolean(GETBOOLEANPARENTS(This)); ourfree(This); diff --git a/src/AST/boolean.h b/src/AST/boolean.h index 2a80d39..cdc05a6 100644 --- a/src/AST/boolean.h +++ b/src/AST/boolean.h @@ -14,8 +14,8 @@ #define GETBOOLEANTYPE(o) GETASTNODETYPE(o) #define GETBOOLEANPARENTS(o) (&((Boolean *)(o))->parents) -#define GETBOOLEANPOLARITY(b) (((Boolean*)b)->polarity) -#define GETBOOLEANVALUE(b) (((Boolean*)b)->boolVal) +#define GETBOOLEANPOLARITY(b) (((Boolean *)b)->polarity) +#define GETBOOLEANVALUE(b) (((Boolean *)b)->boolVal) struct Boolean { ASTNode base; @@ -26,7 +26,7 @@ struct Boolean { struct BooleanOrder { Boolean base; - Order* order; + Order *order; uint64_t first; uint64_t second; }; @@ -45,18 +45,18 @@ struct BooleanLogic { struct BooleanPredicate { Boolean base; - Predicate * predicate; + Predicate *predicate; FunctionEncoding encoding; ArrayElement inputs; - Boolean* undefStatus; + Boolean *undefStatus; }; -Boolean * allocBooleanVar(VarType t); -Boolean * allocBooleanOrder(Order * order, uint64_t first, uint64_t second); -Boolean * allocBooleanPredicate(Predicate * predicate, Element ** inputs, uint numInputs, Boolean* undefinedStatus); -Boolean * allocBooleanLogicArray(CSolver *solver, LogicOp op, Boolean ** array, uint asize); -void deleteBoolean(Boolean * This); -static inline FunctionEncoding* getPredicateFunctionEncoding(BooleanPredicate* func){ +Boolean *allocBooleanVar(VarType t); +Boolean *allocBooleanOrder(Order *order, uint64_t first, uint64_t second); +Boolean *allocBooleanPredicate(Predicate *predicate, Element **inputs, uint numInputs, Boolean *undefinedStatus); +Boolean *allocBooleanLogicArray(CSolver *solver, LogicOp op, Boolean **array, uint asize); +void deleteBoolean(Boolean *This); +static inline FunctionEncoding *getPredicateFunctionEncoding(BooleanPredicate *func) { return &func->encoding; } diff --git a/src/AST/element.c b/src/AST/element.c index 8a7d28f..5d126c7 100644 --- a/src/AST/element.c +++ b/src/AST/element.c @@ -5,53 +5,53 @@ #include "function.h" #include "table.h" -Element *allocElementSet(Set * s) { - ElementSet * This=(ElementSet *)ourmalloc(sizeof(ElementSet)); - GETELEMENTTYPE(This)= ELEMSET; - This->set=s; +Element *allocElementSet(Set *s) { + ElementSet *This = (ElementSet *)ourmalloc(sizeof(ElementSet)); + GETELEMENTTYPE(This) = ELEMSET; + This->set = s; initDefVectorASTNode(GETELEMENTPARENTS(This)); initElementEncoding(&This->encoding, (Element *) This); return &This->base; } -Element* allocElementFunction(Function * function, Element ** array, uint numArrays, Boolean * overflowstatus){ - ElementFunction* This = (ElementFunction*) ourmalloc(sizeof(ElementFunction)); - GETELEMENTTYPE(This)= ELEMFUNCRETURN; - This->function=function; +Element *allocElementFunction(Function *function, Element **array, uint numArrays, Boolean *overflowstatus) { + ElementFunction *This = (ElementFunction *) ourmalloc(sizeof(ElementFunction)); + GETELEMENTTYPE(This) = ELEMFUNCRETURN; + This->function = function; ASSERT(GETBOOLEANTYPE(overflowstatus) == BOOLEANVAR); This->overflowstatus = overflowstatus; initArrayInitElement(&This->inputs, array, numArrays); initDefVectorASTNode(GETELEMENTPARENTS(This)); - for(uint i=0;irangeencoding, (Element *) This); initFunctionEncoding(&This->functionencoding, (Element *) This); return &This->base; } -Element * allocElementConst(uint64_t value, VarType type) { - ElementConst * This=(ElementConst *)ourmalloc(sizeof(ElementConst)); - GETELEMENTTYPE(This)= ELEMCONST; - This->value=value; - This->set=allocSet(type, (uint64_t[]){value}, 1); +Element *allocElementConst(uint64_t value, VarType type) { + ElementConst *This = (ElementConst *)ourmalloc(sizeof(ElementConst)); + GETELEMENTTYPE(This) = ELEMCONST; + This->value = value; + This->set = allocSet(type, (uint64_t[]) {value}, 1); initDefVectorASTNode(GETELEMENTPARENTS(This)); initElementEncoding(&This->encoding, (Element *) This); return &This->base; } -Set* getElementSet(Element* This){ - switch(GETELEMENTTYPE(This)){ +Set *getElementSet(Element *This) { + switch (GETELEMENTTYPE(This)) { case ELEMSET: - return ((ElementSet*)This)->set; + return ((ElementSet *)This)->set; case ELEMCONST: - return ((ElementConst*)This)->set; + return ((ElementConst *)This)->set; case ELEMFUNCRETURN: { - Function* func = ((ElementFunction*)This)->function; - switch(GETFUNCTIONTYPE(func)){ + Function *func = ((ElementFunction *)This)->function; + switch (GETFUNCTIONTYPE(func)) { case TABLEFUNC: - return ((FunctionTable*)func)->table->range; + return ((FunctionTable *)func)->table->range; case OPERATORFUNC: - return ((FunctionOperator*)func)->range; + return ((FunctionOperator *)func)->range; default: ASSERT(0); } @@ -64,7 +64,7 @@ Set* getElementSet(Element* This){ } void deleteElement(Element *This) { - switch(GETELEMENTTYPE(This)) { + switch (GETELEMENTTYPE(This)) { case ELEMFUNCRETURN: { ElementFunction *ef = (ElementFunction *) This; deleteInlineArrayElement(&ef->inputs); diff --git a/src/AST/element.h b/src/AST/element.h index 23e016c..8640a47 100644 --- a/src/AST/element.h +++ b/src/AST/element.h @@ -9,7 +9,7 @@ #include "boolean.h" #define GETELEMENTTYPE(o) GETASTNODETYPE(o) -#define GETELEMENTPARENTS(o) (&((Element*)o)->parents) +#define GETELEMENTPARENTS(o) (&((Element *)o)->parents) struct Element { ASTNode base; VectorASTNode parents; @@ -17,47 +17,47 @@ struct Element { struct ElementConst { Element base; - Set * set; + Set *set; uint64_t value; ElementEncoding encoding; }; struct ElementSet { Element base; - Set * set; + Set *set; ElementEncoding encoding; }; struct ElementFunction { Element base; - Function * function; + Function *function; ArrayElement inputs; - Boolean * overflowstatus; + Boolean *overflowstatus; FunctionEncoding functionencoding; ElementEncoding rangeencoding; }; -Element * allocElementConst(uint64_t value, VarType type); -Element * allocElementSet(Set *s); -Element* allocElementFunction(Function * function, Element ** array, uint numArrays, Boolean * overflowstatus); +Element *allocElementConst(uint64_t value, VarType type); +Element *allocElementSet(Set *s); +Element *allocElementFunction(Function *function, Element **array, uint numArrays, Boolean *overflowstatus); void deleteElement(Element *This); -Set* getElementSet(Element* This); +Set *getElementSet(Element *This); -static inline ElementEncoding* getElementEncoding(Element* This){ - switch(GETELEMENTTYPE(This)){ - case ELEMSET: - return &((ElementSet*)This)->encoding; - case ELEMFUNCRETURN: - return &((ElementFunction*)This)->rangeencoding; - case ELEMCONST: - return &((ElementConst*)This)->encoding; - default: - ASSERT(0); +static inline ElementEncoding *getElementEncoding(Element *This) { + switch (GETELEMENTTYPE(This)) { + case ELEMSET: + return &((ElementSet *)This)->encoding; + case ELEMFUNCRETURN: + return &((ElementFunction *)This)->rangeencoding; + case ELEMCONST: + return &((ElementConst *)This)->encoding; + default: + ASSERT(0); } return NULL; } -static inline FunctionEncoding* getElementFunctionEncoding(ElementFunction* func){ +static inline FunctionEncoding *getElementFunctionEncoding(ElementFunction *func) { return &func->functionencoding; } #endif diff --git a/src/AST/function.c b/src/AST/function.c index a67fe29..3a32139 100644 --- a/src/AST/function.c +++ b/src/AST/function.c @@ -3,35 +3,35 @@ #include "set.h" -Function* allocFunctionOperator(ArithOp op, Set ** domain, uint numDomain, Set * range, OverFlowBehavior overflowbehavior) { - FunctionOperator* This = (FunctionOperator*) ourmalloc(sizeof(FunctionOperator)); - GETFUNCTIONTYPE(This)=OPERATORFUNC; +Function *allocFunctionOperator(ArithOp op, Set **domain, uint numDomain, Set *range, OverFlowBehavior overflowbehavior) { + FunctionOperator *This = (FunctionOperator *) ourmalloc(sizeof(FunctionOperator)); + GETFUNCTIONTYPE(This) = OPERATORFUNC; initArrayInitSet(&This->domains, domain, numDomain); - This->op=op; + This->op = op; This->overflowbehavior = overflowbehavior; - This->range=range; + This->range = range; return &This->base; } -Function* allocFunctionTable (Table* table, UndefinedBehavior undefBehavior){ - FunctionTable* This = (FunctionTable*) ourmalloc(sizeof(FunctionTable)); - GETFUNCTIONTYPE(This)=TABLEFUNC; +Function *allocFunctionTable (Table *table, UndefinedBehavior undefBehavior) { + FunctionTable *This = (FunctionTable *) ourmalloc(sizeof(FunctionTable)); + GETFUNCTIONTYPE(This) = TABLEFUNC; This->table = table; This->undefBehavior = undefBehavior; return &This->base; } -uint64_t applyFunctionOperator(FunctionOperator* This, uint numVals, uint64_t * values) { +uint64_t applyFunctionOperator(FunctionOperator *This, uint numVals, uint64_t *values) { ASSERT(numVals == 2); - switch(This->op){ - case ADD: - return values[0] + values[1]; - break; - case SUB: - return values[0] - values[1]; - break; - default: - ASSERT(0); + switch (This->op) { + case ADD: + return values[0] + values[1]; + break; + case SUB: + return values[0] - values[1]; + break; + default: + ASSERT(0); } } @@ -39,12 +39,12 @@ bool isInRangeFunction(FunctionOperator *This, uint64_t val) { return existsInSet(This->range, val); } -void deleteFunction(Function* This){ - switch(GETFUNCTIONTYPE(This)){ +void deleteFunction(Function *This) { + switch (GETFUNCTIONTYPE(This)) { case TABLEFUNC: break; case OPERATORFUNC: - deleteInlineArraySet(&((FunctionOperator*) This)->domains); + deleteInlineArraySet(&((FunctionOperator *) This)->domains); break; default: ASSERT(0); diff --git a/src/AST/function.h b/src/AST/function.h index 562d3e9..37e1376 100644 --- a/src/AST/function.h +++ b/src/AST/function.h @@ -5,7 +5,7 @@ #include "ops.h" #include "structs.h" -#define GETFUNCTIONTYPE(o) (((Function*)o)->type) +#define GETFUNCTIONTYPE(o) (((Function *)o)->type) struct Function { FunctionType type; @@ -15,20 +15,20 @@ struct FunctionOperator { Function base; ArithOp op; ArraySet domains; - Set * range; + Set *range; OverFlowBehavior overflowbehavior; }; struct FunctionTable { Function base; - Table* table; + Table *table; UndefinedBehavior undefBehavior; }; -Function* allocFunctionOperator(ArithOp op, Set ** domain, uint numDomain, Set * range, OverFlowBehavior overflowbehavior); -Function* allocFunctionTable (Table* table, UndefinedBehavior behavior); -uint64_t applyFunctionOperator(FunctionOperator* This, uint numVals, uint64_t * values); +Function *allocFunctionOperator(ArithOp op, Set **domain, uint numDomain, Set *range, OverFlowBehavior overflowbehavior); +Function *allocFunctionTable (Table *table, UndefinedBehavior behavior); +uint64_t applyFunctionOperator(FunctionOperator *This, uint numVals, uint64_t *values); bool isInRangeFunction(FunctionOperator *This, uint64_t val); -void deleteFunction(Function* This); +void deleteFunction(Function *This); #endif diff --git a/src/AST/mutableset.c b/src/AST/mutableset.c index 1c893a3..19552f6 100644 --- a/src/AST/mutableset.c +++ b/src/AST/mutableset.c @@ -1,15 +1,15 @@ #include "mutableset.h" -MutableSet * allocMutableSet(VarType t) { - MutableSet * This=(MutableSet *)ourmalloc(sizeof(MutableSet)); - This->type=t; - This->isRange=false; - This->low=0; - This->high=0; - This->members=allocDefVectorInt(); +MutableSet *allocMutableSet(VarType t) { + 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) { +void addElementMSet(MutableSet *set, uint64_t element) { pushVectorInt(set->members, element); } diff --git a/src/AST/mutableset.h b/src/AST/mutableset.h index fe089f4..754d395 100644 --- a/src/AST/mutableset.h +++ b/src/AST/mutableset.h @@ -2,6 +2,6 @@ #define MUTABLESET_H #include "set.h" -MutableSet * allocMutableSet(VarType t); -void addElementMSet(MutableSet * set, uint64_t element); +MutableSet *allocMutableSet(VarType t); +void addElementMSet(MutableSet *set, uint64_t element); #endif diff --git a/src/AST/order.c b/src/AST/order.c index 054de91..fde8c1f 100644 --- a/src/AST/order.c +++ b/src/AST/order.c @@ -3,32 +3,32 @@ #include "set.h" #include "boolean.h" -Order* allocOrder(OrderType type, Set * set){ - Order* This = (Order*)ourmalloc(sizeof(Order)); - This->set=set; - initDefVectorBooleanOrder(& This->constraints); - This->type=type; - initOrderEncoding(& This->order, This); +Order *allocOrder(OrderType type, Set *set) { + Order *This = (Order *)ourmalloc(sizeof(Order)); + This->set = set; + initDefVectorBooleanOrder(&This->constraints); + This->type = type; + initOrderEncoding(&This->order, This); This->orderPairTable = NULL; return This; } -void initializeOrderHashTable(Order* This){ - This->orderPairTable=allocHashTableOrderPair(HT_INITIAL_CAPACITY, HT_DEFAULT_FACTOR); +void initializeOrderHashTable(Order *This) { + This->orderPairTable = allocHashTableOrderPair(HT_INITIAL_CAPACITY, HT_DEFAULT_FACTOR); } -void addOrderConstraint(Order* This, BooleanOrder* constraint){ +void addOrderConstraint(Order *This, BooleanOrder *constraint) { pushVectorBooleanOrder( &This->constraints, constraint); } -void setOrderEncodingType(Order* This, OrderEncodingType type){ +void setOrderEncodingType(Order *This, OrderEncodingType type) { This->order.type = type; } -void deleteOrder(Order* This){ - deleteVectorArrayBooleanOrder(& This->constraints); - deleteOrderEncoding(& This->order); - if(This->orderPairTable != NULL) { +void deleteOrder(Order *This) { + deleteVectorArrayBooleanOrder(&This->constraints); + deleteOrderEncoding(&This->order); + if (This->orderPairTable != NULL) { resetAndDeleteHashTableOrderPair(This->orderPairTable); deleteHashTableOrderPair(This->orderPairTable); } diff --git a/src/AST/order.h b/src/AST/order.h index 7a173b9..53bf878 100644 --- a/src/AST/order.h +++ b/src/AST/order.h @@ -9,15 +9,15 @@ struct Order { OrderType type; - Set * set; - HashTableOrderPair * orderPairTable; + Set *set; + HashTableOrderPair *orderPairTable; VectorBooleanOrder constraints; OrderEncoding order; }; -Order* allocOrder(OrderType type, Set * set); -void initializeOrderHashTable(Order * This); -void addOrderConstraint(Order * This, BooleanOrder * constraint); -void setOrderEncodingType(Order * This, OrderEncodingType type); -void deleteOrder(Order * This); +Order *allocOrder(OrderType type, Set *set); +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 24d1f34..0e0238a 100644 --- a/src/AST/predicate.c +++ b/src/AST/predicate.c @@ -3,27 +3,27 @@ #include "set.h" #include "table.h" -Predicate* allocPredicateOperator(CompOp op, Set ** domain, uint numDomain){ - PredicateOperator* This = ourmalloc(sizeof(PredicateOperator)); - GETPREDICATETYPE(This)=OPERATORPRED; +Predicate *allocPredicateOperator(CompOp op, Set **domain, uint numDomain) { + PredicateOperator *This = ourmalloc(sizeof(PredicateOperator)); + GETPREDICATETYPE(This) = OPERATORPRED; initArrayInitSet(&This->domains, domain, numDomain); - This->op=op; + This->op = op; return &This->base; } -Predicate* allocPredicateTable(Table* table, UndefinedBehavior undefBehavior){ +Predicate *allocPredicateTable(Table *table, UndefinedBehavior undefBehavior) { ASSERT(table->range == NULL); - PredicateTable* This = ourmalloc(sizeof(PredicateTable)); + PredicateTable *This = ourmalloc(sizeof(PredicateTable)); GETPREDICATETYPE(This) = TABLEPRED; - This->table=table; - This->undefinedbehavior=undefBehavior; + This->table = table; + This->undefinedbehavior = undefBehavior; return &This->base; } -void deletePredicate(Predicate* This){ - switch(GETPREDICATETYPE(This)) { +void deletePredicate(Predicate *This) { + switch (GETPREDICATETYPE(This)) { case OPERATORPRED: { - PredicateOperator * operpred=(PredicateOperator *) This; + PredicateOperator *operpred = (PredicateOperator *) This; deleteInlineArraySet(&operpred->domains); break; } @@ -35,18 +35,18 @@ void deletePredicate(Predicate* This){ ourfree(This); } -bool evalPredicateOperator(PredicateOperator * This, uint64_t * inputs) { - switch(This->op) { +bool evalPredicateOperator(PredicateOperator *This, uint64_t *inputs) { + switch (This->op) { case EQUALS: - return inputs[0]==inputs[1]; + return inputs[0] == inputs[1]; case LT: - return inputs[0]inputs[1]; + return inputs[0] > inputs[1]; case LTE: - return inputs[0]<=inputs[1]; + return inputs[0] <= inputs[1]; case GTE: - return inputs[0]>=inputs[1]; + return inputs[0] >= inputs[1]; } ASSERT(0); return false; diff --git a/src/AST/predicate.h b/src/AST/predicate.h index 105e91b..ff4ee8c 100644 --- a/src/AST/predicate.h +++ b/src/AST/predicate.h @@ -19,12 +19,12 @@ struct PredicateOperator { struct PredicateTable { Predicate base; - Table* table; + Table *table; UndefinedBehavior undefinedbehavior; }; -Predicate* allocPredicateOperator(CompOp op, Set ** domain, uint numDomain); -Predicate* allocPredicateTable(Table* table, UndefinedBehavior undefBehavior); -bool evalPredicateOperator(PredicateOperator * This, uint64_t * inputs); -void deletePredicate(Predicate* This); +Predicate *allocPredicateOperator(CompOp op, Set **domain, uint numDomain); +Predicate *allocPredicateTable(Table *table, UndefinedBehavior undefBehavior); +bool evalPredicateOperator(PredicateOperator *This, uint64_t *inputs); +void deletePredicate(Predicate *This); #endif diff --git a/src/AST/rewriter.c b/src/AST/rewriter.c index 1ff40a3..0c5d6a4 100644 --- a/src/AST/rewriter.c +++ b/src/AST/rewriter.c @@ -1,12 +1,12 @@ #include "rewriter.h" #include "boolean.h" -void replaceBooleanWithTrue(Boolean * This) { - uint size=getSizeVectorBoolean(&This->parents); - for(uint i=0;iparents, i); - BooleanLogic * logicop=(BooleanLogic*) parent; - switch(logicop->op) { +void replaceBooleanWithTrue(Boolean *This) { + uint size = getSizeVectorBoolean(&This->parents); + for (uint i = 0; i < size; i++) { + Boolean *parent = getVectorBoolean(&This->parents, i); + BooleanLogic *logicop = (BooleanLogic *) parent; + switch (logicop->op) { case L_AND: handleANDTrue(logicop, This); break; @@ -27,16 +27,16 @@ void replaceBooleanWithTrue(Boolean * This) { } void replaceBooleanWithBoolean(Boolean *oldb, Boolean *newb) { - uint size=getSizeVectorBoolean(&oldb->parents); - for(uint i=0;iparents, i); - BooleanLogic * logicop=(BooleanLogic*) parent; - - uint parentsize=getSizeArrayBoolean(&logicop->inputs); - - for(uint j=0;jinputs, i); - if (b==oldb) { + uint size = getSizeVectorBoolean(&oldb->parents); + for (uint i = 0; i < size; i++) { + Boolean *parent = getVectorBoolean(&oldb->parents, i); + BooleanLogic *logicop = (BooleanLogic *) parent; + + uint parentsize = getSizeArrayBoolean(&logicop->inputs); + + for (uint j = 0; j < parentsize; j++) { + Boolean *b = getArrayBoolean(&logicop->inputs, i); + if (b == oldb) { setArrayBoolean(&logicop->inputs, i, newb); pushVectorBoolean(&newb->parents, parent); } @@ -45,24 +45,24 @@ void replaceBooleanWithBoolean(Boolean *oldb, Boolean *newb) { } void handleXORTrue(BooleanLogic *This, Boolean *child) { - uint size=getSizeArrayBoolean(&This->inputs); - Boolean *b=getArrayBoolean(&This->inputs, 0); - uint otherindex=(b==child)?1:0; + uint size = getSizeArrayBoolean(&This->inputs); + Boolean *b = getArrayBoolean(&This->inputs, 0); + uint otherindex = (b == child) ? 1 : 0; removeElementArrayBoolean(&This->inputs, otherindex); - This->op=L_NOT; + This->op = L_NOT; } void handleXORFalse(BooleanLogic *This, Boolean *child) { - uint size=getSizeArrayBoolean(&This->inputs); - Boolean *b=getArrayBoolean(&This->inputs, 0); - uint otherindex=(b==child)?1:0; + uint size = getSizeArrayBoolean(&This->inputs); + Boolean *b = getArrayBoolean(&This->inputs, 0); + uint otherindex = (b == child) ? 1 : 0; replaceBooleanWithBoolean((Boolean *)This, getArrayBoolean(&This->inputs, otherindex)); } void handleIMPLIESTrue(BooleanLogic *This, Boolean *child) { - uint size=getSizeArrayBoolean(&This->inputs); - Boolean *b=getArrayBoolean(&This->inputs, 0); - if (b==child) { + uint size = getSizeArrayBoolean(&This->inputs); + Boolean *b = getArrayBoolean(&This->inputs, 0); + if (b == child) { //Replace with other term replaceBooleanWithBoolean((Boolean *)This, getArrayBoolean(&This->inputs, 1)); } else { @@ -72,63 +72,63 @@ void handleIMPLIESTrue(BooleanLogic *This, Boolean *child) { } void handleIMPLIESFalse(BooleanLogic *This, Boolean *child) { - uint size=getSizeArrayBoolean(&This->inputs); - Boolean *b=getArrayBoolean(&This->inputs, 0); - if (b==child) { + uint size = getSizeArrayBoolean(&This->inputs); + Boolean *b = getArrayBoolean(&This->inputs, 0); + if (b == child) { //Statement is true... replaceBooleanWithTrue((Boolean *)This); } else { //Make into negation of first term removeElementArrayBoolean(&This->inputs, 1); - This->op=L_NOT; + This->op = L_NOT; } } void handleANDTrue(BooleanLogic *This, Boolean *child) { - uint size=getSizeArrayBoolean(&This->inputs); + uint size = getSizeArrayBoolean(&This->inputs); - if (size==1) { + if (size == 1) { replaceBooleanWithTrue((Boolean *)This); return; } - - for(uint i=0;iinputs, i); - if (b==child) { + + for (uint i = 0; i < size; i++) { + Boolean *b = getArrayBoolean(&This->inputs, i); + if (b == child) { removeElementArrayBoolean(&This->inputs, i); } } - - if (size==2) { + + if (size == 2) { replaceBooleanWithBoolean((Boolean *)This, getArrayBoolean(&This->inputs, 0)); } } void handleORFalse(BooleanLogic *This, Boolean *child) { - uint size=getSizeArrayBoolean(&This->inputs); + uint size = getSizeArrayBoolean(&This->inputs); - if (size==1) { - replaceBooleanWithFalse((Boolean*) This); + if (size == 1) { + replaceBooleanWithFalse((Boolean *) This); } - - for(uint i=0;iinputs, i); - if (b==child) { + + for (uint i = 0; i < size; i++) { + Boolean *b = getArrayBoolean(&This->inputs, i); + if (b == child) { removeElementArrayBoolean(&This->inputs, i); } } - if (size==2) { + if (size == 2) { replaceBooleanWithBoolean((Boolean *)This, getArrayBoolean(&This->inputs, 0)); } } -void replaceBooleanWithFalse(Boolean * This) { - uint size=getSizeVectorBoolean(&This->parents); - for(uint i=0;iparents, i); - BooleanLogic * logicop=(BooleanLogic*) parent; - switch(logicop->op) { +void replaceBooleanWithFalse(Boolean *This) { + uint size = getSizeVectorBoolean(&This->parents); + for (uint i = 0; i < size; i++) { + Boolean *parent = getVectorBoolean(&This->parents, i); + BooleanLogic *logicop = (BooleanLogic *) parent; + switch (logicop->op) { case L_AND: replaceBooleanWithFalse(parent); break; @@ -145,5 +145,5 @@ void replaceBooleanWithFalse(Boolean * This) { handleIMPLIESFalse(logicop, This); break; } - } + } } diff --git a/src/AST/rewriter.h b/src/AST/rewriter.h index 9050b73..83c5043 100644 --- a/src/AST/rewriter.h +++ b/src/AST/rewriter.h @@ -2,8 +2,8 @@ #define REWRITER_H #include "classlist.h" -void replaceBooleanWithTrue(Boolean * This); -void replaceBooleanWithFalse(Boolean * This); +void replaceBooleanWithTrue(Boolean *This); +void replaceBooleanWithFalse(Boolean *This); void replaceBooleanWithBoolean(Boolean *oldb, Boolean *newb); void handleXORTrue(BooleanLogic *This, Boolean *child); void handleXORFalse(BooleanLogic *This, Boolean *child); diff --git a/src/AST/set.c b/src/AST/set.c index 2569ed2..003379e 100644 --- a/src/AST/set.c +++ b/src/AST/set.c @@ -1,55 +1,55 @@ #include "set.h" #include -Set * allocSet(VarType t, uint64_t* elements, uint num) { - Set * This=(Set *)ourmalloc(sizeof(Set)); - This->type=t; - This->isRange=false; - This->low=0; - This->high=0; - This->members=allocVectorArrayInt(num, elements); +Set *allocSet(VarType t, uint64_t *elements, uint num) { + 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 * This=(Set *)ourmalloc(sizeof(Set)); - This->type=t; - This->isRange=true; - This->low=lowrange; - This->high=highrange; - This->members=NULL; +Set *allocSetRange(VarType t, uint64_t lowrange, uint64_t highrange) { + 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* This, uint64_t element){ - if(This->isRange){ +bool existsInSet(Set *This, uint64_t element) { + if (This->isRange) { return element >= This->low && element <= This->high; } else { uint size = getSizeVectorInt(This->members); - for(uint i=0; i< size; i++){ - if(element == getVectorInt(This->members, i)) + for (uint i = 0; i < size; i++) { + if (element == getVectorInt(This->members, i)) return true; } return false; } } -uint64_t getSetElement(Set * This, uint index) { +uint64_t getSetElement(Set *This, uint index) { if (This->isRange) - return This->low+index; + return This->low + index; else return getVectorInt(This->members, index); } -uint getSetSize(Set* This){ - if(This->isRange){ - return This->high - This->low+1; - }else{ +uint getSetSize(Set *This) { + if (This->isRange) { + return This->high - This->low + 1; + } else { return getSizeVectorInt(This->members); } } -void deleteSet(Set * This) { +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 1555ae9..16fde20 100644 --- a/src/AST/set.h +++ b/src/AST/set.h @@ -17,14 +17,14 @@ struct Set { bool isRange; uint64_t low;//also used to count unique items uint64_t high; - VectorInt * members; + VectorInt *members; }; -Set * allocSet(VarType t, uint64_t * elements, uint num); -Set * allocSetRange(VarType t, uint64_t lowrange, uint64_t highrange); -bool existsInSet(Set * This, uint64_t element); -uint getSetSize(Set * This); -uint64_t getSetElement(Set * This, uint index); -void deleteSet(Set * This); +Set *allocSet(VarType t, uint64_t *elements, uint num); +Set *allocSetRange(VarType t, uint64_t lowrange, uint64_t highrange); +bool existsInSet(Set *This, uint64_t element); +uint getSetSize(Set *This); +uint64_t getSetElement(Set *This, uint index); +void deleteSet(Set *This); #endif/* SET_H */ diff --git a/src/AST/table.c b/src/AST/table.c index 6b3863e..b903744 100644 --- a/src/AST/table.c +++ b/src/AST/table.c @@ -5,41 +5,41 @@ #include "set.h" #include "mutableset.h" -Table * allocTable(Set **domains, uint numDomain, Set * range){ - Table* This = (Table*) ourmalloc(sizeof(Table)); +Table *allocTable(Set **domains, uint numDomain, Set *range) { + Table *This = (Table *) ourmalloc(sizeof(Table)); initArrayInitSet(&This->domains, domains, numDomain); - This->entries= allocHashSetTableEntry(HT_INITIAL_CAPACITY, HT_DEFAULT_FACTOR); - This->range =range; + This->entries = allocHashSetTableEntry(HT_INITIAL_CAPACITY, HT_DEFAULT_FACTOR); + This->range = range; return This; } -void addNewTableEntry(Table* This, uint64_t* inputs, uint inputSize, uint64_t result){ +void addNewTableEntry(Table *This, uint64_t *inputs, uint inputSize, uint64_t result) { ASSERT(getSizeArraySet( &This->domains) == inputSize); #ifdef CONFIG_ASSERT - if(This->range==NULL) + if (This->range == NULL) ASSERT(result == true || result == false); #endif - TableEntry* tb = allocTableEntry(inputs, inputSize, result); + TableEntry *tb = allocTableEntry(inputs, inputSize, result); ASSERT(!containsHashSetTableEntry(This->entries, tb)); - bool status= addHashSetTableEntry(This->entries, tb); + bool status = addHashSetTableEntry(This->entries, tb); ASSERT(status); } -TableEntry* getTableEntryFromTable(Table* table, uint64_t* inputs, uint inputSize){ - TableEntry* temp = allocTableEntry(inputs, inputSize, -1); - TableEntry* result= getHashSetTableEntry(table->entries, temp); +TableEntry *getTableEntryFromTable(Table *table, uint64_t *inputs, uint inputSize) { + TableEntry *temp = allocTableEntry(inputs, inputSize, -1); + TableEntry *result = getHashSetTableEntry(table->entries, temp); deleteTableEntry(temp); return result; } -void deleteTable(Table* This){ - deleteInlineArraySet(&This->domains); - HSIteratorTableEntry* iterator = iteratorTableEntry(This->entries); - while(hasNextTableEntry(iterator)){ - deleteTableEntry( nextTableEntry(iterator) ); - } - deleteIterTableEntry(iterator); - deleteHashSetTableEntry(This->entries); - ourfree(This); +void deleteTable(Table *This) { + deleteInlineArraySet(&This->domains); + HSIteratorTableEntry *iterator = iteratorTableEntry(This->entries); + while (hasNextTableEntry(iterator)) { + deleteTableEntry( nextTableEntry(iterator) ); + } + deleteIterTableEntry(iterator); + deleteHashSetTableEntry(This->entries); + ourfree(This); } diff --git a/src/AST/table.h b/src/AST/table.h index 970882a..d9a0c18 100644 --- a/src/AST/table.h +++ b/src/AST/table.h @@ -6,12 +6,12 @@ struct Table { ArraySet domains; - Set * range; - HashSetTableEntry* entries; + Set *range; + HashSetTableEntry *entries; }; -Table * allocTable(Set ** domains, uint numDomain, Set * range); -void addNewTableEntry(Table * This, uint64_t * inputs, uint inputSize, uint64_t result); -TableEntry* getTableEntryFromTable(Table* table, uint64_t* inputs, uint inputSize); -void deleteTable(Table * This); +Table *allocTable(Set **domains, uint numDomain, Set *range); +void addNewTableEntry(Table *This, uint64_t *inputs, uint inputSize, uint64_t result); +TableEntry *getTableEntryFromTable(Table *table, uint64_t *inputs, uint inputSize); +void deleteTable(Table *This); #endif diff --git a/src/AST/tableentry.c b/src/AST/tableentry.c index 4fb74a5..64aae20 100644 --- a/src/AST/tableentry.c +++ b/src/AST/tableentry.c @@ -1,14 +1,14 @@ #include "tableentry.h" #include -TableEntry* allocTableEntry(uint64_t* inputs, uint inputSize, uint64_t result){ - TableEntry* te = (TableEntry*) ourmalloc(sizeof(TableEntry)+inputSize*sizeof(uint64_t)); - te->output=result; - te->inputSize=inputSize; +TableEntry *allocTableEntry(uint64_t *inputs, uint inputSize, uint64_t result) { + TableEntry *te = (TableEntry *) ourmalloc(sizeof(TableEntry) + inputSize * sizeof(uint64_t)); + te->output = result; + te->inputSize = inputSize; memcpy(te->inputs, inputs, inputSize * sizeof(uint64_t)); return te; } -void deleteTableEntry(TableEntry* tableEntry){ +void deleteTableEntry(TableEntry *tableEntry) { ourfree(tableEntry); } diff --git a/src/AST/tableentry.h b/src/AST/tableentry.h index 1901e53..c85255f 100644 --- a/src/AST/tableentry.h +++ b/src/AST/tableentry.h @@ -22,8 +22,8 @@ struct TableEntry { uint64_t inputs[]; }; -TableEntry* allocTableEntry(uint64_t* inputs, uint inputSize, uint64_t result); -void deleteTableEntry(TableEntry* tableEntry); +TableEntry *allocTableEntry(uint64_t *inputs, uint inputSize, uint64_t result); +void deleteTableEntry(TableEntry *tableEntry); #endif/* TABLEENTRY_H */ diff --git a/src/Backend/cnfexpr.c b/src/Backend/cnfexpr.c index c2a5bc9..ae1104f 100644 --- a/src/Backend/cnfexpr.c +++ b/src/Backend/cnfexpr.c @@ -1,70 +1,70 @@ #include "cnfexpr.h" #include -/* -V2 Copyright (c) 2014 Ben Chambers, Eugene Goldberg, Pete Manolios, -Vasilis Papavasileiou, Sudarshan Srinivasan, and Daron Vroon. - -Permission is hereby granted, free of charge, to any person obtaining -a copy of this software and associated documentation files (the -"Software"), to deal in the Software without restriction, including -without limitation the rights to use, copy, modify, merge, publish, -distribute, sublicense, and/or sell copies of the Software, and to -permit persons to whom the Software is furnished to do so, subject to -the following conditions: - -The above copyright notice and this permission notice shall be -included in all copies or substantial portions of the Software. If -you download or use the software, send email to Pete Manolios -(pete@ccs.neu.edu) with your name, contact information, and a short -note describing what you want to use BAT for. For any reuse or -distribution, you must make clear to others the license terms of this -work. - -Contact Pete Manolios if you want any of these conditions waived. - -THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, -EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF -MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND -NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE -LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION -OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION -WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. -*/ - -/* -C port of CNF SAT Conversion Copyright Brian Demsky 2017. -*/ +/* + V2 Copyright (c) 2014 Ben Chambers, Eugene Goldberg, Pete Manolios, + Vasilis Papavasileiou, Sudarshan Srinivasan, and Daron Vroon. + + Permission is hereby granted, free of charge, to any person obtaining + a copy of this software and associated documentation files (the + "Software"), to deal in the Software without restriction, including + without limitation the rights to use, copy, modify, merge, publish, + distribute, sublicense, and/or sell copies of the Software, and to + permit persons to whom the Software is furnished to do so, subject to + the following conditions: + + The above copyright notice and this permission notice shall be + included in all copies or substantial portions of the Software. If + you download or use the software, send email to Pete Manolios + (pete@ccs.neu.edu) with your name, contact information, and a short + note describing what you want to use BAT for. For any reuse or + distribution, you must make clear to others the license terms of this + work. + + Contact Pete Manolios if you want any of these conditions waived. + + THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, + EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF + MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND + NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE + LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION + OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION + WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. + */ + +/* + C port of CNF SAT Conversion Copyright Brian Demsky 2017. + */ #define LITCAPACITY 4 #define MERGESIZE 5 VectorImpl(LitVector, LitVector *, 4) -static inline uint boundedSize(uint x) { return (x > MERGESIZE)?MERGESIZE:x; } +static inline uint boundedSize(uint x) { return (x > MERGESIZE) ? MERGESIZE : x; } -LitVector * allocLitVector() { - LitVector *This=ourmalloc(sizeof(LitVector)); +LitVector *allocLitVector() { + LitVector *This = ourmalloc(sizeof(LitVector)); initLitVector(This); return This; } void initLitVector(LitVector *This) { - This->size=0; - This->capacity=LITCAPACITY; - This->literals=ourmalloc(This->capacity * sizeof(Literal)); + This->size = 0; + This->capacity = LITCAPACITY; + This->literals = ourmalloc(This->capacity * sizeof(Literal)); } LitVector *cloneLitVector(LitVector *orig) { - LitVector *This=ourmalloc(sizeof(LitVector)); - This->size=orig->size; - This->capacity=orig->capacity; - This->literals=ourmalloc(This->capacity * sizeof(Literal)); + LitVector *This = ourmalloc(sizeof(LitVector)); + This->size = orig->size; + This->capacity = orig->capacity; + This->literals = ourmalloc(This->capacity * sizeof(Literal)); memcpy(This->literals, orig->literals, sizeof(Literal) * This->size); return This; } void clearLitVector(LitVector *This) { - This->size=0; + This->size = 0; } void freeLitVector(LitVector *This) { @@ -81,14 +81,14 @@ Literal getLiteralLitVector(LitVector *This, uint index) { } void setLiteralLitVector(LitVector *This, uint index, Literal l) { - This->literals[index]=l; + This->literals[index] = l; } void addLiteralLitVector(LitVector *This, Literal l) { Literal labs = abs(l); - uint vec_size=This->size; - uint searchsize=boundedSize(vec_size); - uint i=0; + uint vec_size = This->size; + uint searchsize = boundedSize(vec_size); + uint i = 0; for (; i < searchsize; i++) { Literal curr = This->literals[i]; Literal currabs = abs(curr); @@ -96,36 +96,36 @@ void addLiteralLitVector(LitVector *This, Literal l) { break; if (currabs == labs) { if (curr == -l) - This->size = 0; //either true or false now depending on whether this is a conj or disj + This->size = 0; //either true or false now depending on whether this is a conj or disj return; } } if ((++This->size) >= This->capacity) { This->capacity <<= 1; - This->literals=ourrealloc(This->literals, This->capacity * sizeof(Literal)); + This->literals = ourrealloc(This->literals, This->capacity * sizeof(Literal)); } - + if (vec_size < MERGESIZE) { - memmove(&This->literals[i+1], &This->literals[i], (vec_size-i) * sizeof(Literal)); - This->literals[i]=l; + memmove(&This->literals[i + 1], &This->literals[i], (vec_size - i) * sizeof(Literal)); + This->literals[i] = l; } else { - This->literals[vec_size]=l; + This->literals[vec_size] = l; } } -CNFExpr * allocCNFExprBool(bool isTrue) { - CNFExpr *This=ourmalloc(sizeof(CNFExpr)); - This->litSize=0; - This->isTrue=isTrue; +CNFExpr *allocCNFExprBool(bool isTrue) { + CNFExpr *This = ourmalloc(sizeof(CNFExpr)); + This->litSize = 0; + This->isTrue = isTrue; initVectorLitVector(&This->clauses, 2); initLitVector(&This->singletons); return This; } -CNFExpr * allocCNFExprLiteral(Literal l) { - CNFExpr *This=ourmalloc(sizeof(CNFExpr)); - This->litSize=1; - This->isTrue=false; +CNFExpr *allocCNFExprLiteral(Literal l) { + CNFExpr *This = ourmalloc(sizeof(CNFExpr)); + This->litSize = 1; + This->isTrue = false; initVectorLitVector(&This->clauses, 2); initLitVector(&This->singletons); addLiteralLitVector(&This->singletons, l); @@ -133,17 +133,17 @@ CNFExpr * allocCNFExprLiteral(Literal l) { } void clearCNFExpr(CNFExpr *This, bool isTrue) { - for(uint i=0;iclauses);i++) { + for (uint i = 0; i < getSizeVectorLitVector(&This->clauses); i++) { deleteLitVector(getVectorLitVector(&This->clauses, i)); } clearVectorLitVector(&This->clauses); clearLitVector(&This->singletons); - This->litSize=0; - This->isTrue=isTrue; + This->litSize = 0; + This->isTrue = isTrue; } void deleteCNFExpr(CNFExpr *This) { - for(uint i=0;iclauses);i++) { + for (uint i = 0; i < getSizeVectorLitVector(&This->clauses); i++) { deleteLitVector(getVectorLitVector(&This->clauses, i)); } deleteVectorArrayLitVector(&This->clauses); @@ -152,44 +152,44 @@ void deleteCNFExpr(CNFExpr *This) { } void conjoinCNFLit(CNFExpr *This, Literal l) { - if (This->litSize==0 && !This->isTrue) //Handle False + if (This->litSize == 0 && !This->isTrue)//Handle False return; - - This->litSize-=getSizeLitVector(&This->singletons); + + This->litSize -= getSizeLitVector(&This->singletons); addLiteralLitVector(&This->singletons, l); - uint newsize=getSizeLitVector(&This->singletons); - if (newsize==0) - clearCNFExpr(This, false); //We found a conflict + uint newsize = getSizeLitVector(&This->singletons); + if (newsize == 0) + clearCNFExpr(This, false);//We found a conflict else - This->litSize+=getSizeLitVector(&This->singletons); + This->litSize += getSizeLitVector(&This->singletons); } void copyCNF(CNFExpr *This, CNFExpr *expr, bool destroy) { if (destroy) { ourfree(This->singletons.literals); ourfree(This->clauses.array); - This->litSize=expr->litSize; - This->singletons.literals=expr->singletons.literals; - This->singletons.capacity=expr->singletons.capacity; - This->clauses.size=expr->clauses.size; - This->clauses.array=expr->clauses.array; - This->clauses.capacity=expr->clauses.capacity; + This->litSize = expr->litSize; + This->singletons.literals = expr->singletons.literals; + This->singletons.capacity = expr->singletons.capacity; + This->clauses.size = expr->clauses.size; + This->clauses.array = expr->clauses.array; + This->clauses.capacity = expr->clauses.capacity; ourfree(expr); } else { - for(uint i=0;isingletons);i++) { - Literal l=getLiteralLitVector(&expr->singletons,i); + for (uint i = 0; i < getSizeLitVector(&expr->singletons); i++) { + Literal l = getLiteralLitVector(&expr->singletons,i); addLiteralLitVector(&This->singletons, l); } - for(uint i=0;iclauses);i++) { - LitVector *lv=getVectorLitVector(&expr->clauses,i); + for (uint i = 0; i < getSizeVectorLitVector(&expr->clauses); i++) { + LitVector *lv = getVectorLitVector(&expr->clauses,i); pushVectorLitVector(&This->clauses, cloneLitVector(lv)); } - This->litSize=expr->litSize; + This->litSize = expr->litSize; } } void conjoinCNFExpr(CNFExpr *This, CNFExpr *expr, bool destroy) { - if (expr->litSize==0) { + if (expr->litSize == 0) { if (!This->isTrue) { clearCNFExpr(This, false); } @@ -198,7 +198,7 @@ void conjoinCNFExpr(CNFExpr *This, CNFExpr *expr, bool destroy) { } return; } - if (This->litSize==0) { + if (This->litSize == 0) { if (This->isTrue) { copyCNF(This, expr, destroy); } else if (destroy) { @@ -206,12 +206,12 @@ void conjoinCNFExpr(CNFExpr *This, CNFExpr *expr, bool destroy) { } return; } - uint litSize=This->litSize; - litSize-=getSizeLitVector(&expr->singletons); - for(uint i=0;isingletons);i++) { - Literal l=getLiteralLitVector(&expr->singletons,i); + uint litSize = This->litSize; + litSize -= getSizeLitVector(&expr->singletons); + for (uint i = 0; i < getSizeLitVector(&expr->singletons); i++) { + Literal l = getLiteralLitVector(&expr->singletons,i); addLiteralLitVector(&This->singletons, l); - if (getSizeLitVector(&This->singletons)==0) { + if (getSizeLitVector(&This->singletons) == 0) { //Found conflict... clearCNFExpr(This, false); if (destroy) { @@ -220,27 +220,27 @@ void conjoinCNFExpr(CNFExpr *This, CNFExpr *expr, bool destroy) { return; } } - litSize+=getSizeLitVector(&expr->singletons); + litSize += getSizeLitVector(&expr->singletons); if (destroy) { - for(uint i=0;iclauses);i++) { - LitVector *lv=getVectorLitVector(&expr->clauses,i); - litSize+=getSizeLitVector(lv); + for (uint i = 0; i < getSizeVectorLitVector(&expr->clauses); i++) { + LitVector *lv = getVectorLitVector(&expr->clauses,i); + litSize += getSizeLitVector(lv); pushVectorLitVector(&This->clauses, lv); } clearVectorLitVector(&expr->clauses); deleteCNFExpr(expr); } else { - for(uint i=0;iclauses);i++) { - LitVector *lv=getVectorLitVector(&expr->clauses,i); - litSize+=getSizeLitVector(lv); + for (uint i = 0; i < getSizeVectorLitVector(&expr->clauses); i++) { + LitVector *lv = getVectorLitVector(&expr->clauses,i); + litSize += getSizeLitVector(lv); pushVectorLitVector(&This->clauses, cloneLitVector(lv)); } } - This->litSize=litSize; + This->litSize = litSize; } void disjoinCNFLit(CNFExpr *This, Literal l) { - if (This->litSize==0) { + if (This->litSize == 0) { if (!This->isTrue) { This->litSize++; addLiteralLitVector(&This->singletons, l); @@ -248,32 +248,32 @@ void disjoinCNFLit(CNFExpr *This, Literal l) { return; } - uint litSize=0; - uint newindex=0; - for(uint i=0;iclauses);i++) { - LitVector * lv=getVectorLitVector(&This->clauses, i); + uint litSize = 0; + uint newindex = 0; + for (uint i = 0; i < getSizeVectorLitVector(&This->clauses); i++) { + LitVector *lv = getVectorLitVector(&This->clauses, i); addLiteralLitVector(lv, l); - uint newSize=getSizeLitVector(lv); - if (newSize!=0) { + uint newSize = getSizeLitVector(lv); + if (newSize != 0) { setVectorLitVector(&This->clauses, newindex++, lv); } else { deleteLitVector(lv); } - litSize+=newSize; + litSize += newSize; } setSizeVectorLitVector(&This->clauses, newindex); - bool hasSameSingleton=false; - for(uint i=0;isingletons);i++) { - Literal lsing=getLiteralLitVector(&This->singletons, i); + bool hasSameSingleton = false; + for (uint i = 0; i < getSizeLitVector(&This->singletons); i++) { + Literal lsing = getLiteralLitVector(&This->singletons, i); if (lsing == l) { - hasSameSingleton=true; + hasSameSingleton = true; } else if (lsing != -l) { //Create new LitVector with both l and lsing - LitVector *newlitvec=allocLitVector(); + LitVector *newlitvec = allocLitVector(); addLiteralLitVector(newlitvec, l); addLiteralLitVector(newlitvec, lsing); - litSize+=2; + litSize += 2; pushVectorLitVector(&This->clauses, newlitvec); } } @@ -281,60 +281,60 @@ void disjoinCNFLit(CNFExpr *This, Literal l) { if (hasSameSingleton) { addLiteralLitVector(&This->singletons, l); litSize++; - } else if (litSize==0) { - This->isTrue=true;//we are true + } else if (litSize == 0) { + This->isTrue = true;//we are true } - This->litSize=litSize; + This->litSize = litSize; } #define MERGETHRESHOLD 2 -LitVector * mergeLitVectors(LitVector *This, LitVector *expr) { - uint maxsize=This->size+expr->size+MERGETHRESHOLD; - LitVector *merged=ourmalloc(sizeof(LitVector)); - merged->literals=ourmalloc(sizeof(Literal)*maxsize); - merged->capacity=maxsize; - uint thisSize=boundedSize(This->size); - uint exprSize=boundedSize(expr->size); - uint iThis=0, iExpr=0, iMerge=0; - Literal lThis=This->literals[iThis]; - Literal lExpr=expr->literals[iExpr]; - Literal thisAbs=abs(lThis); - Literal exprAbs=abs(lExpr); - - while(iThisliterals[iMerge++]=lThis; - lThis=This->literals[++iThis]; - thisAbs=abs(lThis); - } else if(thisAbs>exprAbs) { - merged->literals[iMerge++]=lExpr; - lExpr=expr->literals[++iExpr]; - exprAbs=abs(lExpr); - } else if(lThis==lExpr) { - merged->literals[iMerge++]=lExpr; - lExpr=expr->literals[++iExpr]; - exprAbs=abs(lExpr); - lThis=This->literals[++iThis]; - thisAbs=abs(lThis); - } else if(lThis==-lExpr) { - merged->size=0; +LitVector *mergeLitVectors(LitVector *This, LitVector *expr) { + uint maxsize = This->size + expr->size + MERGETHRESHOLD; + LitVector *merged = ourmalloc(sizeof(LitVector)); + merged->literals = ourmalloc(sizeof(Literal) * maxsize); + merged->capacity = maxsize; + uint thisSize = boundedSize(This->size); + uint exprSize = boundedSize(expr->size); + uint iThis = 0, iExpr = 0, iMerge = 0; + Literal lThis = This->literals[iThis]; + Literal lExpr = expr->literals[iExpr]; + Literal thisAbs = abs(lThis); + Literal exprAbs = abs(lExpr); + + while (iThis < thisSize && iExpr < exprSize) { + if (thisAbs < exprAbs) { + merged->literals[iMerge++] = lThis; + lThis = This->literals[++iThis]; + thisAbs = abs(lThis); + } else if (thisAbs > exprAbs) { + merged->literals[iMerge++] = lExpr; + lExpr = expr->literals[++iExpr]; + exprAbs = abs(lExpr); + } else if (lThis == lExpr) { + merged->literals[iMerge++] = lExpr; + lExpr = expr->literals[++iExpr]; + exprAbs = abs(lExpr); + lThis = This->literals[++iThis]; + thisAbs = abs(lThis); + } else if (lThis == -lExpr) { + merged->size = 0; return merged; } } if (iThis < thisSize) { - memcpy(&merged->literals[iMerge], &This->literals[iThis], (thisSize-iThis) * sizeof(Literal)); - iMerge += (thisSize-iThis); + memcpy(&merged->literals[iMerge], &This->literals[iThis], (thisSize - iThis) * sizeof(Literal)); + iMerge += (thisSize - iThis); } if (iExpr < exprSize) { - memcpy(&merged->literals[iMerge], &expr->literals[iExpr], (exprSize-iExpr) * sizeof(Literal)); - iMerge += (exprSize-iExpr); + memcpy(&merged->literals[iMerge], &expr->literals[iExpr], (exprSize - iExpr) * sizeof(Literal)); + iMerge += (exprSize - iExpr); } - merged->size=iMerge; + merged->size = iMerge; return merged; } -LitVector * mergeLitVectorLiteral(LitVector *This, Literal l) { - LitVector *copy=cloneLitVector(This); +LitVector *mergeLitVectorLiteral(LitVector *This, Literal l) { + LitVector *copy = cloneLitVector(This); addLiteralLitVector(copy, l); return copy; } @@ -363,100 +363,100 @@ void disjoinCNFExpr(CNFExpr *This, CNFExpr *expr, bool destroy) { } return; } else if (destroy && This->litSize == 1) { - Literal l=getLiteralLitVector(&This->singletons,0); + Literal l = getLiteralLitVector(&This->singletons,0); copyCNF(This, expr, true); disjoinCNFLit(This, l); return; } - + /** Handle the full cross product */ - uint mergeIndex=0; - uint newCapacity=getClauseSizeCNF(This)*getClauseSizeCNF(expr); - LitVector ** mergeArray=ourmalloc(newCapacity*sizeof(LitVector*)); - uint singleIndex=0; + uint mergeIndex = 0; + uint newCapacity = getClauseSizeCNF(This) * getClauseSizeCNF(expr); + LitVector **mergeArray = ourmalloc(newCapacity * sizeof(LitVector *)); + uint singleIndex = 0; /** First do the singleton, clause pairs */ - for(uint i=0;isingletons);i++) { - Literal lThis=getLiteralLitVector(&This->singletons, i); - for(uint j=0;jclauses);j++) { - LitVector * lExpr=getVectorLitVector(&expr->clauses, j); - LitVector * copy=cloneLitVector(lExpr); + for (uint i = 0; i < getSizeLitVector(&This->singletons); i++) { + Literal lThis = getLiteralLitVector(&This->singletons, i); + for (uint j = 0; j < getSizeVectorLitVector(&expr->clauses); j++) { + LitVector *lExpr = getVectorLitVector(&expr->clauses, j); + LitVector *copy = cloneLitVector(lExpr); addLiteralLitVector(copy, lThis); - if (getSizeLitVector(copy)==0) { + if (getSizeLitVector(copy) == 0) { deleteLitVector(copy); } else { - mergeArray[mergeIndex++]=copy; + mergeArray[mergeIndex++] = copy; } } } /** Next do the clause, singleton pairs */ - for(uint i=0;isingletons);i++) { - Literal lExpr=getLiteralLitVector(&expr->singletons, i); - for(uint j=0;jclauses);j++) { - LitVector * lThis=getVectorLitVector(&This->clauses, j); - LitVector * copy=cloneLitVector(lThis); + for (uint i = 0; i < getSizeLitVector(&expr->singletons); i++) { + Literal lExpr = getLiteralLitVector(&expr->singletons, i); + for (uint j = 0; j < getSizeVectorLitVector(&This->clauses); j++) { + LitVector *lThis = getVectorLitVector(&This->clauses, j); + LitVector *copy = cloneLitVector(lThis); addLiteralLitVector(copy, lExpr); - if (getSizeLitVector(copy)==0) { + if (getSizeLitVector(copy) == 0) { deleteLitVector(copy); } else { - mergeArray[mergeIndex++]=copy; + mergeArray[mergeIndex++] = copy; } } } /** Next do the clause, clause pairs */ - for(uint i=0;iclauses);i++) { - LitVector * lThis=getVectorLitVector(&This->clauses, i); - for(uint j=0;jclauses);j++) { - LitVector * lExpr=getVectorLitVector(&expr->clauses, j); - LitVector * merge=mergeLitVectors(lThis, lExpr); - if (getSizeLitVector(merge)==0) { + for (uint i = 0; i < getSizeVectorLitVector(&This->clauses); i++) { + LitVector *lThis = getVectorLitVector(&This->clauses, i); + for (uint j = 0; j < getSizeVectorLitVector(&expr->clauses); j++) { + LitVector *lExpr = getVectorLitVector(&expr->clauses, j); + LitVector *merge = mergeLitVectors(lThis, lExpr); + if (getSizeLitVector(merge) == 0) { deleteLitVector(merge); } else { - mergeArray[mergeIndex++]=merge; + mergeArray[mergeIndex++] = merge; } } deleteLitVector(lThis);//Done with this litVector } - + /** Finally do the singleton, singleton pairs */ - for(uint i=0;isingletons);i++) { - Literal lThis=getLiteralLitVector(&This->singletons, i); - for(uint j=0;jsingletons);j++) { - Literal lExpr=getLiteralLitVector(&expr->singletons, j); - if (lThis==lExpr) { - //We have a singleton still in the final result - setLiteralLitVector(&This->singletons, singleIndex++, lThis); - } else if (lThis!=-lExpr) { - LitVector *mergeLV=allocLitVector(); - addLiteralLitVector(mergeLV, lThis); - addLiteralLitVector(mergeLV, lExpr); - mergeArray[mergeIndex++]=mergeLV; - } + for (uint i = 0; i < getSizeLitVector(&This->singletons); i++) { + Literal lThis = getLiteralLitVector(&This->singletons, i); + for (uint j = 0; j < getSizeLitVector(&expr->singletons); j++) { + Literal lExpr = getLiteralLitVector(&expr->singletons, j); + if (lThis == lExpr) { + //We have a singleton still in the final result + setLiteralLitVector(&This->singletons, singleIndex++, lThis); + } else if (lThis != -lExpr) { + LitVector *mergeLV = allocLitVector(); + addLiteralLitVector(mergeLV, lThis); + addLiteralLitVector(mergeLV, lExpr); + mergeArray[mergeIndex++] = mergeLV; } + } } - + ourfree(This->clauses.array); setSizeLitVector(&This->singletons, singleIndex); - This->clauses.capacity=newCapacity; - This->clauses.array=mergeArray; - This->clauses.size=mergeIndex; + This->clauses.capacity = newCapacity; + This->clauses.array = mergeArray; + This->clauses.size = mergeIndex; if (destroy) deleteCNFExpr(expr); } void printCNFExpr(CNFExpr *This) { - for(uint i=0;isingletons);i++) { - if (i!=0) + for (uint i = 0; i < getSizeLitVector(&This->singletons); i++) { + if (i != 0) printf(" ^ "); - Literal l=getLiteralLitVector(&This->singletons,i); + Literal l = getLiteralLitVector(&This->singletons,i); printf ("%d",l); } - for(uint i=0;iclauses);i++) { - LitVector *lv=getVectorLitVector(&This->clauses,i); + for (uint i = 0; i < getSizeVectorLitVector(&This->clauses); i++) { + LitVector *lv = getVectorLitVector(&This->clauses,i); printf(" ^ ("); - for(uint j=0;jsize;} -static inline void setSizeLitVector(LitVector *This, uint size) {This->size=size;} +static inline void setSizeLitVector(LitVector *This, uint size) {This->size = size;} -CNFExpr * allocCNFExprBool(bool isTrue); -CNFExpr * allocCNFExprLiteral(Literal l); +CNFExpr *allocCNFExprBool(bool isTrue); +CNFExpr *allocCNFExprLiteral(Literal l); void deleteCNFExpr(CNFExpr *This); void clearCNFExpr(CNFExpr *This, bool isTrue); void printCNFExpr(CNFExpr *This); void copyCNF(CNFExpr *This, CNFExpr *expr, bool destroy); -static inline bool alwaysTrueCNF(CNFExpr * This) {return (This->litSize==0) && This->isTrue;} -static inline bool alwaysFalseCNF(CNFExpr * This) {return (This->litSize==0) && !This->isTrue;} -static inline uint getLitSizeCNF(CNFExpr * This) {return This->litSize;} -static inline uint getClauseSizeCNF(CNFExpr * This) {return getSizeLitVector(&This->singletons) + getSizeVectorLitVector(&This->clauses);} +static inline bool alwaysTrueCNF(CNFExpr *This) {return (This->litSize == 0) && This->isTrue;} +static inline bool alwaysFalseCNF(CNFExpr *This) {return (This->litSize == 0) && !This->isTrue;} +static inline uint getLitSizeCNF(CNFExpr *This) {return This->litSize;} +static inline uint getClauseSizeCNF(CNFExpr *This) {return getSizeLitVector(&This->singletons) + getSizeVectorLitVector(&This->clauses);} void conjoinCNFLit(CNFExpr *This, Literal l); void disjoinCNFLit(CNFExpr *This, Literal l); void disjoinCNFExpr(CNFExpr *This, CNFExpr *expr, bool destroy); diff --git a/src/Backend/constraint.c b/src/Backend/constraint.c index 92a47fd..62c3c81 100644 --- a/src/Backend/constraint.c +++ b/src/Backend/constraint.c @@ -4,129 +4,129 @@ #include "inc_solver.h" #include "cnfexpr.h" #include "common.h" -/* -V2 Copyright (c) 2014 Ben Chambers, Eugene Goldberg, Pete Manolios, -Vasilis Papavasileiou, Sudarshan Srinivasan, and Daron Vroon. - -Permission is hereby granted, free of charge, to any person obtaining -a copy of this software and associated documentation files (the -"Software"), to deal in the Software without restriction, including -without limitation the rights to use, copy, modify, merge, publish, -distribute, sublicense, and/or sell copies of the Software, and to -permit persons to whom the Software is furnished to do so, subject to -the following conditions: - -The above copyright notice and this permission notice shall be -included in all copies or substantial portions of the Software. If -you download or use the software, send email to Pete Manolios -(pete@ccs.neu.edu) with your name, contact information, and a short -note describing what you want to use BAT for. For any reuse or -distribution, you must make clear to others the license terms of this -work. - -Contact Pete Manolios if you want any of these conditions waived. - -THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, -EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF -MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND -NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE -LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION -OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION -WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. -*/ - -/* -C port of CNF SAT Conversion Copyright Brian Demsky 2017. -*/ +/* + V2 Copyright (c) 2014 Ben Chambers, Eugene Goldberg, Pete Manolios, + Vasilis Papavasileiou, Sudarshan Srinivasan, and Daron Vroon. + + Permission is hereby granted, free of charge, to any person obtaining + a copy of this software and associated documentation files (the + "Software"), to deal in the Software without restriction, including + without limitation the rights to use, copy, modify, merge, publish, + distribute, sublicense, and/or sell copies of the Software, and to + permit persons to whom the Software is furnished to do so, subject to + the following conditions: + + The above copyright notice and this permission notice shall be + included in all copies or substantial portions of the Software. If + you download or use the software, send email to Pete Manolios + (pete@ccs.neu.edu) with your name, contact information, and a short + note describing what you want to use BAT for. For any reuse or + distribution, you must make clear to others the license terms of this + work. + + Contact Pete Manolios if you want any of these conditions waived. + + THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, + EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF + MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND + NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE + LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION + OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION + WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. + */ + +/* + C port of CNF SAT Conversion Copyright Brian Demsky 2017. + */ VectorImpl(Edge, Edge, 16) -Edge E_True={(Node *)(uintptr_t) EDGE_IS_VAR_CONSTANT}; -Edge E_False={(Node *)(uintptr_t) (EDGE_IS_VAR_CONSTANT | NEGATE_EDGE)}; -Edge E_BOGUS={(Node *)0x12345673}; -Edge E_NULL={(Node *)NULL}; - - -CNF * createCNF() { - CNF * cnf=ourmalloc(sizeof(CNF)); - cnf->varcount=1; - cnf->capacity=DEFAULT_CNF_ARRAY_SIZE; - cnf->mask=cnf->capacity-1; - cnf->node_array=ourcalloc(1, sizeof(Node *)*cnf->capacity); - cnf->size=0; - cnf->maxsize=(uint)(((double)cnf->capacity)*LOAD_FACTOR); - cnf->enableMatching=true; - initDefVectorEdge(& cnf->constraints); - initDefVectorEdge(& cnf->args); - cnf->solver=allocIncrementalSolver(); +Edge E_True = {(Node *)(uintptr_t) EDGE_IS_VAR_CONSTANT}; +Edge E_False = {(Node *)(uintptr_t) (EDGE_IS_VAR_CONSTANT | NEGATE_EDGE)}; +Edge E_BOGUS = {(Node *)0x12345673}; +Edge E_NULL = {(Node *)NULL}; + + +CNF *createCNF() { + CNF *cnf = ourmalloc(sizeof(CNF)); + cnf->varcount = 1; + cnf->capacity = DEFAULT_CNF_ARRAY_SIZE; + cnf->mask = cnf->capacity - 1; + cnf->node_array = ourcalloc(1, sizeof(Node *) * cnf->capacity); + cnf->size = 0; + cnf->maxsize = (uint)(((double)cnf->capacity) * LOAD_FACTOR); + cnf->enableMatching = true; + initDefVectorEdge(&cnf->constraints); + initDefVectorEdge(&cnf->args); + cnf->solver = allocIncrementalSolver(); return cnf; } -void deleteCNF(CNF * cnf) { - for(uint i=0;icapacity;i++) { - Node *n=cnf->node_array[i]; - if (n!=NULL) +void deleteCNF(CNF *cnf) { + for (uint i = 0; i < cnf->capacity; i++) { + Node *n = cnf->node_array[i]; + if (n != NULL) ourfree(n); } - deleteVectorArrayEdge(& cnf->constraints); - deleteVectorArrayEdge(& cnf->args); + deleteVectorArrayEdge(&cnf->constraints); + deleteVectorArrayEdge(&cnf->args); deleteIncrementalSolver(cnf->solver); ourfree(cnf->node_array); ourfree(cnf); } void resizeCNF(CNF *cnf, uint newCapacity) { - Node **old_array=cnf->node_array; - Node **new_array=ourcalloc(1, sizeof(Node *)*newCapacity); - uint oldCapacity=cnf->capacity; - uint newMask=newCapacity-1; - for(uint i=0;ihashCode; - uint newindex=hashCode & newMask; - for(;;newindex=(newindex+1) & newMask) { + Node **old_array = cnf->node_array; + Node **new_array = ourcalloc(1, sizeof(Node *) * newCapacity); + uint oldCapacity = cnf->capacity; + uint newMask = newCapacity - 1; + for (uint i = 0; i < oldCapacity; i++) { + Node *n = old_array[i]; + uint hashCode = n->hashCode; + uint newindex = hashCode & newMask; + for (;; newindex = (newindex + 1) & newMask) { if (new_array[newindex] == NULL) { - new_array[newindex]=n; + new_array[newindex] = n; break; } } } ourfree(old_array); - cnf->node_array=new_array; - cnf->capacity=newCapacity; - cnf->maxsize=(uint)(((double)cnf->capacity)*LOAD_FACTOR); - cnf->mask=newMask; -} - -Node * allocNode(NodeType type, uint numEdges, Edge * edges, uint hashcode) { - Node *n=(Node *)ourmalloc(sizeof(Node)+sizeof(Edge)*numEdges); - memcpy(n->edges, edges, sizeof(Edge)*numEdges); - n->flags.type=type; - n->flags.wasExpanded=0; - n->flags.cnfVisitedDown=0; - n->flags.cnfVisitedUp=0; - n->flags.varForced=0; - n->numEdges=numEdges; - n->hashCode=hashcode; - n->intAnnot[0]=0;n->intAnnot[1]=0; - n->ptrAnnot[0]=NULL;n->ptrAnnot[1]=NULL; + cnf->node_array = new_array; + cnf->capacity = newCapacity; + cnf->maxsize = (uint)(((double)cnf->capacity) * LOAD_FACTOR); + cnf->mask = newMask; +} + +Node *allocNode(NodeType type, uint numEdges, Edge *edges, uint hashcode) { + Node *n = (Node *)ourmalloc(sizeof(Node) + sizeof(Edge) * numEdges); + memcpy(n->edges, edges, sizeof(Edge) * numEdges); + n->flags.type = type; + n->flags.wasExpanded = 0; + n->flags.cnfVisitedDown = 0; + n->flags.cnfVisitedUp = 0; + n->flags.varForced = 0; + n->numEdges = numEdges; + n->hashCode = hashcode; + n->intAnnot[0] = 0;n->intAnnot[1] = 0; + n->ptrAnnot[0] = NULL;n->ptrAnnot[1] = NULL; return n; } -Edge createNode(CNF *cnf, NodeType type, uint numEdges, Edge * edges) { +Edge createNode(CNF *cnf, NodeType type, uint numEdges, Edge *edges) { if (cnf->size > cnf->maxsize) { resizeCNF(cnf, cnf->capacity << 1); } - uint hashvalue=hashNode(type, numEdges, edges); - uint mask=cnf->mask; - uint index=hashvalue & mask; + uint hashvalue = hashNode(type, numEdges, edges); + uint mask = cnf->mask; + uint index = hashvalue & mask; Node **n_ptr; - for(;;index=(index+1)&mask) { - n_ptr=&cnf->node_array[index]; - if (*n_ptr!=NULL) { - if ((*n_ptr)->hashCode==hashvalue) { + for (;; index = (index + 1) & mask) { + n_ptr = &cnf->node_array[index]; + if (*n_ptr != NULL) { + if ((*n_ptr)->hashCode == hashvalue) { if (compareNodes(*n_ptr, type, numEdges, edges)) { - Edge e={*n_ptr}; + Edge e = {*n_ptr}; return e; } } @@ -134,60 +134,60 @@ Edge createNode(CNF *cnf, NodeType type, uint numEdges, Edge * edges) { break; } } - *n_ptr=allocNode(type, numEdges, edges, hashvalue); - Edge e={*n_ptr}; + *n_ptr = allocNode(type, numEdges, edges, hashvalue); + Edge e = {*n_ptr}; return e; } -uint hashNode(NodeType type, uint numEdges, Edge * edges) { - uint hashvalue=type ^ numEdges; - for(uint i=0;i> 29); //rotate left by 3 bits + hashvalue = (hashvalue << 3) | (hashvalue >> 29); //rotate left by 3 bits } return (uint) hashvalue; } -bool compareNodes(Node * node, NodeType type, uint numEdges, Edge *edges) { - if (node->flags.type!=type || node->numEdges != numEdges) +bool compareNodes(Node *node, NodeType type, uint numEdges, Edge *edges) { + if (node->flags.type != type || node->numEdges != numEdges) return false; - Edge *nodeedges=node->edges; - for(uint i=0;iedges; + for (uint i = 0; i < numEdges; i++) { if (!equalsEdge(nodeedges[i], edges[i])) return false; } return true; } -Edge constraintOR(CNF * cnf, uint numEdges, Edge *edges) { +Edge constraintOR(CNF *cnf, uint numEdges, Edge *edges) { Edge edgearray[numEdges]; - - for(uint i=0; inode_ptr)-((uintptr_t)e2->node_ptr); +int comparefunction(const Edge *e1, const Edge *e2) { + return ((uintptr_t)e1->node_ptr) - ((uintptr_t)e2->node_ptr); } -Edge constraintAND(CNF * cnf, uint numEdges, Edge * edges) { - ASSERT(numEdges!=0); - qsort(edges, numEdges, sizeof(Edge), (int (*)(const void *, const void *)) comparefunction); - int initindex=0; - while(initindexenableMatching && lowindex==2 && + if (cnf->enableMatching && lowindex == 2 && isNegNodeEdge(edges[0]) && isNegNodeEdge(edges[1]) && getNodeType(edges[0]) == NodeType_AND && getNodeType(edges[1]) == NodeType_AND && getNodeSize(edges[0]) == 2 && getNodeSize(edges[1]) == 2) { - Edge * e0edges=getEdgeArray(edges[0]); - Edge * e1edges=getEdgeArray(edges[1]); + Edge *e0edges = getEdgeArray(edges[0]); + Edge *e1edges = getEdgeArray(edges[1]); if (sameNodeOppSign(e0edges[0], e1edges[0])) { return constraintNegate(constraintITE(cnf, e0edges[0], e0edges[1], e1edges[1])); } else if (sameNodeOppSign(e0edges[0], e1edges[1])) { @@ -237,76 +237,76 @@ Edge constraintAND(CNF * cnf, uint numEdges, Edge * edges) { return createNode(cnf, NodeType_AND, lowindex, edges); } -Edge constraintAND2(CNF * cnf, Edge left, Edge right) { - Edge edges[2]={left, right}; +Edge constraintAND2(CNF *cnf, Edge left, Edge right) { + Edge edges[2] = {left, right}; return constraintAND(cnf, 2, edges); } -Edge constraintIMPLIES(CNF * cnf, Edge left, Edge right) { +Edge constraintIMPLIES(CNF *cnf, Edge left, Edge right) { Edge array[2]; - array[0]=left; - array[1]=constraintNegate(right); - Edge eand=constraintAND(cnf, 2, array); + array[0] = left; + array[1] = constraintNegate(right); + Edge eand = constraintAND(cnf, 2, array); return constraintNegate(eand); } -Edge constraintIFF(CNF * cnf, Edge left, Edge right) { - bool negate=!sameSignEdge(left, right); - Edge lpos=getNonNeg(left); - Edge rpos=getNonNeg(right); +Edge constraintIFF(CNF *cnf, Edge left, Edge right) { + bool negate = !sameSignEdge(left, right); + Edge lpos = getNonNeg(left); + Edge rpos = getNonNeg(right); Edge e; if (equalsEdge(lpos, rpos)) { - e=E_True; + e = E_True; } else if (ltEdge(lpos, rpos)) { - Edge edges[]={lpos, rpos}; - e=(edgeIsConst(lpos)) ? rpos : createNode(cnf, NodeType_IFF, 2, edges); + Edge edges[] = {lpos, rpos}; + e = (edgeIsConst(lpos)) ? rpos : createNode(cnf, NodeType_IFF, 2, edges); } else { - Edge edges[]={rpos, lpos}; - e=(edgeIsConst(rpos)) ? lpos : createNode(cnf, NodeType_IFF, 2, edges); + Edge edges[] = {rpos, lpos}; + e = (edgeIsConst(rpos)) ? lpos : createNode(cnf, NodeType_IFF, 2, edges); } if (negate) - e=constraintNegate(e); + e = constraintNegate(e); return e; } -Edge constraintITE(CNF * cnf, Edge cond, Edge thenedge, Edge elseedge) { +Edge constraintITE(CNF *cnf, Edge cond, Edge thenedge, Edge elseedge) { if (isNegEdge(cond)) { - cond=constraintNegate(cond); - Edge tmp=thenedge; - thenedge=elseedge; - elseedge=tmp; + cond = constraintNegate(cond); + Edge tmp = thenedge; + thenedge = elseedge; + elseedge = tmp; } - + bool negate = isNegEdge(thenedge); if (negate) { - thenedge=constraintNegate(thenedge); - elseedge=constraintNegate(elseedge); + thenedge = constraintNegate(thenedge); + elseedge = constraintNegate(elseedge); } Edge result; if (equalsEdge(cond, E_True)) { - result=thenedge; + result = thenedge; } else if (equalsEdge(thenedge, E_True) || equalsEdge(cond, thenedge)) { - result=constraintOR(cnf, 2, (Edge[]) {cond, elseedge}); - } else if (equalsEdge(elseedge, E_True) || sameNodeOppSign(cond, elseedge)) { - result=constraintIMPLIES(cnf, cond, thenedge); + result = constraintOR(cnf, 2, (Edge[]) {cond, elseedge}); + } else if (equalsEdge(elseedge, E_True) || sameNodeOppSign(cond, elseedge)) { + result = constraintIMPLIES(cnf, cond, thenedge); } else if (equalsEdge(thenedge, E_False) || equalsEdge(cond, elseedge)) { - result=constraintAND(cnf, 2, (Edge[]) {cond, thenedge}); + result = constraintAND(cnf, 2, (Edge[]) {cond, thenedge}); } else if (equalsEdge(thenedge, elseedge)) { - result=thenedge; + result = thenedge; } else if (sameNodeOppSign(thenedge, elseedge)) { if (ltEdge(cond, thenedge)) { - result=createNode(cnf, NodeType_IFF, 2, (Edge[]) {cond, thenedge}); + result = createNode(cnf, NodeType_IFF, 2, (Edge[]) {cond, thenedge}); } else { - result=createNode(cnf, NodeType_IFF, 2, (Edge[]) {thenedge, cond}); + result = createNode(cnf, NodeType_IFF, 2, (Edge[]) {thenedge, cond}); } } else { - Edge edges[]={cond, thenedge, elseedge}; - result=createNode(cnf, NodeType_ITE, 3, edges); + Edge edges[] = {cond, thenedge, elseedge}; + result = createNode(cnf, NodeType_ITE, 3, edges); } if (negate) - result=constraintNegate(result); + result = constraintNegate(result); return result; } @@ -318,8 +318,8 @@ void addConstraintCNF(CNF *cnf, Edge constraint) { } Edge constraintNewVar(CNF *cnf) { - uint varnum=cnf->varcount++; - Edge e={(Node *) ((((uintptr_t)varnum) << VAR_SHIFT) | EDGE_IS_VAR_CONSTANT) }; + uint varnum = cnf->varcount++; + Edge e = {(Node *) ((((uintptr_t)varnum) << VAR_SHIFT) | EDGE_IS_VAR_CONSTANT) }; return e; } @@ -331,16 +331,16 @@ int solveCNF(CNF *cnf) { } bool getValueCNF(CNF *cnf, Edge var) { - Literal l=getEdgeVar(var); - bool isneg=(l<0); - l=abs(l); + Literal l = getEdgeVar(var); + bool isneg = (l < 0); + l = abs(l); return isneg ^ getValueSolver(cnf->solver, l); } void countPass(CNF *cnf) { - uint numConstraints=getSizeVectorEdge(&cnf->constraints); - VectorEdge *ve=allocDefVectorEdge(); - for(uint i=0; iconstraints); + VectorEdge *ve = allocDefVectorEdge(); + for (uint i = 0; i < numConstraints; i++) { countConstraint(cnf, ve, getVectorEdge(&cnf->constraints, i)); } deleteVectorEdge(ve); @@ -353,16 +353,16 @@ void countConstraint(CNF *cnf, VectorEdge *stack, Edge eroot) { clearVectorEdge(stack);pushVectorEdge(stack, eroot); - bool isMatching=cnf->enableMatching; - - while(getSizeVectorEdge(stack) != 0) { - Edge e=lastVectorEdge(stack); popVectorEdge(stack); - bool polarity=isNegEdge(e); - Node *n=getNodePtrFromEdge(e); + bool isMatching = cnf->enableMatching; + + while (getSizeVectorEdge(stack) != 0) { + Edge e = lastVectorEdge(stack); popVectorEdge(stack); + bool polarity = isNegEdge(e); + Node *n = getNodePtrFromEdge(e); if (getExpanded(n, polarity)) { if (n->flags.type == NodeType_IFF || n->flags.type == NodeType_ITE) { - Edge pExp={n->ptrAnnot[polarity]}; + Edge pExp = {n->ptrAnnot[polarity]}; getNodePtrFromEdge(pExp)->intAnnot[0]++; } else { n->intAnnot[polarity]++; @@ -370,39 +370,39 @@ void countConstraint(CNF *cnf, VectorEdge *stack, Edge eroot) { } else { setExpanded(n, polarity); - if (n->flags.type == NodeType_ITE|| + if (n->flags.type == NodeType_ITE || n->flags.type == NodeType_IFF) { - n->intAnnot[polarity]=0; - Edge cond=n->edges[0]; - Edge thenedge=n->edges[1]; - Edge elseedge=n->flags.type == NodeType_IFF? constraintNegate(thenedge): n->edges[2]; - thenedge=constraintNegateIf(thenedge, !polarity); - elseedge=constraintNegateIf(elseedge, !polarity); - thenedge=constraintAND2(cnf, cond, thenedge); - cond=constraintNegate(cond); - elseedge=constraintAND2(cnf, cond, elseedge); - thenedge=constraintNegate(thenedge); - elseedge=constraintNegate(elseedge); - cnf->enableMatching=false; - Edge succ1=constraintAND2(cnf, thenedge, elseedge); - n->ptrAnnot[polarity]=succ1.node_ptr; - cnf->enableMatching=isMatching; + n->intAnnot[polarity] = 0; + Edge cond = n->edges[0]; + Edge thenedge = n->edges[1]; + Edge elseedge = n->flags.type == NodeType_IFF ? constraintNegate(thenedge) : n->edges[2]; + thenedge = constraintNegateIf(thenedge, !polarity); + elseedge = constraintNegateIf(elseedge, !polarity); + thenedge = constraintAND2(cnf, cond, thenedge); + cond = constraintNegate(cond); + elseedge = constraintAND2(cnf, cond, elseedge); + thenedge = constraintNegate(thenedge); + elseedge = constraintNegate(elseedge); + cnf->enableMatching = false; + Edge succ1 = constraintAND2(cnf, thenedge, elseedge); + n->ptrAnnot[polarity] = succ1.node_ptr; + cnf->enableMatching = isMatching; pushVectorEdge(stack, succ1); if (getExpanded(n, !polarity)) { - Edge succ2={(Node *)n->ptrAnnot[!polarity]}; - Node *n1=getNodePtrFromEdge(succ1); - Node *n2=getNodePtrFromEdge(succ2); - n1->ptrAnnot[0]=succ2.node_ptr; - n2->ptrAnnot[0]=succ1.node_ptr; - n1->ptrAnnot[1]=succ2.node_ptr; - n2->ptrAnnot[1]=succ1.node_ptr; - } + Edge succ2 = {(Node *)n->ptrAnnot[!polarity]}; + Node *n1 = getNodePtrFromEdge(succ1); + Node *n2 = getNodePtrFromEdge(succ2); + n1->ptrAnnot[0] = succ2.node_ptr; + n2->ptrAnnot[0] = succ1.node_ptr; + n1->ptrAnnot[1] = succ2.node_ptr; + n2->ptrAnnot[1] = succ1.node_ptr; + } } else { - n->intAnnot[polarity]=1; - for (uint i=0;inumEdges;i++) { - Edge succ=n->edges[i]; - if(!edgeIsVarConst(succ)) { - succ=constraintNegateIf(succ, polarity); + n->intAnnot[polarity] = 1; + for (uint i = 0; i < n->numEdges; i++) { + Edge succ = n->edges[i]; + if (!edgeIsVarConst(succ)) { + succ = constraintNegateIf(succ, polarity); pushVectorEdge(stack, succ); } } @@ -412,17 +412,17 @@ void countConstraint(CNF *cnf, VectorEdge *stack, Edge eroot) { } void convertPass(CNF *cnf, bool backtrackLit) { - uint numConstraints=getSizeVectorEdge(&cnf->constraints); - VectorEdge *ve=allocDefVectorEdge(); - for(uint i=0; iconstraints); + VectorEdge *ve = allocDefVectorEdge(); + for (uint i = 0; i < numConstraints; i++) { convertConstraint(cnf, ve, getVectorEdge(&cnf->constraints, i), backtrackLit); } deleteVectorEdge(ve); } void convertConstraint(CNF *cnf, VectorEdge *stack, Edge root, bool backtrackLit) { - Node *nroot=getNodePtrFromEdge(root); - + Node *nroot = getNodePtrFromEdge(root); + if (isNodeEdge(root) && (nroot->flags.type == NodeType_ITE || nroot->flags.type == NodeType_IFF)) { nroot = (Node *) nroot->ptrAnnot[isNegEdge(root)]; root = (Edge) { nroot }; @@ -430,11 +430,11 @@ void convertConstraint(CNF *cnf, VectorEdge *stack, Edge root, bool backtrackLit if (edgeIsConst(root)) { if (isNegEdge(root)) { //trivally unsat - Edge newvar=constraintNewVar(cnf); - Literal var=getEdgeVar(newvar); + Edge newvar = constraintNewVar(cnf); + Literal var = getEdgeVar(newvar); Literal clause[] = {var}; addArrayClauseLiteral(cnf->solver, 1, clause); - clause[0]=-var; + clause[0] = -var; addArrayClauseLiteral(cnf->solver, 1, clause); return; } else { @@ -446,21 +446,21 @@ void convertConstraint(CNF *cnf, VectorEdge *stack, Edge root, bool backtrackLit addArrayClauseLiteral(cnf->solver, 1, clause); return; } - + clearVectorEdge(stack);pushVectorEdge(stack, root); - while(getSizeVectorEdge(stack)!=0) { - Edge e=lastVectorEdge(stack); - Node *n=getNodePtrFromEdge(e); + while (getSizeVectorEdge(stack) != 0) { + Edge e = lastVectorEdge(stack); + Node *n = getNodePtrFromEdge(e); if (edgeIsVarConst(e)) { popVectorEdge(stack); continue; - } else if (n->flags.type==NodeType_ITE || - n->flags.type==NodeType_IFF) { + } else if (n->flags.type == NodeType_ITE || + n->flags.type == NodeType_IFF) { popVectorEdge(stack); - if (n->ptrAnnot[0]!=NULL) + if (n->ptrAnnot[0] != NULL) pushVectorEdge(stack, (Edge) {(Node *)n->ptrAnnot[0]}); - if (n->ptrAnnot[1]!=NULL) + if (n->ptrAnnot[1] != NULL) pushVectorEdge(stack, (Edge) {(Node *)n->ptrAnnot[1]}); continue; } @@ -473,27 +473,27 @@ void convertConstraint(CNF *cnf, VectorEdge *stack, Edge root, bool backtrackLit } else if ((needPos && !(n->flags.cnfVisitedDown & 1)) || (needNeg && !(n->flags.cnfVisitedDown & 2))) { if (needPos) - n->flags.cnfVisitedDown|=1; + n->flags.cnfVisitedDown |= 1; if (needNeg) - n->flags.cnfVisitedDown|=2; - for(uint i=0; inumEdges; i++) { - Edge arg=n->edges[i]; - arg=constraintNegateIf(arg, isNegEdge(e)); - pushVectorEdge(stack, arg); //WARNING, THIS LOOKS LIKE A BUG IN THE ORIGINAL CODE + n->flags.cnfVisitedDown |= 2; + for (uint i = 0; i < n->numEdges; i++) { + Edge arg = n->edges[i]; + arg = constraintNegateIf(arg, isNegEdge(e)); + pushVectorEdge(stack, arg); //WARNING, THIS LOOKS LIKE A BUG IN THE ORIGINAL CODE } } else { popVectorEdge(stack); produceCNF(cnf, e); } } - CNFExpr * cnfExp = (CNFExpr *) nroot->ptrAnnot[isNegEdge(root)]; - ASSERT(cnfExp!=NULL); + CNFExpr *cnfExp = (CNFExpr *) nroot->ptrAnnot[isNegEdge(root)]; + ASSERT(cnfExp != NULL); if (isProxy(cnfExp)) { - Literal l=getProxy(cnfExp); + Literal l = getProxy(cnfExp); Literal clause[] = {l}; addArrayClauseLiteral(cnf->solver, 1, clause); } else if (backtrackLit) { - Literal l=introProxy(cnf, root, cnfExp, isNegEdge(root)); + Literal l = introProxy(cnf, root, cnfExp, isNegEdge(root)); Literal clause[] = {l}; addArrayClauseLiteral(cnf->solver, 1, clause); } else { @@ -507,30 +507,30 @@ void convertConstraint(CNF *cnf, VectorEdge *stack, Edge root, bool backtrackLit } -Literal introProxy(CNF * cnf, Edge e, CNFExpr* exp, bool isNeg) { +Literal introProxy(CNF *cnf, Edge e, CNFExpr *exp, bool isNeg) { Literal l = 0; - Node * n = getNodePtrFromEdge(e); - - if (n->flags.cnfVisitedUp & (1<ptrAnnot[!isNeg]; + Node *n = getNodePtrFromEdge(e); + + if (n->flags.cnfVisitedUp & (1 << !isNeg)) { + CNFExpr *otherExp = (CNFExpr *) n->ptrAnnot[!isNeg]; if (isProxy(otherExp)) l = -getProxy(otherExp); } else { - Edge semNeg={(Node *) n->ptrAnnot[isNeg]}; - Node * nsemNeg=getNodePtrFromEdge(semNeg); + Edge semNeg = {(Node *) n->ptrAnnot[isNeg]}; + Node *nsemNeg = getNodePtrFromEdge(semNeg); if (nsemNeg != NULL) { if (nsemNeg->flags.cnfVisitedUp & (1 << isNeg)) { - CNFExpr* otherExp = (CNFExpr*) nsemNeg->ptrAnnot[isNeg]; + CNFExpr *otherExp = (CNFExpr *) nsemNeg->ptrAnnot[isNeg]; if (isProxy(otherExp)) l = -getProxy(otherExp); - } else if (nsemNeg->flags.cnfVisitedUp & (1<< !isNeg)) { - CNFExpr* otherExp = (CNFExpr*) nsemNeg->ptrAnnot[!isNeg]; + } else if (nsemNeg->flags.cnfVisitedUp & (1 << !isNeg)) { + CNFExpr *otherExp = (CNFExpr *) nsemNeg->ptrAnnot[!isNeg]; if (isProxy(otherExp)) l = getProxy(otherExp); } } } - + if (l == 0) { Edge newvar = constraintNewVar(cnf); l = getEdgeVar(newvar); @@ -538,17 +538,17 @@ Literal introProxy(CNF * cnf, Edge e, CNFExpr* exp, bool isNeg) { // Output the constraints on the auxiliary variable constrainCNF(cnf, l, exp); deleteCNFExpr(exp); - - n->ptrAnnot[isNeg] = (void*) ((intptr_t) (l << 1) | 1); - + + n->ptrAnnot[isNeg] = (void *) ((intptr_t) (l << 1) | 1); + return l; } -void produceCNF(CNF * cnf, Edge e) { - CNFExpr* expPos = NULL; - CNFExpr* expNeg = NULL; +void produceCNF(CNF *cnf, Edge e) { + CNFExpr *expPos = NULL; + CNFExpr *expNeg = NULL; Node *n = getNodePtrFromEdge(e); - + if (n->intAnnot[0] > 0) { expPos = produceConjunction(cnf, e); } @@ -564,11 +564,11 @@ void produceCNF(CNF * cnf, Edge e) { /// produced for them at the right point /// /// propagate(solver, expPos, snPos, false) || propagate(solver, expNeg, snNeg, false) - + // propagate from positive to negative, negative to positive - if (!propagate(cnf, & expPos, expNeg, true)) - propagate(cnf, & expNeg, expPos, true); - + if (!propagate(cnf, &expPos, expNeg, true)) + propagate(cnf, &expNeg, expPos, true); + // The polarity heuristic entails visiting the discovery polarity first if (isPosEdge(e)) { saveCNF(cnf, expPos, e, false); @@ -579,7 +579,7 @@ void produceCNF(CNF * cnf, Edge e) { } } -bool propagate(CNF *cnf, CNFExpr ** dest, CNFExpr * src, bool negate) { +bool propagate(CNF *cnf, CNFExpr **dest, CNFExpr *src, bool negate) { if (src != NULL && !isProxy(src) && getLitSizeCNF(src) == 0) { if (*dest == NULL) { *dest = allocCNFExprBool(negate ? alwaysFalseCNF(src) : alwaysTrueCNF(src)); @@ -592,7 +592,7 @@ bool propagate(CNF *cnf, CNFExpr ** dest, CNFExpr * src, bool negate) { Literal clause[] = {-getProxy(*dest)}; addArrayClauseLiteral(cnf->solver, 1, clause); } - + *dest = allocCNFExprBool(negate ? alwaysFalseCNF(src) : alwaysTrueCNF(src)); } else { clearCNFExpr(*dest, negate ? alwaysFalseCNF(src) : alwaysTrueCNF(src)); @@ -602,15 +602,15 @@ bool propagate(CNF *cnf, CNFExpr ** dest, CNFExpr * src, bool negate) { return false; } -void saveCNF(CNF *cnf, CNFExpr* exp, Edge e, bool sign) { - Node *n=getNodePtrFromEdge(e); +void saveCNF(CNF *cnf, CNFExpr *exp, Edge e, bool sign) { + Node *n = getNodePtrFromEdge(e); n->flags.cnfVisitedUp |= (1 << sign); if (exp == NULL || isProxy(exp)) return; - + if (exp->litSize == 1) { Literal l = getLiteralLitVector(&exp->singletons, 0); deleteCNFExpr(exp); - n->ptrAnnot[sign] = (void*) ((((intptr_t) l) << 1) | 1); + n->ptrAnnot[sign] = (void *) ((((intptr_t) l) << 1) | 1); } else if (exp->litSize != 0 && (n->intAnnot[sign] > 1 || n->flags.varForced)) { introProxy(cnf, e, exp, sign); } else { @@ -618,7 +618,7 @@ void saveCNF(CNF *cnf, CNFExpr* exp, Edge e, bool sign) { } } -void constrainCNF(CNF * cnf, Literal lcond, CNFExpr *expr) { +void constrainCNF(CNF *cnf, Literal lcond, CNFExpr *expr) { if (alwaysTrueCNF(expr)) { return; } else if (alwaysFalseCNF(expr)) { @@ -626,85 +626,85 @@ void constrainCNF(CNF * cnf, Literal lcond, CNFExpr *expr) { addArrayClauseLiteral(cnf->solver, 1, clause); return; } - - for(uint i=0;isingletons);i++) { - Literal l=getLiteralLitVector(&expr->singletons,i); + + for (uint i = 0; i < getSizeLitVector(&expr->singletons); i++) { + Literal l = getLiteralLitVector(&expr->singletons,i); Literal clause[] = {-lcond, l}; addArrayClauseLiteral(cnf->solver, 2, clause); } - for(uint i=0;iclauses);i++) { - LitVector *lv=getVectorLitVector(&expr->clauses,i); - addClauseLiteral(cnf->solver, -lcond); //Add first literal - addArrayClauseLiteral(cnf->solver, getSizeLitVector(lv), lv->literals); //Add rest + for (uint i = 0; i < getSizeVectorLitVector(&expr->clauses); i++) { + LitVector *lv = getVectorLitVector(&expr->clauses,i); + addClauseLiteral(cnf->solver, -lcond);//Add first literal + addArrayClauseLiteral(cnf->solver, getSizeLitVector(lv), lv->literals); //Add rest } } void outputCNF(CNF *cnf, CNFExpr *expr) { - for(uint i=0;isingletons);i++) { - Literal l=getLiteralLitVector(&expr->singletons,i); + for (uint i = 0; i < getSizeLitVector(&expr->singletons); i++) { + Literal l = getLiteralLitVector(&expr->singletons,i); Literal clause[] = {l}; addArrayClauseLiteral(cnf->solver, 1, clause); } - for(uint i=0;iclauses);i++) { - LitVector *lv=getVectorLitVector(&expr->clauses,i); + for (uint i = 0; i < getSizeVectorLitVector(&expr->clauses); i++) { + LitVector *lv = getVectorLitVector(&expr->clauses,i); addArrayClauseLiteral(cnf->solver, getSizeLitVector(lv), lv->literals); } } -CNFExpr* fillArgs(CNF *cnf, Edge e, bool isNeg, Edge * largestEdge) { +CNFExpr *fillArgs(CNF *cnf, Edge e, bool isNeg, Edge *largestEdge) { clearVectorEdge(&cnf->args); - *largestEdge = (Edge) {(Node*) NULL}; - CNFExpr* largest = NULL; - Node *n=getNodePtrFromEdge(e); + *largestEdge = (Edge) {(Node *) NULL}; + CNFExpr *largest = NULL; + Node *n = getNodePtrFromEdge(e); int i = n->numEdges; while (i != 0) { Edge arg = n->edges[--i]; - arg=constraintNegateIf(arg, isNeg); - Node * narg = getNodePtrFromEdge(arg); - + arg = constraintNegateIf(arg, isNeg); + Node *narg = getNodePtrFromEdge(arg); + if (edgeIsVarConst(arg)) { pushVectorEdge(&cnf->args, arg); continue; } - + if (narg->flags.type == NodeType_ITE || narg->flags.type == NodeType_IFF) { arg = (Edge) {(Node *) narg->ptrAnnot[isNegEdge(arg)]}; } - + if (narg->intAnnot[isNegEdge(arg)] == 1) { - CNFExpr* argExp = (CNFExpr*) narg->ptrAnnot[isNegEdge(arg)]; + CNFExpr *argExp = (CNFExpr *) narg->ptrAnnot[isNegEdge(arg)]; if (!isProxy(argExp)) { if (largest == NULL) { largest = argExp; - * largestEdge = arg; + *largestEdge = arg; continue; } else if (argExp->litSize > largest->litSize) { pushVectorEdge(&cnf->args, *largestEdge); largest = argExp; - * largestEdge = arg; + *largestEdge = arg; continue; } } } pushVectorEdge(&cnf->args, arg); } - + if (largest != NULL) { - Node *nlargestEdge=getNodePtrFromEdge(*largestEdge); + Node *nlargestEdge = getNodePtrFromEdge(*largestEdge); nlargestEdge->ptrAnnot[isNegEdge(*largestEdge)] = NULL; } - + return largest; } void printCNF(Edge e) { if (edgeIsVarConst(e)) { - Literal l=getEdgeVar(e); + Literal l = getEdgeVar(e); model_print ("%d", l); return; } - bool isNeg=isNegEdge(e); + bool isNeg = isNegEdge(e); if (edgeIsConst(e)) { if (isNeg) model_print("T"); @@ -712,14 +712,14 @@ void printCNF(Edge e) { model_print("F"); return; } - Node *n=getNodePtrFromEdge(e); + Node *n = getNodePtrFromEdge(e); if (isNeg) { //Pretty print things that are equivalent to OR's - if (getNodeType(e)==NodeType_AND) { + if (getNodeType(e) == NodeType_AND) { model_print("or("); - for(uint i=0;inumEdges;i++) { - Edge e=n->edges[i]; - if (i!=0) + for (uint i = 0; i < n->numEdges; i++) { + Edge e = n->edges[i]; + if (i != 0) model_print(" "); printCNF(constraintNegate(e)); } @@ -729,7 +729,7 @@ void printCNF(Edge e) { model_print("!"); } - switch(getNodeType(e)) { + switch (getNodeType(e)) { case NodeType_AND: model_print("and"); break; @@ -741,33 +741,33 @@ void printCNF(Edge e) { break; } model_print("("); - for(uint i=0;inumEdges;i++) { - Edge e=n->edges[i]; - if (i!=0) + for (uint i = 0; i < n->numEdges; i++) { + Edge e = n->edges[i]; + if (i != 0) model_print(" "); printCNF(e); } model_print(")"); } -CNFExpr * produceConjunction(CNF * cnf, Edge e) { +CNFExpr *produceConjunction(CNF *cnf, Edge e) { Edge largestEdge; - - CNFExpr* accum = fillArgs(cnf, e, false, &largestEdge); + + CNFExpr *accum = fillArgs(cnf, e, false, &largestEdge); if (accum == NULL) accum = allocCNFExprBool(true); - + int i = getSizeVectorEdge(&cnf->args); while (i != 0) { Edge arg = getVectorEdge(&cnf->args, --i); if (edgeIsVarConst(arg)) { conjoinCNFLit(accum, getEdgeVar(arg)); } else { - Node *narg=getNodePtrFromEdge(arg); - CNFExpr* argExp = (CNFExpr*) narg->ptrAnnot[isNegEdge(arg)]; - + Node *narg = getNodePtrFromEdge(arg); + CNFExpr *argExp = (CNFExpr *) narg->ptrAnnot[isNegEdge(arg)]; + bool destroy = (--narg->intAnnot[isNegEdge(arg)] == 0); - if (isProxy(argExp)) { // variable has been introduced + if (isProxy(argExp)) {// variable has been introduced conjoinCNFLit(accum, getProxy(argExp)); } else { conjoinCNFExpr(accum, argExp, destroy); @@ -776,53 +776,53 @@ CNFExpr * produceConjunction(CNF * cnf, Edge e) { } } } - + return accum; } #define CLAUSE_MAX 3 -CNFExpr* produceDisjunction(CNF *cnf, Edge e) { +CNFExpr *produceDisjunction(CNF *cnf, Edge e) { Edge largestEdge; - CNFExpr* accum = fillArgs(cnf, e, true, &largestEdge); + CNFExpr *accum = fillArgs(cnf, e, true, &largestEdge); if (accum == NULL) accum = allocCNFExprBool(false); - + // This is necessary to check to make sure that we don't start out // with an accumulator that is "too large". - + /// @todo Strictly speaking, introProxy doesn't *need* to free /// memory, then this wouldn't have to reallocate CNFExpr - + /// @todo When this call to introProxy is made, the semantic /// negation pointer will have been destroyed. Thus, it will not /// be possible to use the correct proxy. That should be fixed. - + // at this point, we will either have NULL, or a destructible expression if (getClauseSizeCNF(accum) > CLAUSE_MAX) accum = allocCNFExprLiteral(introProxy(cnf, largestEdge, accum, isNegEdge(largestEdge))); - + int i = getSizeVectorEdge(&cnf->args); while (i != 0) { - Edge arg=getVectorEdge(&cnf->args, --i); - Node *narg=getNodePtrFromEdge(arg); + Edge arg = getVectorEdge(&cnf->args, --i); + Node *narg = getNodePtrFromEdge(arg); if (edgeIsVarConst(arg)) { disjoinCNFLit(accum, getEdgeVar(arg)); } else { - CNFExpr* argExp = (CNFExpr*) narg->ptrAnnot[isNegEdge(arg)]; - + CNFExpr *argExp = (CNFExpr *) narg->ptrAnnot[isNegEdge(arg)]; + bool destroy = (--narg->intAnnot[isNegEdge(arg)] == 0); - if (isProxy(argExp)) { // variable has been introduced + if (isProxy(argExp)) {// variable has been introduced disjoinCNFLit(accum, getProxy(argExp)); } else if (argExp->litSize == 0) { disjoinCNFExpr(accum, argExp, destroy); } else { // check to see if we should introduce a proxy - int aL = accum->litSize; // lits in accum - int eL = argExp->litSize; // lits in argument - int aC = getClauseSizeCNF(accum); // clauses in accum - int eC = getClauseSizeCNF(argExp); // clauses in argument - + int aL = accum->litSize; // lits in accum + int eL = argExp->litSize; // lits in argument + int aC = getClauseSizeCNF(accum); // clauses in accum + int eC = getClauseSizeCNF(argExp); // clauses in argument + if (eC > CLAUSE_MAX || (eL * aC + aL * eC > eL + aC + aL + aC)) { disjoinCNFLit(accum, introProxy(cnf, arg, argExp, isNegEdge(arg))); } else { @@ -832,51 +832,51 @@ CNFExpr* produceDisjunction(CNF *cnf, Edge e) { } } } - + return accum; } -Edge generateBinaryConstraint(CNF *cnf, uint numvars, Edge * vars, uint value) { +Edge generateBinaryConstraint(CNF *cnf, uint numvars, Edge *vars, uint value) { Edge carray[numvars]; - for(uint j=0;j>1; + for (uint j = 0; j < numvars; j++) { + carray[j] = ((value & 1) == 1) ? vars[j] : constraintNegate(vars[j]); + value = value >> 1; } - + return constraintAND(cnf, numvars, carray); } - + /** Generates a constraint to ensure that all encodings are less than value */ -Edge generateLTConstraint(CNF *cnf, uint numvars, Edge * vars, uint value) { +Edge generateLTConstraint(CNF *cnf, uint numvars, Edge *vars, uint value) { Edge orarray[numvars]; Edge andarray[numvars]; - uint andi=0; - - while(true) { - uint val=value; - uint ori=0; - for(uint j=0;j>1; + uint andi = 0; + + while (true) { + uint val = value; + uint ori = 0; + for (uint j = 0; j < numvars; j++) { + if ((val & 1) == 1) + orarray[ori++] = constraintNegate(vars[j]); + val = val >> 1; } //no ones to flip, so bail now... - if (ori==0) { + if (ori == 0) { return constraintAND(cnf, andi, andarray); } - andarray[andi++]=constraintOR(cnf, ori, orarray); - - value=value+(1<<(__builtin_ctz(value))); + andarray[andi++] = constraintOR(cnf, ori, orarray); + + value = value + (1 << (__builtin_ctz(value))); //flip the last one } } - + Edge generateEquivNVConstraint(CNF *cnf, uint numvars, Edge *var1, Edge *var2) { - if (numvars==0) + if (numvars == 0) return E_True; Edge array[numvars]; - for(uint i=0;iflags.wasExpanded & (1<flags.wasExpanded & (1 << isNegated); } static inline void setExpanded(Node *n, int isNegated) { - n->flags.wasExpanded |= (1<flags.wasExpanded |= (1 << isNegated); } static inline Edge constraintNegate(Edge e) { @@ -84,7 +84,7 @@ static inline Edge constraintNegate(Edge e) { } static inline bool sameNodeVarEdge(Edge e1, Edge e2) { - return ! (((uintptr_t) e1.node_ptr ^ (uintptr_t) e2.node_ptr) & (~ (uintptr_t) NEGATE_EDGE)); + return !(((uintptr_t) e1.node_ptr ^ (uintptr_t) e2.node_ptr) & (~(uintptr_t) NEGATE_EDGE)); } static inline bool sameSignEdge(Edge e1, Edge e2) { @@ -111,12 +111,12 @@ static inline bool isNegNodeEdge(Edge e) { return (((uintptr_t) e.node_ptr) & (NEGATE_EDGE | EDGE_IS_VAR_CONSTANT)) == NEGATE_EDGE; } -static inline Node * getNodePtrFromEdge(Edge e) { +static inline Node *getNodePtrFromEdge(Edge e) { return (Node *) (((uintptr_t) e.node_ptr) & ~((uintptr_t) EDGE_MASK)); } static inline NodeType getNodeType(Edge e) { - Node * n=getNodePtrFromEdge(e); + Node *n = getNodePtrFromEdge(e); return n->flags.type; } @@ -129,17 +129,17 @@ static inline bool ltEdge(Edge e1, Edge e2) { } static inline uint getNodeSize(Edge e) { - Node * n=getNodePtrFromEdge(e); + Node *n = getNodePtrFromEdge(e); return n->numEdges; } -static inline Edge * getEdgeArray(Edge e) { - Node * n=getNodePtrFromEdge(e); +static inline Edge *getEdgeArray(Edge e) { + Node *n = getNodePtrFromEdge(e); return n->edges; } static inline Edge getNonNeg(Edge e) { - Edge enew={(Node *)(((uintptr_t)e.node_ptr)&(~((uintptr_t)NEGATE_EDGE)))}; + Edge enew = {(Node *)(((uintptr_t)e.node_ptr) & (~((uintptr_t)NEGATE_EDGE)))}; return enew; } @@ -156,7 +156,7 @@ static inline bool edgeIsVarConst(Edge e) { } static inline Edge constraintNegateIf(Edge e, bool negate) { - Edge eret={(Node *)(((uintptr_t)e.node_ptr) ^ negate)}; + Edge eret = {(Node *)(((uintptr_t)e.node_ptr) ^ negate)}; return eret; } @@ -173,24 +173,24 @@ static inline Literal getProxy(CNFExpr *expr) { return (Literal) (((intptr_t) expr) >> 1); } -CNF * createCNF(); -void deleteCNF(CNF * cnf); +CNF *createCNF(); +void deleteCNF(CNF *cnf); -uint hashNode(NodeType type, uint numEdges, Edge * edges); -Node * allocNode(NodeType type, uint numEdges, Edge * edges, uint hashCode); -bool compareNodes(Node * node, NodeType type, uint numEdges, Edge *edges); -Edge create(CNF *cnf, NodeType type, uint numEdges, Edge * edges); -Edge constraintOR(CNF * cnf, uint numEdges, Edge *edges); -Edge constraintAND(CNF * cnf, uint numEdges, Edge * edges); -Edge constraintOR2(CNF * cnf, Edge left, Edge right); -Edge constraintAND2(CNF * cnf, Edge left, Edge right); -Edge constraintIMPLIES(CNF * cnf, Edge left, Edge right); -Edge constraintIFF(CNF * cnf, Edge left, Edge right); +uint hashNode(NodeType type, uint numEdges, Edge *edges); +Node *allocNode(NodeType type, uint numEdges, Edge *edges, uint hashCode); +bool compareNodes(Node *node, NodeType type, uint numEdges, Edge *edges); +Edge create(CNF *cnf, NodeType type, uint numEdges, Edge *edges); +Edge constraintOR(CNF *cnf, uint numEdges, Edge *edges); +Edge constraintAND(CNF *cnf, uint numEdges, Edge *edges); +Edge constraintOR2(CNF *cnf, Edge left, Edge right); +Edge constraintAND2(CNF *cnf, Edge left, Edge right); +Edge constraintIMPLIES(CNF *cnf, Edge left, Edge right); +Edge constraintIFF(CNF *cnf, Edge left, Edge right); static inline Edge constraintXOR(CNF *cnf, Edge left, Edge right) {return constraintNegate(constraintIFF(cnf, left,right));} -Edge constraintITE(CNF * cnf, Edge cond, Edge thenedge, Edge elseedge); +Edge constraintITE(CNF *cnf, Edge cond, Edge thenedge, Edge elseedge); Edge constraintNewVar(CNF *cnf); void countPass(CNF *cnf); -void countConstraint(CNF *cnf, VectorEdge * stack, Edge e); +void countConstraint(CNF *cnf, VectorEdge *stack, Edge e); void addConstraintCNF(CNF *cnf, Edge constraint); int solveCNF(CNF *cnf); bool getValueCNF(CNF *cnf, Edge var); @@ -198,18 +198,18 @@ void printCNF(Edge e); void convertPass(CNF *cnf, bool backtrackLit); void convertConstraint(CNF *cnf, VectorEdge *stack, Edge e, bool backtrackLit); -void constrainCNF(CNF * cnf, Literal l, CNFExpr *exp); -void produceCNF(CNF * cnf, Edge e); -CNFExpr * produceConjunction(CNF * cnf, Edge e); -CNFExpr* produceDisjunction(CNF *cnf, Edge e); -bool propagate(CNF *cnf, CNFExpr ** dest, CNFExpr * src, bool negate); -void saveCNF(CNF *cnf, CNFExpr* exp, Edge e, bool sign); -CNFExpr* fillArgs(CNF * cnf, Edge e, bool isNeg, Edge * largestEdge); -Literal introProxy(CNF * cnf, Edge e, CNFExpr* exp, bool isNeg); +void constrainCNF(CNF *cnf, Literal l, CNFExpr *exp); +void produceCNF(CNF *cnf, Edge e); +CNFExpr *produceConjunction(CNF *cnf, Edge e); +CNFExpr *produceDisjunction(CNF *cnf, Edge e); +bool propagate(CNF *cnf, CNFExpr **dest, CNFExpr *src, bool negate); +void saveCNF(CNF *cnf, CNFExpr *exp, Edge e, bool sign); +CNFExpr *fillArgs(CNF *cnf, Edge e, bool isNeg, Edge *largestEdge); +Literal introProxy(CNF *cnf, Edge e, CNFExpr *exp, bool isNeg); void outputCNF(CNF *cnf, CNFExpr *expr); -Edge generateBinaryConstraint(CNF *cnf, uint numvars, Edge * vars, uint value); -Edge generateLTConstraint(CNF *cnf, uint numvars, Edge * vars, uint value); +Edge generateBinaryConstraint(CNF *cnf, uint numvars, Edge *vars, uint value); +Edge generateLTConstraint(CNF *cnf, uint numvars, Edge *vars, uint value); Edge generateEquivNVConstraint(CNF *cnf, uint numvars, Edge *var1, Edge *var2); extern Edge E_True; diff --git a/src/Backend/inc_solver.c b/src/Backend/inc_solver.c index 8a37343..85528dc 100644 --- a/src/Backend/inc_solver.c +++ b/src/Backend/inc_solver.c @@ -13,17 +13,17 @@ #include "common.h" #include -IncrementalSolver * allocIncrementalSolver() { - IncrementalSolver *This=(IncrementalSolver *)ourmalloc(sizeof(IncrementalSolver)); - This->buffer=((int *)ourmalloc(sizeof(int)*IS_BUFFERSIZE)); - This->solution=NULL; - This->solutionsize=0; - This->offset=0; +IncrementalSolver *allocIncrementalSolver() { + IncrementalSolver *This = (IncrementalSolver *)ourmalloc(sizeof(IncrementalSolver)); + This->buffer = ((int *)ourmalloc(sizeof(int) * IS_BUFFERSIZE)); + This->solution = NULL; + This->solutionsize = 0; + This->offset = 0; createSolver(This); return This; } -void deleteIncrementalSolver(IncrementalSolver * This) { +void deleteIncrementalSolver(IncrementalSolver *This) { killSolver(This); ourfree(This->buffer); if (This->solution != NULL) @@ -31,51 +31,51 @@ void deleteIncrementalSolver(IncrementalSolver * This) { ourfree(This); } -void resetSolver(IncrementalSolver * This) { +void resetSolver(IncrementalSolver *This) { killSolver(This); This->offset = 0; createSolver(This); } -void addClauseLiteral(IncrementalSolver * This, int literal) { - This->buffer[This->offset++]=literal; - if (This->offset==IS_BUFFERSIZE) { +void addClauseLiteral(IncrementalSolver *This, int literal) { + This->buffer[This->offset++] = literal; + if (This->offset == IS_BUFFERSIZE) { flushBufferSolver(This); } } -void addArrayClauseLiteral(IncrementalSolver * This, uint numliterals, int * literals) { - uint index=0; - while(true) { - uint bufferspace=IS_BUFFERSIZE-This->offset; - uint numtowrite=numliterals-index; +void addArrayClauseLiteral(IncrementalSolver *This, uint numliterals, int *literals) { + uint index = 0; + while (true) { + uint bufferspace = IS_BUFFERSIZE - This->offset; + uint numtowrite = numliterals - index; if (bufferspace > numtowrite) { - memcpy(&This->buffer[This->offset], &literals[index], numtowrite*sizeof(int)); - This->offset+=numtowrite; - This->buffer[This->offset++]=0; //have one extra spot always - if (This->offset==IS_BUFFERSIZE) {//Check if full + memcpy(&This->buffer[This->offset], &literals[index], numtowrite * sizeof(int)); + This->offset += numtowrite; + This->buffer[This->offset++] = 0; //have one extra spot always + if (This->offset == IS_BUFFERSIZE) {//Check if full flushBufferSolver(This); } return; } else { - memcpy(&This->buffer[This->offset], &literals[index], bufferspace*sizeof(int)); - This->offset+=bufferspace; - index+=bufferspace; + memcpy(&This->buffer[This->offset], &literals[index], bufferspace * sizeof(int)); + This->offset += bufferspace; + index += bufferspace; flushBufferSolver(This); } } } -void finishedClauses(IncrementalSolver * This) { +void finishedClauses(IncrementalSolver *This) { addClauseLiteral(This, 0); } -void freeze(IncrementalSolver * This, int variable) { +void freeze(IncrementalSolver *This, int variable) { addClauseLiteral(This, IS_FREEZE); addClauseLiteral(This, variable); } -int solve(IncrementalSolver * This) { +int solve(IncrementalSolver *This) { //add an empty clause startSolve(This); return getSolution(This); @@ -86,14 +86,14 @@ void startSolve(IncrementalSolver *This) { flushBufferSolver(This); } -int getSolution(IncrementalSolver * This) { - int result=readIntSolver(This); +int getSolution(IncrementalSolver *This) { + int result = readIntSolver(This); if (result == IS_SAT) { - int numVars=readIntSolver(This); + int numVars = readIntSolver(This); if (numVars > This->solutionsize) { if (This->solution != NULL) ourfree(This->solution); - This->solution = (int *) ourmalloc((numVars+1)*sizeof(int)); + This->solution = (int *) ourmalloc((numVars + 1) * sizeof(int)); This->solution[0] = 0; } readSolver(This, &This->solution[1], numVars * sizeof(int)); @@ -102,32 +102,32 @@ int getSolution(IncrementalSolver * This) { return result; } -int readIntSolver(IncrementalSolver * This) { +int readIntSolver(IncrementalSolver *This) { int value; readSolver(This, &value, 4); return value; } -void readSolver(IncrementalSolver * This, void * tmp, ssize_t size) { +void readSolver(IncrementalSolver *This, void *tmp, ssize_t size) { char *result = (char *) tmp; - ssize_t bytestoread=size; - ssize_t bytesread=0; + ssize_t bytestoread = size; + ssize_t bytesread = 0; do { - ssize_t n=read(This->from_solver_fd, &((char *)result)[bytesread], bytestoread); + ssize_t n = read(This->from_solver_fd, &((char *)result)[bytesread], bytestoread); if (n == -1) { model_print("Read failure\n"); exit(-1); } bytestoread -= n; bytesread += n; - } while(bytestoread != 0); + } while (bytestoread != 0); } -bool getValueSolver(IncrementalSolver * This, int variable) { +bool getValueSolver(IncrementalSolver *This, int variable) { return This->solution[variable]; } -void createSolver(IncrementalSolver * This) { +void createSolver(IncrementalSolver *This) { int to_pipe[2]; int from_pipe[2]; if (pipe(to_pipe) || pipe(from_pipe)) { @@ -142,7 +142,7 @@ void createSolver(IncrementalSolver * This) { //Solver process close(to_pipe[1]); close(from_pipe[0]); - int fd=open("log_file", O_WRONLY|O_CREAT|O_TRUNC, S_IRWXU); + int fd = open("log_file", O_WRONLY | O_CREAT | O_TRUNC, S_IRWXU); if ((dup2(to_pipe[0], 0) == -1) || (dup2(from_pipe[1], IS_OUT_FD) == -1) || @@ -162,7 +162,7 @@ void createSolver(IncrementalSolver * This) { } } -void killSolver(IncrementalSolver * This) { +void killSolver(IncrementalSolver *This) { close(This->to_solver_fd); close(This->from_solver_fd); //Stop the solver @@ -174,29 +174,29 @@ void killSolver(IncrementalSolver * This) { } //DEBUGGING CODE STARTS -bool first=true; +bool first = true; //DEBUGGING CODE ENDS -void flushBufferSolver(IncrementalSolver * This) { - ssize_t bytestowrite=sizeof(int)*This->offset; - ssize_t byteswritten=0; +void flushBufferSolver(IncrementalSolver *This) { + ssize_t bytestowrite = sizeof(int) * This->offset; + ssize_t byteswritten = 0; //DEBUGGING CODE STARTS - for(uint i=0;ioffset;i++) { + for (uint i = 0; i < This->offset; i++) { if (first) printf("("); - if (This->buffer[i]==0) { + if (This->buffer[i] == 0) { printf(")\n"); - first=true; + first = true; } else { if (!first) printf(" + "); - first=false; + first = false; printf("%d", This->buffer[i]); } } //DEBUGGING CODE ENDS do { - ssize_t n=write(This->to_solver_fd, &((char *)This->buffer)[byteswritten], bytestowrite); + ssize_t n = write(This->to_solver_fd, &((char *)This->buffer)[byteswritten], bytestowrite); if (n == -1) { perror("Write failure\n"); model_print("to_solver_fd=%d\n",This->to_solver_fd); @@ -204,6 +204,6 @@ void flushBufferSolver(IncrementalSolver * This) { } bytestowrite -= n; byteswritten += n; - } while(bytestowrite != 0); + } while (bytestowrite != 0); This->offset = 0; } diff --git a/src/Backend/inc_solver.h b/src/Backend/inc_solver.h index 9b3e2ab..9e9424e 100644 --- a/src/Backend/inc_solver.h +++ b/src/Backend/inc_solver.h @@ -19,8 +19,8 @@ #include "classlist.h" struct IncrementalSolver { - int * buffer; - int * solution; + int *buffer; + int *solution; int solutionsize; int offset; pid_t solver_pid; @@ -28,20 +28,20 @@ struct IncrementalSolver { int from_solver_fd; }; -IncrementalSolver * allocIncrementalSolver(); -void deleteIncrementalSolver(IncrementalSolver * This); -void addClauseLiteral(IncrementalSolver * This, int literal); -void addArrayClauseLiteral(IncrementalSolver * This, uint numliterals, int * literals); -void finishedClauses(IncrementalSolver * This); -void freeze(IncrementalSolver * This, int variable); -int solve(IncrementalSolver * This); -void startSolve(IncrementalSolver * This); -int getSolution(IncrementalSolver * This); -bool getValueSolver(IncrementalSolver * This, int variable); -void resetSolver(IncrementalSolver * This); -void createSolver(IncrementalSolver * This); -void killSolver(IncrementalSolver * This); -void flushBufferSolver(IncrementalSolver * This); -int readIntSolver(IncrementalSolver * This); -void readSolver(IncrementalSolver * This, void * buffer, ssize_t size); +IncrementalSolver *allocIncrementalSolver(); +void deleteIncrementalSolver(IncrementalSolver *This); +void addClauseLiteral(IncrementalSolver *This, int literal); +void addArrayClauseLiteral(IncrementalSolver *This, uint numliterals, int *literals); +void finishedClauses(IncrementalSolver *This); +void freeze(IncrementalSolver *This, int variable); +int solve(IncrementalSolver *This); +void startSolve(IncrementalSolver *This); +int getSolution(IncrementalSolver *This); +bool getValueSolver(IncrementalSolver *This, int variable); +void resetSolver(IncrementalSolver *This); +void createSolver(IncrementalSolver *This); +void killSolver(IncrementalSolver *This); +void flushBufferSolver(IncrementalSolver *This); +int readIntSolver(IncrementalSolver *This); +void readSolver(IncrementalSolver *This, void *buffer, ssize_t size); #endif diff --git a/src/Backend/orderpair.c b/src/Backend/orderpair.c index 4db56ca..9501af5 100644 --- a/src/Backend/orderpair.c +++ b/src/Backend/orderpair.c @@ -1,14 +1,14 @@ #include "orderpair.h" -OrderPair* allocOrderPair(uint64_t first, uint64_t second, Edge constraint){ - OrderPair* pair = (OrderPair*) ourmalloc(sizeof(OrderPair)); +OrderPair *allocOrderPair(uint64_t first, uint64_t second, Edge constraint) { + OrderPair *pair = (OrderPair *) ourmalloc(sizeof(OrderPair)); pair->first = first; pair->second = second; pair->constraint = constraint; return pair; } -void deleteOrderPair(OrderPair* pair){ +void deleteOrderPair(OrderPair *pair) { ourfree(pair); } diff --git a/src/Backend/orderpair.h b/src/Backend/orderpair.h index 05c8ffa..57b96b4 100644 --- a/src/Backend/orderpair.h +++ b/src/Backend/orderpair.h @@ -1,4 +1,4 @@ -/* +/* * File: orderpair.h * Author: hamed * @@ -12,14 +12,14 @@ #include "mymemory.h" #include "constraint.h" -struct OrderPair{ +struct OrderPair { uint64_t first; uint64_t second; Edge constraint; -}; +}; -OrderPair* allocOrderPair(uint64_t first, uint64_t second, Edge constraint); -void deleteOrderPair(OrderPair* pair); +OrderPair *allocOrderPair(uint64_t first, uint64_t second, Edge constraint); +void deleteOrderPair(OrderPair *pair); -#endif /* ORDERPAIR_H */ +#endif/* ORDERPAIR_H */ diff --git a/src/Backend/satelemencoder.c b/src/Backend/satelemencoder.c index ca71c6e..5beae4f 100644 --- a/src/Backend/satelemencoder.c +++ b/src/Backend/satelemencoder.c @@ -5,74 +5,74 @@ #include "element.h" #include "set.h" -Edge getElementValueConstraint(SATEncoder* This, Element* elem, uint64_t value) { - switch(getElementEncoding(elem)->type){ - case ONEHOT: - return getElementValueOneHotConstraint(This, elem, value); - case UNARY: - return getElementValueUnaryConstraint(This, elem, value); - case BINARYINDEX: - return getElementValueBinaryIndexConstraint(This, elem, value); - case ONEHOTBINARY: - ASSERT(0); - break; - case BINARYVAL: - return getElementValueBinaryValueConstraint(This, elem, value); - break; - default: - ASSERT(0); - break; +Edge getElementValueConstraint(SATEncoder *This, Element *elem, uint64_t value) { + switch (getElementEncoding(elem)->type) { + case ONEHOT: + return getElementValueOneHotConstraint(This, elem, value); + case UNARY: + return getElementValueUnaryConstraint(This, elem, value); + case BINARYINDEX: + return getElementValueBinaryIndexConstraint(This, elem, value); + case ONEHOTBINARY: + ASSERT(0); + break; + case BINARYVAL: + return getElementValueBinaryValueConstraint(This, elem, value); + break; + default: + ASSERT(0); + break; } return E_BOGUS; } -Edge getElementValueBinaryIndexConstraint(SATEncoder * This, Element* elem, uint64_t value) { +Edge getElementValueBinaryIndexConstraint(SATEncoder *This, Element *elem, uint64_t value) { ASTNodeType type = GETELEMENTTYPE(elem); ASSERT(type == ELEMSET || type == ELEMFUNCRETURN || type == ELEMCONST); - ElementEncoding* elemEnc = getElementEncoding(elem); - for(uint i=0; iencArraySize; i++){ - if(isinUseElement(elemEnc, i) && elemEnc->encodingArray[i]==value) { - return (elemEnc->numVars == 0) ? E_True: generateBinaryConstraint(This->cnf, elemEnc->numVars, elemEnc->variables, i); + ElementEncoding *elemEnc = getElementEncoding(elem); + for (uint i = 0; i < elemEnc->encArraySize; i++) { + if (isinUseElement(elemEnc, i) && elemEnc->encodingArray[i] == value) { + return (elemEnc->numVars == 0) ? E_True : generateBinaryConstraint(This->cnf, elemEnc->numVars, elemEnc->variables, i); } } return E_False; } -Edge getElementValueOneHotConstraint(SATEncoder * This, Element* elem, uint64_t value) { +Edge getElementValueOneHotConstraint(SATEncoder *This, Element *elem, uint64_t value) { ASTNodeType type = GETELEMENTTYPE(elem); ASSERT(type == ELEMSET || type == ELEMFUNCRETURN || type == ELEMCONST); - ElementEncoding* elemEnc = getElementEncoding(elem); - for(uint i=0; iencArraySize; i++){ - if (isinUseElement(elemEnc, i) && elemEnc->encodingArray[i]==value) { - return (elemEnc->numVars == 0) ? E_True: elemEnc->variables[i]; + ElementEncoding *elemEnc = getElementEncoding(elem); + for (uint i = 0; i < elemEnc->encArraySize; i++) { + if (isinUseElement(elemEnc, i) && elemEnc->encodingArray[i] == value) { + return (elemEnc->numVars == 0) ? E_True : elemEnc->variables[i]; } } return E_False; } -Edge getElementValueUnaryConstraint(SATEncoder * This, Element* elem, uint64_t value) { +Edge getElementValueUnaryConstraint(SATEncoder *This, Element *elem, uint64_t value) { ASTNodeType type = GETELEMENTTYPE(elem); ASSERT(type == ELEMSET || type == ELEMFUNCRETURN || type == ELEMCONST); - ElementEncoding* elemEnc = getElementEncoding(elem); - for(uint i=0; iencArraySize; i++){ - if (isinUseElement(elemEnc, i) && elemEnc->encodingArray[i]==value) { - if(elemEnc->numVars == 0) + ElementEncoding *elemEnc = getElementEncoding(elem); + for (uint i = 0; i < elemEnc->encArraySize; i++) { + if (isinUseElement(elemEnc, i) && elemEnc->encodingArray[i] == value) { + if (elemEnc->numVars == 0) return E_True; - if (i==0) + if (i == 0) return constraintNegate(elemEnc->variables[0]); - else if ((i+1)==elemEnc->encArraySize) - return elemEnc->variables[i-1]; + else if ((i + 1) == elemEnc->encArraySize) + return elemEnc->variables[i - 1]; else - return constraintAND2(This->cnf, elemEnc->variables[i-1], constraintNegate(elemEnc->variables[i])); + return constraintAND2(This->cnf, elemEnc->variables[i - 1], constraintNegate(elemEnc->variables[i])); } } return E_False; } -Edge getElementValueBinaryValueConstraint(SATEncoder * This, Element* element, uint64_t value){ +Edge getElementValueBinaryValueConstraint(SATEncoder *This, Element *element, uint64_t value) { ASTNodeType type = GETELEMENTTYPE(element); ASSERT(type == ELEMSET || type == ELEMFUNCRETURN); - ElementEncoding* elemEnc = getElementEncoding(element); + ElementEncoding *elemEnc = getElementEncoding(element); if (elemEnc->low <= elemEnc->high) { if (value < elemEnc->low || value > elemEnc->high) return E_False; @@ -81,33 +81,33 @@ Edge getElementValueBinaryValueConstraint(SATEncoder * This, Element* element, u if (value < elemEnc->low && value > elemEnc->high) return E_False; } - - uint64_t valueminusoffset=value-elemEnc->offset; + + uint64_t valueminusoffset = value - elemEnc->offset; return generateBinaryConstraint(This->cnf, elemEnc->numVars, elemEnc->variables, valueminusoffset); } -void allocElementConstraintVariables(ElementEncoding* This, uint numVars) { +void allocElementConstraintVariables(ElementEncoding *This, uint numVars) { This->numVars = numVars; This->variables = ourmalloc(sizeof(Edge) * numVars); } -void generateBinaryValueEncodingVars(SATEncoder* This, ElementEncoding* encoding){ - ASSERT(encoding->type==BINARYVAL); +void generateBinaryValueEncodingVars(SATEncoder *This, ElementEncoding *encoding) { + ASSERT(encoding->type == BINARYVAL); allocElementConstraintVariables(encoding, encoding->numBits); getArrayNewVarsSATEncoder(This, encoding->numVars, encoding->variables); } void generateBinaryIndexEncodingVars(SATEncoder *This, ElementEncoding *encoding) { - ASSERT(encoding->type==BINARYINDEX); - allocElementConstraintVariables(encoding, NUMBITS(encoding->encArraySize-1)); + ASSERT(encoding->type == BINARYINDEX); + allocElementConstraintVariables(encoding, NUMBITS(encoding->encArraySize - 1)); getArrayNewVarsSATEncoder(This, encoding->numVars, encoding->variables); } void generateOneHotEncodingVars(SATEncoder *This, ElementEncoding *encoding) { allocElementConstraintVariables(encoding, encoding->encArraySize); - getArrayNewVarsSATEncoder(This, encoding->numVars, encoding->variables); - for(uint i=0;inumVars;i++) { - for(uint j=i+1;jnumVars;j++) { + getArrayNewVarsSATEncoder(This, encoding->numVars, encoding->variables); + for (uint i = 0; i < encoding->numVars; i++) { + for (uint j = i + 1; j < encoding->numVars; j++) { addConstraintCNF(This->cnf, constraintNegate(constraintAND2(This->cnf, encoding->variables[i], encoding->variables[j]))); } } @@ -115,20 +115,20 @@ void generateOneHotEncodingVars(SATEncoder *This, ElementEncoding *encoding) { } void generateUnaryEncodingVars(SATEncoder *This, ElementEncoding *encoding) { - allocElementConstraintVariables(encoding, encoding->encArraySize-1); - getArrayNewVarsSATEncoder(This, encoding->numVars, encoding->variables); + allocElementConstraintVariables(encoding, encoding->encArraySize - 1); + getArrayNewVarsSATEncoder(This, encoding->numVars, encoding->variables); //Add unary constraint - for(uint i=1;inumVars;i++) { - addConstraintCNF(This->cnf, constraintOR2(This->cnf, encoding->variables[i-1], constraintNegate(encoding->variables[i]))); + for (uint i = 1; i < encoding->numVars; i++) { + addConstraintCNF(This->cnf, constraintOR2(This->cnf, encoding->variables[i - 1], constraintNegate(encoding->variables[i]))); } } -void generateElementEncoding(SATEncoder* This, Element * element) { - ElementEncoding* encoding = getElementEncoding(element); - ASSERT(encoding->type!=ELEM_UNASSIGNED); - if(encoding->variables!=NULL) +void generateElementEncoding(SATEncoder *This, Element *element) { + ElementEncoding *encoding = getElementEncoding(element); + ASSERT(encoding->type != ELEM_UNASSIGNED); + if (encoding->variables != NULL) return; - switch(encoding->type) { + switch (encoding->type) { case ONEHOT: generateOneHotEncodingVars(This, encoding); return; diff --git a/src/Backend/satelemencoder.h b/src/Backend/satelemencoder.h index 7ba81cd..d75f2f8 100644 --- a/src/Backend/satelemencoder.h +++ b/src/Backend/satelemencoder.h @@ -1,15 +1,15 @@ #ifndef SATELEMENTENCODER_H #define SATELEMENTENCODER_H -Edge getElementValueOneHotConstraint(SATEncoder * This, Element* elem, uint64_t value); -Edge getElementValueUnaryConstraint(SATEncoder * This, Element* elem, uint64_t value); -Edge getElementValueBinaryIndexConstraint(SATEncoder * This, Element* element, uint64_t value); -Edge getElementValueBinaryValueConstraint(SATEncoder * This, Element* element, uint64_t value); -Edge getElementValueConstraint(SATEncoder* encoder, Element* This, uint64_t value); -void allocElementConstraintVariables(ElementEncoding* This, uint numVars); +Edge getElementValueOneHotConstraint(SATEncoder *This, Element *elem, uint64_t value); +Edge getElementValueUnaryConstraint(SATEncoder *This, Element *elem, uint64_t value); +Edge getElementValueBinaryIndexConstraint(SATEncoder *This, Element *element, uint64_t value); +Edge getElementValueBinaryValueConstraint(SATEncoder *This, Element *element, uint64_t value); +Edge getElementValueConstraint(SATEncoder *encoder, Element *This, uint64_t value); +void allocElementConstraintVariables(ElementEncoding *This, uint numVars); void generateOneHotEncodingVars(SATEncoder *This, ElementEncoding *encoding); void generateUnaryEncodingVars(SATEncoder *This, ElementEncoding *encoding); -void generateBinaryIndexEncodingVars(SATEncoder* This, ElementEncoding* encoding); -void generateBinaryValueEncodingVars(SATEncoder* This, ElementEncoding* encoding); -void generateElementEncoding(SATEncoder* This, Element* element); +void generateBinaryIndexEncodingVars(SATEncoder *This, ElementEncoding *encoding); +void generateBinaryValueEncodingVars(SATEncoder *This, ElementEncoding *encoding); +void generateElementEncoding(SATEncoder *This, Element *element); #endif diff --git a/src/Backend/satencoder.c b/src/Backend/satencoder.c index 885aab8..9717886 100644 --- a/src/Backend/satencoder.c +++ b/src/Backend/satencoder.c @@ -15,10 +15,10 @@ //TODO: Should handle sharing of AST Nodes without recoding them a second time -SATEncoder * allocSATEncoder() { - SATEncoder *This=ourmalloc(sizeof (SATEncoder)); - This->varcount=1; - This->cnf=createCNF(); +SATEncoder *allocSATEncoder() { + SATEncoder *This = ourmalloc(sizeof (SATEncoder)); + This->varcount = 1; + This->cnf = createCNF(); return This; } @@ -27,20 +27,20 @@ void deleteSATEncoder(SATEncoder *This) { ourfree(This); } -void encodeAllSATEncoder(CSolver *csolver, SATEncoder * This) { - VectorBoolean *constraints=csolver->constraints; - uint size=getSizeVectorBoolean(constraints); - for(uint i=0;iconstraints; + uint size = getSizeVectorBoolean(constraints); + for (uint i = 0; i < size; i++) { model_print("Encoding All ...\n\n"); - Boolean *constraint=getVectorBoolean(constraints, i); - Edge c= encodeConstraintSATEncoder(This, constraint); + Boolean *constraint = getVectorBoolean(constraints, i); + Edge c = encodeConstraintSATEncoder(This, constraint); model_print("Returned Constraint in EncodingAll:\n"); addConstraintCNF(This->cnf, c); } } Edge encodeConstraintSATEncoder(SATEncoder *This, Boolean *constraint) { - switch(GETBOOLEANTYPE(constraint)) { + switch (GETBOOLEANTYPE(constraint)) { case ORDERCONST: return encodeOrderSATEncoder(This, (BooleanOrder *) constraint); case BOOLEANVAR: @@ -55,40 +55,40 @@ Edge encodeConstraintSATEncoder(SATEncoder *This, Boolean *constraint) { } } -void getArrayNewVarsSATEncoder(SATEncoder* encoder, uint num, Edge * carray) { - for(uint i=0;icnf); } -Edge encodeVarSATEncoder(SATEncoder *This, BooleanVar * constraint) { +Edge encodeVarSATEncoder(SATEncoder *This, BooleanVar *constraint) { if (edgeIsNull(constraint->var)) { - constraint->var=getNewVarSATEncoder(This); + constraint->var = getNewVarSATEncoder(This); } return constraint->var; } -Edge encodeLogicSATEncoder(SATEncoder *This, BooleanLogic * constraint) { +Edge encodeLogicSATEncoder(SATEncoder *This, BooleanLogic *constraint) { Edge array[getSizeArrayBoolean(&constraint->inputs)]; - for(uint i=0;iinputs);i++) - array[i]=encodeConstraintSATEncoder(This, getArrayBoolean(&constraint->inputs, i)); + for (uint i = 0; i < getSizeArrayBoolean(&constraint->inputs); i++) + array[i] = encodeConstraintSATEncoder(This, getArrayBoolean(&constraint->inputs, i)); - switch(constraint->op) { + switch (constraint->op) { case L_AND: return constraintAND(This->cnf, getSizeArrayBoolean(&constraint->inputs), array); case L_OR: return constraintOR(This->cnf, getSizeArrayBoolean(&constraint->inputs), array); case L_NOT: - ASSERT( getSizeArrayBoolean(&constraint->inputs)==1); + ASSERT( getSizeArrayBoolean(&constraint->inputs) == 1); return constraintNegate(array[0]); case L_XOR: - ASSERT( getSizeArrayBoolean(&constraint->inputs)==2); + ASSERT( getSizeArrayBoolean(&constraint->inputs) == 2); return constraintXOR(This->cnf, array[0], array[1]); case L_IMPLIES: - ASSERT( getSizeArrayBoolean( &constraint->inputs)==2); + ASSERT( getSizeArrayBoolean( &constraint->inputs) == 2); return constraintIMPLIES(This->cnf, array[0], array[1]); default: model_print("Unhandled case in encodeLogicSATEncoder %u", constraint->op); @@ -96,70 +96,70 @@ Edge encodeLogicSATEncoder(SATEncoder *This, BooleanLogic * constraint) { } } -Edge encodePredicateSATEncoder(SATEncoder * This, BooleanPredicate * constraint) { - switch(GETPREDICATETYPE(constraint->predicate) ){ - case TABLEPRED: - return encodeTablePredicateSATEncoder(This, constraint); - case OPERATORPRED: - return encodeOperatorPredicateSATEncoder(This, constraint); - default: - ASSERT(0); +Edge encodePredicateSATEncoder(SATEncoder *This, BooleanPredicate *constraint) { + switch (GETPREDICATETYPE(constraint->predicate) ) { + case TABLEPRED: + return encodeTablePredicateSATEncoder(This, constraint); + case OPERATORPRED: + return encodeOperatorPredicateSATEncoder(This, constraint); + default: + ASSERT(0); } return E_BOGUS; } -Edge encodeTablePredicateSATEncoder(SATEncoder * This, BooleanPredicate * constraint){ - switch(constraint->encoding.type){ - case ENUMERATEIMPLICATIONS: - case ENUMERATEIMPLICATIONSNEGATE: - return encodeEnumTablePredicateSATEncoder(This, constraint); - case CIRCUIT: - ASSERT(0); - break; - default: - ASSERT(0); +Edge encodeTablePredicateSATEncoder(SATEncoder *This, BooleanPredicate *constraint) { + switch (constraint->encoding.type) { + case ENUMERATEIMPLICATIONS: + case ENUMERATEIMPLICATIONSNEGATE: + return encodeEnumTablePredicateSATEncoder(This, constraint); + case CIRCUIT: + ASSERT(0); + break; + default: + ASSERT(0); } return E_BOGUS; } -void encodeElementSATEncoder(SATEncoder* encoder, Element *This){ - switch( GETELEMENTTYPE(This) ){ - case ELEMFUNCRETURN: - generateElementEncoding(encoder, This); - encodeElementFunctionSATEncoder(encoder, (ElementFunction*) This); - break; - case ELEMSET: - generateElementEncoding(encoder, This); - return; - case ELEMCONST: - return; - default: - ASSERT(0); +void encodeElementSATEncoder(SATEncoder *encoder, Element *This) { + switch ( GETELEMENTTYPE(This) ) { + case ELEMFUNCRETURN: + generateElementEncoding(encoder, This); + encodeElementFunctionSATEncoder(encoder, (ElementFunction *) This); + break; + case ELEMSET: + generateElementEncoding(encoder, This); + return; + case ELEMCONST: + return; + default: + ASSERT(0); } } -void encodeElementFunctionSATEncoder(SATEncoder* encoder, ElementFunction *This){ - switch(GETFUNCTIONTYPE(This->function)){ - case TABLEFUNC: - encodeTableElementFunctionSATEncoder(encoder, This); - break; - case OPERATORFUNC: - encodeOperatorElementFunctionSATEncoder(encoder, This); - break; - default: - ASSERT(0); +void encodeElementFunctionSATEncoder(SATEncoder *encoder, ElementFunction *This) { + switch (GETFUNCTIONTYPE(This->function)) { + case TABLEFUNC: + encodeTableElementFunctionSATEncoder(encoder, This); + break; + case OPERATORFUNC: + encodeOperatorElementFunctionSATEncoder(encoder, This); + break; + default: + ASSERT(0); } } -void encodeTableElementFunctionSATEncoder(SATEncoder* encoder, ElementFunction* This){ - switch(getElementFunctionEncoding(This)->type){ - case ENUMERATEIMPLICATIONS: - encodeEnumTableElemFunctionSATEncoder(encoder, This); - break; - case CIRCUIT: - ASSERT(0); - break; - default: - ASSERT(0); +void encodeTableElementFunctionSATEncoder(SATEncoder *encoder, ElementFunction *This) { + switch (getElementFunctionEncoding(This)->type) { + case ENUMERATEIMPLICATIONS: + encodeEnumTableElemFunctionSATEncoder(encoder, This); + break; + case CIRCUIT: + ASSERT(0); + break; + default: + ASSERT(0); } } diff --git a/src/Backend/satencoder.h b/src/Backend/satencoder.h index aceb271..8db6239 100644 --- a/src/Backend/satencoder.h +++ b/src/Backend/satencoder.h @@ -8,28 +8,28 @@ struct SATEncoder { uint varcount; - CNF * cnf; + CNF *cnf; }; #include "satelemencoder.h" #include "satorderencoder.h" #include "satfunctableencoder.h" -SATEncoder * allocSATEncoder(); +SATEncoder *allocSATEncoder(); void deleteSATEncoder(SATEncoder *This); void encodeAllSATEncoder(CSolver *csolver, SATEncoder *This); Edge getNewVarSATEncoder(SATEncoder *This); -void getArrayNewVarsSATEncoder(SATEncoder* encoder, uint num, Edge*carray); +void getArrayNewVarsSATEncoder(SATEncoder *encoder, uint num, Edge *carray); Edge encodeConstraintSATEncoder(SATEncoder *This, Boolean *constraint); -Edge encodeVarSATEncoder(SATEncoder *This, BooleanVar * constraint); -Edge encodeLogicSATEncoder(SATEncoder *This, BooleanLogic * constraint); -Edge encodePredicateSATEncoder(SATEncoder * This, BooleanPredicate * constraint); -Edge encodeTablePredicateSATEncoder(SATEncoder * This, BooleanPredicate * constraint); +Edge encodeVarSATEncoder(SATEncoder *This, BooleanVar *constraint); +Edge encodeLogicSATEncoder(SATEncoder *This, BooleanLogic *constraint); +Edge encodePredicateSATEncoder(SATEncoder *This, BooleanPredicate *constraint); +Edge encodeTablePredicateSATEncoder(SATEncoder *This, BooleanPredicate *constraint); -void encodeElementSATEncoder(SATEncoder* encoder, Element *This); -void encodeElementFunctionSATEncoder(SATEncoder* encoder, ElementFunction *This); -void encodeTableElementFunctionSATEncoder(SATEncoder* encoder, ElementFunction* This); +void encodeElementSATEncoder(SATEncoder *encoder, Element *This); +void encodeElementFunctionSATEncoder(SATEncoder *encoder, ElementFunction *This); +void encodeTableElementFunctionSATEncoder(SATEncoder *encoder, ElementFunction *This); #endif diff --git a/src/Backend/satfuncopencoder.c b/src/Backend/satfuncopencoder.c index 1df9c61..b8a814d 100644 --- a/src/Backend/satfuncopencoder.c +++ b/src/Backend/satfuncopencoder.c @@ -11,121 +11,121 @@ #include "common.h" #include "satfuncopencoder.h" -Edge encodeOperatorPredicateSATEncoder(SATEncoder * This, BooleanPredicate * constraint) { - switch(constraint->encoding.type){ - case ENUMERATEIMPLICATIONS: - return encodeEnumOperatorPredicateSATEncoder(This, constraint); - case CIRCUIT: - return encodeCircuitOperatorPredicateEncoder(This, constraint); - default: - ASSERT(0); +Edge encodeOperatorPredicateSATEncoder(SATEncoder *This, BooleanPredicate *constraint) { + switch (constraint->encoding.type) { + case ENUMERATEIMPLICATIONS: + return encodeEnumOperatorPredicateSATEncoder(This, constraint); + case CIRCUIT: + return encodeCircuitOperatorPredicateEncoder(This, constraint); + default: + ASSERT(0); } exit(-1); } -Edge encodeEnumOperatorPredicateSATEncoder(SATEncoder * This, BooleanPredicate * constraint) { - PredicateOperator* predicate = (PredicateOperator*)constraint->predicate; - uint numDomains=getSizeArraySet(&predicate->domains); +Edge encodeEnumOperatorPredicateSATEncoder(SATEncoder *This, BooleanPredicate *constraint) { + PredicateOperator *predicate = (PredicateOperator *)constraint->predicate; + uint numDomains = getSizeArraySet(&predicate->domains); FunctionEncodingType encType = constraint->encoding.type; bool generateNegation = encType == ENUMERATEIMPLICATIONSNEGATE; /* Call base encoders for children */ - for(uint i=0;iinputs, i); encodeElementSATEncoder(This, elem); } - VectorEdge * clauses=allocDefVectorEdge(); // Setup array of clauses - - uint indices[numDomains]; //setup indices - bzero(indices, sizeof(uint)*numDomains); - - uint64_t vals[numDomains]; //setup value array - for(uint i=0;idomains, i); - vals[i]=getSetElement(set, indices[i]); + VectorEdge *clauses = allocDefVectorEdge(); // Setup array of clauses + + uint indices[numDomains]; //setup indices + bzero(indices, sizeof(uint) * numDomains); + + uint64_t vals[numDomains];//setup value array + for (uint i = 0; i < numDomains; i++) { + Set *set = getArraySet(&predicate->domains, i); + vals[i] = getSetElement(set, indices[i]); } - - bool notfinished=true; - while(notfinished) { + + bool notfinished = true; + while (notfinished) { Edge carray[numDomains]; if (evalPredicateOperator(predicate, vals) ^ generateNegation) { //Include this in the set of terms - for(uint i=0;iinputs, i); + for (uint i = 0; i < numDomains; i++) { + Element *elem = getArrayElement(&constraint->inputs, i); carray[i] = getElementValueConstraint(This, elem, vals[i]); } - Edge term=constraintAND(This->cnf, numDomains, carray); + Edge term = constraintAND(This->cnf, numDomains, carray); pushVectorEdge(clauses, term); } - - notfinished=false; - for(uint i=0;idomains, i); + + notfinished = false; + for (uint i = 0; i < numDomains; i++) { + uint index = ++indices[i]; + Set *set = getArraySet(&predicate->domains, i); if (index < getSetSize(set)) { - vals[i]=getSetElement(set, index); - notfinished=true; + vals[i] = getSetElement(set, index); + notfinished = true; break; } else { - indices[i]=0; - vals[i]=getSetElement(set, 0); + indices[i] = 0; + vals[i] = getSetElement(set, 0); } } } - if(getSizeVectorEdge(clauses) == 0) { + if (getSizeVectorEdge(clauses) == 0) { deleteVectorEdge(clauses); return E_False; } - Edge cor=constraintOR(This->cnf, getSizeVectorEdge(clauses), exposeArrayEdge(clauses)); + Edge cor = constraintOR(This->cnf, getSizeVectorEdge(clauses), exposeArrayEdge(clauses)); deleteVectorEdge(clauses); return generateNegation ? constraintNegate(cor) : cor; } -void encodeOperatorElementFunctionSATEncoder(SATEncoder* This, ElementFunction* func) { +void encodeOperatorElementFunctionSATEncoder(SATEncoder *This, ElementFunction *func) { #ifdef TRACE_DEBUG model_print("Operator Function ...\n"); #endif - FunctionOperator * function = (FunctionOperator *) func->function; - uint numDomains=getSizeArrayElement(&func->inputs); + FunctionOperator *function = (FunctionOperator *) func->function; + uint numDomains = getSizeArrayElement(&func->inputs); /* Call base encoders for children */ - for(uint i=0;iinputs, i); encodeElementSATEncoder(This, elem); } - VectorEdge * clauses=allocDefVectorEdge(); // Setup array of clauses - - uint indices[numDomains]; //setup indices - bzero(indices, sizeof(uint)*numDomains); - - uint64_t vals[numDomains]; //setup value array - for(uint i=0;iinputs, i)); - vals[i]=getSetElement(set, indices[i]); + VectorEdge *clauses = allocDefVectorEdge(); // Setup array of clauses + + uint indices[numDomains]; //setup indices + bzero(indices, sizeof(uint) * numDomains); + + uint64_t vals[numDomains];//setup value array + for (uint i = 0; i < numDomains; i++) { + Set *set = getElementSet(getArrayElement(&func->inputs, i)); + vals[i] = getSetElement(set, indices[i]); } - Edge overFlowConstraint = ((BooleanVar*) func->overflowstatus)->var; - - bool notfinished=true; - while(notfinished) { - Edge carray[numDomains+1]; + Edge overFlowConstraint = ((BooleanVar *) func->overflowstatus)->var; + + bool notfinished = true; + while (notfinished) { + Edge carray[numDomains + 1]; - uint64_t result=applyFunctionOperator(function, numDomains, vals); - bool isInRange = isInRangeFunction((FunctionOperator*)func->function, result); + uint64_t result = applyFunctionOperator(function, numDomains, vals); + bool isInRange = isInRangeFunction((FunctionOperator *)func->function, result); bool needClause = isInRange; if (function->overflowbehavior == OVERFLOWSETSFLAG || function->overflowbehavior == FLAGIFFOVERFLOW) { - needClause=true; + needClause = true; } - + if (needClause) { //Include this in the set of terms - for(uint i=0;iinputs, i); + for (uint i = 0; i < numDomains; i++) { + Element *elem = getArrayElement(&func->inputs, i); carray[i] = getElementValueConstraint(This, elem, vals[i]); } if (isInRange) { @@ -133,30 +133,30 @@ void encodeOperatorElementFunctionSATEncoder(SATEncoder* This, ElementFunction* } Edge clause; - switch(function->overflowbehavior) { + switch (function->overflowbehavior) { case IGNORE: case NOOVERFLOW: case WRAPAROUND: { - clause=constraintIMPLIES(This->cnf,constraintAND(This->cnf, numDomains, carray), carray[numDomains]); + clause = constraintIMPLIES(This->cnf,constraintAND(This->cnf, numDomains, carray), carray[numDomains]); break; } case FLAGFORCESOVERFLOW: { - clause=constraintIMPLIES(This->cnf,constraintAND(This->cnf, numDomains, carray), constraintAND2(This->cnf, carray[numDomains], constraintNegate(overFlowConstraint))); + clause = constraintIMPLIES(This->cnf,constraintAND(This->cnf, numDomains, carray), constraintAND2(This->cnf, carray[numDomains], constraintNegate(overFlowConstraint))); break; } case OVERFLOWSETSFLAG: { if (isInRange) { - clause=constraintIMPLIES(This->cnf,constraintAND(This->cnf, numDomains, carray), carray[numDomains]); + clause = constraintIMPLIES(This->cnf,constraintAND(This->cnf, numDomains, carray), carray[numDomains]); } else { - clause=constraintIMPLIES(This->cnf,constraintAND(This->cnf, numDomains, carray), overFlowConstraint); + clause = constraintIMPLIES(This->cnf,constraintAND(This->cnf, numDomains, carray), overFlowConstraint); } break; } case FLAGIFFOVERFLOW: { if (isInRange) { - clause=constraintIMPLIES(This->cnf,constraintAND(This->cnf, numDomains, carray), constraintAND2(This->cnf, carray[numDomains], constraintNegate(overFlowConstraint))); + clause = constraintIMPLIES(This->cnf,constraintAND(This->cnf, numDomains, carray), constraintAND2(This->cnf, carray[numDomains], constraintNegate(overFlowConstraint))); } else { - clause=constraintIMPLIES(This->cnf,constraintAND(This->cnf, numDomains, carray), overFlowConstraint); + clause = constraintIMPLIES(This->cnf,constraintAND(This->cnf, numDomains, carray), overFlowConstraint); } break; } @@ -170,35 +170,35 @@ void encodeOperatorElementFunctionSATEncoder(SATEncoder* This, ElementFunction* #endif pushVectorEdge(clauses, clause); } - - notfinished=false; - for(uint i=0;iinputs, i)); + + notfinished = false; + for (uint i = 0; i < numDomains; i++) { + uint index = ++indices[i]; + Set *set = getElementSet(getArrayElement(&func->inputs, i)); if (index < getSetSize(set)) { - vals[i]=getSetElement(set, index); - notfinished=true; + vals[i] = getSetElement(set, index); + notfinished = true; break; } else { - indices[i]=0; - vals[i]=getSetElement(set, 0); + indices[i] = 0; + vals[i] = getSetElement(set, 0); } } } - if(getSizeVectorEdge(clauses) == 0){ + if (getSizeVectorEdge(clauses) == 0) { deleteVectorEdge(clauses); return; } - Edge cor=constraintAND(This->cnf, getSizeVectorEdge(clauses), exposeArrayEdge(clauses)); + Edge cor = constraintAND(This->cnf, getSizeVectorEdge(clauses), exposeArrayEdge(clauses)); addConstraintCNF(This->cnf, cor); deleteVectorEdge(clauses); } -Edge encodeCircuitOperatorPredicateEncoder(SATEncoder *This, BooleanPredicate * constraint) { - PredicateOperator * predicate = (PredicateOperator*) constraint->predicate; - - switch(predicate->op) { +Edge encodeCircuitOperatorPredicateEncoder(SATEncoder *This, BooleanPredicate *constraint) { + PredicateOperator *predicate = (PredicateOperator *) constraint->predicate; + + switch (predicate->op) { case EQUALS: { return encodeCircuitEquals(This, constraint); } @@ -208,21 +208,21 @@ Edge encodeCircuitOperatorPredicateEncoder(SATEncoder *This, BooleanPredicate * exit(-1); } -Edge encodeCircuitEquals(SATEncoder * This, BooleanPredicate * constraint) { - PredicateOperator * predicate = (PredicateOperator*) constraint->predicate; +Edge encodeCircuitEquals(SATEncoder *This, BooleanPredicate *constraint) { + PredicateOperator *predicate = (PredicateOperator *) constraint->predicate; ASSERT(getSizeArraySet(&predicate->domains) == 2); Element *elem0 = getArrayElement( &constraint->inputs, 0); encodeElementSATEncoder(This, elem0); Element *elem1 = getArrayElement( &constraint->inputs, 1); encodeElementSATEncoder(This, elem1); - ElementEncoding *ee0=getElementEncoding(elem0); - ElementEncoding *ee1=getElementEncoding(elem1); - ASSERT(ee0->numVars==ee1->numVars); - uint numVars=ee0->numVars; + ElementEncoding *ee0 = getElementEncoding(elem0); + ElementEncoding *ee1 = getElementEncoding(elem1); + ASSERT(ee0->numVars == ee1->numVars); + uint numVars = ee0->numVars; ASSERT(numVars != 0); Edge carray[numVars]; - for (uint i=0; icnf, ee0->variables[i], ee1->variables[i]); + for (uint i = 0; i < numVars; i++) { + carray[i] = constraintIFF(This->cnf, ee0->variables[i], ee1->variables[i]); } return constraintAND(This->cnf, numVars, carray); } diff --git a/src/Backend/satfuncopencoder.h b/src/Backend/satfuncopencoder.h index 0bfca3d..8b39194 100644 --- a/src/Backend/satfuncopencoder.h +++ b/src/Backend/satfuncopencoder.h @@ -1,10 +1,10 @@ #ifndef SATFUNCOPENCODER_H #define SATFUNCOPENCODER_H -Edge encodeOperatorPredicateSATEncoder(SATEncoder * This, BooleanPredicate * constraint); -Edge encodeEnumOperatorPredicateSATEncoder(SATEncoder * This, BooleanPredicate * constraint); -void encodeOperatorElementFunctionSATEncoder(SATEncoder* encoder,ElementFunction* This); -Edge encodeCircuitOperatorPredicateEncoder(SATEncoder *This, BooleanPredicate * constraint); -Edge encodeCircuitEquals(SATEncoder * This, BooleanPredicate * constraint); +Edge encodeOperatorPredicateSATEncoder(SATEncoder *This, BooleanPredicate *constraint); +Edge encodeEnumOperatorPredicateSATEncoder(SATEncoder *This, BooleanPredicate *constraint); +void encodeOperatorElementFunctionSATEncoder(SATEncoder *encoder,ElementFunction *This); +Edge encodeCircuitOperatorPredicateEncoder(SATEncoder *This, BooleanPredicate *constraint); +Edge encodeCircuitEquals(SATEncoder *This, BooleanPredicate *constraint); #endif diff --git a/src/Backend/satfunctableencoder.c b/src/Backend/satfunctableencoder.c index 7e81dfd..d37e6dc 100644 --- a/src/Backend/satfunctableencoder.c +++ b/src/Backend/satfunctableencoder.c @@ -10,135 +10,135 @@ #include "element.h" #include "common.h" -Edge encodeEnumEntriesTablePredicateSATEncoder(SATEncoder * This, BooleanPredicate * constraint){ +Edge encodeEnumEntriesTablePredicateSATEncoder(SATEncoder *This, BooleanPredicate *constraint) { ASSERT(GETPREDICATETYPE(constraint->predicate) == TABLEPRED); - UndefinedBehavior undefStatus = ((PredicateTable*)constraint->predicate)->undefinedbehavior; + UndefinedBehavior undefStatus = ((PredicateTable *)constraint->predicate)->undefinedbehavior; ASSERT(undefStatus == IGNOREBEHAVIOR || undefStatus == FLAGFORCEUNDEFINED); - Table* table = ((PredicateTable*)constraint->predicate)->table; + Table *table = ((PredicateTable *)constraint->predicate)->table; FunctionEncodingType encType = constraint->encoding.type; - ArrayElement* inputs = &constraint->inputs; - uint inputNum =getSizeArrayElement(inputs); + ArrayElement *inputs = &constraint->inputs; + uint inputNum = getSizeArrayElement(inputs); uint size = getSizeHashSetTableEntry(table->entries); bool generateNegation = encType == ENUMERATEIMPLICATIONSNEGATE; Edge constraints[size]; Edge undefConst = encodeConstraintSATEncoder(This, constraint->undefStatus); printCNF(undefConst); model_print("**\n"); - HSIteratorTableEntry* iterator = iteratorTableEntry(table->entries); - uint i=0; - while(hasNextTableEntry(iterator)){ - TableEntry* entry = nextTableEntry(iterator); - if(generateNegation == entry->output && undefStatus == IGNOREBEHAVIOR) { + HSIteratorTableEntry *iterator = iteratorTableEntry(table->entries); + uint i = 0; + while (hasNextTableEntry(iterator)) { + TableEntry *entry = nextTableEntry(iterator); + if (generateNegation == entry->output && undefStatus == IGNOREBEHAVIOR) { //Skip the irrelevant entries continue; } Edge carray[inputNum]; - for(uint j=0; jinputs[j]); printCNF(carray[j]); model_print("\n"); } Edge row; - switch(undefStatus){ - case IGNOREBEHAVIOR: - row=constraintAND(This->cnf, inputNum, carray); - break; - case FLAGFORCEUNDEFINED:{ - addConstraintCNF(This->cnf, constraintIMPLIES(This->cnf,constraintAND(This->cnf, inputNum, carray), constraintNegate(undefConst))); - if(generateNegation == entry->output){ - continue; - } - row=constraintAND(This->cnf, inputNum, carray); - break; + switch (undefStatus) { + case IGNOREBEHAVIOR: + row = constraintAND(This->cnf, inputNum, carray); + break; + case FLAGFORCEUNDEFINED: { + addConstraintCNF(This->cnf, constraintIMPLIES(This->cnf,constraintAND(This->cnf, inputNum, carray), constraintNegate(undefConst))); + if (generateNegation == entry->output) { + continue; } - default: - ASSERT(0); + row = constraintAND(This->cnf, inputNum, carray); + break; + } + default: + ASSERT(0); } constraints[i++] = row; printCNF(row); - + model_print("\n\n"); } deleteIterTableEntry(iterator); - ASSERT(i!=0); - Edge result= generateNegation?constraintNegate(constraintOR(This->cnf, i, constraints)) - :constraintOR(This->cnf, i, constraints); + ASSERT(i != 0); + Edge result = generateNegation ? constraintNegate(constraintOR(This->cnf, i, constraints)) + : constraintOR(This->cnf, i, constraints); printCNF(result); return result; } -Edge encodeEnumTablePredicateSATEncoder(SATEncoder * This, BooleanPredicate * constraint){ +Edge encodeEnumTablePredicateSATEncoder(SATEncoder *This, BooleanPredicate *constraint) { #ifdef TRACE_DEBUG model_print("Enumeration Table Predicate ...\n"); #endif ASSERT(GETPREDICATETYPE(constraint->predicate) == TABLEPRED); //First encode children - ArrayElement* inputs = &constraint->inputs; - uint inputNum =getSizeArrayElement(inputs); + ArrayElement *inputs = &constraint->inputs; + uint inputNum = getSizeArrayElement(inputs); //Encode all the inputs first ... - for(uint i=0; ipredicate; - switch(predicate->undefinedbehavior){ - case IGNOREBEHAVIOR: - case FLAGFORCEUNDEFINED: - return encodeEnumEntriesTablePredicateSATEncoder(This, constraint); - default: - break; + PredicateTable *predicate = (PredicateTable *)constraint->predicate; + switch (predicate->undefinedbehavior) { + case IGNOREBEHAVIOR: + case FLAGFORCEUNDEFINED: + return encodeEnumEntriesTablePredicateSATEncoder(This, constraint); + default: + break; } bool generateNegation = constraint->encoding.type == ENUMERATEIMPLICATIONSNEGATE; - uint numDomains=getSizeArraySet(&predicate->table->domains); + uint numDomains = getSizeArraySet(&predicate->table->domains); - VectorEdge * clauses=allocDefVectorEdge(); - - uint indices[numDomains]; //setup indices - bzero(indices, sizeof(uint)*numDomains); - - uint64_t vals[numDomains]; //setup value array - for(uint i=0;itable->domains, i); - vals[i]=getSetElement(set, indices[i]); + VectorEdge *clauses = allocDefVectorEdge(); + + uint indices[numDomains]; //setup indices + bzero(indices, sizeof(uint) * numDomains); + + uint64_t vals[numDomains];//setup value array + for (uint i = 0; i < numDomains; i++) { + Set *set = getArraySet(&predicate->table->domains, i); + vals[i] = getSetElement(set, indices[i]); } bool hasOverflow = false; Edge undefConstraint = encodeConstraintSATEncoder (This, constraint->undefStatus); printCNF(undefConstraint); - bool notfinished=true; - while(notfinished) { + bool notfinished = true; + while (notfinished) { Edge carray[numDomains]; - TableEntry* tableEntry = getTableEntryFromTable(predicate->table, vals, numDomains); - bool isInRange = tableEntry!=NULL; - if(!isInRange && !hasOverflow){ - hasOverflow=true; + TableEntry *tableEntry = getTableEntryFromTable(predicate->table, vals, numDomains); + bool isInRange = tableEntry != NULL; + if (!isInRange && !hasOverflow) { + hasOverflow = true; } Edge clause; - for(uint i=0;iinputs, i); - carray[i] = getElementValueConstraint(This, elem, vals[i]); + for (uint i = 0; i < numDomains; i++) { + Element *elem = getArrayElement(&constraint->inputs, i); + carray[i] = getElementValueConstraint(This, elem, vals[i]); } - - switch(predicate->undefinedbehavior) { - case UNDEFINEDSETSFLAG: - if(isInRange){ - clause=constraintAND(This->cnf, numDomains, carray); - }else{ - addConstraintCNF(This->cnf, constraintIMPLIES(This->cnf,constraintAND(This->cnf, numDomains, carray), undefConstraint) ); - } - break; - case FLAGIFFUNDEFINED: - if(isInRange){ - clause=constraintAND(This->cnf, numDomains, carray); - addConstraintCNF(This->cnf, constraintIMPLIES(This->cnf,constraintAND(This->cnf, numDomains, carray), constraintNegate(undefConstraint))); - }else{ - addConstraintCNF(This->cnf, constraintIMPLIES(This->cnf,constraintAND(This->cnf, numDomains, carray), undefConstraint) ); - } - break; - default: - ASSERT(0); + switch (predicate->undefinedbehavior) { + case UNDEFINEDSETSFLAG: + if (isInRange) { + clause = constraintAND(This->cnf, numDomains, carray); + } else { + addConstraintCNF(This->cnf, constraintIMPLIES(This->cnf,constraintAND(This->cnf, numDomains, carray), undefConstraint) ); + } + break; + case FLAGIFFUNDEFINED: + if (isInRange) { + clause = constraintAND(This->cnf, numDomains, carray); + addConstraintCNF(This->cnf, constraintIMPLIES(This->cnf,constraintAND(This->cnf, numDomains, carray), constraintNegate(undefConstraint))); + } else { + addConstraintCNF(This->cnf, constraintIMPLIES(This->cnf,constraintAND(This->cnf, numDomains, carray), undefConstraint) ); + } + break; + + default: + ASSERT(0); } - - if(isInRange){ + + if (isInRange) { #ifdef TRACE_DEBUG model_print("added clause in predicate table enumeration ...\n"); printCNF(clause); @@ -146,29 +146,29 @@ Edge encodeEnumTablePredicateSATEncoder(SATEncoder * This, BooleanPredicate * co #endif pushVectorEdge(clauses, clause); } - - notfinished=false; - for(uint i=0;itable->domains, i); + + notfinished = false; + for (uint i = 0; i < numDomains; i++) { + uint index = ++indices[i]; + Set *set = getArraySet(&predicate->table->domains, i); if (index < getSetSize(set)) { - vals[i]=getSetElement(set, index); - notfinished=true; + vals[i] = getSetElement(set, index); + notfinished = true; break; } else { - indices[i]=0; - vals[i]=getSetElement(set, 0); + indices[i] = 0; + vals[i] = getSetElement(set, 0); } } } Edge result = E_NULL; ASSERT(getSizeVectorEdge(clauses) != 0); - result=constraintOR(This->cnf, getSizeVectorEdge(clauses), exposeArrayEdge(clauses)); - if(hasOverflow){ + result = constraintOR(This->cnf, getSizeVectorEdge(clauses), exposeArrayEdge(clauses)); + if (hasOverflow) { result = constraintOR2(This->cnf, result, undefConstraint); } - if(generateNegation){ + if (generateNegation) { ASSERT(!hasOverflow); result = constraintNegate(result); } @@ -176,119 +176,119 @@ Edge encodeEnumTablePredicateSATEncoder(SATEncoder * This, BooleanPredicate * co return result; } -void encodeEnumEntriesTableElemFuncSATEncoder(SATEncoder* This, ElementFunction* func){ - UndefinedBehavior undefStatus = ((FunctionTable*) func->function)->undefBehavior; +void encodeEnumEntriesTableElemFuncSATEncoder(SATEncoder *This, ElementFunction *func) { + UndefinedBehavior undefStatus = ((FunctionTable *) func->function)->undefBehavior; ASSERT(undefStatus == IGNOREBEHAVIOR || undefStatus == FLAGFORCEUNDEFINED); - ArrayElement* elements= &func->inputs; - Table* table = ((FunctionTable*) (func->function))->table; + ArrayElement *elements = &func->inputs; + Table *table = ((FunctionTable *) (func->function))->table; uint size = getSizeHashSetTableEntry(table->entries); Edge constraints[size]; - HSIteratorTableEntry* iterator = iteratorTableEntry(table->entries); - uint i=0; - while(hasNextTableEntry(iterator)) { - TableEntry* entry = nextTableEntry(iterator); - ASSERT(entry!=NULL); + HSIteratorTableEntry *iterator = iteratorTableEntry(table->entries); + uint i = 0; + while (hasNextTableEntry(iterator)) { + TableEntry *entry = nextTableEntry(iterator); + ASSERT(entry != NULL); uint inputNum = getSizeArrayElement(elements); Edge carray[inputNum]; - for(uint j=0; jinputs[j]); } - Edge output = getElementValueConstraint(This, (Element*)func, entry->output); + Edge output = getElementValueConstraint(This, (Element *)func, entry->output); Edge row; - switch(undefStatus ){ - case IGNOREBEHAVIOR: { - row=constraintIMPLIES(This->cnf,constraintAND(This->cnf, inputNum, carray), output); - break; - } - case FLAGFORCEUNDEFINED: { - Edge undefConst = encodeConstraintSATEncoder(This, func->overflowstatus); - row=constraintIMPLIES(This->cnf,constraintAND(This->cnf, inputNum, carray), constraintAND2(This->cnf, output, constraintNegate(undefConst))); - break; - } - default: - ASSERT(0); - + switch (undefStatus ) { + case IGNOREBEHAVIOR: { + row = constraintIMPLIES(This->cnf,constraintAND(This->cnf, inputNum, carray), output); + break; + } + case FLAGFORCEUNDEFINED: { + Edge undefConst = encodeConstraintSATEncoder(This, func->overflowstatus); + row = constraintIMPLIES(This->cnf,constraintAND(This->cnf, inputNum, carray), constraintAND2(This->cnf, output, constraintNegate(undefConst))); + break; + } + default: + ASSERT(0); + } - constraints[i++]=row; + constraints[i++] = row; } deleteIterTableEntry(iterator); addConstraintCNF(This->cnf, constraintAND(This->cnf, size, constraints)); } -void encodeEnumTableElemFunctionSATEncoder(SATEncoder* This, ElementFunction* elemFunc){ +void encodeEnumTableElemFunctionSATEncoder(SATEncoder *This, ElementFunction *elemFunc) { #ifdef TRACE_DEBUG model_print("Enumeration Table functions ...\n"); #endif - ASSERT(GETFUNCTIONTYPE(elemFunc->function)==TABLEFUNC); + ASSERT(GETFUNCTIONTYPE(elemFunc->function) == TABLEFUNC); //First encode children - ArrayElement* elements= &elemFunc->inputs; - for(uint i=0; iinputs; + for (uint i = 0; i < getSizeArrayElement(elements); i++) { Element *elem = getArrayElement( elements, i); encodeElementSATEncoder(This, elem); } - FunctionTable* function =(FunctionTable*)elemFunc->function; - switch(function->undefBehavior){ - case IGNOREBEHAVIOR: - case FLAGFORCEUNDEFINED: - return encodeEnumEntriesTableElemFuncSATEncoder(This, elemFunc); - default: - break; + FunctionTable *function = (FunctionTable *)elemFunc->function; + switch (function->undefBehavior) { + case IGNOREBEHAVIOR: + case FLAGFORCEUNDEFINED: + return encodeEnumEntriesTableElemFuncSATEncoder(This, elemFunc); + default: + break; } - - uint numDomains=getSizeArraySet(&function->table->domains); - VectorEdge * clauses=allocDefVectorEdge(); // Setup array of clauses - - uint indices[numDomains]; //setup indices - bzero(indices, sizeof(uint)*numDomains); - - uint64_t vals[numDomains]; //setup value array - for(uint i=0;itable->domains, i); - vals[i]=getSetElement(set, indices[i]); + uint numDomains = getSizeArraySet(&function->table->domains); + + VectorEdge *clauses = allocDefVectorEdge(); // Setup array of clauses + + uint indices[numDomains]; //setup indices + bzero(indices, sizeof(uint) * numDomains); + + uint64_t vals[numDomains];//setup value array + for (uint i = 0; i < numDomains; i++) { + Set *set = getArraySet(&function->table->domains, i); + vals[i] = getSetElement(set, indices[i]); } Edge undefConstraint = encodeConstraintSATEncoder(This, elemFunc->overflowstatus); - bool notfinished=true; - while(notfinished) { - Edge carray[numDomains+1]; - TableEntry* tableEntry = getTableEntryFromTable(function->table, vals, numDomains); - bool isInRange = tableEntry!=NULL; + bool notfinished = true; + while (notfinished) { + Edge carray[numDomains + 1]; + TableEntry *tableEntry = getTableEntryFromTable(function->table, vals, numDomains); + bool isInRange = tableEntry != NULL; ASSERT(function->undefBehavior == UNDEFINEDSETSFLAG || function->undefBehavior == FLAGIFFUNDEFINED); - for(uint i=0;iinputs, i); + for (uint i = 0; i < numDomains; i++) { + Element *elem = getArrayElement(&elemFunc->inputs, i); carray[i] = getElementValueConstraint(This, elem, vals[i]); } if (isInRange) { - carray[numDomains] = getElementValueConstraint(This, (Element*)elemFunc, tableEntry->output); + carray[numDomains] = getElementValueConstraint(This, (Element *)elemFunc, tableEntry->output); } Edge clause; - switch(function->undefBehavior) { - case UNDEFINEDSETSFLAG: { - if (isInRange) { - //FIXME: Talk to Brian, It should be IFF not only IMPLY. --HG - clause=constraintIMPLIES(This->cnf,constraintAND(This->cnf, numDomains, carray), carray[numDomains]); - } else { - addConstraintCNF(This->cnf, constraintIMPLIES(This->cnf,constraintAND(This->cnf, numDomains, carray), undefConstraint)); - } - break; + switch (function->undefBehavior) { + case UNDEFINEDSETSFLAG: { + if (isInRange) { + //FIXME: Talk to Brian, It should be IFF not only IMPLY. --HG + clause = constraintIMPLIES(This->cnf,constraintAND(This->cnf, numDomains, carray), carray[numDomains]); + } else { + addConstraintCNF(This->cnf, constraintIMPLIES(This->cnf,constraintAND(This->cnf, numDomains, carray), undefConstraint)); } - case FLAGIFFUNDEFINED: { - if (isInRange) { - clause=constraintIMPLIES(This->cnf,constraintAND(This->cnf, numDomains, carray), carray[numDomains]); - addConstraintCNF(This->cnf, constraintIMPLIES(This->cnf, constraintAND(This->cnf, numDomains, carray), constraintNegate(undefConstraint) )); - } else { - addConstraintCNF(This->cnf,constraintIMPLIES(This->cnf, constraintAND(This->cnf, numDomains, carray), undefConstraint)); - } - break; + break; + } + case FLAGIFFUNDEFINED: { + if (isInRange) { + clause = constraintIMPLIES(This->cnf,constraintAND(This->cnf, numDomains, carray), carray[numDomains]); + addConstraintCNF(This->cnf, constraintIMPLIES(This->cnf, constraintAND(This->cnf, numDomains, carray), constraintNegate(undefConstraint) )); + } else { + addConstraintCNF(This->cnf,constraintIMPLIES(This->cnf, constraintAND(This->cnf, numDomains, carray), undefConstraint)); } - default: - ASSERT(0); + break; + } + default: + ASSERT(0); } - if(isInRange){ + if (isInRange) { #ifdef TRACE_DEBUG model_print("added clause in function table enumeration ...\n"); printCNF(clause); @@ -296,28 +296,28 @@ void encodeEnumTableElemFunctionSATEncoder(SATEncoder* This, ElementFunction* el #endif pushVectorEdge(clauses, clause); } - - notfinished=false; - for(uint i=0;itable->domains, i); + + notfinished = false; + for (uint i = 0; i < numDomains; i++) { + uint index = ++indices[i]; + Set *set = getArraySet(&function->table->domains, i); if (index < getSetSize(set)) { - vals[i]=getSetElement(set, index); - notfinished=true; + vals[i] = getSetElement(set, index); + notfinished = true; break; } else { - indices[i]=0; - vals[i]=getSetElement(set, 0); + indices[i] = 0; + vals[i] = getSetElement(set, 0); } } } - if(getSizeVectorEdge(clauses) == 0){ + if (getSizeVectorEdge(clauses) == 0) { deleteVectorEdge(clauses); return; } - Edge cor=constraintAND(This->cnf, getSizeVectorEdge(clauses), exposeArrayEdge(clauses)); + Edge cor = constraintAND(This->cnf, getSizeVectorEdge(clauses), exposeArrayEdge(clauses)); addConstraintCNF(This->cnf, cor); deleteVectorEdge(clauses); - + } diff --git a/src/Backend/satfunctableencoder.h b/src/Backend/satfunctableencoder.h index 6ac111c..ad11a1c 100644 --- a/src/Backend/satfunctableencoder.h +++ b/src/Backend/satfunctableencoder.h @@ -1,9 +1,9 @@ #ifndef SATFUNCTABLEENCODER_H #define SATFUNCTABLEENCODER_H -Edge encodeEnumEntriesTablePredicateSATEncoder(SATEncoder * This, BooleanPredicate * constraint); -Edge encodeEnumTablePredicateSATEncoder(SATEncoder * This, BooleanPredicate * constraint); -void encodeEnumTableElemFunctionSATEncoder(SATEncoder* encoder, ElementFunction* This); -void encodeEnumEntriesTableElemFuncSATEncoder(SATEncoder* encoder, ElementFunction* This); +Edge encodeEnumEntriesTablePredicateSATEncoder(SATEncoder *This, BooleanPredicate *constraint); +Edge encodeEnumTablePredicateSATEncoder(SATEncoder *This, BooleanPredicate *constraint); +void encodeEnumTableElemFunctionSATEncoder(SATEncoder *encoder, ElementFunction *This); +void encodeEnumEntriesTableElemFuncSATEncoder(SATEncoder *encoder, ElementFunction *This); #endif diff --git a/src/Backend/satorderencoder.c b/src/Backend/satorderencoder.c index e8a7f3d..0b2622d 100644 --- a/src/Backend/satorderencoder.c +++ b/src/Backend/satorderencoder.c @@ -5,31 +5,31 @@ #include "orderpair.h" #include "set.h" -Edge encodeOrderSATEncoder(SATEncoder *This, BooleanOrder * constraint) { - switch( constraint->order->type){ - case PARTIAL: - return encodePartialOrderSATEncoder(This, constraint); - case TOTAL: - return encodeTotalOrderSATEncoder(This, constraint); - default: - ASSERT(0); +Edge encodeOrderSATEncoder(SATEncoder *This, BooleanOrder *constraint) { + switch ( constraint->order->type) { + case PARTIAL: + return encodePartialOrderSATEncoder(This, constraint); + case TOTAL: + return encodeTotalOrderSATEncoder(This, constraint); + default: + ASSERT(0); } return E_BOGUS; } -Edge getPairConstraint(SATEncoder *This, HashTableOrderPair * table, OrderPair * pair) { +Edge getPairConstraint(SATEncoder *This, HashTableOrderPair *table, OrderPair *pair) { bool negate = false; OrderPair flipped; if (pair->first < pair->second) { - negate=true; - flipped.first=pair->second; - flipped.second=pair->first; + negate = true; + flipped.first = pair->second; + flipped.second = pair->first; pair = &flipped; } Edge constraint; if (!containsOrderPair(table, pair)) { constraint = getNewVarSATEncoder(This); - OrderPair * paircopy = allocOrderPair(pair->first, pair->second, constraint); + OrderPair *paircopy = allocOrderPair(pair->first, pair->second, constraint); putOrderPair(table, paircopy, paircopy); } else constraint = getOrderPair(table, pair)->constraint; @@ -37,72 +37,72 @@ Edge getPairConstraint(SATEncoder *This, HashTableOrderPair * table, OrderPair * return negate ? constraintNegate(constraint) : constraint; } -Edge encodeTotalOrderSATEncoder(SATEncoder *This, BooleanOrder * boolOrder) { +Edge encodeTotalOrderSATEncoder(SATEncoder *This, BooleanOrder *boolOrder) { ASSERT(boolOrder->order->type == TOTAL); - if(boolOrder->order->orderPairTable == NULL) { + if (boolOrder->order->orderPairTable == NULL) { initializeOrderHashTable(boolOrder->order); createAllTotalOrderConstraintsSATEncoder(This, boolOrder->order); } - HashTableOrderPair* orderPairTable = boolOrder->order->orderPairTable; - OrderPair pair={boolOrder->first, boolOrder->second, E_NULL}; - Edge constraint = getPairConstraint(This, orderPairTable, & pair); + HashTableOrderPair *orderPairTable = boolOrder->order->orderPairTable; + OrderPair pair = {boolOrder->first, boolOrder->second, E_NULL}; + Edge constraint = getPairConstraint(This, orderPairTable, &pair); return constraint; } -void createAllTotalOrderConstraintsSATEncoder(SATEncoder* This, Order* order){ +void createAllTotalOrderConstraintsSATEncoder(SATEncoder *This, Order *order) { #ifdef TRACE_DEBUG model_print("in total order ...\n"); -#endif +#endif ASSERT(order->type == TOTAL); - VectorInt* mems = order->set->members; - HashTableOrderPair* table = order->orderPairTable; + VectorInt *mems = order->set->members; + HashTableOrderPair *table = order->orderPairTable; uint size = getSizeVectorInt(mems); - for(uint i=0; icnf, generateTransOrderConstraintSATEncoder(This, constIJ, constJK, constIK)); + Edge constIK = getPairConstraint(This, table, &pairIK); + Edge constJK = getPairConstraint(This, table, &pairJK); + addConstraintCNF(This->cnf, generateTransOrderConstraintSATEncoder(This, constIJ, constJK, constIK)); } } } } -Edge getOrderConstraint(HashTableOrderPair *table, OrderPair *pair){ - ASSERT(pair->first!= pair->second); +Edge getOrderConstraint(HashTableOrderPair *table, OrderPair *pair) { + ASSERT(pair->first != pair->second); bool negate = false; OrderPair flipped; if (pair->first < pair->second) { - negate=true; - flipped.first=pair->second; - flipped.second=pair->first; + negate = true; + flipped.first = pair->second; + flipped.second = pair->first; pair = &flipped; } if (!containsOrderPair(table, pair)) { return E_NULL; } - Edge constraint= getOrderPair(table, pair)->constraint; + Edge constraint = getOrderPair(table, pair)->constraint; ASSERT(!edgeIsNull(constraint)); return negate ? constraintNegate(constraint) : constraint; } -Edge generateTransOrderConstraintSATEncoder(SATEncoder *This, Edge constIJ,Edge constJK,Edge constIK){ +Edge generateTransOrderConstraintSATEncoder(SATEncoder *This, Edge constIJ,Edge constJK,Edge constIK) { Edge carray[] = {constIJ, constJK, constraintNegate(constIK)}; - Edge loop1= constraintOR(This->cnf, 3, carray); + Edge loop1 = constraintOR(This->cnf, 3, carray); Edge carray2[] = {constraintNegate(constIJ), constraintNegate(constJK), constIK}; - Edge loop2= constraintOR(This->cnf, 3, carray2 ); + Edge loop2 = constraintOR(This->cnf, 3, carray2 ); return constraintAND2(This->cnf, loop1, loop2); } -Edge encodePartialOrderSATEncoder(SATEncoder *This, BooleanOrder * constraint){ +Edge encodePartialOrderSATEncoder(SATEncoder *This, BooleanOrder *constraint) { ASSERT(constraint->order->type == PARTIAL); return E_BOGUS; } diff --git a/src/Backend/satorderencoder.h b/src/Backend/satorderencoder.h index c26e668..53d7415 100644 --- a/src/Backend/satorderencoder.h +++ b/src/Backend/satorderencoder.h @@ -1,11 +1,11 @@ #ifndef SATORDERENCODER_H #define SATORDERENCODER_H -Edge encodeOrderSATEncoder(SATEncoder *This, BooleanOrder * constraint); +Edge encodeOrderSATEncoder(SATEncoder *This, BooleanOrder *constraint); Edge getPairConstraint(SATEncoder *This, HashTableOrderPair *table, OrderPair *pair); -Edge encodeTotalOrderSATEncoder(SATEncoder *This, BooleanOrder * constraint); -Edge encodePartialOrderSATEncoder(SATEncoder *This, BooleanOrder * constraint); -void createAllTotalOrderConstraintsSATEncoder(SATEncoder* This, Order* order); +Edge encodeTotalOrderSATEncoder(SATEncoder *This, BooleanOrder *constraint); +Edge encodePartialOrderSATEncoder(SATEncoder *This, BooleanOrder *constraint); +void createAllTotalOrderConstraintsSATEncoder(SATEncoder *This, Order *order); Edge getOrderConstraint(HashTableOrderPair *table, OrderPair *pair); Edge generateTransOrderConstraintSATEncoder(SATEncoder *This, Edge constIJ, Edge constJK, Edge constIK); #endif diff --git a/src/Backend/sattranslator.c b/src/Backend/sattranslator.c index 7736f94..ca0fdae 100644 --- a/src/Backend/sattranslator.c +++ b/src/Backend/sattranslator.c @@ -6,49 +6,49 @@ #include "order.h" #include "orderpair.h" -uint64_t getElementValueBinaryIndexSATTranslator(CSolver* This, ElementEncoding* elemEnc){ - uint index=0; - for(int i=elemEnc->numVars-1;i>=0;i--) { - index=index<<1; +uint64_t getElementValueBinaryIndexSATTranslator(CSolver *This, ElementEncoding *elemEnc) { + uint index = 0; + for (int i = elemEnc->numVars - 1; i >= 0; i--) { + index = index << 1; if (getValueSolver(This->satEncoder->cnf->solver, getEdgeVar( elemEnc->variables[i] ))) index |= 1; } model_print("index:%u\tencArraySize:%u\tisInUseElement:%u\n", index, elemEnc->encArraySize, isinUseElement(elemEnc, index)); - ASSERT(elemEnc->encArraySize >index && isinUseElement(elemEnc, index)); + ASSERT(elemEnc->encArraySize > index && isinUseElement(elemEnc, index)); return elemEnc->encodingArray[index]; } -uint64_t getElementValueBinaryValueSATTranslator(CSolver* This, ElementEncoding* elemEnc){ - uint64_t value=0; - for(int i=elemEnc->numVars-1;i>=0;i--) { - value=value<<1; +uint64_t getElementValueBinaryValueSATTranslator(CSolver *This, ElementEncoding *elemEnc) { + uint64_t value = 0; + for (int i = elemEnc->numVars - 1; i >= 0; i--) { + value = value << 1; if (getValueSolver(This->satEncoder->cnf->solver, getEdgeVar( elemEnc->variables[i] )) ) value |= 1; } if (elemEnc->isBinaryValSigned && - This->satEncoder->cnf->solver->solution[ getEdgeVar( elemEnc->variables[elemEnc->numVars-1])]) { + This->satEncoder->cnf->solver->solution[ getEdgeVar( elemEnc->variables[elemEnc->numVars - 1])]) { //Do sign extension of negative number - uint64_t highbits=0xffffffffffffffff - ((1 << (elemEnc->numVars)) - 1); - value+=highbits; + uint64_t highbits = 0xffffffffffffffff - ((1 << (elemEnc->numVars)) - 1); + value += highbits; } - value+=elemEnc->offset; + value += elemEnc->offset; return value; } -uint64_t getElementValueOneHotSATTranslator(CSolver* This, ElementEncoding* elemEnc){ - uint index=0; - for(uint i=0; i< elemEnc->numVars; i++) { +uint64_t getElementValueOneHotSATTranslator(CSolver *This, ElementEncoding *elemEnc) { + uint index = 0; + for (uint i = 0; i < elemEnc->numVars; i++) { if (getValueSolver(This->satEncoder->cnf->solver, getEdgeVar( elemEnc->variables[i] ))) index = i; } - ASSERT(elemEnc->encArraySize >index && isinUseElement(elemEnc, index)); + ASSERT(elemEnc->encArraySize > index && isinUseElement(elemEnc, index)); return elemEnc->encodingArray[index]; } -uint64_t getElementValueUnarySATTranslator(CSolver* This, ElementEncoding* elemEnc){ +uint64_t getElementValueUnarySATTranslator(CSolver *This, ElementEncoding *elemEnc) { uint i; - for(i=0;inumVars;i++) { - if (! getValueSolver(This->satEncoder->cnf->solver, getEdgeVar( elemEnc->variables[i] )) ) { + for (i = 0; i < elemEnc->numVars; i++) { + if (!getValueSolver(This->satEncoder->cnf->solver, getEdgeVar( elemEnc->variables[i] )) ) { break; } } @@ -56,41 +56,41 @@ uint64_t getElementValueUnarySATTranslator(CSolver* This, ElementEncoding* elemE return elemEnc->encodingArray[i]; } -uint64_t getElementValueSATTranslator(CSolver* This, Element* element){ - ElementEncoding* elemEnc = getElementEncoding(element); - if(elemEnc->numVars == 0) //case when the set has only one item +uint64_t getElementValueSATTranslator(CSolver *This, Element *element) { + ElementEncoding *elemEnc = getElementEncoding(element); + if (elemEnc->numVars == 0)//case when the set has only one item return getSetElement(getElementSet(element), 0); - switch(elemEnc->type){ - case ONEHOT: - return getElementValueOneHotSATTranslator(This, elemEnc); - case UNARY: - return getElementValueUnarySATTranslator(This, elemEnc); - case BINARYINDEX: - return getElementValueBinaryIndexSATTranslator(This, elemEnc); - case ONEHOTBINARY: - ASSERT(0); - break; - case BINARYVAL: - ASSERT(0); - break; - default: - ASSERT(0); - break; + switch (elemEnc->type) { + case ONEHOT: + return getElementValueOneHotSATTranslator(This, elemEnc); + case UNARY: + return getElementValueUnarySATTranslator(This, elemEnc); + case BINARYINDEX: + return getElementValueBinaryIndexSATTranslator(This, elemEnc); + case ONEHOTBINARY: + ASSERT(0); + break; + case BINARYVAL: + ASSERT(0); + break; + default: + ASSERT(0); + break; } return -1; } -bool getBooleanVariableValueSATTranslator( CSolver* This , Boolean* boolean){ - int index = getEdgeVar( ((BooleanVar*) boolean)->var ); +bool getBooleanVariableValueSATTranslator( CSolver *This, Boolean *boolean) { + int index = getEdgeVar( ((BooleanVar *) boolean)->var ); return getValueSolver(This->satEncoder->cnf->solver, index); } -HappenedBefore getOrderConstraintValueSATTranslator(CSolver* This, Order * order, uint64_t first, uint64_t second){ - ASSERT(order->orderPairTable!= NULL); - OrderPair pair={first, second, E_NULL}; - Edge var = getOrderConstraint(order->orderPairTable, &pair); - if(edgeIsNull(var)) +HappenedBefore getOrderConstraintValueSATTranslator(CSolver *This, Order *order, uint64_t first, uint64_t second) { + ASSERT(order->orderPairTable != NULL); + OrderPair pair = {first, second, E_NULL}; + Edge var = getOrderConstraint(order->orderPairTable, &pair); + if (edgeIsNull(var)) return UNORDERED; - return getValueCNF(This->satEncoder->cnf, var)? FIRST: SECOND; + return getValueCNF(This->satEncoder->cnf, var) ? FIRST : SECOND; } diff --git a/src/Backend/sattranslator.h b/src/Backend/sattranslator.h index 0b1a996..ad204f3 100644 --- a/src/Backend/sattranslator.h +++ b/src/Backend/sattranslator.h @@ -1,4 +1,4 @@ -/* +/* * File: sattranslator.h * Author: hamed * @@ -12,13 +12,13 @@ #include "ops.h" -bool getBooleanVariableValueSATTranslator( CSolver* This , Boolean* boolean); -HappenedBefore getOrderConstraintValueSATTranslator(CSolver* This, Order * order, uint64_t first, uint64_t second); -uint64_t getElementValueBinaryIndexSATTranslator(CSolver* This, ElementEncoding* elemEnc); -uint64_t getElementValueBinaryValueSATTranslator(CSolver* This, ElementEncoding* elemEnc); -uint64_t getElementValueOneHotSATTranslator(CSolver* This, ElementEncoding* elemEnc); -uint64_t getElementValueUnarySATTranslator(CSolver* This, ElementEncoding* elemEnc); -uint64_t getElementValueSATTranslator(CSolver* This, Element* element); +bool getBooleanVariableValueSATTranslator( CSolver *This, Boolean *boolean); +HappenedBefore getOrderConstraintValueSATTranslator(CSolver *This, Order *order, uint64_t first, uint64_t second); +uint64_t getElementValueBinaryIndexSATTranslator(CSolver *This, ElementEncoding *elemEnc); +uint64_t getElementValueBinaryValueSATTranslator(CSolver *This, ElementEncoding *elemEnc); +uint64_t getElementValueOneHotSATTranslator(CSolver *This, ElementEncoding *elemEnc); +uint64_t getElementValueUnarySATTranslator(CSolver *This, ElementEncoding *elemEnc); +uint64_t getElementValueSATTranslator(CSolver *This, Element *element); -#endif /* SATTRANSLATOR_H */ +#endif/* SATTRANSLATOR_H */ diff --git a/src/Collections/array.h b/src/Collections/array.h index f823d8c..d211759 100644 --- a/src/Collections/array.h +++ b/src/Collections/array.h @@ -1,55 +1,55 @@ #ifndef ARRAY_H #define ARRAY_H -#define ArrayDef(name, type) \ - struct Array ## name { \ - type * array; \ - uint size; \ +#define ArrayDef(name, type) \ + struct Array ## name { \ + type *array; \ + uint size; \ }; \ - typedef struct Array ## name Array ## name; \ - static inline Array ## name * allocArray ## name(uint size) { \ - Array ## name * tmp = (Array ## name *)ourmalloc(sizeof(type)); \ - tmp->size = size; \ - tmp->array = (type *) ourcalloc(1, sizeof(type) * size); \ + typedef struct Array ## name Array ## name; \ + static inline Array ## name *allocArray ## name(uint size) { \ + Array ## name * tmp = (Array ## name *)ourmalloc(sizeof(type)); \ + tmp->size = size; \ + tmp->array = (type *) ourcalloc(1, sizeof(type) * size); \ return tmp; \ } \ - static inline Array ## name * allocArrayInit ## name(type * array, uint size) { \ - Array ## name * tmp = allocArray ## name(size); \ - memcpy(tmp->array, array, size * sizeof(type)); \ + static inline Array ## name *allocArrayInit ## name(type * array, uint size) { \ + Array ## name * tmp = allocArray ## name(size); \ + memcpy(tmp->array, array, size * sizeof(type)); \ return tmp; \ } \ static inline void removeElementArray ## name(Array ## name * This, uint index) { \ - This->size--; \ - for(;indexsize;index++) { \ - This->array[index]=This->array[index+1]; \ - } \ - } \ - static inline type getArray ## name(Array ## name * This, uint index) { \ - return This->array[index]; \ - } \ - static inline void setArray ## name(Array ## name * This, uint index, type item) { \ - This->array[index]=item; \ - } \ - static inline uint getSizeArray ## name(Array ## name *This) { \ - return This->size; \ - } \ - static inline void deleteArray ## name(Array ## name *This) { \ - ourfree(This->array); \ - ourfree(This); \ - } \ - static inline type * exposeCArray ## name(Array ## name * This) { \ - return This->array; \ - } \ - static inline void deleteInlineArray ## name(Array ## name *This) { \ - ourfree(This->array); \ - } \ - static inline void initArray ## name(Array ## name * This, uint size) { \ - This->size = size; \ - This->array = (type *) ourcalloc(1, sizeof(type) * size); \ - } \ - static inline void initArrayInit ## name(Array ## name * This, type *array, uint size) { \ - initArray ##name(This, size); \ - memcpy(This->array, array, size * sizeof(type)); \ + This->size--; \ + for (; index < This->size; index++) { \ + This->array[index] = This->array[index + 1]; \ + } \ + } \ + static inline type getArray ## name(Array ## name * This, uint index) { \ + return This->array[index]; \ + } \ + static inline void setArray ## name(Array ## name * This, uint index, type item) { \ + This->array[index] = item; \ + } \ + static inline uint getSizeArray ## name(Array ## name * This) { \ + return This->size; \ + } \ + static inline void deleteArray ## name(Array ## name * This) { \ + ourfree(This->array); \ + ourfree(This); \ + } \ + static inline type *exposeCArray ## name(Array ## name * This) { \ + return This->array; \ + } \ + static inline void deleteInlineArray ## name(Array ## name * This) { \ + ourfree(This->array); \ + } \ + static inline void initArray ## name(Array ## name * This, uint size) { \ + This->size = size; \ + This->array = (type *) ourcalloc(1, sizeof(type) * size); \ + } \ + static inline void initArrayInit ## name(Array ## name * This, type * array, uint size) { \ + initArray ## name(This, size); \ + memcpy(This->array, array, size * sizeof(type)); \ } #endif diff --git a/src/Collections/hashset.h b/src/Collections/hashset.h index f647c38..c9656a6 100644 --- a/src/Collections/hashset.h +++ b/src/Collections/hashset.h @@ -11,7 +11,7 @@ #define HASH_SET_H #include "hashtable.h" -#define HashSetDef(Name, _Key) \ +#define HashSetDef(Name, _Key) \ struct LinkNode ## Name { \ _Key key; \ struct LinkNode ## Name *prev; \ @@ -21,27 +21,27 @@ struct HashSet ## Name; \ typedef struct HashSet ## Name HashSet ## Name; \ struct HSIterator ## Name { \ - LinkNode ## Name *curr; \ - LinkNode ## Name *last; \ + LinkNode ## Name * curr; \ + LinkNode ## Name * last; \ HashSet ## Name * set; \ }; \ typedef struct HSIterator ## Name HSIterator ## Name; \ - HashTableDef(Name ## Set, _Key, LinkNode ## Name *); \ - HSIterator ## Name * allocHSIterator ## Name(LinkNode ## Name *_curr, HashSet ## Name * _set); \ - void deleteIter ## Name(HSIterator ## Name *hsit); \ - bool hasNext ## Name(HSIterator ## Name *hsit); \ - _Key next ## Name(HSIterator ## Name *hsit); \ - _Key currKey ## Name(HSIterator ## Name *hsit); \ - void removeIter ## Name(HSIterator ## Name *hsit); \ + HashTableDef(Name ## Set, _Key, LinkNode ## Name *); \ + HSIterator ## Name * allocHSIterator ## Name(LinkNode ## Name * _curr, HashSet ## Name * _set); \ + void deleteIter ## Name(HSIterator ## Name * hsit); \ + bool hasNext ## Name(HSIterator ## Name * hsit); \ + _Key next ## Name(HSIterator ## Name * hsit); \ + _Key currKey ## Name(HSIterator ## Name * hsit); \ + void removeIter ## Name(HSIterator ## Name * hsit); \ struct HashSet ## Name { \ HashTable ## Name ## Set * table; \ - LinkNode ## Name *list; \ - LinkNode ## Name *tail; \ + LinkNode ## Name * list; \ + LinkNode ## Name * tail; \ }; \ typedef struct HashSet ## Name HashSet ## Name; \ \ HashSet ## Name * allocHashSet ## Name (unsigned int initialcapacity, double factor); \ - void deleteHashSet ## Name(struct HashSet ## Name * set); \ + void deleteHashSet ## Name(struct HashSet ## Name *set); \ HashSet ## Name * copyHashSet ## Name(HashSet ## Name * set); \ void resetHashSet ## Name(HashSet ## Name * set); \ bool addHashSet ## Name(HashSet ## Name * set,_Key key); \ @@ -56,88 +56,88 @@ #define HashSetImpl(Name, _Key, hash_function, equals) \ HashTableImpl(Name ## Set, _Key, LinkNode ## Name *, hash_function, equals, ourfree); \ - HSIterator ## Name * allocHSIterator ## Name(LinkNode ## Name *_curr, HashSet ## Name * _set) { \ + HSIterator ## Name * allocHSIterator ## Name(LinkNode ## Name * _curr, HashSet ## Name * _set) { \ HSIterator ## Name * hsit = (HSIterator ## Name *)ourmalloc(sizeof(HSIterator ## Name)); \ - hsit->curr=_curr; \ - hsit->set=_set; \ + hsit->curr = _curr; \ + hsit->set = _set; \ return hsit; \ } \ \ - void deleteIter ## Name(HSIterator ## Name *hsit) { \ + void deleteIter ## Name(HSIterator ## Name * hsit) { \ ourfree(hsit); \ } \ \ - bool hasNext ## Name(HSIterator ## Name *hsit) { \ - return hsit->curr!=NULL; \ + bool hasNext ## Name(HSIterator ## Name * hsit) { \ + return hsit->curr != NULL; \ } \ \ - _Key next ## Name(HSIterator ## Name *hsit) { \ - _Key k=hsit->curr->key; \ - hsit->last=hsit->curr; \ - hsit->curr=hsit->curr->next; \ + _Key next ## Name(HSIterator ## Name * hsit) { \ + _Key k = hsit->curr->key; \ + hsit->last = hsit->curr; \ + hsit->curr = hsit->curr->next; \ return k; \ } \ \ - _Key currKey ## Name(HSIterator ## Name *hsit) { \ + _Key currKey ## Name(HSIterator ## Name * hsit) { \ return hsit->last->key; \ } \ \ - void removeIter ## Name(HSIterator ## Name *hsit) { \ - _Key k=hsit->last->key; \ + void removeIter ## Name(HSIterator ## Name * hsit) { \ + _Key k = hsit->last->key; \ removeHashSet ## Name(hsit->set, k); \ } \ \ HashSet ## Name * allocHashSet ## Name (unsigned int initialcapacity, double factor) { \ HashSet ## Name * set = (HashSet ## Name *)ourmalloc(sizeof(struct HashSet ## Name)); \ - set->table=allocHashTable ## Name ## Set(initialcapacity, factor); \ - set->list=NULL; \ - set->tail=NULL; \ + set->table = allocHashTable ## Name ## Set(initialcapacity, factor); \ + set->list = NULL; \ + set->tail = NULL; \ return set; \ } \ \ - void deleteHashSet ## Name(struct HashSet ## Name * set) { \ - LinkNode ## Name *tmp=set->list; \ - while(tmp!=NULL) { \ - LinkNode ## Name *tmpnext=tmp->next; \ + void deleteHashSet ## Name(struct HashSet ## Name *set) { \ + LinkNode ## Name *tmp = set->list; \ + while (tmp != NULL) { \ + LinkNode ## Name * tmpnext = tmp->next; \ ourfree(tmp); \ - tmp=tmpnext; \ + tmp = tmpnext; \ } \ deleteHashTable ## Name ## Set(set->table); \ ourfree(set); \ } \ \ HashSet ## Name * copyHashSet ## Name(HashSet ## Name * set) { \ - HashSet ## Name *copy=allocHashSet ## Name(getCapacity ## Name ## Set(set->table), getLoadFactor ## Name ## Set(set->table)); \ - HSIterator ## Name * it=iterator ## Name(set); \ - while(hasNext ## Name(it)) \ + HashSet ## Name * copy = allocHashSet ## Name(getCapacity ## Name ## Set(set->table), getLoadFactor ## Name ## Set(set->table)); \ + HSIterator ## Name * it = iterator ## Name(set); \ + while (hasNext ## Name(it)) \ addHashSet ## Name(copy, next ## Name(it)); \ deleteIter ## Name(it); \ return copy; \ } \ \ void resetHashSet ## Name(HashSet ## Name * set) { \ - LinkNode ## Name *tmp=set->list; \ - while(tmp!=NULL) { \ - LinkNode ## Name *tmpnext=tmp->next; \ + LinkNode ## Name * tmp = set->list; \ + while (tmp != NULL) { \ + LinkNode ## Name * tmpnext = tmp->next; \ ourfree(tmp); \ - tmp=tmpnext; \ + tmp = tmpnext; \ } \ - set->list=set->tail=NULL; \ + set->list = set->tail = NULL; \ reset ## Name ## Set(set->table); \ } \ \ bool addHashSet ## Name(HashSet ## Name * set,_Key key) { \ - LinkNode ## Name * val=get ## Name ## Set(set->table, key); \ - if (val==NULL) { \ - LinkNode ## Name * newnode=(LinkNode ## Name *)ourmalloc(sizeof(struct LinkNode ## Name)); \ - newnode->prev=set->tail; \ - newnode->next=NULL; \ - newnode->key=key; \ - if (set->tail!=NULL) \ - set->tail->next=newnode; \ + LinkNode ## Name * val = get ## Name ## Set(set->table, key); \ + if (val == NULL) { \ + LinkNode ## Name * newnode = (LinkNode ## Name *)ourmalloc(sizeof(struct LinkNode ## Name)); \ + newnode->prev = set->tail; \ + newnode->next = NULL; \ + newnode->key = key; \ + if (set->tail != NULL) \ + set->tail->next = newnode; \ else \ - set->list=newnode; \ - set->tail=newnode; \ + set->list = newnode; \ + set->tail = newnode; \ put ## Name ## Set(set->table, key, newnode); \ return true; \ } else \ @@ -145,8 +145,8 @@ } \ \ _Key getHashSet ## Name(HashSet ## Name * set,_Key key) { \ - LinkNode ## Name * val=get ## Name ## Set(set->table, key); \ - if (val!=NULL) \ + LinkNode ## Name * val = get ## Name ## Set(set->table, key); \ + if (val != NULL) \ return val->key; \ else \ return NULL; \ @@ -157,25 +157,25 @@ } \ \ bool containsHashSet ## Name(HashSet ## Name * set,_Key key) { \ - return get ## Name ## Set(set->table, key)!=NULL; \ + return get ## Name ## Set(set->table, key) != NULL; \ } \ \ bool removeHashSet ## Name(HashSet ## Name * set,_Key key) { \ LinkNode ## Name * oldlinknode; \ - oldlinknode=get ## Name ## Set(set->table, key); \ - if (oldlinknode==NULL) { \ + oldlinknode = get ## Name ## Set(set->table, key); \ + if (oldlinknode == NULL) { \ return false; \ } \ remove ## Name ## Set(set->table, key); \ \ - if (oldlinknode->prev==NULL) \ - set->list=oldlinknode->next; \ + if (oldlinknode->prev == NULL) \ + set->list = oldlinknode->next; \ else \ - oldlinknode->prev->next=oldlinknode->next; \ - if (oldlinknode->next!=NULL) \ - oldlinknode->next->prev=oldlinknode->prev; \ + oldlinknode->prev->next = oldlinknode->next; \ + if (oldlinknode->next != NULL) \ + oldlinknode->next->prev = oldlinknode->prev; \ else \ - set->tail=oldlinknode->prev; \ + set->tail = oldlinknode->prev; \ ourfree(oldlinknode); \ return true; \ } \ @@ -185,7 +185,7 @@ } \ \ bool isEmptyHashSet ## Name(HashSet ## Name * set) { \ - return getSizeHashSet ## Name(set)==0; \ + return getSizeHashSet ## Name(set) == 0; \ } \ \ HSIterator ## Name * iterator ## Name(HashSet ## Name * set) { \ diff --git a/src/Collections/hashtable.h b/src/Collections/hashtable.h index dbf61f9..15f69af 100644 --- a/src/Collections/hashtable.h +++ b/src/Collections/hashtable.h @@ -62,7 +62,7 @@ bool contains ## Name(const HashTable ## Name * tab, _Key key); \ void resize ## Name(HashTable ## Name * tab, unsigned int newsize); \ double getLoadFactor ## Name(HashTable ## Name * tab); \ - unsigned int getCapacity ## Name(HashTable ## Name * tab); \ + unsigned int getCapacity ## Name(HashTable ## Name * tab); \ void resetAndDeleteHashTable ## Name(HashTable ## Name * tab); #define HashTableImpl(Name, _Key, _Val, hash_function, equals, freefunction) \ @@ -78,34 +78,34 @@ tab->size = 0; \ return tab; \ } \ - \ - void deleteHashTable ## Name(HashTable ## Name * tab) { \ + \ + void deleteHashTable ## Name(HashTable ## Name * tab) { \ ourfree(tab->table); \ if (tab->zero) \ ourfree(tab->zero); \ ourfree(tab); \ } \ - \ - void resetAndDeleteHashTable ## Name(HashTable ## Name * tab) { \ - for(uint i=0;icapacity;i++) { \ - struct hashlistnode ## Name * bin=&tab->table[i]; \ - if (bin->key!=NULL) { \ - bin->key=NULL; \ - if (bin->val!=NULL) { \ - freefunction(bin->val); \ - bin->val=NULL; \ - } \ - } \ - } \ - if (tab->zero) { \ - if (tab->zero->val != NULL) \ - freefunction(tab->zero->val); \ - ourfree(tab->zero); \ - tab->zero=NULL; \ - } \ - tab->size=0; \ - } \ - \ + \ + void resetAndDeleteHashTable ## Name(HashTable ## Name * tab) { \ + for (uint i = 0; i < tab->capacity; i++) { \ + struct hashlistnode ## Name *bin = &tab->table[i]; \ + if (bin->key != NULL) { \ + bin->key = NULL; \ + if (bin->val != NULL) { \ + freefunction(bin->val); \ + bin->val = NULL; \ + } \ + } \ + } \ + if (tab->zero) { \ + if (tab->zero->val != NULL) \ + freefunction(tab->zero->val); \ + ourfree(tab->zero); \ + tab->zero = NULL; \ + } \ + tab->size = 0; \ + } \ + \ void reset ## Name(HashTable ## Name * tab) { \ memset(tab->table, 0, tab->capacity * sizeof(struct hashlistnode ## Name)); \ if (tab->zero) { \ @@ -116,7 +116,7 @@ } \ \ void resetandfree ## Name(HashTable ## Name * tab) { \ - for(unsigned int i=0;icapacity;i++) { \ + for (unsigned int i = 0; i < tab->capacity; i++) { \ struct hashlistnode ## Name *bin = &tab->table[i]; \ if (bin->key != NULL) { \ bin->key = NULL; \ @@ -138,11 +138,11 @@ void put ## Name(HashTable ## Name * tab, _Key key, _Val val) { \ if (!key) { \ if (!tab->zero) { \ - tab->zero=(struct hashlistnode ## Name *)ourmalloc(sizeof(struct hashlistnode ## Name)); \ + tab->zero = (struct hashlistnode ## Name *)ourmalloc(sizeof(struct hashlistnode ## Name)); \ tab->size++; \ } \ - tab->zero->key=key; \ - tab->zero->val=val; \ + tab->zero->key = key; \ + tab->zero->val = val; \ return; \ } \ \ @@ -181,7 +181,7 @@ } \ \ unsigned int oindex = hash_function(key) & tab->capacitymask; \ - unsigned int index=oindex; \ + unsigned int index = oindex; \ do { \ search = &tab->table[index]; \ if (!search->key) { \ @@ -192,7 +192,7 @@ return search->val; \ index++; \ index &= tab->capacitymask; \ - if (index==oindex) \ + if (index == oindex) \ break; \ } while (true); \ return (_Val)0; \ @@ -205,9 +205,9 @@ if (!tab->zero) { \ return (_Val)0; \ } else { \ - _Val v=tab->zero->val; \ + _Val v = tab->zero->val; \ ourfree(tab->zero); \ - tab->zero=NULL; \ + tab->zero = NULL; \ tab->size--; \ return v; \ } \ @@ -222,9 +222,9 @@ break; \ } else \ if (equals(search->key, key)) { \ - _Val v=search->val; \ - search->val=(_Val) 1; \ - search->key=0; \ + _Val v = search->val; \ + search->val = (_Val) 1; \ + search->key = 0; \ tab->size--; \ return v; \ } \ @@ -241,7 +241,7 @@ bool contains ## Name(const HashTable ## Name * tab, _Key key) { \ struct hashlistnode ## Name *search; \ if (!key) { \ - return tab->zero!=NULL; \ + return tab->zero != NULL; \ } \ unsigned int index = hash_function(key); \ do { \ @@ -276,7 +276,7 @@ \ struct hashlistnode ## Name *bin = &oldtable[0]; \ struct hashlistnode ## Name *lastbin = &oldtable[oldcapacity]; \ - for (;bin < lastbin;bin++) { \ + for (; bin < lastbin; bin++) { \ _Key key = bin->key; \ \ struct hashlistnode ## Name *search; \ diff --git a/src/Collections/structs.c b/src/Collections/structs.c index 459edd1..b41a0b5 100644 --- a/src/Collections/structs.c +++ b/src/Collections/structs.c @@ -17,63 +17,63 @@ VectorImpl(Order, Order *, 4); VectorImpl(TableEntry, TableEntry *, 4); VectorImpl(ASTNode, ASTNode *, 4); VectorImpl(Int, uint64_t, 4); -VectorImpl(OrderNode, OrderNode*, 4); -VectorImpl(OrderGraph, OrderGraph*, 4); +VectorImpl(OrderNode, OrderNode *, 4); +VectorImpl(OrderGraph, OrderGraph *, 4); -inline unsigned int Ptr_hash_function(void * hash) { +inline unsigned int Ptr_hash_function(void *hash) { return (unsigned int)((int64)hash >> 4); } -inline bool Ptr_equals(void * key1, void * key2) { +inline bool Ptr_equals(void *key1, void *key2) { return key1 == key2; } -static inline unsigned int order_pair_hash_Function(OrderPair* This){ +static inline unsigned int order_pair_hash_Function(OrderPair *This) { return (uint) (This->first << 2) ^ This->second; } -static inline unsigned int order_pair_equals(OrderPair* key1, OrderPair* key2){ - return key1->first== key2->first && key1->second == key2->second; +static inline unsigned int order_pair_equals(OrderPair *key1, OrderPair *key2) { + return key1->first == key2->first && key1->second == key2->second; } -static inline unsigned int table_entry_hash_Function(TableEntry* This){ +static inline unsigned int table_entry_hash_Function(TableEntry *This) { unsigned int h = 0; - for(uint i=0; iinputSize; i++){ + for (uint i = 0; i < This->inputSize; i++) { h += This->inputs[i]; h *= 31; } return h; } -static inline bool table_entry_equals(TableEntry* key1, TableEntry* key2){ - if(key1->inputSize != key2->inputSize) +static inline bool table_entry_equals(TableEntry *key1, TableEntry *key2) { + if (key1->inputSize != key2->inputSize) return false; - for(uint i=0; iinputSize; i++) - if(key1->inputs[i]!=key2->inputs[i]) + for (uint i = 0; i < key1->inputSize; i++) + if (key1->inputs[i] != key2->inputs[i]) return false; return true; } -static inline unsigned int order_node_hash_Function(OrderNode* This){ +static inline unsigned int order_node_hash_Function(OrderNode *This) { return (uint) This->id; - + } -static inline bool order_node_equals(OrderNode* key1, OrderNode* key2){ +static inline bool order_node_equals(OrderNode *key1, OrderNode *key2) { return key1->id == key2->id; } -static inline unsigned int order_edge_hash_Function(OrderEdge* This){ - return (uint) (( (uintptr_t)This->sink)^((uintptr_t)This->source << 4) ); +static inline unsigned int order_edge_hash_Function(OrderEdge *This) { + return (uint) (((uintptr_t)This->sink) ^ ((uintptr_t)This->source << 4)); } -static inline bool order_edge_equals(OrderEdge* key1, OrderEdge* key2){ +static inline bool order_edge_equals(OrderEdge *key1, OrderEdge *key2) { return key1->sink == key2->sink && key1->source == key2->source; } HashTableImpl(OrderPair, OrderPair *, OrderPair *, order_pair_hash_Function, order_pair_equals, ourfree); -HashSetImpl(TableEntry, TableEntry*, table_entry_hash_Function, table_entry_equals); -HashSetImpl(OrderNode, OrderNode*, order_node_hash_Function, order_node_equals); -HashSetImpl(OrderEdge, OrderEdge*, order_edge_hash_Function, order_edge_equals); +HashSetImpl(TableEntry, TableEntry *, table_entry_hash_Function, table_entry_equals); +HashSetImpl(OrderNode, OrderNode *, order_node_hash_Function, order_node_equals); +HashSetImpl(OrderEdge, OrderEdge *, order_edge_hash_Function, order_edge_equals); diff --git a/src/Collections/structs.h b/src/Collections/structs.h index 5713e89..36ba052 100644 --- a/src/Collections/structs.h +++ b/src/Collections/structs.h @@ -21,14 +21,14 @@ VectorDef(Order, Order *); VectorDef(TableEntry, TableEntry *); VectorDef(ASTNode, ASTNode *); VectorDef(Int, uint64_t); -VectorDef(OrderNode, OrderNode*); -VectorDef(OrderGraph, OrderGraph*); +VectorDef(OrderNode, OrderNode *); +VectorDef(OrderGraph, OrderGraph *); HashTableDef(Void, void *, void *); HashTableDef(OrderPair, OrderPair *, OrderPair *); HashSetDef(Void, void *); -HashSetDef(TableEntry, TableEntry*); -HashSetDef(OrderNode, OrderNode*); -HashSetDef(OrderEdge, OrderEdge*); +HashSetDef(TableEntry, TableEntry *); +HashSetDef(OrderNode, OrderNode *); +HashSetDef(OrderEdge, OrderEdge *); #endif diff --git a/src/Collections/vector.h b/src/Collections/vector.h index 650f33d..f140fac 100644 --- a/src/Collections/vector.h +++ b/src/Collections/vector.h @@ -2,29 +2,29 @@ #define VECTOR_H #include -#define VectorDef(name, type) \ +#define VectorDef(name, type) \ struct Vector ## name { \ uint size; \ uint capacity; \ - type * array; \ + type *array; \ }; \ typedef struct Vector ## name Vector ## name; \ Vector ## name * allocVector ## name(uint capacity); \ Vector ## name * allocDefVector ## name(); \ Vector ## name * allocVectorArray ## name(uint capacity, type * array); \ - void pushVector ## name(Vector ## name *vector, type item); \ - type lastVector ## name(Vector ## name *vector); \ - void popVector ## name(Vector ## name *vector); \ - type getVector ## name(Vector ## name *vector, uint index); \ - void setVector ## name(Vector ## name *vector, uint index, type item); \ - uint getSizeVector ## name(Vector ## name *vector); \ - void setSizeVector ## name(Vector ## name *vector, uint size); \ - void deleteVector ## name(Vector ## name *vector); \ - void clearVector ## name(Vector ## name *vector); \ - void deleteVectorArray ## name(Vector ## name *vector); \ - type * exposeArray ## name(Vector ## name * vector); \ + void pushVector ## name(Vector ## name * vector, type item); \ + type lastVector ## name(Vector ## name * vector); \ + void popVector ## name(Vector ## name * vector); \ + type getVector ## name(Vector ## name * vector, uint index); \ + void setVector ## name(Vector ## name * vector, uint index, type item); \ + uint getSizeVector ## name(Vector ## name * vector); \ + void setSizeVector ## name(Vector ## name * vector, uint size); \ + void deleteVector ## name(Vector ## name * vector); \ + void clearVector ## name(Vector ## name * vector); \ + void deleteVectorArray ## name(Vector ## name * vector); \ + type *exposeArray ## name(Vector ## name * vector); \ void initVector ## name(Vector ## name * vector, uint capacity); \ - void initDefVector ## name(Vector ## name * vector); \ + void initDefVector ## name(Vector ## name * vector); \ void initVectorArray ## name(Vector ## name * vector, uint capacity, type * array); #define VectorImpl(name, type, defcap) \ @@ -35,37 +35,37 @@ Vector ## name * tmp = (Vector ## name *)ourmalloc(sizeof(Vector ## name)); \ tmp->size = 0; \ tmp->capacity = capacity; \ - tmp->array = (type *) ourmalloc(sizeof(type) * capacity); \ + tmp->array = (type *) ourmalloc(sizeof(type) * capacity); \ return tmp; \ } \ Vector ## name * allocVectorArray ## name(uint capacity, type * array) { \ Vector ## name * tmp = allocVector ## name(capacity); \ - tmp->size=capacity; \ - memcpy(tmp->array, array, capacity * sizeof(type)); \ + tmp->size = capacity; \ + memcpy(tmp->array, array, capacity * sizeof(type)); \ return tmp; \ } \ - void popVector ## name(Vector ## name *vector) { \ - vector->size--; \ - } \ - type lastVector ## name(Vector ## name *vector) { \ - return vector->array[vector->size-1]; \ - } \ - void setSizeVector ## name(Vector ## name *vector, uint size) { \ - if (size <= vector->size) { \ - vector->size=size; \ - return; \ - } else if (size > vector->capacity) { \ - vector->array=(type *)ourrealloc(vector->array, size * sizeof(type)); \ - vector->capacity=size; \ - } \ - bzero(&vector->array[vector->size], (size-vector->size)*sizeof(type)); \ - vector->size=size; \ - } \ - void pushVector ## name(Vector ## name *vector, type item) { \ - if (vector->size >= vector->capacity) { \ - uint newcap=vector->capacity << 1; \ - vector->array=(type *)ourrealloc(vector->array, newcap * sizeof(type)); \ - vector->capacity=newcap; \ + void popVector ## name(Vector ## name * vector) { \ + vector->size--; \ + } \ + type lastVector ## name(Vector ## name * vector) { \ + return vector->array[vector->size - 1]; \ + } \ + void setSizeVector ## name(Vector ## name * vector, uint size) { \ + if (size <= vector->size) { \ + vector->size = size; \ + return; \ + } else if (size > vector->capacity) { \ + vector->array = (type *)ourrealloc(vector->array, size * sizeof(type)); \ + vector->capacity = size; \ + } \ + bzero(&vector->array[vector->size], (size - vector->size) * sizeof(type)); \ + vector->size = size; \ + } \ + void pushVector ## name(Vector ## name * vector, type item) { \ + if (vector->size >= vector->capacity) { \ + uint newcap = vector->capacity << 1; \ + vector->array = (type *)ourrealloc(vector->array, newcap * sizeof(type)); \ + vector->capacity = newcap; \ } \ vector->array[vector->size++] = item; \ } \ @@ -73,35 +73,35 @@ return vector->array[index]; \ } \ void setVector ## name(Vector ## name * vector, uint index, type item) { \ - vector->array[index]=item; \ + vector->array[index] = item; \ } \ - uint getSizeVector ## name(Vector ## name *vector) { \ + uint getSizeVector ## name(Vector ## name * vector) { \ return vector->size; \ } \ - void deleteVector ## name(Vector ## name *vector) { \ + void deleteVector ## name(Vector ## name * vector) { \ ourfree(vector->array); \ ourfree(vector); \ } \ - void clearVector ## name(Vector ## name *vector) { \ - vector->size=0; \ + void clearVector ## name(Vector ## name * vector) { \ + vector->size = 0; \ } \ - type * exposeArray ## name(Vector ## name * vector) { \ + type *exposeArray ## name(Vector ## name * vector) { \ return vector->array; \ - } \ - void deleteVectorArray ## name(Vector ## name *vector) { \ + } \ + void deleteVectorArray ## name(Vector ## name * vector) { \ ourfree(vector->array); \ - } \ + } \ void initVector ## name(Vector ## name * vector, uint capacity) { \ vector->size = 0; \ - vector->capacity = capacity; \ - vector->array = (type *) ourmalloc(sizeof(type) * capacity); \ - } \ - void initDefVector ## name(Vector ## name * vector) { \ - initVector ## name(vector, defcap); \ - } \ - void initVectorArray ## name(Vector ## name * vector, uint capacity, type * array) { \ - initVector ##name(vector, capacity); \ - vector->size=capacity; \ - memcpy(vector->array, array, capacity * sizeof(type)); \ + vector->capacity = capacity; \ + vector->array = (type *) ourmalloc(sizeof(type) * capacity); \ + } \ + void initDefVector ## name(Vector ## name * vector) { \ + initVector ## name(vector, defcap); \ + } \ + void initVectorArray ## name(Vector ## name * vector, uint capacity, type * array) { \ + initVector ## name(vector, capacity); \ + vector->size = capacity; \ + memcpy(vector->array, array, capacity * sizeof(type)); \ } #endif diff --git a/src/Encoders/elementencoding.c b/src/Encoders/elementencoding.c index 47c6ea0..1b0c6b8 100644 --- a/src/Encoders/elementencoding.c +++ b/src/Encoders/elementencoding.c @@ -4,36 +4,36 @@ #include "element.h" #include "satencoder.h" -void initElementEncoding(ElementEncoding * This, Element *element) { - This->element=element; - This->type=ELEM_UNASSIGNED; - This->variables=NULL; - This->encodingArray=NULL; - This->inUseArray=NULL; - This->numVars=0; - This->encArraySize=0; +void initElementEncoding(ElementEncoding *This, Element *element) { + This->element = element; + This->type = ELEM_UNASSIGNED; + This->variables = NULL; + This->encodingArray = NULL; + This->inUseArray = NULL; + This->numVars = 0; + This->encArraySize = 0; } void deleteElementEncoding(ElementEncoding *This) { - if (This->variables!=NULL) + if (This->variables != NULL) ourfree(This->variables); - if (This->encodingArray!=NULL) + if (This->encodingArray != NULL) ourfree(This->encodingArray); - if (This->inUseArray!=NULL) + if (This->inUseArray != NULL) ourfree(This->inUseArray); } void allocEncodingArrayElement(ElementEncoding *This, uint size) { - This->encodingArray=ourcalloc(1, sizeof(uint64_t)*size); - This->encArraySize=size; + This->encodingArray = ourcalloc(1, sizeof(uint64_t) * size); + This->encArraySize = size; } void allocInUseArrayElement(ElementEncoding *This, uint size) { - uint bytes = ((size + ((1 << 9)-1)) >> 6)&~7;//Depends on size of inUseArray - This->inUseArray=ourcalloc(1, bytes); + uint bytes = ((size + ((1 << 9) - 1)) >> 6) & ~7;//Depends on size of inUseArray + This->inUseArray = ourcalloc(1, bytes); } -void setElementEncodingType(ElementEncoding* This, ElementEncodingType type){ +void setElementEncodingType(ElementEncoding *This, ElementEncodingType type) { This->type = type; } diff --git a/src/Encoders/elementencoding.h b/src/Encoders/elementencoding.h index 61bdb3e..c0f0d2d 100644 --- a/src/Encoders/elementencoding.h +++ b/src/Encoders/elementencoding.h @@ -12,12 +12,12 @@ typedef enum ElementEncodingType ElementEncodingType; struct ElementEncoding { ElementEncodingType type; - Element * element; - Edge * variables;/* List Variables Used To Encode Element */ + Element *element; + Edge *variables;/* List Variables Used To Encode Element */ union { struct { - uint64_t * encodingArray; /* List the Variables in the appropriate order */ - uint64_t * inUseArray;/* Bitmap to track variables in use */ + uint64_t *encodingArray; /* List the Variables in the appropriate order */ + uint64_t *inUseArray; /* Bitmap to track variables in use */ uint encArraySize; }; struct { @@ -32,19 +32,19 @@ struct ElementEncoding { }; void initElementEncoding(ElementEncoding *This, Element *element); -static inline ElementEncodingType getElementEncodingType(ElementEncoding * This) {return This->type;} -void setElementEncodingType(ElementEncoding* This, ElementEncodingType type); +static inline ElementEncodingType getElementEncodingType(ElementEncoding *This) {return This->type;} +void setElementEncodingType(ElementEncoding *This, ElementEncodingType type); void deleteElementEncoding(ElementEncoding *This); void allocEncodingArrayElement(ElementEncoding *This, uint size); void allocInUseArrayElement(ElementEncoding *This, uint size); static inline uint numEncodingVars(ElementEncoding *This) {return This->numVars;} static inline bool isinUseElement(ElementEncoding *This, uint offset) { - return (This->inUseArray[(offset>>6)] >> (offset & 63)) &0x1; + return (This->inUseArray[(offset >> 6)] >> (offset & 63)) & 0x1; } static inline void setInUseElement(ElementEncoding *This, uint offset) { - This->inUseArray[(offset>>6)] |= 1 << (offset & 63); + This->inUseArray[(offset >> 6)] |= 1 << (offset & 63); } #endif diff --git a/src/Encoders/functionencoding.c b/src/Encoders/functionencoding.c index 74cfb76..75910cf 100644 --- a/src/Encoders/functionencoding.c +++ b/src/Encoders/functionencoding.c @@ -1,18 +1,18 @@ #include "functionencoding.h" void initFunctionEncoding(FunctionEncoding *This, Element *function) { - This->op.function=function; - This->type=FUNC_UNASSIGNED; + This->op.function = function; + This->type = FUNC_UNASSIGNED; } void initPredicateEncoding(FunctionEncoding *This, Boolean *predicate) { - This->op.predicate=predicate; - This->type=FUNC_UNASSIGNED; + This->op.predicate = predicate; + This->type = FUNC_UNASSIGNED; } void deleteFunctionEncoding(FunctionEncoding *This) { } -void setFunctionEncodingType(FunctionEncoding* encoding, FunctionEncodingType type){ - encoding->type=type; +void setFunctionEncodingType(FunctionEncoding *encoding, FunctionEncodingType type) { + encoding->type = type; } diff --git a/src/Encoders/functionencoding.h b/src/Encoders/functionencoding.h index fa8729e..bc98cd3 100644 --- a/src/Encoders/functionencoding.h +++ b/src/Encoders/functionencoding.h @@ -9,8 +9,8 @@ enum FunctionEncodingType { typedef enum FunctionEncodingType FunctionEncodingType; union ElementPredicate { - Element * function; - Boolean * predicate; + Element *function; + Boolean *predicate; }; typedef union ElementPredicate ElementPredicate; @@ -23,8 +23,8 @@ struct FunctionEncoding { void initFunctionEncoding(FunctionEncoding *encoding, Element *function); void initPredicateEncoding(FunctionEncoding *encoding, Boolean *predicate); -void setFunctionEncodingType(FunctionEncoding* encoding, FunctionEncodingType type); -static inline FunctionEncodingType getFunctionEncodingType(FunctionEncoding* This) {return This->type;} +void setFunctionEncodingType(FunctionEncoding *encoding, FunctionEncodingType type); +static inline FunctionEncodingType getFunctionEncodingType(FunctionEncoding *This) {return This->type;} void deleteFunctionEncoding(FunctionEncoding *This); #endif diff --git a/src/Encoders/naiveencoder.c b/src/Encoders/naiveencoder.c index bc64cc4..a7941a6 100644 --- a/src/Encoders/naiveencoder.c +++ b/src/Encoders/naiveencoder.c @@ -13,20 +13,20 @@ #include "order.h" #include -void naiveEncodingDecision(CSolver* This) { - for (uint i=0; i < getSizeVectorBoolean(This->constraints); i++) { - Boolean* boolean = getVectorBoolean(This->constraints, i); +void naiveEncodingDecision(CSolver *This) { + for (uint i = 0; i < getSizeVectorBoolean(This->constraints); i++) { + Boolean *boolean = getVectorBoolean(This->constraints, i); naiveEncodingConstraint(boolean); } } -void naiveEncodingConstraint(Boolean * This) { - switch(GETBOOLEANTYPE(This)) { +void naiveEncodingConstraint(Boolean *This) { + switch (GETBOOLEANTYPE(This)) { case BOOLEANVAR: { return; } case ORDERCONST: { - setOrderEncodingType( ((BooleanOrder*)This)->order, PAIRWISE ); + setOrderEncodingType( ((BooleanOrder *)This)->order, PAIRWISE ); return; } case LOGICOP: { @@ -42,34 +42,34 @@ void naiveEncodingConstraint(Boolean * This) { } } -void naiveEncodingLogicOp(BooleanLogic * This) { - for(uint i=0; i < getSizeArrayBoolean(&This->inputs); i++) { +void naiveEncodingLogicOp(BooleanLogic *This) { + for (uint i = 0; i < getSizeArrayBoolean(&This->inputs); i++) { naiveEncodingConstraint(getArrayBoolean(&This->inputs, i)); } } -void naiveEncodingPredicate(BooleanPredicate * This) { +void naiveEncodingPredicate(BooleanPredicate *This) { FunctionEncoding *encoding = getPredicateFunctionEncoding(This); if (getFunctionEncodingType(encoding) == FUNC_UNASSIGNED) setFunctionEncodingType(getPredicateFunctionEncoding(This), ENUMERATEIMPLICATIONS); - for(uint i=0; i < getSizeArrayElement(&This->inputs); i++) { - Element *element=getArrayElement(&This->inputs, i); + for (uint i = 0; i < getSizeArrayElement(&This->inputs); i++) { + Element *element = getArrayElement(&This->inputs, i); naiveEncodingElement(element); } } -void naiveEncodingElement(Element * This) { - ElementEncoding * encoding = getElementEncoding(This); +void naiveEncodingElement(Element *This) { + ElementEncoding *encoding = getElementEncoding(This); if (getElementEncodingType(encoding) == ELEM_UNASSIGNED) { setElementEncodingType(encoding, BINARYINDEX); encodingArrayInitialization(encoding); } - - if(GETELEMENTTYPE(This) == ELEMFUNCRETURN) { - ElementFunction *function=(ElementFunction *) This; - for(uint i=0; i < getSizeArrayElement(&function->inputs); i++) { - Element * element=getArrayElement(&function->inputs, i); + + if (GETELEMENTTYPE(This) == ELEMFUNCRETURN) { + ElementFunction *function = (ElementFunction *) This; + for (uint i = 0; i < getSizeArrayElement(&function->inputs); i++) { + Element *element = getArrayElement(&function->inputs, i); naiveEncodingElement(element); } FunctionEncoding *encoding = getElementFunctionEncoding(function); @@ -78,29 +78,29 @@ void naiveEncodingElement(Element * This) { } } -uint getSizeEncodingArray(ElementEncoding *This, uint setSize){ - switch(This->type){ - case BINARYINDEX: - return NEXTPOW2(setSize); - case ONEHOT: - case UNARY: - return setSize; - default: - ASSERT(0); +uint getSizeEncodingArray(ElementEncoding *This, uint setSize) { + switch (This->type) { + case BINARYINDEX: + return NEXTPOW2(setSize); + case ONEHOT: + case UNARY: + return setSize; + default: + ASSERT(0); } return -1; } void encodingArrayInitialization(ElementEncoding *This) { - Element * element=This->element; - Set * set= getElementSet(element); - ASSERT(set->isRange==false); - uint size=getSizeVectorInt(set->members); - uint encSize=getSizeEncodingArray(This, size); + Element *element = This->element; + Set *set = getElementSet(element); + ASSERT(set->isRange == false); + uint size = getSizeVectorInt(set->members); + uint encSize = getSizeEncodingArray(This, size); allocEncodingArrayElement(This, encSize); allocInUseArrayElement(This, encSize); - for(uint i=0;iencodingArray[i]=getVectorInt(set->members, i); + for (uint i = 0; i < size; i++) { + This->encodingArray[i] = getVectorInt(set->members, i); setInUseElement(This, i); } } diff --git a/src/Encoders/naiveencoder.h b/src/Encoders/naiveencoder.h index a4b9ec1..c3260a0 100644 --- a/src/Encoders/naiveencoder.h +++ b/src/Encoders/naiveencoder.h @@ -9,11 +9,11 @@ * @param encoder */ -void naiveEncodingDecision(CSolver* csolver); -void naiveEncodingConstraint(Boolean * This); -void naiveEncodingLogicOp(BooleanLogic * This); -void naiveEncodingPredicate(BooleanPredicate * This); -void naiveEncodingElement(Element * This); +void naiveEncodingDecision(CSolver *csolver); +void naiveEncodingConstraint(Boolean *This); +void naiveEncodingLogicOp(BooleanLogic *This); +void naiveEncodingPredicate(BooleanPredicate *This); +void naiveEncodingElement(Element *This); void encodingArrayInitialization(ElementEncoding *This); uint getSizeEncodingArray(ElementEncoding *, uint setSize); diff --git a/src/Encoders/orderedge.c b/src/Encoders/orderedge.c index bc22a83..c4632da 100644 --- a/src/Encoders/orderedge.c +++ b/src/Encoders/orderedge.c @@ -1,8 +1,8 @@ #include "orderedge.h" #include "ordergraph.h" -OrderEdge* allocOrderEdge(OrderNode* source, OrderNode* sink) { - OrderEdge* This = (OrderEdge*) ourmalloc(sizeof(OrderEdge)); +OrderEdge *allocOrderEdge(OrderNode *source, OrderNode *sink) { + OrderEdge *This = (OrderEdge *) ourmalloc(sizeof(OrderEdge)); This->source = source; This->sink = sink; This->polPos = false; @@ -13,7 +13,7 @@ OrderEdge* allocOrderEdge(OrderNode* source, OrderNode* sink) { return This; } -void deleteOrderEdge(OrderEdge* This) { +void deleteOrderEdge(OrderEdge *This) { ourfree(This); } diff --git a/src/Encoders/orderedge.h b/src/Encoders/orderedge.h index a34e3d2..21fa903 100644 --- a/src/Encoders/orderedge.h +++ b/src/Encoders/orderedge.h @@ -1,4 +1,4 @@ -/* +/* * File: orderedge.h * Author: hamed * @@ -11,22 +11,22 @@ #include "mymemory.h" struct OrderEdge { - OrderNode* source; - OrderNode* sink; - unsigned int polPos:1; - unsigned int polNeg:1; - unsigned int mustPos:1; - unsigned int mustNeg:1; - unsigned int pseudoPos:1; + OrderNode *source; + OrderNode *sink; + unsigned int polPos : 1; + unsigned int polNeg : 1; + unsigned int mustPos : 1; + unsigned int mustNeg : 1; + unsigned int pseudoPos : 1; }; -OrderEdge* allocOrderEdge(OrderNode* begin, OrderNode* end); -void deleteOrderEdge(OrderEdge* This); -void setPseudoPos(OrderGraph *graph, OrderEdge* edge); +OrderEdge *allocOrderEdge(OrderNode *begin, OrderNode *end); +void deleteOrderEdge(OrderEdge *This); +void setPseudoPos(OrderGraph *graph, OrderEdge *edge); void setMustPos(OrderGraph *graph, OrderEdge *edge); void setMustNeg(OrderGraph *graph, OrderEdge *edge); void setPolPos(OrderGraph *graph, OrderEdge *edge); void setPolNeg(OrderGraph *graph, OrderEdge *edge); -#endif /* ORDEREDGE_H */ +#endif/* ORDEREDGE_H */ diff --git a/src/Encoders/orderencoder.c b/src/Encoders/orderencoder.c index ee3480d..103b962 100644 --- a/src/Encoders/orderencoder.c +++ b/src/Encoders/orderencoder.c @@ -7,20 +7,20 @@ #include "ordernode.h" #include "rewriter.h" -OrderGraph* buildOrderGraph(Order *order) { - OrderGraph* orderGraph = allocOrderGraph(order); +OrderGraph *buildOrderGraph(Order *order) { + OrderGraph *orderGraph = allocOrderGraph(order); uint constrSize = getSizeVectorBooleanOrder(&order->constraints); - for(uint j=0; jconstraints, j)); } return orderGraph; } -void DFS(OrderGraph* graph, VectorOrderNode* finishNodes) { - HSIteratorOrderNode* iterator = iteratorOrderNode(graph->nodes); - while(hasNextOrderNode(iterator)){ - OrderNode* node = nextOrderNode(iterator); - if(node->status == NOTVISITED){ +void DFS(OrderGraph *graph, VectorOrderNode *finishNodes) { + HSIteratorOrderNode *iterator = iteratorOrderNode(graph->nodes); + while (hasNextOrderNode(iterator)) { + OrderNode *node = nextOrderNode(iterator); + if (node->status == NOTVISITED) { node->status = VISITED; DFSNodeVisit(node, finishNodes, false, 0); node->status = FINISHED; @@ -30,12 +30,12 @@ void DFS(OrderGraph* graph, VectorOrderNode* finishNodes) { deleteIterOrderNode(iterator); } -void DFSReverse(OrderGraph* graph, VectorOrderNode* finishNodes) { +void DFSReverse(OrderGraph *graph, VectorOrderNode *finishNodes) { uint size = getSizeVectorOrderNode(finishNodes); - uint sccNum=1; - for(int i=size-1; i>=0; i--){ - OrderNode* node = getVectorOrderNode(finishNodes, i); - if(node->status == NOTVISITED){ + uint sccNum = 1; + for (int i = size - 1; i >= 0; i--) { + OrderNode *node = getVectorOrderNode(finishNodes, i); + if (node->status == NOTVISITED) { node->status = VISITED; DFSNodeVisit(node, NULL, true, sccNum); node->sccNum = sccNum; @@ -45,21 +45,21 @@ void DFSReverse(OrderGraph* graph, VectorOrderNode* finishNodes) { } } -void DFSNodeVisit(OrderNode* node, VectorOrderNode* finishNodes, bool isReverse, uint sccNum) { - HSIteratorOrderEdge* iterator = isReverse?iteratorOrderEdge(node->inEdges):iteratorOrderEdge(node->outEdges); - while(hasNextOrderEdge(iterator)){ - OrderEdge* edge = nextOrderEdge(iterator); - if (!edge->polPos && !edge->pseudoPos) //Ignore edges that do not have positive polarity +void DFSNodeVisit(OrderNode *node, VectorOrderNode *finishNodes, bool isReverse, uint sccNum) { + HSIteratorOrderEdge *iterator = isReverse ? iteratorOrderEdge(node->inEdges) : iteratorOrderEdge(node->outEdges); + while (hasNextOrderEdge(iterator)) { + OrderEdge *edge = nextOrderEdge(iterator); + if (!edge->polPos && !edge->pseudoPos)//Ignore edges that do not have positive polarity continue; - - OrderNode* child = isReverse? edge->source: edge->sink; - if(child->status == NOTVISITED) { + OrderNode *child = isReverse ? edge->source : edge->sink; + + if (child->status == NOTVISITED) { child->status = VISITED; DFSNodeVisit(child, finishNodes, isReverse, sccNum); child->status = FINISHED; - if(!isReverse) - pushVectorOrderNode(finishNodes, child); + if (!isReverse) + pushVectorOrderNode(finishNodes, child); else child->sccNum = sccNum; } @@ -67,17 +67,17 @@ void DFSNodeVisit(OrderNode* node, VectorOrderNode* finishNodes, bool isReverse, deleteIterOrderEdge(iterator); } -void resetNodeInfoStatusSCC(OrderGraph* graph) { - HSIteratorOrderNode* iterator = iteratorOrderNode(graph->nodes); - while(hasNextOrderNode(iterator)){ +void resetNodeInfoStatusSCC(OrderGraph *graph) { + HSIteratorOrderNode *iterator = iteratorOrderNode(graph->nodes); + while (hasNextOrderNode(iterator)) { nextOrderNode(iterator)->status = NOTVISITED; } deleteIterOrderNode(iterator); } -void computeStronglyConnectedComponentGraph(OrderGraph* graph) { +void computeStronglyConnectedComponentGraph(OrderGraph *graph) { VectorOrderNode finishNodes; - initDefVectorOrderNode(& finishNodes); + initDefVectorOrderNode(&finishNodes); DFS(graph, &finishNodes); resetNodeInfoStatusSCC(graph); DFSReverse(graph, &finishNodes); @@ -85,32 +85,32 @@ void computeStronglyConnectedComponentGraph(OrderGraph* graph) { deleteVectorArrayOrderNode(&finishNodes); } -void removeMustBeTrueNodes(OrderGraph* graph) { +void removeMustBeTrueNodes(OrderGraph *graph) { //TODO: Nodes that all the incoming/outgoing edges are MUST_BE_TRUE } -void DFSPseudoNodeVisit(OrderGraph *graph, OrderNode* node) { - HSIteratorOrderEdge* iterator = iteratorOrderEdge(node->inEdges); - while(hasNextOrderEdge(iterator)){ - OrderEdge* inEdge = nextOrderEdge(iterator); +void DFSPseudoNodeVisit(OrderGraph *graph, OrderNode *node) { + HSIteratorOrderEdge *iterator = iteratorOrderEdge(node->inEdges); + while (hasNextOrderEdge(iterator)) { + OrderEdge *inEdge = nextOrderEdge(iterator); if (inEdge->polNeg) { - OrderNode* src = inEdge->source; - if (src->status==VISITED) { + OrderNode *src = inEdge->source; + if (src->status == VISITED) { //Make a pseudoEdge to point backwards - OrderEdge * newedge = getOrderEdgeFromOrderGraph(graph, inEdge->sink, inEdge->source); + OrderEdge *newedge = getOrderEdgeFromOrderGraph(graph, inEdge->sink, inEdge->source); newedge->pseudoPos = true; } } } deleteIterOrderEdge(iterator); iterator = iteratorOrderEdge(node->outEdges); - while(hasNextOrderEdge(iterator)){ - OrderEdge* edge = nextOrderEdge(iterator); - if (!edge->polPos) //Ignore edges that do not have positive polarity + while (hasNextOrderEdge(iterator)) { + OrderEdge *edge = nextOrderEdge(iterator); + if (!edge->polPos)//Ignore edges that do not have positive polarity continue; - - OrderNode* child = edge->sink; - if(child->status == NOTVISITED){ + + OrderNode *child = edge->sink; + if (child->status == NOTVISITED) { child->status = VISITED; DFSPseudoNodeVisit(graph, child); child->status = FINISHED; @@ -119,16 +119,16 @@ void DFSPseudoNodeVisit(OrderGraph *graph, OrderNode* node) { deleteIterOrderEdge(iterator); } -void completePartialOrderGraph(OrderGraph* graph) { +void completePartialOrderGraph(OrderGraph *graph) { VectorOrderNode finishNodes; - initDefVectorOrderNode(& finishNodes); + initDefVectorOrderNode(&finishNodes); DFS(graph, &finishNodes); resetNodeInfoStatusSCC(graph); uint size = getSizeVectorOrderNode(&finishNodes); - for(int i=size-1; i>=0; i--){ - OrderNode* node = getVectorOrderNode(&finishNodes, i); - if(node->status == NOTVISITED){ + for (int i = size - 1; i >= 0; i--) { + OrderNode *node = getVectorOrderNode(&finishNodes, i); + if (node->status == NOTVISITED) { node->status = VISITED; DFSPseudoNodeVisit(graph, node); node->status = FINISHED; @@ -139,11 +139,11 @@ void completePartialOrderGraph(OrderGraph* graph) { deleteVectorArrayOrderNode(&finishNodes); } -void DFSMust(OrderGraph* graph, VectorOrderNode* finishNodes) { - HSIteratorOrderNode* iterator = iteratorOrderNode(graph->nodes); - while(hasNextOrderNode(iterator)){ - OrderNode* node = nextOrderNode(iterator); - if(node->status == NOTVISITED){ +void DFSMust(OrderGraph *graph, VectorOrderNode *finishNodes) { + HSIteratorOrderNode *iterator = iteratorOrderNode(graph->nodes); + while (hasNextOrderNode(iterator)) { + OrderNode *node = nextOrderNode(iterator); + if (node->status == NOTVISITED) { node->status = VISITED; DFSMustNodeVisit(node, finishNodes, false); node->status = FINISHED; @@ -153,12 +153,12 @@ void DFSMust(OrderGraph* graph, VectorOrderNode* finishNodes) { deleteIterOrderNode(iterator); } -void DFSMustNodeVisit(OrderNode* node, VectorOrderNode* finishNodes, bool clearBackEdges) { +void DFSMustNodeVisit(OrderNode *node, VectorOrderNode *finishNodes, bool clearBackEdges) { //First compute implication of transitive closure on must pos edges - HSIteratorOrderEdge* iterator = iteratorOrderEdge(node->outEdges); - while(hasNextOrderEdge(iterator)){ - OrderEdge* edge = nextOrderEdge(iterator); - OrderNode* parent = edge->source; + HSIteratorOrderEdge *iterator = iteratorOrderEdge(node->outEdges); + while (hasNextOrderEdge(iterator)) { + OrderEdge *edge = nextOrderEdge(iterator); + OrderNode *parent = edge->source; if (parent->status == VISITED) { edge->mustPos = true; } @@ -167,33 +167,33 @@ void DFSMustNodeVisit(OrderNode* node, VectorOrderNode* finishNodes, bool clearB //Next compute implication of transitive closure on must neg edges iterator = iteratorOrderEdge(node->outEdges); - while(hasNextOrderEdge(iterator)){ - OrderEdge* edge = nextOrderEdge(iterator); - OrderNode* child = edge->sink; - - if (clearBackEdges && child->status==VISITED) { + while (hasNextOrderEdge(iterator)) { + OrderEdge *edge = nextOrderEdge(iterator); + OrderNode *child = edge->sink; + + if (clearBackEdges && child->status == VISITED) { //We have a backedge, so note that this edge must be negative edge->mustNeg = true; } - if (!edge->mustPos) //Ignore edges that are not must Positive edges + if (!edge->mustPos) //Ignore edges that are not must Positive edges continue; - if(child->status == NOTVISITED){ + if (child->status == NOTVISITED) { child->status = VISITED; DFSMustNodeVisit(child, finishNodes, clearBackEdges); child->status = FINISHED; - pushVectorOrderNode(finishNodes, child); + pushVectorOrderNode(finishNodes, child); } } deleteIterOrderEdge(iterator); } -void DFSClearContradictions(OrderGraph* graph, VectorOrderNode* finishNodes) { - uint size=getSizeVectorOrderNode(finishNodes); - for(int i=size-1; i>=0; i--){ - OrderNode* node=getVectorOrderNode(finishNodes, i); - if(node->status == NOTVISITED){ +void DFSClearContradictions(OrderGraph *graph, VectorOrderNode *finishNodes) { + uint size = getSizeVectorOrderNode(finishNodes); + for (int i = size - 1; i >= 0; i--) { + OrderNode *node = getVectorOrderNode(finishNodes, i); + if (node->status == NOTVISITED) { node->status = VISITED; DFSMustNodeVisit(node, NULL, true); node->status = FINISHED; @@ -202,13 +202,13 @@ void DFSClearContradictions(OrderGraph* graph, VectorOrderNode* finishNodes) { } /* This function finds edges that would form a cycle with must edges - and forces them to be mustNeg. It also decides whether an edge - must be true because of transitivity from other must be true - edges. */ + and forces them to be mustNeg. It also decides whether an edge + must be true because of transitivity from other must be true + edges. */ void reachMustAnalysis(OrderGraph *graph) { VectorOrderNode finishNodes; - initDefVectorOrderNode(& finishNodes); + initDefVectorOrderNode(&finishNodes); //Topologically sort the mustPos edge graph DFSMust(graph, &finishNodes); resetNodeInfoStatusSCC(graph); @@ -220,16 +220,16 @@ void reachMustAnalysis(OrderGraph *graph) { } /* This function finds edges that must be positive and forces the - inverse edge to be negative (and clears its positive polarity if it - had one). */ + inverse edge to be negative (and clears its positive polarity if it + had one). */ void localMustAnalysisTotal(OrderGraph *graph) { - HSIteratorOrderEdge* iterator = iteratorOrderEdge(graph->edges); - while(hasNextOrderEdge(iterator)) { + HSIteratorOrderEdge *iterator = iteratorOrderEdge(graph->edges); + while (hasNextOrderEdge(iterator)) { OrderEdge *edge = nextOrderEdge(iterator); - if (edge -> mustPos) { - OrderEdge *invEdge=getInverseOrderEdge(graph, edge); - if (invEdge!= NULL && !invEdge -> mustPos && invEdge->polPos) { + if (edge->mustPos) { + OrderEdge *invEdge = getInverseOrderEdge(graph, edge); + if (invEdge != NULL && !invEdge->mustPos && invEdge->polPos) { invEdge->polPos = false; } invEdge->mustNeg = true; @@ -239,20 +239,20 @@ void localMustAnalysisTotal(OrderGraph *graph) { } /** This finds edges that must be positive and forces the inverse edge - to be negative. It also clears the negative flag of this edge. - It also finds edges that must be negative and clears the positive - polarity. */ + to be negative. It also clears the negative flag of this edge. + It also finds edges that must be negative and clears the positive + polarity. */ void localMustAnalysisPartial(OrderGraph *graph) { - HSIteratorOrderEdge* iterator = iteratorOrderEdge(graph->edges); - while(hasNextOrderEdge(iterator)) { + HSIteratorOrderEdge *iterator = iteratorOrderEdge(graph->edges); + while (hasNextOrderEdge(iterator)) { OrderEdge *edge = nextOrderEdge(iterator); - if (edge -> mustPos) { + if (edge->mustPos) { if (edge->polNeg && !edge->mustNeg) { edge->polNeg = false; } - OrderEdge *invEdge=getInverseOrderEdge(graph, edge); - if (invEdge != NULL && !invEdge -> mustPos) { + OrderEdge *invEdge = getInverseOrderEdge(graph, edge); + if (invEdge != NULL && !invEdge->mustPos) { invEdge->polPos = false; } invEdge->mustNeg = true; @@ -265,12 +265,12 @@ void localMustAnalysisPartial(OrderGraph *graph) { } void decomposeOrder(Order *order, OrderGraph *graph) { - uint size=getSizeVectorBooleanOrder(&order->constraints); - for(uint i=0;iconstraints, i); - OrderNode *from=getOrderNodeFromOrderGraph(graph, orderconstraint->first); - OrderNode *to=getOrderNodeFromOrderGraph(graph, orderconstraint->second); - OrderEdge* edge=getOrderEdgeFromOrderGraph(graph, from, to); + uint size = getSizeVectorBooleanOrder(&order->constraints); + for (uint i = 0; i < size; i++) { + BooleanOrder *orderconstraint = getVectorBooleanOrder(&order->constraints, i); + OrderNode *from = getOrderNodeFromOrderGraph(graph, orderconstraint->first); + OrderNode *to = getOrderNodeFromOrderGraph(graph, orderconstraint->second); + OrderEdge *edge = getOrderEdgeFromOrderGraph(graph, from, to); if (from->sccNum < to->sccNum) { //replace with true replaceBooleanWithTrue((Boolean *)orderconstraint); @@ -284,12 +284,12 @@ void decomposeOrder(Order *order, OrderGraph *graph) { } } -void orderAnalysis(CSolver* This) { +void orderAnalysis(CSolver *This) { uint size = getSizeVectorOrder(This->allOrders); - for(uint i=0; iallOrders, i); - OrderGraph* graph = buildOrderGraph(order); - if (order->type==PARTIAL) { + for (uint i = 0; i < size; i++) { + Order *order = getVectorOrder(This->allOrders, i); + OrderGraph *graph = buildOrderGraph(order); + if (order->type == PARTIAL) { //Required to do SCC analysis for partial order graphs. It //makes sure we don't incorrectly optimize graphs with negative //polarity edges @@ -298,9 +298,9 @@ void orderAnalysis(CSolver* This) { //This analysis is completely optional reachMustAnalysis(graph); - + //This pair of analysis is also optional - if (order->type==PARTIAL) { + if (order->type == PARTIAL) { localMustAnalysisPartial(graph); } else { localMustAnalysisTotal(graph); @@ -313,7 +313,7 @@ void orderAnalysis(CSolver* This) { computeStronglyConnectedComponentGraph(graph); decomposeOrder(order, graph); - + deleteOrderGraph(graph); } } diff --git a/src/Encoders/orderencoder.h b/src/Encoders/orderencoder.h index e25ee42..c48a0f7 100644 --- a/src/Encoders/orderencoder.h +++ b/src/Encoders/orderencoder.h @@ -1,4 +1,4 @@ -/* +/* * File: orderencoder.h * Author: hamed * @@ -11,26 +11,26 @@ #include "structs.h" #include "mymemory.h" -OrderGraph* buildOrderGraph(Order *order); -void computeStronglyConnectedComponentGraph(OrderGraph* graph); -void orderAnalysis(CSolver* solver); -void initializeNodeInfoSCC(OrderGraph* graph); -void DFSNodeVisit(OrderNode* node, VectorOrderNode* finishNodes, bool isReverse, uint sccNum); -void DFS(OrderGraph* graph, VectorOrderNode* finishNodes); -void DFSReverse(OrderGraph* graph, VectorOrderNode* finishNodes); -void completePartialOrderGraph(OrderGraph* graph); -void resetNodeInfoStatusSCC(OrderGraph* graph); -void removeMustBeTrueNodes(OrderGraph* graph); -void DFSPseudoNodeVisit(OrderGraph *graph, OrderNode* node); -void completePartialOrderGraph(OrderGraph* graph); -void DFSMust(OrderGraph* graph, VectorOrderNode* finishNodes); -void DFSMustNodeVisit(OrderNode* node, VectorOrderNode* finishNodes, bool clearBackEdges); -void DFSClearContradictions(OrderGraph* graph, VectorOrderNode* finishNodes); +OrderGraph *buildOrderGraph(Order *order); +void computeStronglyConnectedComponentGraph(OrderGraph *graph); +void orderAnalysis(CSolver *solver); +void initializeNodeInfoSCC(OrderGraph *graph); +void DFSNodeVisit(OrderNode *node, VectorOrderNode *finishNodes, bool isReverse, uint sccNum); +void DFS(OrderGraph *graph, VectorOrderNode *finishNodes); +void DFSReverse(OrderGraph *graph, VectorOrderNode *finishNodes); +void completePartialOrderGraph(OrderGraph *graph); +void resetNodeInfoStatusSCC(OrderGraph *graph); +void removeMustBeTrueNodes(OrderGraph *graph); +void DFSPseudoNodeVisit(OrderGraph *graph, OrderNode *node); +void completePartialOrderGraph(OrderGraph *graph); +void DFSMust(OrderGraph *graph, VectorOrderNode *finishNodes); +void DFSMustNodeVisit(OrderNode *node, VectorOrderNode *finishNodes, bool clearBackEdges); +void DFSClearContradictions(OrderGraph *graph, VectorOrderNode *finishNodes); void reachMustAnalysis(OrderGraph *graph); void localMustAnalysisTotal(OrderGraph *graph); void localMustAnalysisPartial(OrderGraph *graph); -void orderAnalysis(CSolver* This); +void orderAnalysis(CSolver *This); void decomposeOrder(Order *order, OrderGraph *graph); -#endif /* ORDERGRAPHBUILDER_H */ +#endif/* ORDERGRAPHBUILDER_H */ diff --git a/src/Encoders/orderencoding.c b/src/Encoders/orderencoding.c index 1f1d93f..51dddcc 100644 --- a/src/Encoders/orderencoding.c +++ b/src/Encoders/orderencoding.c @@ -1,8 +1,8 @@ #include "orderencoding.h" -void initOrderEncoding(OrderEncoding * This, Order *order) { - This->type=ORDER_UNASSIGNED; - This->order=order; +void initOrderEncoding(OrderEncoding *This, Order *order) { + This->type = ORDER_UNASSIGNED; + This->order = order; } void deleteOrderEncoding(OrderEncoding *This) { diff --git a/src/Encoders/orderencoding.h b/src/Encoders/orderencoding.h index f408d66..3b7b4f7 100644 --- a/src/Encoders/orderencoding.h +++ b/src/Encoders/orderencoding.h @@ -13,7 +13,7 @@ struct OrderEncoding { Order *order; }; -void initOrderEncoding(OrderEncoding * This, Order *order); +void initOrderEncoding(OrderEncoding *This, Order *order); void deleteOrderEncoding(OrderEncoding *This); #endif diff --git a/src/Encoders/ordergraph.c b/src/Encoders/ordergraph.c index e6cb64e..a9ab298 100644 --- a/src/Encoders/ordergraph.c +++ b/src/Encoders/ordergraph.c @@ -5,40 +5,40 @@ #include "ordergraph.h" #include "order.h" -OrderGraph* allocOrderGraph(Order *order) { - OrderGraph* This = (OrderGraph*) ourmalloc(sizeof(OrderGraph)); +OrderGraph *allocOrderGraph(Order *order) { + OrderGraph *This = (OrderGraph *) ourmalloc(sizeof(OrderGraph)); This->nodes = allocHashSetOrderNode(HT_INITIAL_CAPACITY, HT_DEFAULT_FACTOR); This->order = order; return This; } -void addOrderEdge(OrderGraph* graph, OrderNode* node1, OrderNode* node2, BooleanOrder* constr) { - Polarity polarity=constr->base.polarity; - BooleanValue mustval=constr->base.boolVal; - Order* order=graph->order; - switch(polarity) { +void addOrderEdge(OrderGraph *graph, OrderNode *node1, OrderNode *node2, BooleanOrder *constr) { + Polarity polarity = constr->base.polarity; + BooleanValue mustval = constr->base.boolVal; + Order *order = graph->order; + switch (polarity) { case P_BOTHTRUEFALSE: - case P_TRUE:{ - OrderEdge* _1to2 = getOrderEdgeFromOrderGraph(graph, node1, node2); - if (mustval==BV_MUSTBETRUE || mustval == BV_UNSAT) + case P_TRUE: { + OrderEdge *_1to2 = getOrderEdgeFromOrderGraph(graph, node1, node2); + if (mustval == BV_MUSTBETRUE || mustval == BV_UNSAT) _1to2->mustPos = true; _1to2->polPos = true; addNewOutgoingEdge(node1, _1to2); addNewIncomingEdge(node2, _1to2); - if(constr->base.polarity == P_TRUE) + if (constr->base.polarity == P_TRUE) break; } - case P_FALSE:{ - if (order->type==TOTAL) { - OrderEdge* _2to1 = getOrderEdgeFromOrderGraph(graph, node2, node1); - if (mustval==BV_MUSTBEFALSE || mustval == BV_UNSAT) + case P_FALSE: { + if (order->type == TOTAL) { + OrderEdge *_2to1 = getOrderEdgeFromOrderGraph(graph, node2, node1); + if (mustval == BV_MUSTBEFALSE || mustval == BV_UNSAT) _2to1->mustPos = true; _2to1->polPos = true; addNewOutgoingEdge(node2, _2to1); addNewIncomingEdge(node1, _2to1); } else { - OrderEdge* _1to2 = getOrderEdgeFromOrderGraph(graph, node1, node2); - if (mustval==BV_MUSTBEFALSE || mustval == BV_UNSAT) + OrderEdge *_1to2 = getOrderEdgeFromOrderGraph(graph, node1, node2); + if (mustval == BV_MUSTBEFALSE || mustval == BV_UNSAT) _1to2->mustNeg = true; _1to2->polNeg = true; addNewOutgoingEdge(node1, _1to2); @@ -52,10 +52,10 @@ void addOrderEdge(OrderGraph* graph, OrderNode* node1, OrderNode* node2, Boolean } } -OrderNode* getOrderNodeFromOrderGraph(OrderGraph* graph, uint64_t id) { - OrderNode* node = allocOrderNode(id); - OrderNode* tmp = getHashSetOrderNode(graph->nodes, node); - if( tmp != NULL){ +OrderNode *getOrderNodeFromOrderGraph(OrderGraph *graph, uint64_t id) { + OrderNode *node = allocOrderNode(id); + OrderNode *tmp = getHashSetOrderNode(graph->nodes, node); + if ( tmp != NULL) { deleteOrderNode(node); node = tmp; } else { @@ -64,10 +64,10 @@ OrderNode* getOrderNodeFromOrderGraph(OrderGraph* graph, uint64_t id) { return node; } -OrderEdge* getOrderEdgeFromOrderGraph(OrderGraph* graph, OrderNode* begin, OrderNode* end) { - OrderEdge* edge = allocOrderEdge(begin, end); - OrderEdge* tmp = getHashSetOrderEdge(graph->edges, edge); - if ( tmp!= NULL ) { +OrderEdge *getOrderEdgeFromOrderGraph(OrderGraph *graph, OrderNode *begin, OrderNode *end) { + OrderEdge *edge = allocOrderEdge(begin, end); + OrderEdge *tmp = getHashSetOrderEdge(graph->edges, edge); + if ( tmp != NULL ) { deleteOrderEdge(edge); edge = tmp; } else { @@ -76,29 +76,29 @@ OrderEdge* getOrderEdgeFromOrderGraph(OrderGraph* graph, OrderNode* begin, Order return edge; } -OrderEdge* getInverseOrderEdge(OrderGraph* graph, OrderEdge *edge) { - OrderEdge inverseedge={edge->sink, edge->source, false, false, false, false, false}; - OrderEdge * tmp=getHashSetOrderEdge(graph->edges, &inverseedge); +OrderEdge *getInverseOrderEdge(OrderGraph *graph, OrderEdge *edge) { + OrderEdge inverseedge = {edge->sink, edge->source, false, false, false, false, false}; + OrderEdge *tmp = getHashSetOrderEdge(graph->edges, &inverseedge); return tmp; } -void addOrderConstraintToOrderGraph(OrderGraph* graph, BooleanOrder* bOrder) { - OrderNode* from = getOrderNodeFromOrderGraph(graph, bOrder->first); - OrderNode* to = getOrderNodeFromOrderGraph(graph, bOrder->second); +void addOrderConstraintToOrderGraph(OrderGraph *graph, BooleanOrder *bOrder) { + OrderNode *from = getOrderNodeFromOrderGraph(graph, bOrder->first); + OrderNode *to = getOrderNodeFromOrderGraph(graph, bOrder->second); addOrderEdge(graph, from, to, bOrder); } -void deleteOrderGraph(OrderGraph* graph){ - HSIteratorOrderNode* iterator = iteratorOrderNode(graph->nodes); - while(hasNextOrderNode(iterator)){ - OrderNode* node = nextOrderNode(iterator); +void deleteOrderGraph(OrderGraph *graph) { + HSIteratorOrderNode *iterator = iteratorOrderNode(graph->nodes); + while (hasNextOrderNode(iterator)) { + OrderNode *node = nextOrderNode(iterator); deleteOrderNode(node); } deleteIterOrderNode(iterator); - - HSIteratorOrderEdge* eiterator = iteratorOrderEdge(graph->edges); - while(hasNextOrderEdge(eiterator)){ - OrderEdge* edge = nextOrderEdge(eiterator); + + HSIteratorOrderEdge *eiterator = iteratorOrderEdge(graph->edges); + while (hasNextOrderEdge(eiterator)) { + OrderEdge *edge = nextOrderEdge(eiterator); deleteOrderEdge(edge); } deleteIterOrderEdge(eiterator); diff --git a/src/Encoders/ordergraph.h b/src/Encoders/ordergraph.h index a30c9f9..5540d73 100644 --- a/src/Encoders/ordergraph.h +++ b/src/Encoders/ordergraph.h @@ -1,4 +1,4 @@ -/* +/* * File: ordergraph.h * Author: hamed * @@ -12,17 +12,17 @@ #include "mymemory.h" struct OrderGraph { - HashSetOrderNode* nodes; - HashSetOrderEdge* edges; - Order* order; + HashSetOrderNode *nodes; + HashSetOrderEdge *edges; + Order *order; }; -OrderGraph* allocOrderGraph(Order *order); -void addOrderConstraintToOrderGraph(OrderGraph* graph, BooleanOrder* bOrder); -OrderNode* getOrderNodeFromOrderGraph(OrderGraph* graph, uint64_t id); -OrderEdge* getOrderEdgeFromOrderGraph(OrderGraph* graph, OrderNode* begin, OrderNode* end); -void addOrderEdge(OrderGraph* graph, OrderNode* node1, OrderNode* node2, BooleanOrder* constr); -void deleteOrderGraph(OrderGraph* graph); -OrderEdge* getInverseOrderEdge(OrderGraph* graph, OrderEdge *edge); -#endif /* ORDERGRAPH_H */ +OrderGraph *allocOrderGraph(Order *order); +void addOrderConstraintToOrderGraph(OrderGraph *graph, BooleanOrder *bOrder); +OrderNode *getOrderNodeFromOrderGraph(OrderGraph *graph, uint64_t id); +OrderEdge *getOrderEdgeFromOrderGraph(OrderGraph *graph, OrderNode *begin, OrderNode *end); +void addOrderEdge(OrderGraph *graph, OrderNode *node1, OrderNode *node2, BooleanOrder *constr); +void deleteOrderGraph(OrderGraph *graph); +OrderEdge *getInverseOrderEdge(OrderGraph *graph, OrderEdge *edge); +#endif/* ORDERGRAPH_H */ diff --git a/src/Encoders/ordernode.c b/src/Encoders/ordernode.c index 072e54c..c0bd096 100644 --- a/src/Encoders/ordernode.c +++ b/src/Encoders/ordernode.c @@ -1,27 +1,27 @@ #include "ordernode.h" #include "orderedge.h" -OrderNode* allocOrderNode(uint64_t id) { - OrderNode* This = (OrderNode*) ourmalloc(sizeof(OrderNode)); +OrderNode *allocOrderNode(uint64_t id) { + OrderNode *This = (OrderNode *) ourmalloc(sizeof(OrderNode)); This->id = id; This->inEdges = allocHashSetOrderEdge(HT_INITIAL_CAPACITY, HT_DEFAULT_FACTOR); This->outEdges = allocHashSetOrderEdge(HT_INITIAL_CAPACITY, HT_DEFAULT_FACTOR); - This->status=NOTVISITED; - This->sccNum=0; + This->status = NOTVISITED; + This->sccNum = 0; return This; } -void addNewIncomingEdge(OrderNode* node, OrderEdge* edge){ - ASSERT(!containsHashSetOrderEdge(node->inEdges, edge)); // Only for testing ... Should be removed after testing +void addNewIncomingEdge(OrderNode *node, OrderEdge *edge) { + ASSERT(!containsHashSetOrderEdge(node->inEdges, edge)); // Only for testing ... Should be removed after testing addHashSetOrderEdge(node->inEdges, edge); } -void addNewOutgoingEdge(OrderNode* node, OrderEdge* edge){ +void addNewOutgoingEdge(OrderNode *node, OrderEdge *edge) { ASSERT(!containsHashSetOrderEdge(node->outEdges, edge)); addHashSetOrderEdge(node->outEdges, edge); } -void deleteOrderNode(OrderNode* node){ +void deleteOrderNode(OrderNode *node) { deleteHashSetOrderEdge(node->inEdges); deleteHashSetOrderEdge(node->outEdges); ourfree(node); diff --git a/src/Encoders/ordernode.h b/src/Encoders/ordernode.h index 359b5bf..a6eb4db 100644 --- a/src/Encoders/ordernode.h +++ b/src/Encoders/ordernode.h @@ -1,5 +1,5 @@ -/* +/* * File: ordernode.h * Author: hamed * @@ -19,16 +19,16 @@ typedef enum NodeStatus NodeStatus; struct OrderNode { uint64_t id; - HashSetOrderEdge* inEdges; - HashSetOrderEdge* outEdges; + HashSetOrderEdge *inEdges; + HashSetOrderEdge *outEdges; NodeStatus status; uint sccNum; }; -OrderNode* allocOrderNode(uint64_t id); -void addNewIncomingEdge(OrderNode* node, OrderEdge* edge); -void addNewOutgoingEdge(OrderNode* node, OrderEdge* edge); -void deleteOrderNode(OrderNode* node); +OrderNode *allocOrderNode(uint64_t id); +void addNewIncomingEdge(OrderNode *node, OrderEdge *edge); +void addNewOutgoingEdge(OrderNode *node, OrderEdge *edge); +void deleteOrderNode(OrderNode *node); -#endif /* ORDERNODE_H */ +#endif/* ORDERNODE_H */ diff --git a/src/Encoders/polarityassignment.c b/src/Encoders/polarityassignment.c index 0ad5f88..416da2a 100644 --- a/src/Encoders/polarityassignment.c +++ b/src/Encoders/polarityassignment.c @@ -1,9 +1,9 @@ #include "polarityassignment.h" #include "csolver.h" -void computePolarities(CSolver* This) { - for (uint i=0; i < getSizeVectorBoolean(This->constraints); i++) { - Boolean* boolean = getVectorBoolean(This->constraints, i); +void computePolarities(CSolver *This) { + for (uint i = 0; i < getSizeVectorBoolean(This->constraints); i++) { + Boolean *boolean = getVectorBoolean(This->constraints, i); updatePolarity(boolean, P_TRUE); updateMustValue(boolean, BV_MUSTBETRUE); computePolarityAndBooleanValue(boolean); @@ -18,76 +18,76 @@ void updateMustValue(Boolean *This, BooleanValue value) { This->boolVal |= value; } -void computePolarityAndBooleanValue(Boolean* This) { - switch(GETBOOLEANTYPE(This)){ - case BOOLEANVAR: - case ORDERCONST: - return; - case PREDICATEOP: - return computePredicatePolarityAndBooleanValue((BooleanPredicate*)This); - case LOGICOP: - return computeLogicOpPolarityAndBooleanValue((BooleanLogic*)This); - default: - ASSERT(0); +void computePolarityAndBooleanValue(Boolean *This) { + switch (GETBOOLEANTYPE(This)) { + case BOOLEANVAR: + case ORDERCONST: + return; + case PREDICATEOP: + return computePredicatePolarityAndBooleanValue((BooleanPredicate *)This); + case LOGICOP: + return computeLogicOpPolarityAndBooleanValue((BooleanLogic *)This); + default: + ASSERT(0); } } -void computePredicatePolarityAndBooleanValue(BooleanPredicate* This){ +void computePredicatePolarityAndBooleanValue(BooleanPredicate *This) { updatePolarity(This->undefStatus, P_BOTHTRUEFALSE); computePolarityAndBooleanValue(This->undefStatus); } -void computeLogicOpPolarityAndBooleanValue(BooleanLogic* This) { +void computeLogicOpPolarityAndBooleanValue(BooleanLogic *This) { computeLogicOpBooleanValue(This); computeLogicOpPolarity(This); uint size = getSizeArrayBoolean(&This->inputs); - for(uint i=0; iinputs, i)); } } Polarity negatePolarity(Polarity This) { - switch(This){ - case P_UNDEFINED: - case P_BOTHTRUEFALSE: - return This; - case P_TRUE: - return P_FALSE; - case P_FALSE: - return P_TRUE; - default: - ASSERT(0); + switch (This) { + case P_UNDEFINED: + case P_BOTHTRUEFALSE: + return This; + case P_TRUE: + return P_FALSE; + case P_FALSE: + return P_TRUE; + default: + ASSERT(0); } } BooleanValue negateBooleanValue(BooleanValue This) { - switch(This){ - case BV_UNDEFINED: - case BV_UNSAT: - return This; - case BV_MUSTBETRUE: - return BV_MUSTBEFALSE; - case BV_MUSTBEFALSE: - return BV_MUSTBETRUE; - default: - ASSERT(0); + switch (This) { + case BV_UNDEFINED: + case BV_UNSAT: + return This; + case BV_MUSTBETRUE: + return BV_MUSTBEFALSE; + case BV_MUSTBEFALSE: + return BV_MUSTBETRUE; + default: + ASSERT(0); } } -void computeLogicOpPolarity(BooleanLogic* This) { - Polarity parentpolarity=GETBOOLEANPOLARITY(This); - switch(This->op){ +void computeLogicOpPolarity(BooleanLogic *This) { + Polarity parentpolarity = GETBOOLEANPOLARITY(This); + switch (This->op) { case L_AND: - case L_OR:{ - uint size = getSizeArrayBoolean(& This->inputs); - for(uint i=0; iinputs, i); + case L_OR: { + uint size = getSizeArrayBoolean(&This->inputs); + for (uint i = 0; i < size; i++) { + Boolean *tmp = getArrayBoolean(&This->inputs, i); updatePolarity(tmp, parentpolarity); } break; } - case L_NOT:{ - Boolean* tmp =getArrayBoolean(&This->inputs, 0); + case L_NOT: { + Boolean *tmp = getArrayBoolean(&This->inputs, 0); updatePolarity(tmp, negatePolarity(parentpolarity)); break; } @@ -96,10 +96,10 @@ void computeLogicOpPolarity(BooleanLogic* This) { updatePolarity(getArrayBoolean(&This->inputs, 1), P_BOTHTRUEFALSE); break; } - case L_IMPLIES:{ - Boolean* left = getArrayBoolean(&This->inputs, 0); + case L_IMPLIES: { + Boolean *left = getArrayBoolean(&This->inputs, 0); updatePolarity(left, negatePolarity( parentpolarity)); - Boolean *right = getArrayBoolean(&This->inputs, 1); + Boolean *right = getArrayBoolean(&This->inputs, 1); updatePolarity(right, parentpolarity); break; } @@ -108,22 +108,22 @@ void computeLogicOpPolarity(BooleanLogic* This) { } } -void computeLogicOpBooleanValue(BooleanLogic* This) { +void computeLogicOpBooleanValue(BooleanLogic *This) { BooleanValue parentbv = GETBOOLEANVALUE(This); - switch(This->op){ + switch (This->op) { case L_AND: { - if (parentbv==BV_MUSTBETRUE || parentbv==BV_UNSAT) { - uint size = getSizeArrayBoolean(& This->inputs); - for(uint i=0; iinputs); + for (uint i = 0; i < size; i++) { updateMustValue(getArrayBoolean(&This->inputs, i), parentbv); } } return; } case L_OR: { - if (parentbv==BV_MUSTBEFALSE || parentbv==BV_UNSAT) { - uint size = getSizeArrayBoolean(& This->inputs); - for(uint i=0; iinputs); + for (uint i = 0; i < size; i++) { updateMustValue(getArrayBoolean(&This->inputs, i), parentbv); } } @@ -134,8 +134,8 @@ void computeLogicOpBooleanValue(BooleanLogic* This) { return; case L_IMPLIES: //implies is really an or with the first term negated - if (parentbv==BV_MUSTBEFALSE || parentbv==BV_UNSAT) { - uint size = getSizeArrayBoolean(& This->inputs); + if (parentbv == BV_MUSTBEFALSE || parentbv == BV_UNSAT) { + uint size = getSizeArrayBoolean(&This->inputs); updateMustValue(getArrayBoolean(&This->inputs, 0), negateBooleanValue(parentbv)); updateMustValue(getArrayBoolean(&This->inputs, 1), parentbv); } diff --git a/src/Encoders/polarityassignment.h b/src/Encoders/polarityassignment.h index 5acbd9b..6621d77 100644 --- a/src/Encoders/polarityassignment.h +++ b/src/Encoders/polarityassignment.h @@ -1,4 +1,4 @@ -/* +/* * File: polarityassignment.h * Author: hamed * @@ -13,15 +13,15 @@ #include "ops.h" #include "boolean.h" -void computePolarities(CSolver* This); +void computePolarities(CSolver *This); void updatePolarity(Boolean *This, Polarity polarity); void updateMustValue(Boolean *This, BooleanValue value); -void computePolarityAndBooleanValue(Boolean* boolean); -void computePredicatePolarityAndBooleanValue(BooleanPredicate* This); -void computeLogicOpPolarityAndBooleanValue(BooleanLogic* boolean); +void computePolarityAndBooleanValue(Boolean *boolean); +void computePredicatePolarityAndBooleanValue(BooleanPredicate *This); +void computeLogicOpPolarityAndBooleanValue(BooleanLogic *boolean); Polarity negatePolarity(Polarity This); BooleanValue negateBooleanValue(BooleanValue This); -void computeLogicOpPolarity(BooleanLogic* boolean); -void computeLogicOpBooleanValue(BooleanLogic* boolean); +void computeLogicOpPolarity(BooleanLogic *boolean); +void computeLogicOpBooleanValue(BooleanLogic *boolean); -#endif /* POLARITYASSIGNMENT_H */ +#endif/* POLARITYASSIGNMENT_H */ diff --git a/src/Test/buildconstraintstest.c b/src/Test/buildconstraintstest.c index e7fffe6..71dbafd 100644 --- a/src/Test/buildconstraintstest.c +++ b/src/Test/buildconstraintstest.c @@ -13,26 +13,26 @@ * e3 == e4 * Result: UNSAT! */ -int main(int numargs, char ** argv) { - CSolver * solver=allocCSolver(); - uint64_t set1[]={0, 1, 2}; - uint64_t setbigarray[]={0, 1, 2, 3, 4}; - - Set * s=createSet(solver, 0, set1, 3); - Set * setbig=createSet(solver, 0, setbigarray, 5); - Element * e1=getElementVar(solver, s); - Element * e2=getElementVar(solver, s); - Set * domain[]={s, s}; - Predicate *equals=createPredicateOperator(solver, EQUALS, domain, 2); - Element * inputs[]={e1, e2}; - Boolean * b=applyPredicate(solver, equals, inputs, 2); +int main(int numargs, char **argv) { + CSolver *solver = allocCSolver(); + uint64_t set1[] = {0, 1, 2}; + uint64_t setbigarray[] = {0, 1, 2, 3, 4}; + + Set *s = createSet(solver, 0, set1, 3); + Set *setbig = createSet(solver, 0, setbigarray, 5); + Element *e1 = getElementVar(solver, s); + Element *e2 = getElementVar(solver, s); + Set *domain[] = {s, s}; + Predicate *equals = createPredicateOperator(solver, EQUALS, domain, 2); + Element *inputs[] = {e1, e2}; + Boolean *b = applyPredicate(solver, equals, inputs, 2); addConstraint(solver, b); uint64_t set2[] = {2, 3}; - Set* rangef1 = createSet(solver, 1, set2, 2); - Function * f1 = createFunctionOperator(solver, ADD, domain, 2, setbig, IGNORE); - - Table* table = createTable(solver, domain, 2, s); + Set *rangef1 = createSet(solver, 1, set2, 2); + Function *f1 = createFunctionOperator(solver, ADD, domain, 2, setbig, IGNORE); + + Table *table = createTable(solver, domain, 2, s); uint64_t row1[] = {0, 1}; uint64_t row2[] = {1, 1}; uint64_t row3[] = {2, 1}; @@ -41,17 +41,17 @@ int main(int numargs, char ** argv) { addTableEntry(solver, table, row2, 2, 0); addTableEntry(solver, table, row3, 2, 2); addTableEntry(solver, table, row4, 2, 2); - Function * f2 = completeTable(solver, table, IGNOREBEHAVIOR); //its range would be as same as s - Boolean* overflow = getBooleanVar(solver , 2); - Element * e3 = applyFunction(solver, f1, inputs, 2, overflow); - Element * e4 = applyFunction(solver, f2, inputs, 2, overflow); - Set* domain2[] = {s,rangef1}; - Predicate* equal2 = createPredicateOperator(solver, EQUALS, domain2, 2); - Element* inputs2 [] = {e4, e3}; - Boolean* pred = applyPredicate(solver, equal2, inputs2, 2); + Function *f2 = completeTable(solver, table, IGNOREBEHAVIOR); //its range would be as same as s + Boolean *overflow = getBooleanVar(solver, 2); + Element *e3 = applyFunction(solver, f1, inputs, 2, overflow); + Element *e4 = applyFunction(solver, f2, inputs, 2, overflow); + Set *domain2[] = {s,rangef1}; + Predicate *equal2 = createPredicateOperator(solver, EQUALS, domain2, 2); + Element *inputs2 [] = {e4, e3}; + Boolean *pred = applyPredicate(solver, equal2, inputs2, 2); addConstraint(solver, pred); - - if (startEncoding(solver)==1) + + if (startEncoding(solver) == 1) printf("e1=%llu e2=%llu\n", getElementValue(solver,e1), getElementValue(solver, e2)); else printf("UNSAT\n"); diff --git a/src/Test/cnftest.c b/src/Test/cnftest.c index 6740543..b76af26 100644 --- a/src/Test/cnftest.c +++ b/src/Test/cnftest.c @@ -1,32 +1,32 @@ #include "constraint.h" #include -int main(int numargs, char ** argv) { - CNF *cnf=createCNF(); - Edge v1=constraintNewVar(cnf); - Edge v2=constraintNewVar(cnf); - Edge v3=constraintNewVar(cnf); - Edge v4=constraintNewVar(cnf); +int main(int numargs, char **argv) { + CNF *cnf = createCNF(); + Edge v1 = constraintNewVar(cnf); + Edge v2 = constraintNewVar(cnf); + Edge v3 = constraintNewVar(cnf); + Edge v4 = constraintNewVar(cnf); - Edge nv1=constraintNegate(v1); - Edge nv2=constraintNegate(v2); - Edge nv3=constraintNegate(v3); - Edge nv4=constraintNegate(v4); + Edge nv1 = constraintNegate(v1); + Edge nv2 = constraintNegate(v2); + Edge nv3 = constraintNegate(v3); + Edge nv4 = constraintNegate(v4); - Edge c1=constraintAND2(cnf, v1, nv2); - Edge c2=constraintAND2(cnf, v3, nv4); - Edge c3=constraintAND2(cnf, nv1, v2); - Edge c4=constraintAND2(cnf, nv3, v4); - Edge cor=constraintOR2(cnf, constraintAND2(cnf, c1, c2), constraintAND2(cnf, c3, c4)); + Edge c1 = constraintAND2(cnf, v1, nv2); + Edge c2 = constraintAND2(cnf, v3, nv4); + Edge c3 = constraintAND2(cnf, nv1, v2); + Edge c4 = constraintAND2(cnf, nv3, v4); + Edge cor = constraintOR2(cnf, constraintAND2(cnf, c1, c2), constraintAND2(cnf, c3, c4)); printCNF(cor); printf("\n"); addConstraintCNF(cnf, cor); - int value=solveCNF(cnf); - if (value==1) { - bool v1v=getValueCNF(cnf, v1); - bool v2v=getValueCNF(cnf, v2); - bool v3v=getValueCNF(cnf, v3); - bool v4v=getValueCNF(cnf, v4); + int value = solveCNF(cnf); + if (value == 1) { + bool v1v = getValueCNF(cnf, v1); + bool v2v = getValueCNF(cnf, v2); + bool v3v = getValueCNF(cnf, v3); + bool v4v = getValueCNF(cnf, v4); printf("%d %u %u %u %u\n", value, v1v, v2v, v3v, v4v); } else printf("%d\n",value); diff --git a/src/Test/elemequalsattest.c b/src/Test/elemequalsattest.c index 718dc67..7841a70 100644 --- a/src/Test/elemequalsattest.c +++ b/src/Test/elemequalsattest.c @@ -3,29 +3,29 @@ * e1 = {0, 1, 2} * e2 = {3, 1, 7} * e1 == e2 - * + * * Result (Enumeration): * e1=1 e2=1 * Result (circuit): - * e1=0 e2=3 - * e1=1 e2=1 - * e1=2 e2=7 + * e1=0 e2=3 + * e1=1 e2=1 + * e1=2 e2=7 */ -int main(int numargs, char ** argv) { - CSolver * solver=allocCSolver(); - uint64_t set1[]={0, 1, 2}; - uint64_t set2[]={3, 1, 7}; - Set * s1=createSet(solver, 0, set1, 3); - Set * s2=createSet(solver, 0, set2, 3); - Element * e1=getElementVar(solver, s1); - Element * e2=getElementVar(solver, s2); - Set * domain[]={s1, s2}; - Predicate *equals=createPredicateOperator(solver, EQUALS, domain, 2); - Element * inputs[]={e1, e2}; - Boolean *b=applyPredicate(solver, equals, inputs, 2); +int main(int numargs, char **argv) { + CSolver *solver = allocCSolver(); + uint64_t set1[] = {0, 1, 2}; + uint64_t set2[] = {3, 1, 7}; + Set *s1 = createSet(solver, 0, set1, 3); + Set *s2 = createSet(solver, 0, set2, 3); + Element *e1 = getElementVar(solver, s1); + Element *e2 = getElementVar(solver, s2); + Set *domain[] = {s1, s2}; + Predicate *equals = createPredicateOperator(solver, EQUALS, domain, 2); + Element *inputs[] = {e1, e2}; + Boolean *b = applyPredicate(solver, equals, inputs, 2); addConstraint(solver, b); - - if (startEncoding(solver)==1) + + if (startEncoding(solver) == 1) printf("e1=%llu e2=%llu\n", getElementValue(solver,e1), getElementValue(solver, e2)); else printf("UNSAT\n"); diff --git a/src/Test/elemequalunsattest.c b/src/Test/elemequalunsattest.c index bd38ed9..5cbdd04 100644 --- a/src/Test/elemequalunsattest.c +++ b/src/Test/elemequalunsattest.c @@ -3,24 +3,24 @@ * e1 = {0, 1, 2} * e2 = {3, 4} * e1 == e2 - * + * * Result: UNSAT */ -int main(int numargs, char ** argv) { - CSolver * solver=allocCSolver(); - uint64_t set1[]={0, 1, 2}; - uint64_t set2[]={3, 4}; - Set * s1=createSet(solver, 0, set1, 3); - Set * s2=createSet(solver, 0, set2, 2); - Element * e1=getElementVar(solver, s1); - Element * e2=getElementVar(solver, s2); - Set * domain[]={s1, s2}; - Predicate *equals=createPredicateOperator(solver, EQUALS, domain, 2); - Element * inputs[]={e1, e2}; - Boolean *b=applyPredicate(solver, equals, inputs, 2); +int main(int numargs, char **argv) { + CSolver *solver = allocCSolver(); + uint64_t set1[] = {0, 1, 2}; + uint64_t set2[] = {3, 4}; + Set *s1 = createSet(solver, 0, set1, 3); + Set *s2 = createSet(solver, 0, set2, 2); + Element *e1 = getElementVar(solver, s1); + Element *e2 = getElementVar(solver, s2); + Set *domain[] = {s1, s2}; + Predicate *equals = createPredicateOperator(solver, EQUALS, domain, 2); + Element *inputs[] = {e1, e2}; + Boolean *b = applyPredicate(solver, equals, inputs, 2); addConstraint(solver, b); - - if (startEncoding(solver)==1) + + if (startEncoding(solver) == 1) printf("e1=%llu e2=%llu\n", getElementValue(solver,e1), getElementValue(solver, e2)); else printf("UNSAT\n"); diff --git a/src/Test/funcencodingtest.c b/src/Test/funcencodingtest.c index 4962f3f..24b652f 100644 --- a/src/Test/funcencodingtest.c +++ b/src/Test/funcencodingtest.c @@ -3,7 +3,7 @@ * e1 = {6} * e2={4, 2} * e3=Fsub(e1,e2) {4, 2} - * e4= f(e1, e2) + * e4= f(e1, e2) * 6 2 => 3 * 6 4 => 1 * e5 = f(e1)=>e1 {6} @@ -16,46 +16,46 @@ * e7 > e6 * Result: e1=6, e2=4, e7=2 */ -int main(int numargs, char ** argv) { - CSolver * solver=allocCSolver(); - uint64_t set1[]={6}; - uint64_t set2[]={4, 2}; - uint64_t set3[]={3, 1}; - uint64_t set4[]={2, 3, 1}; - uint64_t set5[]={2, 1, 0}; - Set * s1=createSet(solver, 0, set1, 1); - Set * s2=createSet(solver, 0, set2, 2); - Set * s3=createSet(solver, 0, set3, 2); - Set * s4=createSet(solver, 0, set4, 3); - Set * s5=createSet(solver, 0, set5, 3); - Element * e1=getElementVar(solver, s1); - Element * e2=getElementVar(solver, s2); - Element * e7=getElementVar(solver, s5); - Boolean* overflow = getBooleanVar(solver , 2); - Set * d1[]={s1, s2}; +int main(int numargs, char **argv) { + CSolver *solver = allocCSolver(); + uint64_t set1[] = {6}; + uint64_t set2[] = {4, 2}; + uint64_t set3[] = {3, 1}; + uint64_t set4[] = {2, 3, 1}; + uint64_t set5[] = {2, 1, 0}; + Set *s1 = createSet(solver, 0, set1, 1); + Set *s2 = createSet(solver, 0, set2, 2); + Set *s3 = createSet(solver, 0, set3, 2); + Set *s4 = createSet(solver, 0, set4, 3); + Set *s5 = createSet(solver, 0, set5, 3); + Element *e1 = getElementVar(solver, s1); + Element *e2 = getElementVar(solver, s2); + Element *e7 = getElementVar(solver, s5); + Boolean *overflow = getBooleanVar(solver, 2); + Set *d1[] = {s1, s2}; //change the overflow flag - Function * f1 = createFunctionOperator(solver, SUB, d1, 2, s2, IGNORE); - Element * in1[]={e1, e2}; - Element * e3 = applyFunction(solver, f1, in1, 2, overflow); - Table* t1 = createTable(solver, d1, 2, s3); + Function *f1 = createFunctionOperator(solver, SUB, d1, 2, s2, IGNORE); + Element *in1[] = {e1, e2}; + Element *e3 = applyFunction(solver, f1, in1, 2, overflow); + Table *t1 = createTable(solver, d1, 2, s3); uint64_t row1[] = {6, 2}; uint64_t row2[] = {6, 4}; addTableEntry(solver, t1, row1, 2, 3); addTableEntry(solver, t1, row2, 2, 1); - Function * f2 = completeTable(solver, t1, IGNOREBEHAVIOR); - Element * e4 = applyFunction(solver, f2, in1, 2, overflow); - + Function *f2 = completeTable(solver, t1, IGNOREBEHAVIOR); + Element *e4 = applyFunction(solver, f2, in1, 2, overflow); + Set *d2[] = {s1}; - Element *in2[]={e1}; - Table* t2 = createTable(solver, d2, 1, s1); + Element *in2[] = {e1}; + Table *t2 = createTable(solver, d2, 1, s1); uint64_t row3[] = {6}; addTableEntry(solver, t2, row3, 1, 6); - Function * f3 = completeTable(solver, t2, IGNOREBEHAVIOR); - Element * e5 = applyFunction(solver, f3, in2, 1, overflow); - + Function *f3 = completeTable(solver, t2, IGNOREBEHAVIOR); + Element *e5 = applyFunction(solver, f3, in2, 1, overflow); + Set *d3[] = {s2, s3, s1}; - Element *in3[]={e3, e4, e5}; - Table* t3 = createTable(solver, d3, 3, s4); + Element *in3[] = {e3, e4, e5}; + Table *t3 = createTable(solver, d3, 3, s4); uint64_t row4[] = {4, 3, 6}; uint64_t row5[] = {2, 1, 6}; uint64_t row6[] = {2, 3, 6}; @@ -64,18 +64,18 @@ int main(int numargs, char ** argv) { addTableEntry(solver, t3, row5, 3, 1); addTableEntry(solver, t3, row6, 3, 2); addTableEntry(solver, t3, row7, 3, 1); - Function * f4 = completeTable(solver, t3, IGNOREBEHAVIOR); - Element * e6 = applyFunction(solver, f4, in3, 3, overflow); - - Set* deq[] = {s5,s4}; - Predicate* gt = createPredicateOperator(solver, GT, deq, 2); - Element* inputs2 [] = {e7, e6}; - Boolean* pred = applyPredicate(solver, gt, inputs2, 2); + Function *f4 = completeTable(solver, t3, IGNOREBEHAVIOR); + Element *e6 = applyFunction(solver, f4, in3, 3, overflow); + + Set *deq[] = {s5,s4}; + Predicate *gt = createPredicateOperator(solver, GT, deq, 2); + Element *inputs2 [] = {e7, e6}; + Boolean *pred = applyPredicate(solver, gt, inputs2, 2); addConstraint(solver, pred); - - if (startEncoding(solver)==1) - printf("e1=%llu e2=%llu e7=%llu\n", - getElementValue(solver,e1), getElementValue(solver, e2), getElementValue(solver, e7)); + + if (startEncoding(solver) == 1) + printf("e1=%llu e2=%llu e7=%llu\n", + getElementValue(solver,e1), getElementValue(solver, e2), getElementValue(solver, e7)); else printf("UNSAT\n"); deleteSolver(solver); diff --git a/src/Test/logicopstest.c b/src/Test/logicopstest.c index a01a7f5..9d12a05 100644 --- a/src/Test/logicopstest.c +++ b/src/Test/logicopstest.c @@ -4,25 +4,25 @@ * b1 AND b2=>b3 * !b3 OR b4 * b1 XOR b4 - * Result: b1=1 b2=0 b3=0 b4=0 + * Result: b1=1 b2=0 b3=0 b4=0 */ -int main(int numargs, char** argv){ - CSolver * solver=allocCSolver(); - Boolean *b1= getBooleanVar(solver, 0); - Boolean *b2= getBooleanVar(solver, 0); - Boolean *b3= getBooleanVar(solver, 0); - Boolean *b4= getBooleanVar(solver, 0); +int main(int numargs, char **argv) { + CSolver *solver = allocCSolver(); + Boolean *b1 = getBooleanVar(solver, 0); + Boolean *b2 = getBooleanVar(solver, 0); + Boolean *b3 = getBooleanVar(solver, 0); + Boolean *b4 = getBooleanVar(solver, 0); //L_AND, L_OR, L_NOT, L_XOR, L_IMPLIES - Boolean *andb1b2= applyLogicalOperation(solver, L_AND,(Boolean*[]) {b1, b2}, 2); - Boolean * imply = applyLogicalOperation(solver, L_IMPLIES, (Boolean*[]) {andb1b2, b3}, 2); + Boolean *andb1b2 = applyLogicalOperation(solver, L_AND,(Boolean *[]) {b1, b2}, 2); + Boolean *imply = applyLogicalOperation(solver, L_IMPLIES, (Boolean *[]) {andb1b2, b3}, 2); addConstraint(solver, imply); - Boolean* notb3 = applyLogicalOperation(solver, L_NOT, (Boolean*[]) {b3}, 1); - addConstraint(solver, applyLogicalOperation(solver, L_OR, (Boolean*[]){notb3, b4} , 2)); - addConstraint(solver, applyLogicalOperation(solver, L_XOR, (Boolean* []) {b1, b4}, 2)); - if (startEncoding(solver)==1) - printf("b1=%d b2=%d b3=%d b4=%d\n", - getBooleanValue(solver,b1), getBooleanValue(solver, b2), - getBooleanValue(solver, b3), getBooleanValue(solver, b4)); + Boolean *notb3 = applyLogicalOperation(solver, L_NOT, (Boolean *[]) {b3}, 1); + addConstraint(solver, applyLogicalOperation(solver, L_OR, (Boolean *[]) {notb3, b4}, 2)); + addConstraint(solver, applyLogicalOperation(solver, L_XOR, (Boolean * []) {b1, b4}, 2)); + if (startEncoding(solver) == 1) + printf("b1=%d b2=%d b3=%d b4=%d\n", + getBooleanValue(solver,b1), getBooleanValue(solver, b2), + getBooleanValue(solver, b3), getBooleanValue(solver, b4)); else printf("UNSAT\n"); deleteSolver(solver); diff --git a/src/Test/ltelemconsttest.c b/src/Test/ltelemconsttest.c index 3823949..4818f24 100644 --- a/src/Test/ltelemconsttest.c +++ b/src/Test/ltelemconsttest.c @@ -5,20 +5,20 @@ * e1 < e2 * Result: e1=5 e2=6 */ -int main(int numargs, char ** argv){ - CSolver *solver=allocCSolver(); - uint64_t set1[]={5}; - uint64_t set3[]={1, 3, 4, 6}; - Set * s1=createSet(solver, 0, set1, 3); - Set * s3=createSet(solver, 0, set3, 4); - Element * e1=getElementConst(solver, 4, 5); - Element * e2=getElementVar(solver, s3); - Set * domain2[]={s1, s3}; - Predicate *lt=createPredicateOperator(solver, LT, domain2, 2); - Element * inputs2[]={e1, e2}; - Boolean *b=applyPredicate(solver, lt, inputs2, 2); +int main(int numargs, char **argv) { + CSolver *solver = allocCSolver(); + uint64_t set1[] = {5}; + uint64_t set3[] = {1, 3, 4, 6}; + Set *s1 = createSet(solver, 0, set1, 3); + Set *s3 = createSet(solver, 0, set3, 4); + Element *e1 = getElementConst(solver, 4, 5); + Element *e2 = getElementVar(solver, s3); + Set *domain2[] = {s1, s3}; + Predicate *lt = createPredicateOperator(solver, LT, domain2, 2); + Element *inputs2[] = {e1, e2}; + Boolean *b = applyPredicate(solver, lt, inputs2, 2); addConstraint(solver, b); - if (startEncoding(solver)==1) + if (startEncoding(solver) == 1) printf("e1=%llu e2=%llu\n", getElementValue(solver,e1), getElementValue(solver, e2)); else printf("UNSAT\n"); diff --git a/src/Test/ordertest.c b/src/Test/ordertest.c index 2b8a98d..852df34 100644 --- a/src/Test/ordertest.c +++ b/src/Test/ordertest.c @@ -6,22 +6,22 @@ * 1 => 4 * Result: O(5,1)=0 O(1,4)=0 O(5,4)=0 O(1,5)=1 O(1111,5)=2 */ -int main(int numargs, char ** argv) { - CSolver * solver=allocCSolver(); - uint64_t set1[]={5, 1, 4}; - Set * s=createSet(solver, 0, set1, 3); - Order* order = createOrder(solver, TOTAL, s); - Boolean* b1= orderConstraint(solver, order, 5, 1); - Boolean* b2= orderConstraint(solver, order, 1, 4); +int main(int numargs, char **argv) { + CSolver *solver = allocCSolver(); + uint64_t set1[] = {5, 1, 4}; + Set *s = createSet(solver, 0, set1, 3); + Order *order = createOrder(solver, TOTAL, s); + Boolean *b1 = orderConstraint(solver, order, 5, 1); + Boolean *b2 = orderConstraint(solver, order, 1, 4); addConstraint(solver, b1); addConstraint(solver, b2); - if (startEncoding(solver)==1) - printf("O(5,1)=%d O(1,4)=%d O(5,4)=%d O(1,5)=%d O(1111,5)=%d\n", - getOrderConstraintValue(solver, order, 5, 1), - getOrderConstraintValue(solver, order, 1, 4), - getOrderConstraintValue(solver, order, 5, 4), - getOrderConstraintValue(solver, order, 1, 5), - getOrderConstraintValue(solver, order, 1111, 5)); + if (startEncoding(solver) == 1) + printf("O(5,1)=%d O(1,4)=%d O(5,4)=%d O(1,5)=%d O(1111,5)=%d\n", + getOrderConstraintValue(solver, order, 5, 1), + getOrderConstraintValue(solver, order, 1, 4), + getOrderConstraintValue(solver, order, 5, 4), + getOrderConstraintValue(solver, order, 1, 5), + getOrderConstraintValue(solver, order, 1111, 5)); else printf("UNSAT\n"); deleteSolver(solver); diff --git a/src/Test/tablefuncencodetest.c b/src/Test/tablefuncencodetest.c index 12a589e..a7b9412 100644 --- a/src/Test/tablefuncencodetest.c +++ b/src/Test/tablefuncencodetest.c @@ -2,7 +2,7 @@ /** * e1 = {1, 2} * e2={3, 5, 7} - * e3= f(e1, e2) + * e3= f(e1, e2) * 1 5 => 7 * 2 3 => 5 * 1 7 => 3 @@ -13,21 +13,21 @@ * e4 <= e3 * Result: e1=1, e2=5, e3=7, e4=6, overflow=0 */ -int main(int numargs, char ** argv) { - CSolver * solver=allocCSolver(); - uint64_t set1[]={1, 2}; - uint64_t set2[]={3, 5, 7}; - uint64_t set3[]={6, 10, 19}; - Set * s1=createSet(solver, 0, set1, 2); - Set * s2=createSet(solver, 0, set2, 3); - Set * s3=createSet(solver, 0, set3, 3); - Element * e1=getElementVar(solver, s1); - Element * e2=getElementVar(solver, s2); - Element * e4=getElementVar(solver, s3); - Boolean* overflow = getBooleanVar(solver , 2); - Set * d1[]={s1, s2}; +int main(int numargs, char **argv) { + CSolver *solver = allocCSolver(); + uint64_t set1[] = {1, 2}; + uint64_t set2[] = {3, 5, 7}; + uint64_t set3[] = {6, 10, 19}; + Set *s1 = createSet(solver, 0, set1, 2); + Set *s2 = createSet(solver, 0, set2, 3); + Set *s3 = createSet(solver, 0, set3, 3); + Element *e1 = getElementVar(solver, s1); + Element *e2 = getElementVar(solver, s2); + Element *e4 = getElementVar(solver, s3); + Boolean *overflow = getBooleanVar(solver, 2); + Set *d1[] = {s1, s2}; //change the overflow flag - Table* t1 = createTable(solver, d1, 2, s2); + Table *t1 = createTable(solver, d1, 2, s2); uint64_t row1[] = {1, 5}; uint64_t row2[] = {2, 3}; uint64_t row3[] = {1, 7}; @@ -40,19 +40,19 @@ int main(int numargs, char ** argv) { addTableEntry(solver, t1, row4, 2, 5); addTableEntry(solver, t1, row5, 2, 3); addTableEntry(solver, t1, row6, 2, 5); - Function * f1 = completeTable(solver, t1, FLAGIFFUNDEFINED); - Element * e3 = applyFunction(solver, f1, (Element* []){e1,e2}, 2, overflow); - - Set* deq[] = {s3,s2}; - Predicate* lte = createPredicateOperator(solver, LTE, deq, 2); - Element* inputs2 [] = {e4, e3}; - Boolean* pred = applyPredicate(solver, lte, inputs2, 2); + Function *f1 = completeTable(solver, t1, FLAGIFFUNDEFINED); + Element *e3 = applyFunction(solver, f1, (Element * []) {e1,e2}, 2, overflow); + + Set *deq[] = {s3,s2}; + Predicate *lte = createPredicateOperator(solver, LTE, deq, 2); + Element *inputs2 [] = {e4, e3}; + Boolean *pred = applyPredicate(solver, lte, inputs2, 2); addConstraint(solver, pred); - - if (startEncoding(solver)==1) - printf("e1=%llu e2=%llu e3=%llu e4=%llu overFlow:%d\n", - getElementValue(solver,e1), getElementValue(solver, e2), getElementValue(solver, e3), - getElementValue(solver, e4), getBooleanValue(solver, overflow)); + + if (startEncoding(solver) == 1) + printf("e1=%llu e2=%llu e3=%llu e4=%llu overFlow:%d\n", + getElementValue(solver,e1), getElementValue(solver, e2), getElementValue(solver, e3), + getElementValue(solver, e4), getBooleanValue(solver, overflow)); else printf("UNSAT\n"); deleteSolver(solver); diff --git a/src/Test/tablepredicencodetest.c b/src/Test/tablepredicencodetest.c index 536879e..ee9094b 100644 --- a/src/Test/tablepredicencodetest.c +++ b/src/Test/tablepredicencodetest.c @@ -3,7 +3,7 @@ * e1 = {1, 2} * e2={1, 3, 5, 7} * e3 = {6, 10, 19} - * e4= p(e1, e2, e3) + * e4= p(e1, e2, e3) * 1 5 6 => T * 2 3 19 => T * 1 3 19 => F @@ -11,23 +11,23 @@ * 1 7 6 => F * 2 5 6 => T * e1 == e2 - * e3 >= e2 + * e3 >= e2 * Result: e1=1, e2=1, e3=6 OR 10 OR 19, overflow=1 */ -int main(int numargs, char ** argv) { - CSolver * solver=allocCSolver(); - uint64_t set1[]={1, 2}; - uint64_t set2[]={1, 3, 5, 7}; - uint64_t set3[]={6, 10, 19}; - Set * s1=createSet(solver, 0, set1, 2); - Set * s2=createSet(solver, 0, set2, 4); - Set * s3=createSet(solver, 0, set3, 3); - Element * e1=getElementVar(solver, s1); - Element * e2=getElementVar(solver, s2); - Element * e3=getElementVar(solver, s3); - Set * d2[]={s1, s2, s3}; +int main(int numargs, char **argv) { + CSolver *solver = allocCSolver(); + uint64_t set1[] = {1, 2}; + uint64_t set2[] = {1, 3, 5, 7}; + uint64_t set3[] = {6, 10, 19}; + Set *s1 = createSet(solver, 0, set1, 2); + Set *s2 = createSet(solver, 0, set2, 4); + Set *s3 = createSet(solver, 0, set3, 3); + Element *e1 = getElementVar(solver, s1); + Element *e2 = getElementVar(solver, s2); + Element *e3 = getElementVar(solver, s3); + Set *d2[] = {s1, s2, s3}; //change the overflow flag - Table* t1 = createTableForPredicate(solver, d2, 3); + Table *t1 = createTableForPredicate(solver, d2, 3); uint64_t row1[] = {1, 5, 6}; uint64_t row2[] = {2, 3, 19}; uint64_t row3[] = {1, 3, 19}; @@ -40,26 +40,26 @@ int main(int numargs, char ** argv) { addTableEntry(solver, t1, row4, 3, false); addTableEntry(solver, t1, row5, 3, false); addTableEntry(solver, t1, row6, 3, true); - Predicate * p1 = createPredicateTable(solver, t1, FLAGIFFUNDEFINED); - Boolean* undef = getBooleanVar(solver , 2); - Boolean* b1 =applyPredicateTable(solver, p1, (Element* []){e1, e2, e3}, 3, undef); + Predicate *p1 = createPredicateTable(solver, t1, FLAGIFFUNDEFINED); + Boolean *undef = getBooleanVar(solver, 2); + Boolean *b1 = applyPredicateTable(solver, p1, (Element * []) {e1, e2, e3}, 3, undef); addConstraint(solver, b1); - - Set* deq[] = {s3,s2}; - Predicate* gte = createPredicateOperator(solver, GTE, deq, 2); - Element* inputs2 [] = {e3, e2}; - Boolean* pred = applyPredicate(solver, gte, inputs2, 2); + + Set *deq[] = {s3,s2}; + Predicate *gte = createPredicateOperator(solver, GTE, deq, 2); + Element *inputs2 [] = {e3, e2}; + Boolean *pred = applyPredicate(solver, gte, inputs2, 2); addConstraint(solver, pred); - - Set * d1[]={s1, s2}; - Predicate* eq = createPredicateOperator(solver, EQUALS, d1, 2); - Boolean* pred2 = applyPredicate(solver, eq,(Element*[]) {e1, e2}, 2); + + Set *d1[] = {s1, s2}; + Predicate *eq = createPredicateOperator(solver, EQUALS, d1, 2); + Boolean *pred2 = applyPredicate(solver, eq,(Element *[]) {e1, e2}, 2); addConstraint(solver, pred2); - - if (startEncoding(solver)==1) - printf("e1=%llu e2=%llu e3=%llu undefFlag:%d\n", - getElementValue(solver,e1), getElementValue(solver, e2), - getElementValue(solver, e3), getBooleanValue(solver, undef)); + + if (startEncoding(solver) == 1) + printf("e1=%llu e2=%llu e3=%llu undefFlag:%d\n", + getElementValue(solver,e1), getElementValue(solver, e2), + getElementValue(solver, e3), getBooleanValue(solver, undef)); else printf("UNSAT\n"); deleteSolver(solver); diff --git a/src/common.h b/src/common.h index a06dab2..0ebb7ec 100644 --- a/src/common.h +++ b/src/common.h @@ -18,22 +18,22 @@ #include "config.h" /* -extern int model_out; -extern int model_err; -extern int switch_alloc; + extern int model_out; + extern int model_err; + extern int switch_alloc; -#define model_dprintf(fd, fmt, ...) do { switch_alloc = 1; dprintf(fd, fmt, ## __VA_ARGS__); switch_alloc = 0; } while (0) + #define model_dprintf(fd, fmt, ...) do { switch_alloc = 1; dprintf(fd, fmt, ## __VA_ARGS__); switch_alloc = 0; } while (0) -#define model_print(fmt, ...) do { model_dprintf(model_out, fmt, ## __VA_ARGS__); } while (0) + #define model_print(fmt, ...) do { model_dprintf(model_out, fmt, ## __VA_ARGS__); } while (0) -#define model_print_err(fmt, ...) do { model_dprintf(model_err, fmt, ## __VA_ARGS__); } while (0) + #define model_print_err(fmt, ...) do { model_dprintf(model_err, fmt, ## __VA_ARGS__); } while (0) -*/ + */ #define model_print printf -#define NEXTPOW2(x) ((x==1) ? 1 : (1<<(sizeof(uint)*8-__builtin_clz(x-1)))) -#define NUMBITS(x) ((x==0) ? 0 : 8*sizeof(x)-__builtin_clz(x)) +#define NEXTPOW2(x) ((x == 1) ? 1 : (1 << (sizeof(uint) * 8 - __builtin_clz(x - 1)))) +#define NUMBITS(x) ((x == 0) ? 0 : 8 * sizeof(x) - __builtin_clz(x)) #ifdef CONFIG_DEBUG #define DEBUG(fmt, ...) do { model_print("*** %15s:%-4d %25s() *** " fmt, __FILE__, __LINE__, __func__, ## __VA_ARGS__); } while (0) diff --git a/src/csolver.c b/src/csolver.c index d440aad..683084b 100644 --- a/src/csolver.c +++ b/src/csolver.c @@ -10,12 +10,12 @@ #include "satencoder.h" #include "sattranslator.h" -CSolver * allocCSolver() { - CSolver * This=(CSolver *) ourmalloc(sizeof(CSolver)); - This->constraints=allocDefVectorBoolean(); - This->allBooleans=allocDefVectorBoolean(); - This->allSets=allocDefVectorSet(); - This->allElements=allocDefVectorElement(); +CSolver *allocCSolver() { + CSolver *This = (CSolver *) ourmalloc(sizeof(CSolver)); + This->constraints = allocDefVectorBoolean(); + This->allBooleans = allocDefVectorBoolean(); + This->allSets = allocDefVectorSet(); + This->allElements = allocDefVectorElement(); This->allPredicates = allocDefVectorPredicate(); This->allTables = allocDefVectorTable(); This->allOrders = allocDefVectorOrder(); @@ -29,44 +29,44 @@ CSolver * allocCSolver() { void deleteSolver(CSolver *This) { deleteVectorBoolean(This->constraints); - uint size=getSizeVectorBoolean(This->allBooleans); - for(uint i=0;iallBooleans); + for (uint i = 0; i < size; i++) { deleteBoolean(getVectorBoolean(This->allBooleans, i)); } deleteVectorBoolean(This->allBooleans); - size=getSizeVectorSet(This->allSets); - for(uint i=0;iallSets); + for (uint i = 0; i < size; i++) { deleteSet(getVectorSet(This->allSets, i)); } deleteVectorSet(This->allSets); - size=getSizeVectorElement(This->allElements); - for(uint i=0;iallElements); + for (uint i = 0; i < size; i++) { deleteElement(getVectorElement(This->allElements, i)); } deleteVectorElement(This->allElements); - size=getSizeVectorTable(This->allTables); - for(uint i=0;iallTables); + for (uint i = 0; i < size; i++) { deleteTable(getVectorTable(This->allTables, i)); } deleteVectorTable(This->allTables); - size=getSizeVectorPredicate(This->allPredicates); - for(uint i=0;iallPredicates); + for (uint i = 0; i < size; i++) { deletePredicate(getVectorPredicate(This->allPredicates, i)); } deleteVectorPredicate(This->allPredicates); - size=getSizeVectorOrder(This->allOrders); - for(uint i=0;iallOrders); + for (uint i = 0; i < size; i++) { deleteOrder(getVectorOrder(This->allOrders, i)); } deleteVectorOrder(This->allOrders); - size=getSizeVectorFunction(This->allFunctions); - for(uint i=0;iallFunctions); + for (uint i = 0; i < size; i++) { deleteFunction(getVectorFunction(This->allFunctions, i)); } deleteVectorFunction(This->allFunctions); @@ -74,161 +74,161 @@ void deleteSolver(CSolver *This) { ourfree(This); } -Set * createSet(CSolver * This, VarType type, uint64_t * elements, uint numelements) { - Set * set=allocSet(type, elements, numelements); +Set *createSet(CSolver *This, VarType type, uint64_t *elements, uint numelements) { + Set *set = allocSet(type, elements, numelements); pushVectorSet(This->allSets, set); return set; } -Set * createRangeSet(CSolver * This, VarType type, uint64_t lowrange, uint64_t highrange) { - Set * set=allocSetRange(type, lowrange, highrange); +Set *createRangeSet(CSolver *This, VarType type, uint64_t lowrange, uint64_t highrange) { + Set *set = allocSetRange(type, lowrange, highrange); pushVectorSet(This->allSets, set); return set; } -MutableSet * createMutableSet(CSolver * This, VarType type) { - MutableSet * set=allocMutableSet(type); +MutableSet *createMutableSet(CSolver *This, VarType type) { + MutableSet *set = allocMutableSet(type); pushVectorSet(This->allSets, set); return set; } -void addItem(CSolver *This, MutableSet * set, uint64_t element) { +void addItem(CSolver *This, MutableSet *set, uint64_t element) { addElementMSet(set, element); } -uint64_t createUniqueItem(CSolver *This, MutableSet * set) { - uint64_t element=set->low++; +uint64_t createUniqueItem(CSolver *This, MutableSet *set) { + uint64_t element = set->low++; addElementMSet(set, element); return element; } -Element * getElementVar(CSolver *This, Set * set) { - Element * element=allocElementSet(set); +Element *getElementVar(CSolver *This, Set *set) { + Element *element = allocElementSet(set); pushVectorElement(This->allElements, element); return element; } -Element * getElementConst(CSolver *This, VarType type, uint64_t value) { - Element * element=allocElementConst(value, type); +Element *getElementConst(CSolver *This, VarType type, uint64_t value) { + Element *element = allocElementConst(value, type); pushVectorElement(This->allElements, element); return element; } -Boolean * getBooleanVar(CSolver *This, VarType type) { - Boolean* boolean= allocBooleanVar(type); +Boolean *getBooleanVar(CSolver *This, VarType type) { + Boolean *boolean = allocBooleanVar(type); pushVectorBoolean(This->allBooleans, boolean); return boolean; } -Function * createFunctionOperator(CSolver *This, ArithOp op, Set ** domain, uint numDomain, Set * range,OverFlowBehavior overflowbehavior) { - Function* function = allocFunctionOperator(op, domain, numDomain, range, overflowbehavior); +Function *createFunctionOperator(CSolver *This, ArithOp op, Set **domain, uint numDomain, Set *range,OverFlowBehavior overflowbehavior) { + Function *function = allocFunctionOperator(op, domain, numDomain, range, overflowbehavior); pushVectorFunction(This->allFunctions, function); return function; } -Predicate * createPredicateOperator(CSolver *This, CompOp op, Set ** domain, uint numDomain) { - Predicate* predicate= allocPredicateOperator(op, domain,numDomain); +Predicate *createPredicateOperator(CSolver *This, CompOp op, Set **domain, uint numDomain) { + Predicate *predicate = allocPredicateOperator(op, domain,numDomain); pushVectorPredicate(This->allPredicates, predicate); return predicate; } -Predicate * createPredicateTable(CSolver *This, Table* table, UndefinedBehavior behavior){ - Predicate* predicate = allocPredicateTable(table, behavior); +Predicate *createPredicateTable(CSolver *This, Table *table, UndefinedBehavior behavior) { + Predicate *predicate = allocPredicateTable(table, behavior); pushVectorPredicate(This->allPredicates, predicate); return predicate; } -Table * createTable(CSolver *This, Set **domains, uint numDomain, Set * range) { - Table* table= allocTable(domains,numDomain,range); +Table *createTable(CSolver *This, Set **domains, uint numDomain, Set *range) { + Table *table = allocTable(domains,numDomain,range); pushVectorTable(This->allTables, table); return table; } -Table * createTableForPredicate(CSolver *solver, Set **domains, uint numDomain){ +Table *createTableForPredicate(CSolver *solver, Set **domains, uint numDomain) { return createTable(solver, domains, numDomain, NULL); } -void addTableEntry(CSolver *This, Table* table, uint64_t* inputs, uint inputSize, uint64_t result) { +void addTableEntry(CSolver *This, Table *table, uint64_t *inputs, uint inputSize, uint64_t result) { addNewTableEntry(table,inputs, inputSize,result); } -Function * completeTable(CSolver *This, Table * table, UndefinedBehavior behavior) { - Function* function = allocFunctionTable(table, behavior); +Function *completeTable(CSolver *This, Table *table, UndefinedBehavior behavior) { + Function *function = allocFunctionTable(table, behavior); pushVectorFunction(This->allFunctions,function); return function; } -Element * applyFunction(CSolver *This, Function * function, Element ** array, uint numArrays, Boolean * overflowstatus) { - Element* element= allocElementFunction(function,array,numArrays,overflowstatus); +Element *applyFunction(CSolver *This, Function *function, Element **array, uint numArrays, Boolean *overflowstatus) { + Element *element = allocElementFunction(function,array,numArrays,overflowstatus); pushVectorElement(This->allElements, element); return element; } -Boolean * applyPredicate(CSolver *This, Predicate * predicate, Element ** inputs, uint numInputs) { +Boolean *applyPredicate(CSolver *This, Predicate *predicate, Element **inputs, uint numInputs) { return applyPredicateTable(This, predicate, inputs, numInputs, NULL); } -Boolean * applyPredicateTable(CSolver *This, Predicate * predicate, Element ** inputs, uint numInputs, Boolean* undefinedStatus) { - Boolean* boolean= allocBooleanPredicate(predicate, inputs, numInputs, undefinedStatus); +Boolean *applyPredicateTable(CSolver *This, Predicate *predicate, Element **inputs, uint numInputs, Boolean *undefinedStatus) { + Boolean *boolean = allocBooleanPredicate(predicate, inputs, numInputs, undefinedStatus); pushVectorBoolean(This->allBooleans, boolean); return boolean; } -Boolean * applyLogicalOperation(CSolver *This, LogicOp op, Boolean ** array, uint asize) { +Boolean *applyLogicalOperation(CSolver *This, LogicOp op, Boolean **array, uint asize) { return allocBooleanLogicArray(This, op, array, asize); } -void addConstraint(CSolver *This, Boolean * constraint) { +void addConstraint(CSolver *This, Boolean *constraint) { pushVectorBoolean(This->constraints, constraint); } -Order * createOrder(CSolver *This, OrderType type, Set * set) { - Order* order = allocOrder(type, set); +Order *createOrder(CSolver *This, OrderType type, Set *set) { + Order *order = allocOrder(type, set); pushVectorOrder(This->allOrders, order); return order; } -Boolean * orderConstraint(CSolver *This, Order * order, uint64_t first, uint64_t second) { - Boolean* constraint = allocBooleanOrder(order, first, second); +Boolean *orderConstraint(CSolver *This, Order *order, uint64_t first, uint64_t second) { + Boolean *constraint = allocBooleanOrder(order, first, second); pushVectorBoolean(This->allBooleans,constraint); return constraint; } -int startEncoding(CSolver* This){ +int startEncoding(CSolver *This) { naiveEncodingDecision(This); - SATEncoder* satEncoder = This->satEncoder; + SATEncoder *satEncoder = This->satEncoder; encodeAllSATEncoder(This, satEncoder); - int result= solveCNF(satEncoder->cnf); + int result = solveCNF(satEncoder->cnf); model_print("sat_solver's result:%d\tsolutionSize=%d\n", result, satEncoder->cnf->solver->solutionsize); - for(uint i=1; i<=satEncoder->cnf->solver->solutionsize; i++){ + for (uint i = 1; i <= satEncoder->cnf->solver->solutionsize; i++) { model_print("%d, ", satEncoder->cnf->solver->solution[i]); } model_print("\n"); return result; } -uint64_t getElementValue(CSolver* This, Element* element){ - switch(GETELEMENTTYPE(element)){ - case ELEMSET: - case ELEMCONST: - case ELEMFUNCRETURN: - return getElementValueSATTranslator(This, element); - default: - ASSERT(0); +uint64_t getElementValue(CSolver *This, Element *element) { + switch (GETELEMENTTYPE(element)) { + case ELEMSET: + case ELEMCONST: + case ELEMFUNCRETURN: + return getElementValueSATTranslator(This, element); + default: + ASSERT(0); } exit(-1); } -bool getBooleanValue( CSolver* This , Boolean* boolean){ - switch(GETBOOLEANTYPE(boolean)){ - case BOOLEANVAR: - return getBooleanVariableValueSATTranslator(This, boolean); - default: - ASSERT(0); +bool getBooleanValue( CSolver *This, Boolean *boolean) { + switch (GETBOOLEANTYPE(boolean)) { + case BOOLEANVAR: + return getBooleanVariableValueSATTranslator(This, boolean); + default: + ASSERT(0); } exit(-1); } -HappenedBefore getOrderConstraintValue(CSolver* This, Order * order, uint64_t first, uint64_t second){ +HappenedBefore getOrderConstraintValue(CSolver *This, Order *order, uint64_t first, uint64_t second) { return getOrderConstraintValueSATTranslator(This, order, first, second); } diff --git a/src/csolver.h b/src/csolver.h index b35f801..cde6c64 100644 --- a/src/csolver.h +++ b/src/csolver.h @@ -5,131 +5,131 @@ #include "structs.h" struct CSolver { - SATEncoder* satEncoder; + SATEncoder *satEncoder; /** This is a vector of constraints that must be satisfied. */ - VectorBoolean * constraints; + VectorBoolean *constraints; /** This is a vector of all boolean structs that we have allocated. */ - VectorBoolean * allBooleans; + VectorBoolean *allBooleans; /** This is a vector of all set structs that we have allocated. */ - VectorSet * allSets; + VectorSet *allSets; /** This is a vector of all element structs that we have allocated. */ - VectorElement * allElements; + VectorElement *allElements; /** This is a vector of all predicate structs that we have allocated. */ - VectorPredicate * allPredicates; + VectorPredicate *allPredicates; /** This is a vector of all table structs that we have allocated. */ - VectorTable * allTables; + VectorTable *allTables; /** This is a vector of all order structs that we have allocated. */ - VectorOrder * allOrders; + VectorOrder *allOrders; /** This is a vector of all function structs that we have allocated. */ - VectorFunction* allFunctions; + VectorFunction *allFunctions; }; /** Create a new solver instance. */ -CSolver * allocCSolver(); +CSolver *allocCSolver(); /** Delete solver instance. */ -void deleteSolver(CSolver * This); +void deleteSolver(CSolver *This); /** This function creates a set containing the elements passed in the array. */ -Set * createSet(CSolver *, VarType type, uint64_t * elements, uint num); +Set *createSet(CSolver *, VarType type, uint64_t *elements, uint num); /** This function creates a set from lowrange to highrange (inclusive). */ -Set * createRangeSet(CSolver *, VarType type, uint64_t lowrange, uint64_t highrange); +Set *createRangeSet(CSolver *, VarType type, uint64_t lowrange, uint64_t highrange); /** This function creates a mutable set. */ -MutableSet * createMutableSet(CSolver *, VarType type); +MutableSet *createMutableSet(CSolver *, VarType type); /** This function adds a new item to a set. */ -void addItem(CSolver *, MutableSet * set, uint64_t element); +void addItem(CSolver *, MutableSet *set, uint64_t element); /** This function adds a new unique item to the set and returns it. This function cannot be used in conjunction with manually adding items to the set. */ -uint64_t createUniqueItem(CSolver *, MutableSet * set); +uint64_t createUniqueItem(CSolver *, MutableSet *set); /** This function creates an element variable over a set. */ -Element * getElementVar(CSolver *, Set * set); +Element *getElementVar(CSolver *, Set *set); /** This function creates an element constrant. */ -Element * getElementConst(CSolver *, VarType type, uint64_t value); +Element *getElementConst(CSolver *, VarType type, uint64_t value); /** This function creates a boolean variable. */ -Boolean * getBooleanVar(CSolver *, VarType type); +Boolean *getBooleanVar(CSolver *, VarType type); /** This function creates a function operator. */ -Function * createFunctionOperator(CSolver *solver, ArithOp op, Set ** domain, uint numDomain, Set * range, - OverFlowBehavior overflowbehavior); +Function *createFunctionOperator(CSolver *solver, ArithOp op, Set **domain, uint numDomain, Set *range, + OverFlowBehavior overflowbehavior); /** This function creates a predicate operator. */ -Predicate * createPredicateOperator(CSolver *solver, CompOp op, Set ** domain, uint numDomain); +Predicate *createPredicateOperator(CSolver *solver, CompOp op, Set **domain, uint numDomain); -Predicate * createPredicateTable(CSolver *solver, Table* table, UndefinedBehavior behavior); +Predicate *createPredicateTable(CSolver *solver, Table *table, UndefinedBehavior behavior); /** This function creates an empty instance table.*/ -Table * createTable(CSolver *solver, Set **domains, uint numDomain, Set * range); +Table *createTable(CSolver *solver, Set **domains, uint numDomain, Set *range); -Table * createTableForPredicate(CSolver *solver, Set **domains, uint numDomain); +Table *createTableForPredicate(CSolver *solver, Set **domains, uint numDomain); /** This function adds an input output relation to a table. */ -void addTableEntry(CSolver *solver, Table* table, uint64_t* inputs, uint inputSize, uint64_t result); +void addTableEntry(CSolver *solver, Table *table, uint64_t *inputs, uint inputSize, uint64_t result); /** This function converts a completed table into a function. */ -Function * completeTable(CSolver *, Table *, UndefinedBehavior behavior); +Function *completeTable(CSolver *, Table *, UndefinedBehavior behavior); /** This function applies a function to the Elements in its input. */ -Element * applyFunction(CSolver *, Function * function, Element ** array, uint numArrays, Boolean * overflowstatus); +Element *applyFunction(CSolver *, Function *function, Element **array, uint numArrays, Boolean *overflowstatus); /** This function applies a predicate to the Elements in its input. */ -Boolean * applyPredicateTable(CSolver *, Predicate * predicate, Element ** inputs, uint numInputs, Boolean* undefinedStatus); +Boolean *applyPredicateTable(CSolver *, Predicate *predicate, Element **inputs, uint numInputs, Boolean *undefinedStatus); -Boolean * applyPredicate(CSolver *, Predicate * predicate, Element ** inputs, uint numInputs); +Boolean *applyPredicate(CSolver *, Predicate *predicate, Element **inputs, uint numInputs); /** This function applies a logical operation to the Booleans in its input. */ -Boolean * applyLogicalOperation(CSolver *, LogicOp op, Boolean ** array, uint asize); +Boolean *applyLogicalOperation(CSolver *, LogicOp op, Boolean **array, uint asize); /** This function adds a boolean constraint to the set of constraints to be satisfied */ -void addConstraint(CSolver *, Boolean * constraint); +void addConstraint(CSolver *, Boolean *constraint); /** This function instantiates an order of type type over the set set. */ -Order * createOrder(CSolver *, OrderType type, Set * set); +Order *createOrder(CSolver *, OrderType type, Set *set); /** This function instantiates a boolean on two items in an order. */ -Boolean * orderConstraint(CSolver *, Order * order, uint64_t first, uint64_t second); +Boolean *orderConstraint(CSolver *, Order *order, uint64_t first, uint64_t second); /** When everything is done, the client calls this function and then csolver starts to encode*/ -int startEncoding(CSolver*); +int startEncoding(CSolver *); /** After getting the solution from the SAT solver, client can get the value of an element via this function*/ -uint64_t getElementValue(CSolver*, Element* element); +uint64_t getElementValue(CSolver *, Element *element); /** After getting the solution from the SAT solver, client can get the value of a boolean via this function*/ -bool getBooleanValue( CSolver* , Boolean* boolean); +bool getBooleanValue( CSolver *, Boolean *boolean); -HappenedBefore getOrderConstraintValue(CSolver*, Order * order, uint64_t first, uint64_t second); +HappenedBefore getOrderConstraintValue(CSolver *, Order *order, uint64_t first, uint64_t second); #endif diff --git a/src/mymemory.h b/src/mymemory.h index 32dfa51..b778c48 100644 --- a/src/mymemory.h +++ b/src/mymemory.h @@ -20,15 +20,15 @@ #include "config.h" /* -void * ourmalloc(size_t size); -void ourfree(void *ptr); -void * ourcalloc(size_t count, size_t size); -void * ourrealloc(void *ptr, size_t size); -*/ + void * ourmalloc(size_t size); + void ourfree(void *ptr); + void * ourcalloc(size_t count, size_t size); + void * ourrealloc(void *ptr, size_t size); + */ -static inline void * ourmalloc(size_t size) { return malloc(size); } +static inline void *ourmalloc(size_t size) { return malloc(size); } static inline void ourfree(void *ptr) { free(ptr); } -static inline void * ourcalloc(size_t count, size_t size) { return calloc(count, size); } -static inline void * ourrealloc(void *ptr, size_t size) { return realloc(ptr, size); } +static inline void *ourcalloc(size_t count, size_t size) { return calloc(count, size); } +static inline void *ourrealloc(void *ptr, size_t size) { return realloc(ptr, size); } #endif/* _MY_MEMORY_H */ -- 2.34.1