New type of Element and Boolean.

diff --git a/src/AST/boolean.c b/src/AST/boolean.c
index 7d9aec39f8bac6e042b0bb76b415ee189e2bd5c2..0d3e8929d8d25d3e0131d70c0f86935f0d7688cc 100644 (file)
--- 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; i<asize; i++){
+       boolean=allocBooleanLogic(op,boolean, array[i]);
+       pushVectorBoolean(solver->allBooleans,boolean);
+    }
+    return boolean;
+}
+
 void deleteBoolean(Boolean * This) {
        ourfree(This);
 }

diff --git a/src/AST/boolean.h b/src/AST/boolean.h
index d00a82cf123fa325eb1d2eadef911272df66302d..fd59a21b213c6b631aae0b894b7f2745723566f0 100644 (file)
--- 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 45117e1dccf6abc9f05958eea6d12badd79610a1..903256d61f7e5fd1555fe77aae066eebbe00c6a3 100644 (file)
--- 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 6cbf94cef1cb6d9a75d3ce3bc4da737659c00110..4119b7d2f3dede9555fc7767167a3ae9882ac6af 100644 (file)
--- 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 63da8850249327fbb6fc89bc252a0980d4b52a95..adbef8dda52ede93bcce7c6ace8fdaca57eba28d 100644 (file)
--- 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 1d7b1cfd5db3912c1dc1888bcf17b993b6ce957a..47cc374a1c4fa431c92fa54bd944b15885a95089 100644 (file)
--- 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; i<size; i++){
-        if(getVectorInt(order->set->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; i<size; i++){

diff --git a/src/AST/order.h b/src/AST/order.h
index 0a589a59e20330aaa4f3263b316b3c947a29ccad..7d2bc3c52316f4d2f04932f3a1cfb925c517282c 100644 (file)
--- a/src/AST/order.h
+++ b/src/AST/order.h
@@ -11,7 +11,6 @@ struct Order {
 };
 
 Order* allocOrder(OrderType type, Set * set);
-Boolean* getOrderConstraint(Order* order,uint64_t first, uint64_t second);
 void deleteOrder(Order* order);
 
 #endif

diff --git a/src/classlist.h b/src/classlist.h
index 6de8bcf372c7bff7583bd22f226fe47b56c03d4e..14f43f80c57f857c7547a156fe796b3d30ab9054 100644 (file)
--- a/src/classlist.h
+++ b/src/classlist.h
@@ -26,6 +26,7 @@ typedef struct BooleanOrder BooleanOrder;
 typedef struct BooleanVar BooleanVar;
 typedef struct BooleanLogic BooleanLogic;
 typedef struct BooleanComp BooleanComp;
+typedef struct BooleanPredicate BooleanPredicate;
 
 struct Boolean;
 typedef struct Boolean Boolean;
@@ -38,6 +39,9 @@ typedef struct Set Set;
 
 typedef struct Set MutableSet;
 
+typedef struct ElementFunction ElementFunction;
+typedef struct ElementSet ElementSet;
+
 struct Element;
 typedef struct Element Element;
 

diff --git a/src/csolver.c b/src/csolver.c
index 62f4acdeaf472e3bc6b274698fba7d0c6bfeba1b..2ec12db45a0df213637b75f2c89b5e44cc8acc74 100644 (file)
--- a/src/csolver.c
+++ b/src/csolver.c
@@ -61,7 +61,7 @@ void deleteSolver(CSolver *This) {
        for(uint i=0;i<size;i++) {
                deleteFunction(getVectorFunction(This->allFunctions, 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 93f19a47a5db5b3127e97399c7b563ab1a977c33..ace6e78fb514f1d5803277d1df3f97b0a73a1163 100644 (file)
--- 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 */