From: bdemsky <bdemsky@uci.edu>
Date: Thu, 15 Jun 2017 06:14:13 +0000 (-0700)
Subject: Add Set AST Constructor
X-Git-Url: http://plrg.eecs.uci.edu/git/?p=satune.git;a=commitdiff_plain;h=84245f9abf88882d83e3b9ddfed43ab3abf8638f

Add Set AST Constructor
---

diff --git a/src/C.cfg b/src/C.cfg
index e893a5c..9831cf2 100644
--- 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
+input_tab_size = 2
 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 921096f..8b38540 100644
--- 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)));
-																		
+
 	return allocConstraint(AND, imp1, imp2);
 }
 
diff --git a/src/csolver.c b/src/csolver.c
index a6dde8f..d1b0f58 100644
--- a/src/csolver.c
+++ b/src/csolver.c
@@ -1,35 +1,71 @@
 #include "csolver.h"
+#include "set.h"
+#include "mutableset.h"
+#include "element.h"
 
 CSolver * allocCSolver() {
 	CSolver * tmp=(CSolver *) ourmalloc(sizeof(CSolver));
-	tmp->constraint=allocDefVectorBoolean();
+	tmp->constraints=allocDefVectorBoolean();
+	tmp->sets=allocDefVectorSet();
+	tmp->elements=allocDefVectorElement();
 	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) {
+	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;
 }
 
@@ -68,7 +104,8 @@ Boolean * applyLogicalOperation(CSolver *solver, enum LogicOp op, Boolean ** arr
 	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) {
diff --git a/src/csolver.h b/src/csolver.h
index 7b2d659..63ba766 100644
--- a/src/csolver.h
+++ b/src/csolver.h
@@ -5,19 +5,21 @@
 #include "structs.h"
 
 struct CSolver {
-	VectorBoolean * constraint;
+	VectorBoolean * constraints;
+	VectorSet * sets;
+	VectorElement * elements;
 };
-	
+
 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);
-int64_t createUniqueItem(CSolver *, MutableSet * set);
+uint64_t createUniqueItem(CSolver *, MutableSet * 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
diff --git a/src/element.c b/src/element.c
index 2513fe5..191686c 100644
--- a/src/element.c
+++ b/src/element.c
@@ -5,3 +5,7 @@ Element *allocElement(Set * s) {
 	tmp->set=s;
 	return tmp;
 }
+
+void deleteElement(Element *this) {
+	ourfree(this);
+}
diff --git a/src/element.h b/src/element.h
index 06c33a0..8f0f082 100644
--- a/src/element.h
+++ b/src/element.h
@@ -8,4 +8,5 @@ struct Element {
 };
 
 Element * allocElement(Set *s);
+void deleteElement(Element *this);
 #endif
diff --git a/src/mutableset.c b/src/mutableset.c
index 3f33f90..18f038b 100644
--- a/src/mutableset.c
+++ b/src/mutableset.c
@@ -1,3 +1,15 @@
 #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 eee89bb..fe089f4 100644
--- a/src/mutableset.h
+++ b/src/mutableset.h
@@ -2,5 +2,6 @@
 #define MUTABLESET_H
 #include "set.h"
 
+MutableSet * allocMutableSet(VarType t);
 void addElementMSet(MutableSet * set, uint64_t element);
 #endif
diff --git a/src/set.c b/src/set.c
index 1bab08e..fc056a2 100644
--- a/src/set.c
+++ b/src/set.c
@@ -2,7 +2,7 @@
 #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;
@@ -12,7 +12,7 @@ Set * allocSet(VarType t, uint64_t* elements, uint num) {
 }
 
 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;
@@ -22,7 +22,7 @@ Set * allocSetRange(VarType t, uint64_t lowrange, uint64_t highrange) {
 }
 
 void deleteSet(Set * set) {
-	if (set->isRange)
+	if (!set->isRange)
 		deleteVectorInt(set->members);
 	ourfree(set);
 }
diff --git a/src/set.h b/src/set.h
index 5000674..92315e2 100644
--- a/src/set.h
+++ b/src/set.h
@@ -15,13 +15,14 @@
 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);
-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 */
 
diff --git a/src/structs.c b/src/structs.c
index 4cfb51a..30bca42 100644
--- a/src/structs.c
+++ b/src/structs.c
@@ -2,8 +2,10 @@
 #include "mymemory.h"
 
 VectorImpl(Int, uint64_t, 4);
-VectorImpl(Boolean, Boolean *, 4);
 VectorImpl(Void, void *, 4);
+VectorImpl(Boolean, Boolean *, 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);
diff --git a/src/structs.h b/src/structs.h
index 83ce58c..888f359 100644
--- a/src/structs.h
+++ b/src/structs.h
@@ -6,9 +6,11 @@
 #include "classlist.h"
 
 VectorDef(Int, uint64_t, 4);
+VectorDef(Void, void *, 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);
diff --git a/src/table.h b/src/table.h
index 6e886b7..2bb9805 100644
--- a/src/table.h
+++ b/src/table.h
@@ -4,7 +4,7 @@
 #include "mymemory.h"
 
 struct Table {
-	
+
 };
 
 Table * allocTable();