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