fix tabbing
[satune.git] / src / ccsolver.cc
1 #include "csolver.h"
2 #include "ccsolver.h"
3
4 #define CCSOLVER(solver) ((CSolver *)solver)
5
6 void *createCCSolver() {
7         return (void *) new CSolver();
8 }
9 void deleteCCSolver(void *solver) {
10         delete CCSOLVER(solver);
11 }
12
13 void resetCCSolver(void *solver) {
14         CCSOLVER(solver)->resetSolver();
15 }
16
17 void *createSet(void *solver,unsigned int type, long *elements, unsigned int num) {
18         return CCSOLVER(solver)->createSet((VarType) type, (uint64_t *)elements, (uint) num);
19 }
20
21 void *createRangeSet(void *solver,unsigned int type, long lowrange, long highrange) {
22         return CCSOLVER(solver)->createRangeSet((VarType) type, (uint64_t) lowrange, (uint64_t) highrange);
23 }
24
25 void *createRangeVar(void *solver,unsigned int type, long lowrange, long highrange) {
26         return CCSOLVER(solver)->createRangeVar((VarType) type, (uint64_t) lowrange, (uint64_t) highrange);
27 }
28
29 void *createMutableSet(void *solver,unsigned int type) {
30         return CCSOLVER(solver)->createMutableSet((VarType) type);
31 }
32
33 void addItem(void *solver,void *set, long element) {
34         CCSOLVER(solver)->addItem((MutableSet *) set, (uint64_t) element);
35 }
36
37 void finalizeMutableSet(void *solver,void *set) {
38         CCSOLVER(solver)->finalizeMutableSet((MutableSet *) set);
39 }
40
41 void *getElementVar(void *solver,void *set) {
42         return CCSOLVER(solver)->getElementVar((Set *) set);
43 }
44
45 void *getElementConst(void *solver,unsigned int type, long value) {
46         return CCSOLVER(solver)->getElementConst((VarType) type, (uint64_t) value);
47 }
48
49 void *getElementRange (void *solver,void *element) {
50         return CCSOLVER(solver)->getElementRange ((Element *) element);
51 }
52
53 void *getBooleanVar(void *solver,unsigned int type) {
54         return CCSOLVER(solver)->getBooleanVar((VarType) type).getRaw();
55 }
56
57 void *getBooleanTrue(void *solver) {
58         return CCSOLVER(solver)->getBooleanTrue().getRaw();
59 }
60
61 void *getBooleanFalse(void *solver) {
62         return CCSOLVER(solver)->getBooleanFalse().getRaw();
63 }
64
65 void *createFunctionOperator(void *solver,unsigned int op, void *range,unsigned int overflowbehavior) {
66         return CCSOLVER(solver)->createFunctionOperator((ArithOp) op, (Set *)range, (OverFlowBehavior) overflowbehavior);
67 }
68
69 void *createPredicateOperator(void *solver,unsigned int op) {
70         return CCSOLVER(solver)->createPredicateOperator((CompOp) op);
71 }
72
73 void *createPredicateTable(void *solver,void *table, unsigned int behavior) {
74         return CCSOLVER(solver)->createPredicateTable((Table *)table, (UndefinedBehavior) behavior);
75 }
76
77 void *createTable(void *solver, void *range) {
78         return CCSOLVER(solver)->createTable((Set *)range);
79 }
80
81 void *createTableForPredicate(void *solver) {
82         return CCSOLVER(solver)->createTableForPredicate();
83 }
84
85 void addTableEntry(void *solver,void *table, void *inputs, unsigned int inputSize, long result) {
86         CCSOLVER(solver)->addTableEntry((Table *)table, (uint64_t *)inputs, (uint) inputSize, (uint64_t) result);
87 }
88
89 void *completeTable(void *solver,void *table, unsigned int behavior) {
90         return CCSOLVER(solver)->completeTable((Table *) table, (UndefinedBehavior) behavior);
91 }
92
93 void *applyFunction(void *solver,void *function, void **array, unsigned int numArrays, void *overflowstatus) {
94         return CCSOLVER(solver)->applyFunction((Function *)function, (Element **)array, (uint) numArrays, BooleanEdge ((Boolean *)overflowstatus));
95 }
96
97 void *applyPredicateTable(void *solver,void *predicate, void **inputs, unsigned int numInputs, void *undefinedStatus) {
98         return CCSOLVER(solver)->applyPredicateTable((Predicate *)predicate, (Element **)inputs, (uint) numInputs, BooleanEdge((Boolean *) undefinedStatus)).getRaw();
99 }
100
101 void *applyPredicate(void *solver,void *predicate, void **inputs, unsigned int numInputs) {
102         return CCSOLVER(solver)->applyPredicate((Predicate *)predicate, (Element **)inputs, (uint) numInputs).getRaw();
103 }
104
105 void *applyLogicalOperation(void *solver,unsigned int op, void **array, unsigned int asize) {
106         BooleanEdge constr [asize];
107         for (uint i = 0; i < asize; i++) {
108                 constr[i] = BooleanEdge((Boolean *)array[i]);
109         }
110         return CCSOLVER(solver)->applyLogicalOperation((LogicOp) op, constr, (uint) asize).getRaw();
111 }
112
113 void *applyExactlyOneConstraint(void *solver, void **array, unsigned int asize) {
114         BooleanEdge constr [asize];
115         for (uint i = 0; i < asize; i++) {
116                 constr[i] = BooleanEdge((Boolean *)array[i]);
117         }
118         return CCSOLVER(solver)->applyExactlyOneConstraint( constr, (uint) asize).getRaw();
119 }
120
121 void *applyLogicalOperationTwo(void *solver,unsigned int op, void *arg1, void *arg2) {
122         return CCSOLVER(solver)->applyLogicalOperation((LogicOp) op, BooleanEdge((Boolean *) arg1), BooleanEdge((Boolean *) arg2)).getRaw();
123 }
124
125 void *applyLogicalOperationOne(void *solver,unsigned int op, void *arg) {
126         return CCSOLVER(solver)->applyLogicalOperation((LogicOp) op, BooleanEdge((Boolean *) arg)).getRaw();
127 }
128
129 void addConstraint(void *solver,void *constraint) {
130         CCSOLVER(solver)->addConstraint(BooleanEdge((Boolean *) constraint));
131 }
132
133 void printConstraint(void *solver,void *constraint) {
134         CCSOLVER(solver)->printConstraint(BooleanEdge((Boolean *) constraint));
135 }
136
137 void *createOrder(void *solver,unsigned int type, void *set) {
138         return CCSOLVER(solver)->createOrder((OrderType) type, (Set *)set);
139 }
140
141 void *orderConstraint(void *solver,void *order, long first, long second) {
142         return CCSOLVER(solver)->orderConstraint((Order *)order, (uint64_t) first, (uint64_t) second).getRaw();
143 }
144
145 int solve(void *solver) {
146         return CCSOLVER(solver)->solve();
147 }
148
149 long getElementValue(void *solver,void *element) {
150         return (long) CCSOLVER(solver)->getElementValue((Element *)element);
151 }
152
153 int getBooleanValue(void *solver, void *boolean) {
154         return CCSOLVER(solver)->getBooleanValue(BooleanEdge((Boolean *) boolean));
155 }
156
157 int getOrderConstraintValue(void *solver,void *order, long first, long second) {
158         return CCSOLVER(solver)->getOrderConstraintValue((Order *)order, (uint64_t) first, (uint64_t) second);
159 }
160
161 void printConstraints(void *solver) {
162         CCSOLVER(solver)->printConstraints();
163 }
164
165
166 void serialize(void *solver) {
167         CCSOLVER(solver)->serialize();
168 }
169
170
171 void mustHaveValue(void *solver, void *element) {
172         CCSOLVER(solver)->mustHaveValue( (Element *) element);
173 }
174
175 void setInterpreter(void *solver, unsigned int type) {
176         CCSOLVER(solver)->setInterpreter((InterpreterType)type);
177 }
178
179 void *clone(void *solver) {
180         return CCSOLVER(solver)->clone();
181 }