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);
}
-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());
}
-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);
}
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;
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;
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;
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;
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;
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) {
return NULL;
}
-Element * ElementConst::clone(CSolver *solver, CloneMap * map) {
+Element *ElementConst::clone(CSolver *solver, CloneMap *map) {
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));
- map->element.put(e, e);
+ map->put(e, 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;
}
virtual ~Element() {}
Vector<ASTNode *> parents;
ElementEncoding encoding;
- virtual Element * clone(CSolver * solver, CloneMap * map);
+ virtual Element *clone(CSolver *solver, CloneMap *map);
MEMALLOC;
};
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;
};
public:
ElementSet(Set *s);
Set *set;
- Element * clone(CSolver * solver, CloneMap * map);
+ Element *clone(CSolver *solver, CloneMap *map);
MEMALLOC;
};
Array<Element *> inputs;
Boolean *overflowstatus;
FunctionEncoding functionencoding;
- Element * clone(CSolver * solver, CloneMap * map);
+ Element *clone(CSolver *solver, CloneMap *map);
MEMALLOC;
};
#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) {
}
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;
+}
Function(FunctionType _type) : type(_type) {}
FunctionType type;
virtual ~Function() {}
- virtual Function * clone(CSolver * solver, CloneMap *map);
+ virtual Function *clone(CSolver *solver, CloneMap *map);
MEMALLOC;
};
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;
};
Table *table;
UndefinedBehavior undefBehavior;
FunctionTable (Table *table, UndefinedBehavior behavior);
- Function * clone(CSolver * solver, CloneMap *map);
+ Function *clone(CSolver *solver, CloneMap *map);
MEMALLOC;
};
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;
- 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));
}
- map->set.put(this, s);
+ map->put(this, s);
return s;
}
public:
MutableSet(VarType t);
void addElementMSet(uint64_t element);
- Set * clone(CSolver * solver, CloneMap *map);
+ Set *clone(CSolver *solver, CloneMap *map);
MEMALLOC;
};
#endif
#include "set.h"
#include "boolean.h"
#include "ordergraph.h"
+#include "csolver.h"
Order::Order(OrderType _type, Set *_set) :
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();
HashTableOrderPair *orderPairTable;
HashSetOrderElement *elementTable;
OrderGraph *graph;
- Order * clone(CloneMap *map);
+ Order *clone(CSolver *solver, CloneMap *map);
Vector<BooleanOrder *> constraints;
OrderEncoding order;
void initializeOrderHashTable();
#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) {
}
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;
+}
public:
Predicate(PredicateType _type) : type(_type) {}
virtual ~Predicate() {}
- virtual Predicate * clone(CloneMap *map);
+ virtual Predicate *clone(CSolver *solver, CloneMap *map);
PredicateType type;
MEMALLOC;
};
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;
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;
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) {
- s=solver->createRangeSet(type, low, high);
+ s = solver->createRangeSet(type, low, high);
} 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;
}
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
#include "tableentry.h"
#include "set.h"
#include "mutableset.h"
+#include "csolver.h"
Table::Table(Set **_domains, uint numDomain, Set *_range) :
domains(_domains, numDomain),
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(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;
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;
delete tuner;
}
-CSolver * CSolver::clone() {
- CSolver * copy=new CSolver();
+CSolver *CSolver::clone() {
+ CSolver *copy = new CSolver();
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;
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);
void replaceBooleanWithTrue(Boolean *bexpr);
void replaceBooleanWithFalse(Boolean *bexpr);
void replaceBooleanWithBoolean(Boolean *oldb, Boolean *newb);
- CSolver * clone();
+ CSolver *clone();
MEMALLOC;