Commit after resolving conflicts

diff --combined src/AST/function.h
index 0000000000000000000000000000000000000000,1ea206935f2708ecf53d080bf4792373a42ee7e5..82379f782d6db72c06ef53f6783237e6841323b2
mode 000000,100644..100644
--- /dev/null
--- 2/src/AST/function.h
+++ b/src/AST/function.h
@@@ -1,0 -1,10 +1,14 @@@
 -
+ #ifndef FUNCTION_H
+ #define FUNCTION_H
+ #include "classlist.h"
+ #include "mymemory.h"
 -
 -      Table* table;
++#include "ops.h"
++#include "structs.h"
+ struct Function {
++    enum ArithOp op;
++    VectorSet* domains; 
++    Set * range;
++    enum OverFlowBehavior overflowbehavior;
++    Table* table;
+ };
+ #endif

diff --combined src/csolver.c
index 5ddaaeda13e13e79db6bb291f2705418217241c4,26a4be990b02b09edc0f9bf50f3741c2824b5a77..8835fbf1c75939d67614f7d62624dc58bf3bde7f
--- 1/src/csolver.c
--- 2/src/csolver.c
+++ b/src/csolver.c
@@@ -1,15 -1,17 +1,17 @@@
  #include "csolver.h"
--#include "set.h"
--#include "mutableset.h"
--#include "element.h"
--#include "boolean.h"
--#include "predicate.h"
 -#include "order.h"
++#include "AST/set.h"
++#include "AST/mutableset.h"
++#include "AST/element.h"
++#include "AST/boolean.h"
++#include "AST/predicate.h"
++#include "AST/order.h"
  
  CSolver * allocCSolver() {
        CSolver * tmp=(CSolver *) ourmalloc(sizeof(CSolver));
        tmp->constraints=allocDefVectorBoolean();
-       tmp->sets=allocDefVectorSet();
-       tmp->elements=allocDefVectorElement();
+       tmp->allBooleans=allocDefVectorBoolean();
+       tmp->allSets=allocDefVectorSet();
+       tmp->allElements=allocDefVectorElement();
        return tmp;
  }
  
@@@ -17,37 -19,45 +19,45 @@@
  
  void deleteSolver(CSolver *this) {
        deleteVectorBoolean(this->constraints);
-       uint size=getSizeVectorSet(this->sets);
+ 
+       uint size=getSizeVectorBoolean(this->allBooleans);
+       for(uint i=0;i<size;i++) {
+               deleteBoolean(getVectorBoolean(this->allBooleans, i));
+       }
+ 
+       deleteVectorBoolean(this->allBooleans);
+ 
+       size=getSizeVectorSet(this->allSets);
        for(uint i=0;i<size;i++) {
-               deleteSet(getVectorSet(this->sets, i));
+               deleteSet(getVectorSet(this->allSets, i));
        }
  
-       deleteVectorSet(this->sets);
+       deleteVectorSet(this->allSets);
  
-       size=getSizeVectorElement(this->elements);
+       size=getSizeVectorElement(this->allElements);
        for(uint i=0;i<size;i++) {
-               deleteElement(getVectorElement(this->elements, i));
+               deleteElement(getVectorElement(this->allElements, i));
        }
  
-       deleteVectorElement(this->elements);
+       deleteVectorElement(this->allElements);
        ourfree(this);
  }
  
  Set * createSet(CSolver * this, VarType type, uint64_t * elements, uint numelements) {
        Set * set=allocSet(type, elements, numelements);
-       pushVectorSet(this->sets, set);
+       pushVectorSet(this->allSets, set);
        return set;
  }
  
  Set * createRangeSet(CSolver * this, VarType type, uint64_t lowrange, uint64_t highrange) {
        Set * set=allocSetRange(type, lowrange, highrange);
-       pushVectorSet(this->sets, set);
+       pushVectorSet(this->allSets, set);
        return set;
  }
  
  MutableSet * createMutableSet(CSolver * this, VarType type) {
        MutableSet * set=allocMutableSet(type);
-       pushVectorSet(this->sets, set);
+       pushVectorSet(this->allSets, set);
        return set;
  }
  
@@@ -63,27 -73,22 +73,23 @@@ uint64_t createUniqueItem(CSolver *solv
  
  Element * getElementVar(CSolver *this, Set * set) {
        Element * element=allocElement(set);
-       pushVectorElement(this->elements, element);
+       pushVectorElement(this->allElements, element);
        return element;
  }
  
  Boolean * getBooleanVar(CSolver *solver, VarType type) {
-     Boolean* boolean= allocBoolean(type);
-     pushVectorBoolean(solver->constraints, boolean);
-     return boolean;
+       Boolean* boolean= allocBoolean(type);
+       pushVectorBoolean(solver->allBooleans, boolean);
+       return boolean;
  }
  
 -Function * createFunctionOperator(CSolver *solver, enum ArithOp op, Set ** domain, uint numDomain, Set * range, enum OverFlowBehavior overflowbehavior, Boolean * overflowstatus) {
 +Function * createFunctionOperator(CSolver *solver, enum ArithOp op, Set ** domain, uint numDomain, Set * range,
 +        enum OverFlowBehavior overflowbehavior, Boolean * overflowstatus) {
        return NULL;
  }
  
- //Function * createFunctionOperatorPure(CSolver *solver, enum ArithOp op) {
- //    return NULL;
- //}
- 
  Predicate * createPredicateOperator(CSolver *solver, enum CompOp op, Set ** domain, uint numDomain) {
-     return allocPredicate(op, domain,numDomain);
+       return allocPredicate(op, domain,numDomain);
  }
  
  Table * createTable(CSolver *solver, Set **domains, uint numDomain, Set * range) {
@@@ -114,11 -119,11 +120,11 @@@ void addBoolean(CSolver *this, Boolean 
  }
  
  Order * createOrder(CSolver *solver, enum OrderType type, Set * set) {
-     return allocOrder(type, set);
+       return allocOrder(type, set);
  }
  
  Boolean * orderConstraint(CSolver *solver, Order * order, uint64_t first, uint64_t second) {
-     Boolean* constraint = allocBooleanOrder(order, first, second);
-     pushVectorBoolean(solver->constraints,constraint);
-     return constraint;
+       Boolean* constraint = allocBooleanOrder(order, first, second);
+       pushVectorBoolean(solver->allBooleans,constraint);
+       return constraint;
  }