Add Set AST Constructor

diff --git a/src/C.cfg b/src/C.cfg
index e893a5c6f4962ee091360ccfd225daa5ece7d424..9831cf21c6ddb7019895b14bae4fcfb20016765c 100644 (file)
--- a/src/C.cfg
+++ b/src/C.cfg
@@ -3,6 +3,7 @@ indent_cmt_with_tabs = True
 indent_columns = 2
 indent_class = True
 output_tab_size = 2
 indent_columns = 2
 indent_class = True
 output_tab_size = 2

+input_tab_size = 2

 nl_func_leave_one_liners = True
 sp_after_semi = Ignore
 sp_after_semi_for = Remove
 nl_func_leave_one_liners = True
 sp_after_semi = Ignore
 sp_after_semi_for = Remove

diff --git a/src/constraint.c b/src/constraint.c
index 921096fae0cefa7a61373d76de3d661a7cdaaa5a..8b38540a59657bdca7b90bee60ed100a1aca9a3d 100644 (file)
--- a/src/constraint.c
+++ b/src/constraint.c
@@ -235,7 +235,7 @@ Constraint * generateEquivNVConstraint(uint numvars, Constraint **var1, Constrai
 Constraint * generateEquivConstraint(Constraint *var1, Constraint *var2) {
        Constraint * imp1=allocConstraint(OR, negateConstraint(cloneConstraint(var1)), var2);
        Constraint * imp2=allocConstraint(OR, var1, negateConstraint(cloneConstraint(var2)));
 Constraint * generateEquivConstraint(Constraint *var1, Constraint *var2) {
        Constraint * imp1=allocConstraint(OR, negateConstraint(cloneConstraint(var1)), var2);
        Constraint * imp2=allocConstraint(OR, var1, negateConstraint(cloneConstraint(var2)));

-                                                                                                                                               
+

        return allocConstraint(AND, imp1, imp2);
 }
 
        return allocConstraint(AND, imp1, imp2);
 }
 

diff --git a/src/csolver.c b/src/csolver.c
index a6dde8fe27489b4e775ba39ce441ceb0cc9d80ea..d1b0f5830420ba46a4c2cb3ef87f18262d4bcb3a 100644 (file)
--- a/src/csolver.c
+++ b/src/csolver.c
@@ -1,35 +1,71 @@
 #include "csolver.h"
 #include "csolver.h"

+#include "set.h"
+#include "mutableset.h"
+#include "element.h"

 
 CSolver * allocCSolver() {
        CSolver * tmp=(CSolver *) ourmalloc(sizeof(CSolver));
 
 CSolver * allocCSolver() {
        CSolver * tmp=(CSolver *) ourmalloc(sizeof(CSolver));

-       tmp->constraint=allocDefVectorBoolean();
+       tmp->constraints=allocDefVectorBoolean();
+       tmp->sets=allocDefVectorSet();
+       tmp->elements=allocDefVectorElement();

        return tmp;
 }
 
        return tmp;
 }
 

-Set * createSet(CSolver * solver, VarType type, uint64_t ** elements) {
-       return NULL;
+/** This function tears down the solver and the entire AST */
+
+void deleteSolver(CSolver *this) {
+       deleteVectorBoolean(this->constraints);
+       uint size=getSizeVectorSet(this->sets);
+       for(uint i=0;i<size;i++) {
+               deleteSet(getVectorSet(this->sets, i));
+       }
+
+       deleteVectorSet(this->sets);
+
+       size=getSizeVectorElement(this->elements);
+       for(uint i=0;i<size;i++) {
+               deleteElement(getVectorElement(this->elements, i));
+       }
+
+       deleteVectorElement(this->elements);
+       ourfree(this);

 }
 
 }
 

-Set * createRangeSet(CSolver * solver, VarType type, uint64_t lowrange, uint64_t highrange) {
-       return NULL;
+Set * createSet(CSolver * this, VarType type, uint64_t * elements, uint numelements) {
+       Set * set=allocSet(type, elements, numelements);
+       pushVectorSet(this->sets, set);
+       return set;

 }
 
 }
 

-MutableSet * createMutableSet(CSolver * solver, VarType type) {
-       return NULL;
+Set * createRangeSet(CSolver * this, VarType type, uint64_t lowrange, uint64_t highrange) {
+       Set * set=allocSetRange(type, lowrange, highrange);
+       pushVectorSet(this->sets, set);
+       return set;
+}
+
+MutableSet * createMutableSet(CSolver * this, VarType type) {
+       MutableSet * set=allocMutableSet(type);
+       pushVectorSet(this->sets, set);
+       return set;

 }
 
 void addItem(CSolver *solver, MutableSet * set, uint64_t element) {
 }
 
 void addItem(CSolver *solver, MutableSet * set, uint64_t element) {

+       addElementMSet(set, element);

 }
 
 }
 

-int64_t createUniqueItem(CSolver *solver, MutableSet * set) {
-       return 0;
+uint64_t createUniqueItem(CSolver *solver, MutableSet * set) {
+       uint64_t element=set->low++;
+       addElementMSet(set, element);
+       return element;

 }
 
 }
 

-Element * getElementVar(CSolver *solver, Set * set) {
-       return NULL;
+Element * getElementVar(CSolver *this, Set * set) {
+       Element * element=allocElement(set);
+       pushVectorElement(this->elements, element);
+       return element;

 }
 
 }
 

-Boolean * getBooleanVar(CSolver *solver) {
+Boolean * getBooleanVar(CSolver *solver, VarType type) {

        return NULL;
 }
 
        return NULL;
 }
 


@@ -68,7 +104,8 @@ Boolean * applyLogicalOperation(CSolver *solver, enum LogicOp op, Boolean ** arr
        return NULL;
 }
 
        return NULL;
 }
 

-void addBoolean(CSolver *solver, Boolean * constraint) {
+void addBoolean(CSolver *this, Boolean * constraint) {
+       pushVectorBoolean(this->constraints, constraint);

 }
 
 Order * createOrder(CSolver *solver, enum OrderType type, Set * set) {
 }
 
 Order * createOrder(CSolver *solver, enum OrderType type, Set * set) {

diff --git a/src/csolver.h b/src/csolver.h
index 7b2d65924c917aff764afb476d5ca3c49799dd43..63ba766206e5d125fbc074babcf84eb22271e866 100644 (file)
--- a/src/csolver.h
+++ b/src/csolver.h
@@ -5,19 +5,21 @@
 #include "structs.h"
 
 struct CSolver {
 #include "structs.h"
 
 struct CSolver {

-       VectorBoolean * constraint;
+       VectorBoolean * constraints;
+       VectorSet * sets;
+       VectorElement * elements;

 };
 };

-       
+

 CSolver * allocCSolver();
 CSolver * allocCSolver();

-Set * createSet(CSolver *, VarType type, uint64_t ** elements);
+Set * createSet(CSolver *, VarType type, uint64_t * elements, uint num);

 Set * createRangeSet(CSolver *, VarType type, uint64_t lowrange, uint64_t highrange);
 MutableSet * createMutableSet(CSolver *, VarType type);
 
 void addItem(CSolver *, MutableSet * set, uint64_t element);
 Set * createRangeSet(CSolver *, VarType type, uint64_t lowrange, uint64_t highrange);
 MutableSet * createMutableSet(CSolver *, VarType type);
 
 void addItem(CSolver *, MutableSet * set, uint64_t element);

-int64_t createUniqueItem(CSolver *, MutableSet * set);
+uint64_t createUniqueItem(CSolver *, MutableSet * set);

 
 Element * getElementVar(CSolver *, Set * set);
 
 Element * getElementVar(CSolver *, Set * set);

-Boolean * getBooleanVar(CSolver *);
+Boolean * getBooleanVar(CSolver *, VarType type);

 
 Function * createFunctionOperator(CSolver *, enum ArithOp op, Set ** domain, Set * range, enum OverFlowBehavior overflowbehavior, Boolean * overflowstatus);
 //Does Not Overflow
 
 Function * createFunctionOperator(CSolver *, enum ArithOp op, Set ** domain, Set * range, enum OverFlowBehavior overflowbehavior, Boolean * overflowstatus);
 //Does Not Overflow

diff --git a/src/element.c b/src/element.c
index 2513fe5422122e0d512325b5e3465cc72215a31d..191686cec460d17e1eb8ce2d0136515ab5bcf3a5 100644 (file)
--- a/src/element.c
+++ b/src/element.c
@@ -5,3 +5,7 @@ Element *allocElement(Set * s) {
        tmp->set=s;
        return tmp;
 }
        tmp->set=s;
        return tmp;
 }

+
+void deleteElement(Element *this) {
+       ourfree(this);
+}

diff --git a/src/element.h b/src/element.h
index 06c33a09849eb276a137007e4c325724e2d1f733..8f0f0826548f314de74c2330fef547436677958a 100644 (file)
--- a/src/element.h
+++ b/src/element.h
@@ -8,4 +8,5 @@ struct Element {
 };
 
 Element * allocElement(Set *s);
 };
 
 Element * allocElement(Set *s);

+void deleteElement(Element *this);

 #endif
 #endif

diff --git a/src/mutableset.c b/src/mutableset.c
index 3f33f9035b1f76ab62d1619a43a663d0466b3f99..18f038b420548738fffcc945d1f8eb50305dbf5a 100644 (file)
--- a/src/mutableset.c
+++ b/src/mutableset.c
@@ -1,3 +1,15 @@
 #include "mutableset.h"
 
 #include "mutableset.h"
 

-void addElementMSet(MutableSet * set, uint64_t element) { pushVectorInt(set->members, element); }
+MutableSet * allocMutableSet(VarType t) {
+       MutableSet * tmp=(MutableSet *)ourmalloc(sizeof(MutableSet));
+       tmp->type=t;
+       tmp->isRange=false;
+       tmp->low=0;
+       tmp->high=0;
+       tmp->members=allocDefVectorInt();
+       return tmp;
+}
+
+void addElementMSet(MutableSet * set, uint64_t element) {
+       pushVectorInt(set->members, element);
+}

diff --git a/src/mutableset.h b/src/mutableset.h
index eee89bbf3e47c725d8bee393a4e1b4c6f3ba400e..fe089f4c86a99ab282e2e4703e8d352baa371ee8 100644 (file)
--- a/src/mutableset.h
+++ b/src/mutableset.h
@@ -2,5 +2,6 @@
 #define MUTABLESET_H
 #include "set.h"
 
 #define MUTABLESET_H
 #include "set.h"
 

+MutableSet * allocMutableSet(VarType t);

 void addElementMSet(MutableSet * set, uint64_t element);
 #endif
 void addElementMSet(MutableSet * set, uint64_t element);
 #endif

diff --git a/src/set.c b/src/set.c
index 1bab08e527f97e76c73a5fdc79c5703e4da9ea39..fc056a2e16b95ef9547af781cd800de6956ec461 100644 (file)
--- a/src/set.c
+++ b/src/set.c
@@ -2,7 +2,7 @@
 #include <stddef.h>
 
 Set * allocSet(VarType t, uint64_t* elements, uint num) {
 #include <stddef.h>
 
 Set * allocSet(VarType t, uint64_t* elements, uint num) {

-       Set * tmp=(Set *)ourmalloc(sizeof(struct Set));
+       Set * tmp=(Set *)ourmalloc(sizeof(Set));

        tmp->type=t;
        tmp->isRange=false;
        tmp->low=0;
        tmp->type=t;
        tmp->isRange=false;
        tmp->low=0;


@@ -12,7 +12,7 @@ Set * allocSet(VarType t, uint64_t* elements, uint num) {
 }
 
 Set * allocSetRange(VarType t, uint64_t lowrange, uint64_t highrange) {
 }
 
 Set * allocSetRange(VarType t, uint64_t lowrange, uint64_t highrange) {

-       Set * tmp=(Set *)ourmalloc(sizeof(struct Set));
+       Set * tmp=(Set *)ourmalloc(sizeof(Set));

        tmp->type=t;
        tmp->isRange=true;
        tmp->low=lowrange;
        tmp->type=t;
        tmp->isRange=true;
        tmp->low=lowrange;


@@ -22,7 +22,7 @@ Set * allocSetRange(VarType t, uint64_t lowrange, uint64_t highrange) {
 }
 
 void deleteSet(Set * set) {
 }
 
 void deleteSet(Set * set) {

-       if (set->isRange)
+       if (!set->isRange)

                deleteVectorInt(set->members);
        ourfree(set);
 }
                deleteVectorInt(set->members);
        ourfree(set);
 }

diff --git a/src/set.h b/src/set.h
index 5000674059a598542930c44a10a9da6f4701f73b..92315e22818728089a1d543021aea773529122bc 100644 (file)
--- a/src/set.h
+++ b/src/set.h
@@ -15,13 +15,14 @@
 struct Set {
        VarType type;
        bool isRange;
 struct Set {
        VarType type;
        bool isRange;

-       uint64_t low, high;
+       uint64_t low;//also used to count unique items
+       uint64_t high;

        VectorInt * members;
 };
 
 
 Set *allocSet(VarType t, uint64_t * elements, uint num);
        VectorInt * members;
 };
 
 
 Set *allocSet(VarType t, uint64_t * elements, uint num);

-Set    * allocSetRange(VarType t, uint64_t lowrange, uint64_t highrange);
+Set * allocSetRange(VarType t, uint64_t lowrange, uint64_t highrange);

 void deleteSet(Set *set);
 #endif/* SET_H */
 
 void deleteSet(Set *set);
 #endif/* SET_H */
 

diff --git a/src/structs.c b/src/structs.c
index 4cfb51a271baabbee2b1922a9d43e9722755195f..30bca4217a67e94cba89f58b9f5536fe589a1fe0 100644 (file)
--- a/src/structs.c
+++ b/src/structs.c
@@ -2,8 +2,10 @@
 #include "mymemory.h"
 
 VectorImpl(Int, uint64_t, 4);
 #include "mymemory.h"
 
 VectorImpl(Int, uint64_t, 4);

-VectorImpl(Boolean, Boolean *, 4);

 VectorImpl(Void, void *, 4);
 VectorImpl(Void, void *, 4);

+VectorImpl(Boolean, Boolean *, 4);

 VectorImpl(Constraint, Constraint *, 4);
 VectorImpl(Constraint, Constraint *, 4);

+VectorImpl(Set, Set *, 4);
+VectorImpl(Element, Element *, 4);

 HashTableImpl(Void, void *, void *, Ptr_hash_function, Ptr_equals);
 HashSetImpl(Void, void *, Ptr_hash_function, Ptr_equals);
 HashTableImpl(Void, void *, void *, Ptr_hash_function, Ptr_equals);
 HashSetImpl(Void, void *, Ptr_hash_function, Ptr_equals);

diff --git a/src/structs.h b/src/structs.h
index 83ce58c3eaff28e93126e21db1b7657a80cb5a73..888f359e3fdee2266f7a63a661ecc7e8bba26046 100644 (file)
--- a/src/structs.h
+++ b/src/structs.h
@@ -6,9 +6,11 @@
 #include "classlist.h"
 
 VectorDef(Int, uint64_t, 4);
 #include "classlist.h"
 
 VectorDef(Int, uint64_t, 4);

+VectorDef(Void, void *, 4);

 VectorDef(Boolean, Boolean *, 4);
 VectorDef(Constraint, Constraint *, 4);
 VectorDef(Boolean, Boolean *, 4);
 VectorDef(Constraint, Constraint *, 4);

-VectorDef(Void, void *, 4);
+VectorDef(Set, Set *, 4);
+VectorDef(Element, Element *, 4);

 
 inline unsigned int Ptr_hash_function(void * hash) {
        return (unsigned int)((uint64_t)hash >> 4);
 
 inline unsigned int Ptr_hash_function(void * hash) {
        return (unsigned int)((uint64_t)hash >> 4);

diff --git a/src/table.h b/src/table.h
index 6e886b78100cbc18fa6c44c3c0b6be1672fcf4e4..2bb98051f02c6ec5eefc902c3765cebda393d3b4 100644 (file)
--- a/src/table.h
+++ b/src/table.h
@@ -4,7 +4,7 @@
 #include "mymemory.h"
 
 struct Table {
 #include "mymemory.h"
 
 struct Table {

-       
+

 };
 
 Table * allocTable();
 };
 
 Table * allocTable();