From da8edf8ffe23430b414467fb4e35c66c94562356 Mon Sep 17 00:00:00 2001 From: Hamed Date: Tue, 20 Jun 2017 11:05:36 -0700 Subject: [PATCH] New type of Element and Boolean. --- src/AST/boolean.c | 29 +++++++++++++++++++++++++++++ src/AST/boolean.h | 17 +++++++++++++++++ src/AST/element.c | 17 ++++++++++++++--- src/AST/element.h | 21 +++++++++++++++++++-- src/AST/ops.h | 5 ++++- src/AST/order.c | 25 ------------------------- src/AST/order.h | 1 - src/classlist.h | 4 ++++ src/csolver.c | 16 ++++++++++------ src/csolver.h | 2 +- 10 files changed, 98 insertions(+), 39 deletions(-) diff --git a/src/AST/boolean.c b/src/AST/boolean.c index 7d9aec3..0d3e892 100644 --- a/src/AST/boolean.c +++ b/src/AST/boolean.c @@ -1,4 +1,6 @@ #include "boolean.h" +#include "structs.h" +#include "csolver.h" Boolean* allocBoolean(VarType t) { BooleanVar* tmp=(BooleanVar *) ourmalloc(sizeof (BooleanVar)); @@ -16,6 +18,33 @@ Boolean* allocBooleanOrder(Order* order, uint64_t first, uint64_t second) { return & tmp -> base; } +Boolean * allocBooleanPredicate(Predicate * predicate, Element ** inputs, uint numInputs){ + BooleanPredicate* bp = (BooleanPredicate*) ourmalloc(sizeof(BooleanPredicate)); + GETBOOLEANTYPE(bp)= PREDICATEOP; + bp->predicate=predicate; + bp->inputs= allocVectorArrayElement (numInputs,inputs); + return & bp->base; +} + +Boolean * allocBooleanLogic(LogicOp op, Boolean * left, Boolean* right){ + BooleanLogic* bl = (BooleanLogic*) ourmalloc(sizeof(BooleanLogic)); + GETBOOLEANTYPE(bl) = LOGICOP; + bl->op=op; + bl->left=left; + bl->right=right; + return &bl->base; +} +Boolean * allocBooleanLogicArray(CSolver *solver, LogicOp op, Boolean ** array, uint asize){ + ASSERT(asize>=2); + Boolean* boolean = allocBooleanLogic(op,array[0], array[1]); + pushVectorBoolean(solver->allBooleans,boolean); + for(uint i=2; iallBooleans,boolean); + } + return boolean; +} + void deleteBoolean(Boolean * This) { ourfree(This); } diff --git a/src/AST/boolean.h b/src/AST/boolean.h index d00a82c..fd59a21 100644 --- a/src/AST/boolean.h +++ b/src/AST/boolean.h @@ -3,6 +3,7 @@ #include "classlist.h" #include "mymemory.h" #include "ops.h" +#include "structs.h" /** This is a little sketchy, but apparently legit. @@ -40,10 +41,26 @@ struct BooleanComp { Boolean * right; }; +struct BooleanPredicate{ + Boolean base; + Predicate * predicate; + VectorElement* inputs; +}; Boolean * allocBoolean(VarType t); Boolean * allocBooleanOrder(Order * order, uint64_t first, uint64_t second); +Boolean * allocBooleanPredicate(Predicate * predicate, Element ** inputs, uint numInputs); +Boolean * allocBooleanLogic(LogicOp op, Boolean * left, Boolean* right); +/** + * This function also save new boooleans to solver->allbooleans + * @param solver + * @param op + * @param array + * @param asize + * @return + */ +Boolean * allocBooleanLogicArray(CSolver *solver, LogicOp op, Boolean ** array, uint asize); void deleteBoolean(Boolean * This); #endif diff --git a/src/AST/element.c b/src/AST/element.c index 45117e1..903256d 100644 --- a/src/AST/element.c +++ b/src/AST/element.c @@ -1,9 +1,20 @@ #include "element.h" +#include "structs.h" -Element *allocElement(Set * s) { - Element * tmp=(Element *)ourmalloc(sizeof(Element)); +Element *allocElementSet(Set * s) { + ElementSet * tmp=(ElementSet *)ourmalloc(sizeof(ElementSet)); + GETELEMENTTYPE(tmp)= ELEMSET; tmp->set=s; - return tmp; + return &tmp->base; +} + +Element* allocElementFunction(Function * function, Element ** array, uint numArrays, Boolean * overflowstatus){ + ElementFunction* ef = (ElementFunction*) ourmalloc(sizeof(ElementFunction)); + GETELEMENTTYPE(ef)= ELEMFUNCRETURN; + ef->function=function; + ef->overflowstatus = overflowstatus; + ef->Elements = allocVectorArrayElement(numArrays, array); + return &ef->base; } void deleteElement(Element *This) { diff --git a/src/AST/element.h b/src/AST/element.h index 6cbf94c..4119b7d 100644 --- a/src/AST/element.h +++ b/src/AST/element.h @@ -2,11 +2,28 @@ #define ELEMENT_H #include "classlist.h" #include "mymemory.h" +#include "ops.h" +#include "structs.h" + +#define GETELEMENTTYPE(o) (((Element*)o)->type) struct Element { - Set * set; + ElementType type; +}; + +struct ElementSet { + Element base; + Set * set; +}; + +struct ElementFunction{ + Element base; + Function * function; + VectorElement* Elements; + Boolean * overflowstatus; }; -Element * allocElement(Set *s); +Element * allocElementSet(Set *s); +Element* allocElementFunction(Function * function, Element ** array, uint numArrays, Boolean * overflowstatus); void deleteElement(Element *This); #endif diff --git a/src/AST/ops.h b/src/AST/ops.h index 63da885..adbef8d 100644 --- a/src/AST/ops.h +++ b/src/AST/ops.h @@ -23,9 +23,12 @@ typedef enum OrderType OrderType; enum OverFlowBehavior {IGNORE, WRAPAROUND, FLAGFORCESOVERFLOW, OVERFLOWSETSFLAG, FLAGIFFOVERFLOW, NOOVERFLOW}; typedef enum OverFlowBehavior OverFlowBehavior; -enum BooleanType {ORDERCONST, BOOLEANVAR, LOGICOP, COMPARE}; +enum BooleanType {ORDERCONST, BOOLEANVAR, LOGICOP, COMPARE, PREDICATEOP}; typedef enum BooleanType BooleanType; enum FunctionType {TABLEFUNC, OPERATORFUNC}; typedef enum FunctionType FunctionType; + +enum ElementType {ELEMSET, ELEMFUNCRETURN}; +typedef enum ElementType ElementType; #endif diff --git a/src/AST/order.c b/src/AST/order.c index 1d7b1cf..47cc374 100644 --- a/src/AST/order.c +++ b/src/AST/order.c @@ -12,31 +12,6 @@ Order* allocOrder(OrderType type, Set * set){ return order; } -Boolean* getOrderConstraint(Order* order, uint64_t first, uint64_t second){ - //Probably a bad idea to do a O(n) search through the order... - //We have a hashset data structure, why not use it for O(1) search - - - //We don't like warnings - return NULL; - - /* - uint size = getSizeVectorInt(order->set->members); - //First we need to make sure that first and second are part of the list! - bool exist1=false, exist2=false; - for(int i=0; iset->members, i)==first){ - exist1=true; - }else if(getVectorInt(order->set->members, i) == second){ - exist2=true; - }else if(exist1 && exist2){ - break; - } - } - ASSERT(exist1 && exist2); - */ -} - void deleteOrder(Order* order){ uint size = getSizeVectorBoolean( order->constraints ); for(uint i=0; iallFunctions, i)); } - deleteVectorOrder(This->allFunctions); + deleteVectorFunction(This->allFunctions); ourfree(This); } @@ -94,7 +94,7 @@ uint64_t createUniqueItem(CSolver *solver, MutableSet * set) { } Element * getElementVar(CSolver *This, Set * set) { - Element * element=allocElement(set); + Element * element=allocElementSet(set); pushVectorElement(This->allElements, element); return element; } @@ -134,15 +134,19 @@ Function * completeTable(CSolver *solver, Table * table) { } Element * applyFunction(CSolver *solver, Function * function, Element ** array, uint numArrays, Boolean * overflowstatus) { - return NULL; + Element* element= allocElementFunction(function,array,numArrays,overflowstatus); + pushVectorElement(solver->allElements, element); + return element; } Boolean * applyPredicate(CSolver *solver, Predicate * predicate, Element ** inputs, uint numInputs) { - return NULL; + Boolean* boolean= allocBooleanPredicate(predicate, inputs, numInputs); + pushVectorBoolean(solver->allBooleans, boolean); + return boolean; } -Boolean * applyLogicalOperation(CSolver *solver, LogicOp op, Boolean ** array) { - return NULL; +Boolean * applyLogicalOperation(CSolver *solver, LogicOp op, Boolean ** array, uint asize) { + return allocBooleanLogicArray(solver, op, array, asize); } void addBoolean(CSolver *This, Boolean * constraint) { diff --git a/src/csolver.h b/src/csolver.h index 93f19a4..ace6e78 100644 --- a/src/csolver.h +++ b/src/csolver.h @@ -95,7 +95,7 @@ Boolean * applyPredicate(CSolver *, Predicate * predicate, Element ** inputs, ui /** This function applies a logical operation to the Booleans in its input. */ -Boolean * applyLogicalOperation(CSolver *, LogicOp op, Boolean ** array); +Boolean * applyLogicalOperation(CSolver *, LogicOp op, Boolean ** array, uint asize); /** This function adds a boolean constraint to the set of constraints to be satisfied */ -- 2.34.1