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