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 }