Commit after resolving conflicts
[satune.git] / src / csolver.c
1 #include "csolver.h"
2 #include "AST/set.h"
3 #include "AST/mutableset.h"
4 #include "AST/element.h"
5 #include "AST/boolean.h"
6 #include "AST/predicate.h"
7 #include "AST/order.h"
8
9 CSolver * allocCSolver() {
10         CSolver * tmp=(CSolver *) ourmalloc(sizeof(CSolver));
11         tmp->constraints=allocDefVectorBoolean();
12         tmp->allBooleans=allocDefVectorBoolean();
13         tmp->allSets=allocDefVectorSet();
14         tmp->allElements=allocDefVectorElement();
15         return tmp;
16 }
17
18 /** This function tears down the solver and the entire AST */
19
20 void deleteSolver(CSolver *this) {
21         deleteVectorBoolean(this->constraints);
22
23         uint size=getSizeVectorBoolean(this->allBooleans);
24         for(uint i=0;i<size;i++) {
25                 deleteBoolean(getVectorBoolean(this->allBooleans, i));
26         }
27
28         deleteVectorBoolean(this->allBooleans);
29
30         size=getSizeVectorSet(this->allSets);
31         for(uint i=0;i<size;i++) {
32                 deleteSet(getVectorSet(this->allSets, i));
33         }
34
35         deleteVectorSet(this->allSets);
36
37         size=getSizeVectorElement(this->allElements);
38         for(uint i=0;i<size;i++) {
39                 deleteElement(getVectorElement(this->allElements, i));
40         }
41
42         deleteVectorElement(this->allElements);
43         ourfree(this);
44 }
45
46 Set * createSet(CSolver * this, VarType type, uint64_t * elements, uint numelements) {
47         Set * set=allocSet(type, elements, numelements);
48         pushVectorSet(this->allSets, set);
49         return set;
50 }
51
52 Set * createRangeSet(CSolver * this, VarType type, uint64_t lowrange, uint64_t highrange) {
53         Set * set=allocSetRange(type, lowrange, highrange);
54         pushVectorSet(this->allSets, set);
55         return set;
56 }
57
58 MutableSet * createMutableSet(CSolver * this, VarType type) {
59         MutableSet * set=allocMutableSet(type);
60         pushVectorSet(this->allSets, set);
61         return set;
62 }
63
64 void addItem(CSolver *solver, MutableSet * set, uint64_t element) {
65         addElementMSet(set, element);
66 }
67
68 uint64_t createUniqueItem(CSolver *solver, MutableSet * set) {
69         uint64_t element=set->low++;
70         addElementMSet(set, element);
71         return element;
72 }
73
74 Element * getElementVar(CSolver *this, Set * set) {
75         Element * element=allocElement(set);
76         pushVectorElement(this->allElements, element);
77         return element;
78 }
79
80 Boolean * getBooleanVar(CSolver *solver, VarType type) {
81         Boolean* boolean= allocBoolean(type);
82         pushVectorBoolean(solver->allBooleans, boolean);
83         return boolean;
84 }
85
86 Function * createFunctionOperator(CSolver *solver, enum ArithOp op, Set ** domain, uint numDomain, Set * range,
87         enum OverFlowBehavior overflowbehavior, Boolean * overflowstatus) {
88         return NULL;
89 }
90
91 Predicate * createPredicateOperator(CSolver *solver, enum CompOp op, Set ** domain, uint numDomain) {
92         return allocPredicate(op, domain,numDomain);
93 }
94
95 Table * createTable(CSolver *solver, Set **domains, uint numDomain, Set * range) {
96         return NULL;
97 }
98
99 void addTableEntry(CSolver *solver, uint64_t* inputs, uint inputSize, uint64_t result) {
100 }
101
102 Function * completeTable(CSolver *solver, Table * table) {
103         return NULL;
104 }
105
106 Element * applyFunction(CSolver *solver, Function * function, Element ** array) {
107         return NULL;
108 }
109
110 Boolean * applyPredicate(CSolver *solver, Predicate * predicate, Element ** inputs) {
111         return NULL;
112 }
113
114 Boolean * applyLogicalOperation(CSolver *solver, enum LogicOp op, Boolean ** array) {
115         return NULL;
116 }
117
118 void addBoolean(CSolver *this, Boolean * constraint) {
119         pushVectorBoolean(this->constraints, constraint);
120 }
121
122 Order * createOrder(CSolver *solver, enum OrderType type, Set * set) {
123         return allocOrder(type, set);
124 }
125
126 Boolean * orderConstraint(CSolver *solver, Order * order, uint64_t first, uint64_t second) {
127         Boolean* constraint = allocBooleanOrder(order, first, second);
128         pushVectorBoolean(solver->allBooleans,constraint);
129         return constraint;
130 }