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
   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, ArithOp op, Set ** domain, uint numDomain, Set * range,
  87                                                                                                                                         OverFlowBehavior overflowbehavior) {
  88         return NULL;
  89 }
  90
  91 Predicate * createPredicateOperator(CSolver *solver, 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, Boolean * overflowstatus) {
 107         return NULL;
 108 }
 109
 110 Boolean * applyPredicate(CSolver *solver, Predicate * predicate, Element ** inputs) {
 111         return NULL;
 112 }
 113
 114 Boolean * applyLogicalOperation(CSolver *solver, 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, 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 }