src/csolver.c

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