Finish clone

diff --git a/src/AST/boolean.cc b/src/AST/boolean.cc
index 1eb2f001a50ca8649c25d4364864406b3e7e66a4..77709b6b0918fc63398ae5ddaf7fb98230caf1ad 100644 (file)
--- a/src/AST/boolean.cc
+++ b/src/AST/boolean.cc
@@ -43,36 +43,36 @@ BooleanLogic::BooleanLogic(CSolver *solver, LogicOp _op, Boolean **array, uint a
        inputs(array, asize) {
 }
 
        inputs(array, asize) {
 }
 

-Boolean * BooleanVar::clone(CSolver *solver, CloneMap *map) {
-       if (map->boolean.contains(this)) {
-               return map->boolean.get(this);
-       } else {
-               Boolean * bvar=solver->getBooleanVar(type);
-               map->boolean.put(this, bvar);
-               return bvar;
-       }
+Boolean *BooleanVar::clone(CSolver *solver, CloneMap *map) {
+       Boolean *b = (Boolean *) map->get(this);
+       if (b != NULL)
+               return b;
+       Boolean *bvar = solver->getBooleanVar(type);
+       map->put(this, bvar);
+       return bvar;
+

 }
 
 }
 

-Boolean * BooleanOrder::clone(CSolver * solver, CloneMap *map) {
-       Order * ordercopy=order->clone(map);
+Boolean *BooleanOrder::clone(CSolver *solver, CloneMap *map) {
+       Order *ordercopy = order->clone(solver, map);

        return solver->orderConstraint(ordercopy, first, second);
 }
 
        return solver->orderConstraint(ordercopy, first, second);
 }
 

-Boolean * BooleanLogic::clone(CSolver * solver, CloneMap *map) {
-       Boolean * array[inputs.getSize()];
-       for(uint i=0;i<inputs.getSize();i++) {
-               array[i]=inputs.get(i)->clone(solver, map);
+Boolean *BooleanLogic::clone(CSolver *solver, CloneMap *map) {
+       Boolean *array[inputs.getSize()];
+       for (uint i = 0; i < inputs.getSize(); i++) {
+               array[i] = inputs.get(i)->clone(solver, map);

        }
        return solver->applyLogicalOperation(op, array, inputs.getSize());
 }
 
        }
        return solver->applyLogicalOperation(op, array, inputs.getSize());
 }
 

-Boolean * BooleanPredicate::clone(CSolver * solver, CloneMap *map) {
-       Element * array[inputs.getSize()];
-       for(uint i=0;i<inputs.getSize();i++) {
-               array[i]=inputs.get(i)->clone(solver, map);
+Boolean *BooleanPredicate::clone(CSolver *solver, CloneMap *map) {
+       Element *array[inputs.getSize()];
+       for (uint i = 0; i < inputs.getSize(); i++) {
+               array[i] = inputs.get(i)->clone(solver, map);

        }
        }

-       Predicate * pred=predicate->clone(map);
-       Boolean * defstatus=(undefStatus != NULL) ? undefStatus->clone(solver, map) : NULL;
-       
+       Predicate *pred = predicate->clone(solver, map);
+       Boolean *defstatus = (undefStatus != NULL) ? undefStatus->clone(solver, map) : NULL;
+

        return solver->applyPredicateTable(pred, array, inputs.getSize(), defstatus);
 }
        return solver->applyPredicateTable(pred, array, inputs.getSize(), defstatus);
 }

diff --git a/src/AST/boolean.h b/src/AST/boolean.h
index 2341fcfdf4edbc873515d2ffc105214cba3d9324..bc247c2f558eaee155ddd2a091d7d8bdeede93ae 100644 (file)
--- a/src/AST/boolean.h
+++ b/src/AST/boolean.h
@@ -21,7 +21,7 @@ class Boolean : public ASTNode {
 public:
        Boolean(ASTNodeType _type);
        virtual ~Boolean() {}
 public:
        Boolean(ASTNodeType _type);
        virtual ~Boolean() {}

-       virtual Boolean * clone(CSolver * solver, CloneMap *map);
+       virtual Boolean *clone(CSolver *solver, CloneMap *map);

        Polarity polarity;
        BooleanValue boolVal;
        Vector<Boolean *> parents;
        Polarity polarity;
        BooleanValue boolVal;
        Vector<Boolean *> parents;


@@ -31,8 +31,8 @@ public:
 class BooleanVar : public Boolean {
 public:
        BooleanVar(VarType t);
 class BooleanVar : public Boolean {
 public:
        BooleanVar(VarType t);

-       Boolean * clone(CSolver * solver, CloneMap *map);
-       
+       Boolean *clone(CSolver *solver, CloneMap *map);
+

        VarType vtype;
        Edge var;
        MEMALLOC;
        VarType vtype;
        Edge var;
        MEMALLOC;


@@ -41,8 +41,8 @@ public:
 class BooleanOrder : public Boolean {
 public:
        BooleanOrder(Order *_order, uint64_t _first, uint64_t _second);
 class BooleanOrder : public Boolean {
 public:
        BooleanOrder(Order *_order, uint64_t _first, uint64_t _second);

-       Boolean * clone(CSolver * solver, CloneMap *map);
-       
+       Boolean *clone(CSolver *solver, CloneMap *map);
+

        Order *order;
        uint64_t first;
        uint64_t second;
        Order *order;
        uint64_t first;
        uint64_t second;


@@ -52,8 +52,8 @@ public:
 class BooleanPredicate : public Boolean {
 public:
        BooleanPredicate(Predicate *_predicate, Element **_inputs, uint _numInputs, Boolean *_undefinedStatus);
 class BooleanPredicate : public Boolean {
 public:
        BooleanPredicate(Predicate *_predicate, Element **_inputs, uint _numInputs, Boolean *_undefinedStatus);

-       Boolean * clone(CSolver * solver, CloneMap *map);
-       
+       Boolean *clone(CSolver *solver, CloneMap *map);
+

        Predicate *predicate;
        FunctionEncoding encoding;
        Array<Element *> inputs;
        Predicate *predicate;
        FunctionEncoding encoding;
        Array<Element *> inputs;


@@ -65,7 +65,7 @@ public:
 class BooleanLogic : public Boolean {
 public:
        BooleanLogic(CSolver *solver, LogicOp _op, Boolean **array, uint asize);
 class BooleanLogic : public Boolean {
 public:
        BooleanLogic(CSolver *solver, LogicOp _op, Boolean **array, uint asize);

-       Boolean * clone(CSolver * solver, CloneMap *map);
+       Boolean *clone(CSolver *solver, CloneMap *map);

 
        LogicOp op;
        Array<Boolean *> inputs;
 
        LogicOp op;
        Array<Boolean *> inputs;

diff --git a/src/AST/element.cc b/src/AST/element.cc
index d6832f94d9d8fd2b8d0d5b28c5e42dbdd2dd8547..20cddf3073a363579544583e676272431c9cbffc 100644 (file)
--- a/src/AST/element.cc
+++ b/src/AST/element.cc
@@ -26,7 +26,7 @@ ElementFunction::ElementFunction(Function *_function, Element **array, uint numA
                GETELEMENTPARENTS(array[i])->push(this);
 }
 
                GETELEMENTPARENTS(array[i])->push(this);
 }
 

-ElementConst::ElementConst(uint64_t _value, VarType _type, Set * _set) :
+ElementConst::ElementConst(uint64_t _value, VarType _type, Set *_set) :

        Element(ELEMCONST),
        set(_set),
        value(_value) {
        Element(ELEMCONST),
        set(_set),
        value(_value) {


@@ -56,24 +56,24 @@ Set *getElementSet(Element *This) {
        return NULL;
 }
 
        return NULL;
 }
 

-Element * ElementConst::clone(CSolver *solver, CloneMap * map) {
+Element *ElementConst::clone(CSolver *solver, CloneMap *map) {

        return solver->getElementConst(type, value);
 }
        return solver->getElementConst(type, value);
 }

-               
-Element * ElementSet::clone(CSolver *solver, CloneMap * map) {
-       Element * e = map->element.get(this);
+
+Element *ElementSet::clone(CSolver *solver, CloneMap *map) {
+       Element *e = (Element *) map->get(this);

        if (e != NULL)
                return e;
        e = solver->getElementVar(set->clone(solver, map));
        if (e != NULL)
                return e;
        e = solver->getElementVar(set->clone(solver, map));

-       map->element.put(e, e);
+       map->put(e, e);

        return e;
 }
 
        return e;
 }
 

-Element * ElementFunction::clone(CSolver *solver, CloneMap * map) {
-       Element * array[inputs.getSize()];
-       for(uint i=0; i<inputs.getSize(); i++) {
-               array[i]=inputs.get(i)->clone(solver, map);
+Element *ElementFunction::clone(CSolver *solver, CloneMap *map) {
+       Element *array[inputs.getSize()];
+       for (uint i = 0; i < inputs.getSize(); i++) {
+               array[i] = inputs.get(i)->clone(solver, map);

        }
        }

-       Element * e = solver->applyFunction(function->clone(solver, map), array, inputs.getSize(), overflowstatus->clone(solver, map));
+       Element *e = solver->applyFunction(function->clone(solver, map), array, inputs.getSize(), overflowstatus->clone(solver, map));

        return e;
 }
        return e;
 }

diff --git a/src/AST/element.h b/src/AST/element.h
index a230055fe70285712de99ec0212f869f0235d2ba..267f133f1beff89633bf4fffa540b2eb7ead6acf 100644 (file)
--- a/src/AST/element.h
+++ b/src/AST/element.h
@@ -16,7 +16,7 @@ public:
        virtual ~Element() {}
        Vector<ASTNode *> parents;
        ElementEncoding encoding;
        virtual ~Element() {}
        Vector<ASTNode *> parents;
        ElementEncoding encoding;

-       virtual Element * clone(CSolver * solver, CloneMap * map);
+       virtual Element *clone(CSolver *solver, CloneMap *map);

        MEMALLOC;
 };
 
        MEMALLOC;
 };
 


@@ -25,7 +25,7 @@ public:
        ElementConst(uint64_t value, VarType type, Set *_set);
        Set *set;
        uint64_t value;
        ElementConst(uint64_t value, VarType type, Set *_set);
        Set *set;
        uint64_t value;

-       Element * clone(CSolver * solver, CloneMap * map);
+       Element *clone(CSolver *solver, CloneMap *map);

        MEMALLOC;
 };
 
        MEMALLOC;
 };
 


@@ -33,7 +33,7 @@ class ElementSet : public Element {
 public:
        ElementSet(Set *s);
        Set *set;
 public:
        ElementSet(Set *s);
        Set *set;

-       Element * clone(CSolver * solver, CloneMap * map);
+       Element *clone(CSolver *solver, CloneMap *map);

        MEMALLOC;
 };
 
        MEMALLOC;
 };
 


@@ -44,7 +44,7 @@ public:
        Array<Element *> inputs;
        Boolean *overflowstatus;
        FunctionEncoding functionencoding;
        Array<Element *> inputs;
        Boolean *overflowstatus;
        FunctionEncoding functionencoding;

-       Element * clone(CSolver * solver, CloneMap * map);
+       Element *clone(CSolver *solver, CloneMap *map);

        MEMALLOC;
 };
 
        MEMALLOC;
 };
 

diff --git a/src/AST/function.cc b/src/AST/function.cc
index 50f8715db77a7485e423894cdae8f00d2c4c20e3..1d910e48e9ea0d7d2185357de7633d6384c97fc3 100644 (file)
--- a/src/AST/function.cc
+++ b/src/AST/function.cc
@@ -1,7 +1,7 @@
 #include "function.h"
 #include "table.h"
 #include "set.h"
 #include "function.h"
 #include "table.h"
 #include "set.h"

-
+#include "csolver.h"

 
 FunctionOperator::FunctionOperator(ArithOp _op, Set **domain, uint numDomain, Set *_range, OverFlowBehavior _overflowbehavior) : Function(OPERATORFUNC), op(_op), domains(domain, numDomain), range(_range), overflowbehavior(_overflowbehavior) {
 }
 
 FunctionOperator::FunctionOperator(ArithOp _op, Set **domain, uint numDomain, Set *_range, OverFlowBehavior _overflowbehavior) : Function(OPERATORFUNC), op(_op), domains(domain, numDomain), range(_range), overflowbehavior(_overflowbehavior) {
 }


@@ -27,3 +27,28 @@ bool FunctionOperator::isInRangeFunction(uint64_t val) {
        return range->exists(val);
 }
 
        return range->exists(val);
 }
 

+Function *FunctionOperator::clone(CSolver *solver, CloneMap *map) {
+       Function *f = (Function *) map->get(this);
+       if (f != NULL)
+               return f;
+
+       Set *array[domains.getSize()];
+       for (uint i = 0; i < domains.getSize(); i++) {
+               array[i] = domains.get(i)->clone(solver, map);
+       }
+       Set *rcopy = range->clone(solver, map);
+       f = solver->createFunctionOperator(op, array, domains.getSize(), rcopy, overflowbehavior);
+       map->put(this, f);
+       return f;
+}
+
+Function *FunctionTable::clone(CSolver *solver, CloneMap *map) {
+       Function *f = (Function *) map->get(this);
+       if (f != NULL)
+               return f;
+
+       Table *tcopy = table->clone(solver, map);
+       f = solver->completeTable(tcopy, undefBehavior);
+       map->put(this, f);
+       return f;
+}

diff --git a/src/AST/function.h b/src/AST/function.h
index e00afd30b44b692c8dbb387f660c5dac0e77fb7e..6b0cd134f4660663e4d59e24f959f9a42a6e0029 100644 (file)
--- a/src/AST/function.h
+++ b/src/AST/function.h
@@ -12,7 +12,7 @@ public:
        Function(FunctionType _type) : type(_type) {}
        FunctionType type;
        virtual ~Function() {}
        Function(FunctionType _type) : type(_type) {}
        FunctionType type;
        virtual ~Function() {}

-       virtual Function * clone(CSolver * solver, CloneMap *map);
+       virtual Function *clone(CSolver *solver, CloneMap *map);

        MEMALLOC;
 };
 
        MEMALLOC;
 };
 


@@ -25,7 +25,7 @@ public:
        FunctionOperator(ArithOp op, Set **domain, uint numDomain, Set *range, OverFlowBehavior overflowbehavior);
        uint64_t applyFunctionOperator(uint numVals, uint64_t *values);
        bool isInRangeFunction(uint64_t val);
        FunctionOperator(ArithOp op, Set **domain, uint numDomain, Set *range, OverFlowBehavior overflowbehavior);
        uint64_t applyFunctionOperator(uint numVals, uint64_t *values);
        bool isInRangeFunction(uint64_t val);

-       Function * clone(CSolver * solver, CloneMap *map);
+       Function *clone(CSolver *solver, CloneMap *map);

        MEMALLOC;
 };
 
        MEMALLOC;
 };
 


@@ -34,7 +34,7 @@ public:
        Table *table;
        UndefinedBehavior undefBehavior;
        FunctionTable (Table *table, UndefinedBehavior behavior);
        Table *table;
        UndefinedBehavior undefBehavior;
        FunctionTable (Table *table, UndefinedBehavior behavior);

-       Function * clone(CSolver * solver, CloneMap *map);
+       Function *clone(CSolver *solver, CloneMap *map);

        MEMALLOC;
 };
 
        MEMALLOC;
 };
 

diff --git a/src/AST/mutableset.cc b/src/AST/mutableset.cc
index d029f82bbdcdf428ebf5fe1c5f9c1eb342fc8d46..6b3f9537786ca4b52d6f590b0f9faeb17ed7ace2 100644 (file)
--- a/src/AST/mutableset.cc
+++ b/src/AST/mutableset.cc
@@ -8,14 +8,14 @@ void MutableSet::addElementMSet(uint64_t element) {
        members->push(element);
 }
 
        members->push(element);
 }
 

-Set * MutableSet::clone(CSolver * solver, CloneMap *map) {
-       Set * s=map->set.get(this);
+Set *MutableSet::clone(CSolver *solver, CloneMap *map) {
+       Set *s = (Set *) map->get(this);

        if (s != NULL)
                return s;
        if (s != NULL)
                return s;

-       s=solver->createMutableSet(type);
-       for(uint i=0; i<members->getSize();i++) {
+       s = solver->createMutableSet(type);
+       for (uint i = 0; i < members->getSize(); i++) {

                solver->addItem((MutableSet *) s, members->get(i));
        }
                solver->addItem((MutableSet *) s, members->get(i));
        }

-       map->set.put(this, s);
+       map->put(this, s);

        return s;
 }
        return s;
 }

diff --git a/src/AST/mutableset.h b/src/AST/mutableset.h
index 36ce011f26875f2e8b7b6a91b56aded7cc5ae02d..080db14c863f4bbddf882477a92ca44542da22dd 100644 (file)
--- a/src/AST/mutableset.h
+++ b/src/AST/mutableset.h
@@ -6,7 +6,7 @@ class MutableSet : public Set {
 public:
        MutableSet(VarType t);
        void addElementMSet(uint64_t element);
 public:
        MutableSet(VarType t);
        void addElementMSet(uint64_t element);

-       Set * clone(CSolver * solver, CloneMap *map);
+       Set *clone(CSolver *solver, CloneMap *map);

        MEMALLOC;
 };
 #endif
        MEMALLOC;
 };
 #endif

diff --git a/src/AST/order.cc b/src/AST/order.cc
index debd37cf69defe4107d34c8091a69c1f9d214a16..c9b0a7943def41aafbfd3c9bc19a464f9da9801b 100644 (file)
--- a/src/AST/order.cc
+++ b/src/AST/order.cc
@@ -3,6 +3,7 @@
 #include "set.h"
 #include "boolean.h"
 #include "ordergraph.h"
 #include "set.h"
 #include "boolean.h"
 #include "ordergraph.h"

+#include "csolver.h"

 
 Order::Order(OrderType _type, Set *_set) :
        type(_type),
 
 Order::Order(OrderType _type, Set *_set) :
        type(_type),


@@ -30,6 +31,15 @@ void Order::setOrderEncodingType(OrderEncodingType type) {
        order.type = type;
 }
 
        order.type = type;
 }
 

+Order *Order::clone(CSolver *solver, CloneMap *map) {
+       Order *o = (Order *)map->get(this);
+       if (o != NULL)
+               return o;
+       o = solver->createOrder(type, set->clone(solver, map));
+       map->put(this, o);
+       return o;
+}
+

 Order::~Order() {
        if (orderPairTable != NULL) {
                orderPairTable->resetanddelete();
 Order::~Order() {
        if (orderPairTable != NULL) {
                orderPairTable->resetanddelete();

diff --git a/src/AST/order.h b/src/AST/order.h
index b4abd07e20b88e2b222284ca8288ba51450d9b86..e5f59838741fbc1e824333a2f2bb3e9fe8fd2033 100644 (file)
--- a/src/AST/order.h
+++ b/src/AST/order.h
@@ -17,7 +17,7 @@ public:
        HashTableOrderPair *orderPairTable;
        HashSetOrderElement *elementTable;
        OrderGraph *graph;
        HashTableOrderPair *orderPairTable;
        HashSetOrderElement *elementTable;
        OrderGraph *graph;

-       Order * clone(CloneMap *map);
+       Order *clone(CSolver *solver, CloneMap *map);

        Vector<BooleanOrder *> constraints;
        OrderEncoding order;
        void initializeOrderHashTable();
        Vector<BooleanOrder *> constraints;
        OrderEncoding order;
        void initializeOrderHashTable();

diff --git a/src/AST/predicate.cc b/src/AST/predicate.cc
index 0e04668a6ac719d8c49582f3982fe062734fad35..99cd311757051f10da2a8dccb0a4b6062fda65f3 100644 (file)
--- a/src/AST/predicate.cc
+++ b/src/AST/predicate.cc
@@ -2,6 +2,7 @@
 #include "boolean.h"
 #include "set.h"
 #include "table.h"
 #include "boolean.h"
 #include "set.h"
 #include "table.h"

+#include "csolver.h"

 
 PredicateOperator::PredicateOperator(CompOp _op, Set **domain, uint numDomain) : Predicate(OPERATORPRED), op(_op), domains(domain, numDomain) {
 }
 
 PredicateOperator::PredicateOperator(CompOp _op, Set **domain, uint numDomain) : Predicate(OPERATORPRED), op(_op), domains(domain, numDomain) {
 }


@@ -25,3 +26,27 @@ bool PredicateOperator::evalPredicateOperator(uint64_t *inputs) {
        ASSERT(0);
        return false;
 }
        ASSERT(0);
        return false;
 }

+
+Predicate *PredicateOperator::clone(CSolver *solver, CloneMap *map) {
+       Predicate *p = (Predicate *) map->get(this);
+       if (p != NULL)
+               return p;
+
+       Set *array[domains.getSize()];
+       for (uint i = 0; i < domains.getSize(); i++)
+               array[i] = domains.get(i)->clone(solver, map);
+
+       p = solver->createPredicateOperator(op, array, domains.getSize());
+       map->put(this, p);
+       return p;
+}
+
+Predicate *PredicateTable::clone(CSolver *solver, CloneMap *map) {
+       Predicate *p = (Predicate *) map->get(this);
+       if (p != NULL)
+               return p;
+
+       p = solver->createPredicateTable(table->clone(solver, map), undefinedbehavior);
+       map->put(this, p);
+       return p;
+}

diff --git a/src/AST/predicate.h b/src/AST/predicate.h
index c86c6c2a0c26b26e32a2693dbf3cd27c5864ed47..047ef138145328891d5b44cb9762ff2324248454 100644 (file)
--- a/src/AST/predicate.h
+++ b/src/AST/predicate.h
@@ -11,7 +11,7 @@ class Predicate {
 public:
        Predicate(PredicateType _type) : type(_type) {}
        virtual ~Predicate() {}
 public:
        Predicate(PredicateType _type) : type(_type) {}
        virtual ~Predicate() {}

-       virtual Predicate * clone(CloneMap *map);
+       virtual Predicate *clone(CSolver *solver, CloneMap *map);

        PredicateType type;
        MEMALLOC;
 };
        PredicateType type;
        MEMALLOC;
 };


@@ -20,7 +20,7 @@ class PredicateOperator : public Predicate {
 public:
        PredicateOperator(CompOp op, Set **domain, uint numDomain);
        bool evalPredicateOperator(uint64_t *inputs);
 public:
        PredicateOperator(CompOp op, Set **domain, uint numDomain);
        bool evalPredicateOperator(uint64_t *inputs);

-       Predicate * clone(CloneMap *map);
+       Predicate *clone(CSolver *solver, CloneMap *map);

        CompOp op;
        Array<Set *> domains;
        MEMALLOC;
        CompOp op;
        Array<Set *> domains;
        MEMALLOC;


@@ -29,7 +29,7 @@ public:
 class PredicateTable : public Predicate {
 public:
        PredicateTable(Table *table, UndefinedBehavior undefBehavior);
 class PredicateTable : public Predicate {
 public:
        PredicateTable(Table *table, UndefinedBehavior undefBehavior);

-       Predicate * clone(CloneMap *map);
+       Predicate *clone(CSolver *solver, CloneMap *map);

        Table *table;
        UndefinedBehavior undefinedbehavior;
        MEMALLOC;
        Table *table;
        UndefinedBehavior undefinedbehavior;
        MEMALLOC;

diff --git a/src/AST/set.cc b/src/AST/set.cc
index d5b9c34f360924270cf383252d88b2d88620bf8c..b0e1d8aabb6aadde4dc755b0a67f7ed545a6035c 100644 (file)
--- a/src/AST/set.cc
+++ b/src/AST/set.cc
@@ -46,15 +46,15 @@ Set::~Set() {
                delete members;
 }
 
                delete members;
 }
 

-Set * Set::clone(CSolver * solver, CloneMap *map) {
-       Set * s=map->set.get(this);
+Set *Set::clone(CSolver *solver, CloneMap *map) {
+       Set *s = (Set *) map->get(this);

        if (s != NULL)
                return s;
        if (isRange) {
        if (s != NULL)
                return s;
        if (isRange) {

-               s=solver->createRangeSet(type, low, high);
+               s = solver->createRangeSet(type, low, high);

        } else {
        } else {

-               s=solver->createSet(type, members->expose(), members->getSize());
+               s = solver->createSet(type, members->expose(), members->getSize());

        }
        }

-       map->set.put(this, s);
+       map->put(this, s);

        return s;
 }
        return s;
 }

diff --git a/src/AST/set.h b/src/AST/set.h
index 3ff404a5be1c4b858c0da3ac66dd79501599ec1c..938027b65d06145f834a1ff65ee9a5c72d28072f 100644 (file)
--- a/src/AST/set.h
+++ b/src/AST/set.h
@@ -21,8 +21,8 @@ public:
        bool exists(uint64_t element);
        uint getSize();
        uint64_t getElement(uint index);
        bool exists(uint64_t element);
        uint getSize();
        uint64_t getElement(uint index);

-       virtual Set * clone(CSolver * solver, CloneMap *map);
-       
+       virtual Set *clone(CSolver *solver, CloneMap *map);
+

        VarType type;
        bool isRange;
        uint64_t low;//also used to count unique items
        VarType type;
        bool isRange;
        uint64_t low;//also used to count unique items

diff --git a/src/AST/table.cc b/src/AST/table.cc
index d54aefbac1b03c3babb4a3e0a530cdf24ce0088b..c4e95941a2fbd66e4a56ebe52a77b607ba34c1bd 100644 (file)
--- a/src/AST/table.cc
+++ b/src/AST/table.cc
@@ -4,6 +4,7 @@
 #include "tableentry.h"
 #include "set.h"
 #include "mutableset.h"
 #include "tableentry.h"
 #include "set.h"
 #include "mutableset.h"

+#include "csolver.h"

 
 Table::Table(Set **_domains, uint numDomain, Set *_range) :
        domains(_domains, numDomain),
 
 Table::Table(Set **_domains, uint numDomain, Set *_range) :
        domains(_domains, numDomain),


@@ -28,6 +29,26 @@ TableEntry *Table::getTableEntry(uint64_t *inputs, uint inputSize) {
        return result;
 }
 
        return result;
 }
 

+Table *Table::clone(CSolver *solver, CloneMap *map) {
+       Table *t = (Table *) map->get(this);
+       if (t != NULL)
+               return t;
+       Set *array[domains.getSize()];
+       for (uint i = 0; i < domains.getSize(); i++) {
+               array[i] = domains.get(i)->clone(solver, map);
+       }
+       Set *rcopy = range != NULL ? range->clone(solver, map) : NULL;
+       t = solver->createTable(array, domains.getSize(), rcopy);
+       HSIteratorTableEntry *entryit = entries->iterator();
+       while (entryit->hasNext()) {
+               TableEntry *te = entryit->next();
+               solver->addTableEntry(t, &te->inputs[0], te->inputSize, te->output);
+       }
+       delete entryit;
+       map->put(this, t);
+       return t;
+}
+

 Table::~Table() {
        HSIteratorTableEntry *iterator = entries->iterator();
        while (iterator->hasNext()) {
 Table::~Table() {
        HSIteratorTableEntry *iterator = entries->iterator();
        while (iterator->hasNext()) {

diff --git a/src/AST/table.h b/src/AST/table.h
index 28b13e4716f34b3e6c2b9e576a47181be20cdc1d..346da4791e4c9266c229a6646f64253aae43dd00 100644 (file)
--- a/src/AST/table.h
+++ b/src/AST/table.h
@@ -9,6 +9,7 @@ public:
        Table(Set **domains, uint numDomain, Set *range);
        void addNewTableEntry(uint64_t *inputs, uint inputSize, uint64_t result);
        TableEntry *getTableEntry(uint64_t *inputs, uint inputSize);
        Table(Set **domains, uint numDomain, Set *range);
        void addNewTableEntry(uint64_t *inputs, uint inputSize, uint64_t result);
        TableEntry *getTableEntry(uint64_t *inputs, uint inputSize);

+       Table *clone(CSolver *solver, CloneMap *map);

        ~Table();
        Array<Set *> domains;
        Set *range;
        ~Table();
        Array<Set *> domains;
        Set *range;

diff --git a/src/Collections/structs.h b/src/Collections/structs.h
index 73f5bf59b089b8e9c9b8f0902916daef5bec2598..43efbc542a7460a86a6a771d1f0eecb910056cc0 100644 (file)
--- a/src/Collections/structs.h
+++ b/src/Collections/structs.h
@@ -24,17 +24,7 @@ typedef HashSet<OrderEdge *, uintptr_t, 4, order_edge_hash_function, order_edge_
 typedef HashSet<OrderElement *, uintptr_t, 4, order_element_hash_function, order_element_equals> HashSetOrderElement;
 typedef HashTable<OrderNode *, HashSetOrderNode *, uintptr_t, 4> HashTableNodeToNodeSet;
 typedef HashTable<OrderPair *, OrderPair *, uintptr_t, 4, order_pair_hash_function, order_pair_equals> HashTableOrderPair;
 typedef HashSet<OrderElement *, uintptr_t, 4, order_element_hash_function, order_element_equals> HashSetOrderElement;
 typedef HashTable<OrderNode *, HashSetOrderNode *, uintptr_t, 4> HashTableNodeToNodeSet;
 typedef HashTable<OrderPair *, OrderPair *, uintptr_t, 4, order_pair_hash_function, order_pair_equals> HashTableOrderPair;

-typedef HashTable<Order *, Order *, uintptr_t, 4> OrderMap;
-typedef HashTable<Boolean *, Boolean *, uintptr_t, 4> BooleanMap;
-typedef HashTable<Element *, Element *, uintptr_t, 4> ElementMap;
-typedef HashTable<Set *, Set *, uintptr_t, 4> SetMap;
-
-typedef struct CloneMap {
-       OrderMap order;
-       BooleanMap boolean;
-       ElementMap element;
-       SetMap set;
-} CloneMap;
+typedef HashTable<void *, void *, uintptr_t, 4> CloneMap;

 
 typedef HSIterator<TableEntry *, uintptr_t, 4, table_entry_hash_function, table_entry_equals> HSIteratorTableEntry;
 typedef HSIterator<Boolean *, uintptr_t, 4> HSIteratorBoolean;
 
 typedef HSIterator<TableEntry *, uintptr_t, 4, table_entry_hash_function, table_entry_equals> HSIteratorTableEntry;
 typedef HSIterator<Boolean *, uintptr_t, 4> HSIteratorBoolean;

diff --git a/src/csolver.cc b/src/csolver.cc
index dec85e081ac1a8f7d04a14f1ff8765848ea58e8f..221f5628a275702badd9531e56146511f52f3c39 100644 (file)
--- a/src/csolver.cc
+++ b/src/csolver.cc
@@ -60,12 +60,12 @@ CSolver::~CSolver() {
        delete tuner;
 }
 
        delete tuner;
 }
 

-CSolver * CSolver::clone() {
-       CSolver * copy=new CSolver();
+CSolver *CSolver::clone() {
+       CSolver *copy = new CSolver();

        CloneMap map;
        CloneMap map;

-       HSIteratorBoolean * it=getConstraints();
-       while(it->hasNext()) {
-               Boolean *b=it->next();
+       HSIteratorBoolean *it = getConstraints();
+       while (it->hasNext()) {
+               Boolean *b = it->next();

                b->clone(copy, &map);
        }
        delete it;
                b->clone(copy, &map);
        }
        delete it;


@@ -108,7 +108,7 @@ Element *CSolver::getElementVar(Set *set) {
 
 Element *CSolver::getElementConst(VarType type, uint64_t value) {
        uint64_t array[] = {value};
 
 Element *CSolver::getElementConst(VarType type, uint64_t value) {
        uint64_t array[] = {value};

-       Set * set = new Set(type, array, 1);
+       Set *set = new Set(type, array, 1);

        allSets.push(set);
        Element *element = new ElementConst(value, type, set);
        allElements.push(element);
        allSets.push(set);
        Element *element = new ElementConst(value, type, set);
        allElements.push(element);

diff --git a/src/csolver.h b/src/csolver.h
index 115006f82faaad6403574304d6d4170be42ea42a..1f779935eb4f1ad24250ce4b911bd7fceabe3afd 100644 (file)
--- a/src/csolver.h
+++ b/src/csolver.h
@@ -116,7 +116,7 @@ public:
        void replaceBooleanWithTrue(Boolean *bexpr);
        void replaceBooleanWithFalse(Boolean *bexpr);
        void replaceBooleanWithBoolean(Boolean *oldb, Boolean *newb);
        void replaceBooleanWithTrue(Boolean *bexpr);
        void replaceBooleanWithFalse(Boolean *bexpr);
        void replaceBooleanWithBoolean(Boolean *oldb, Boolean *newb);

-       CSolver * clone();
+       CSolver *clone();

 
        MEMALLOC;
 
 
        MEMALLOC;