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