completed serializer/deserializer

diff --git a/src/AST/astops.h b/src/AST/astops.h
index c3244fb7b2c1fee50cd5ea00fdc8bb22753b3539..f26326f3f2c07b3e9668d08af91daf2460e9661d 100644 (file)
--- a/src/AST/astops.h
+++ b/src/AST/astops.h
@@ -7,7 +7,8 @@ typedef enum FunctionType FunctionType;
 enum PredicateType {TABLEPRED, OPERATORPRED};
 typedef enum PredicateType PredicateType;
 
-enum ASTNodeType {ORDERCONST, BOOLEANVAR, LOGICOP, PREDICATEOP, BOOLCONST, ELEMSET, ELEMFUNCRETURN, ELEMCONST, BOOLEANEDGE, ORDERTYPE, SETTYPE};
+enum ASTNodeType {ORDERCONST, BOOLEANVAR, LOGICOP, PREDICATEOP, BOOLCONST, ELEMSET, ELEMFUNCRETURN, ELEMCONST,
+       BOOLEANEDGE, ORDERTYPE, SETTYPE, PREDTABLETYPE, PREDOPERTYPE, TABLETYPE, FUNCTABLETYPE, FUNCOPTYPE};
 typedef enum ASTNodeType ASTNodeType;
 
 enum Polarity {P_UNDEFINED=0, P_TRUE=1, P_FALSE=2, P_BOTHTRUEFALSE=3};

diff --git a/src/AST/boolean.cc b/src/AST/boolean.cc
index 1795f17f3de32f07e48fd5d0a27808707499dd91..565e0efa9417d62c7fce30f57758a5847363d2db 100644 (file)
--- a/src/AST/boolean.cc
+++ b/src/AST/boolean.cc
@@ -123,9 +123,48 @@ void BooleanOrder::serialize(Serializer* serializer){
 }
 
 void BooleanPredicate::serialize(Serializer* serializer){
-       ASSERT(0);
+       if(serializer->isSerialized(this))
+               return;
+       serializer->addObject(this);
+       
+       predicate->serialize(serializer);
+       uint size = inputs.getSize();
+       for(uint i=0; i<size; i++){
+               Element* input = inputs.get(i);
+               input->serialize(serializer);
+       }
+       serializeBooleanEdge(serializer, undefStatus);
+       
+       serializer->mywrite(&type, sizeof(ASTNodeType));
+       BooleanPredicate* This = this;
+       serializer->mywrite(&This, sizeof(BooleanPredicate*));
+       serializer->mywrite(&predicate, sizeof(Predicate *));
+       serializer->mywrite(&size, sizeof(uint));
+       for(uint i=0; i<size; i++){
+               Element *input = inputs.get(i);
+               serializer->mywrite(&input, sizeof(Element *));
+       }
+       Boolean* undefStat = undefStatus.getRaw();
+       serializer->mywrite(&undefStat, sizeof(Boolean*));
 }
 
 void BooleanLogic::serialize(Serializer* serializer){
-       ASSERT(0);
-}
\ No newline at end of file
+       if(serializer->isSerialized(this))
+               return;
+       serializer->addObject(this);
+       uint size = inputs.getSize();
+       for(uint i=0; i<size; i++){
+               BooleanEdge input = inputs.get(i);
+               serializeBooleanEdge(serializer, input);
+       }
+       serializer->mywrite(&type, sizeof(ASTNodeType));
+       BooleanLogic* This = this;
+       serializer->mywrite(&This, sizeof(BooleanLogic*));
+       serializer->mywrite(&op, sizeof(LogicOp));
+       serializer->mywrite(&size, sizeof(uint));
+       for(uint i=0; i<size; i++){
+               Boolean* input = inputs.get(i).getRaw();
+               serializer->mywrite(&input, sizeof(Boolean*));
+       }
+}
+

diff --git a/src/AST/boolean.h b/src/AST/boolean.h
index 1c45f04b0cdfeb4c73733f67050084249c4c7f52..df1f4e8c152f1f86f88feddfb0e6d3b1eb8167e9 100644 (file)
--- a/src/AST/boolean.h
+++ b/src/AST/boolean.h
@@ -8,10 +8,9 @@
 #include "astnode.h"
 #include "functionencoding.h"
 #include "constraint.h"
-#include "serializable.h"
 #include "serializer.h"
 
-class Boolean : public ASTNode, public Serializable {
+class Boolean : public ASTNode {
 public:
        Boolean(ASTNodeType _type);
        virtual ~Boolean() {}

diff --git a/src/AST/element.cc b/src/AST/element.cc
index 05f6cefdc9a0ab621d092f6747687a7f2691c167..2617022b9abcdfdef75bbcf33fc20552932c1dd3 100644 (file)
--- a/src/AST/element.cc
+++ b/src/AST/element.cc
@@ -63,3 +63,58 @@ void ElementFunction::updateParents() {
 Set * ElementFunction::getRange() {
        return function->getRange();
 }
+
+void ElementSet::serialize(Serializer* serializer){
+       if(serializer->isSerialized(this))
+               return;
+       serializer->addObject(this);
+       
+       set->serialize(serializer);
+       
+       serializer->mywrite(&type, sizeof(ASTNodeType));
+       ElementSet *This = this;
+       serializer->mywrite(&This, sizeof(ElementSet*));
+       serializer->mywrite(&set, sizeof(Set*));
+}
+
+void ElementConst::serialize(Serializer* serializer){
+       if(serializer->isSerialized(this))
+               return;
+       serializer->addObject(this);
+       
+       set->serialize(serializer);
+       
+       serializer->mywrite(&type, sizeof(ASTNodeType));
+       ElementSet *This = this;
+       serializer->mywrite(&This, sizeof(ElementSet*));
+       VarType type = set->getType();
+       serializer->mywrite(&type, sizeof(VarType));
+       serializer->mywrite(&value, sizeof(uint64_t));
+}
+
+void ElementFunction::serialize(Serializer* serializer){
+       if(serializer->isSerialized(this))
+               return;
+       serializer->addObject(this);
+
+       function->serialize(serializer);
+       uint size = inputs.getSize();
+       for(uint i=0; i<size; i++){
+               Element *input = inputs.get(i);
+               input->serialize(serializer);
+       }
+       serializeBooleanEdge(serializer, overflowstatus);
+       
+       serializer->mywrite(&type, sizeof(ASTNodeType));
+       ElementFunction *This = this;
+       serializer->mywrite(&This, sizeof(ElementFunction *));
+       serializer->mywrite(&function, sizeof(Function *));
+       serializer->mywrite(&size, sizeof(uint));
+       for(uint i=0; i<size; i++){
+               Element* input = inputs.get(i);
+               serializer->mywrite(&input, sizeof(Element*));
+       }
+       Boolean* overflowstat = overflowstatus.getRaw();
+       serializer->mywrite(&overflowstat, sizeof(Boolean*));
+}
+

diff --git a/src/AST/element.h b/src/AST/element.h
index 076e83186209ea9f9e3dee0da2ed603c58cba6be..19e35b68f5d07f6c50e78488481f6421032b147f 100644 (file)
--- a/src/AST/element.h
+++ b/src/AST/element.h
@@ -15,6 +15,7 @@ public:
        Vector<ASTNode *> parents;
        ElementEncoding encoding;
        virtual Element *clone(CSolver *solver, CloneMap *map) {ASSERT(0); return NULL;};
+       virtual void serialize(Serializer* serializer) =0;
        virtual void updateParents() {}
        virtual Set * getRange() = 0;
        CMEMALLOC;
@@ -25,9 +26,10 @@ public:
        ElementSet(ASTNodeType type, Set *s);
        ElementSet(Set *s);
        virtual Element *clone(CSolver *solver, CloneMap *map);
+       virtual void serialize(Serializer* serializer);
        CMEMALLOC;
        Set *getRange() {return set;}
- private:
+ protected:
        Set *set;
 
 };
@@ -36,6 +38,7 @@ class ElementConst : public ElementSet {
 public:
        ElementConst(uint64_t value, Set *_set);
        uint64_t value;
+       virtual void serialize(Serializer* serializer);
        Element *clone(CSolver *solver, CloneMap *map);
        CMEMALLOC;
 };
@@ -48,6 +51,7 @@ public:
        BooleanEdge overflowstatus;
        FunctionEncoding functionencoding;
        Element *clone(CSolver *solver, CloneMap *map);
+       virtual void serialize(Serializer* serializer);
        Set * getRange();
        void updateParents();
        CMEMALLOC;

diff --git a/src/AST/function.cc b/src/AST/function.cc
index a882580e957e7e67a5f8d4f5f04d6960c83af1a9..96b0797452aacfb744d418ceaa3170f9604838f1 100644 (file)
--- a/src/AST/function.cc
+++ b/src/AST/function.cc
@@ -2,6 +2,7 @@
 #include "table.h"
 #include "set.h"
 #include "csolver.h"
+#include "serializer.h"
 
 FunctionOperator::FunctionOperator(ArithOp _op, Set **domain, uint numDomain, Set *_range, OverFlowBehavior _overflowbehavior) :
        Function(OPERATORFUNC),
@@ -64,3 +65,45 @@ Function *FunctionTable::clone(CSolver *solver, CloneMap *map) {
 Set * FunctionTable::getRange() {
        return table->getRange();
 }
+
+void FunctionTable::serialize(Serializer* serializer){
+       if(serializer->isSerialized(this))
+               return;
+       serializer->addObject(this);
+       
+       table->serialize(serializer);
+       
+       ASTNodeType type = FUNCTABLETYPE;       
+       serializer->mywrite(&type, sizeof(ASTNodeType));
+       FunctionTable* This = this;
+       serializer->mywrite(&This, sizeof(FunctionTable*));
+       serializer->mywrite(&table, sizeof(Table *));
+       serializer->mywrite(&undefBehavior, sizeof(UndefinedBehavior));
+       
+}
+
+void FunctionOperator::serialize(Serializer* serializer){
+       if(serializer->isSerialized(this))
+               return;
+       serializer->addObject(this);
+       
+       uint size = domains.getSize();
+       for(uint i=0; i<size; i++){
+               Set* domain = domains.get(i);
+               domain->serialize(serializer);
+       }
+       range->serialize(serializer);
+       
+       ASTNodeType nodeType = FUNCOPTYPE; 
+       serializer->mywrite(&nodeType, sizeof(ASTNodeType));
+       FunctionOperator* This = this;
+       serializer->mywrite(&This, sizeof(FunctionOperator*));
+       serializer->mywrite(&op, sizeof(ArithOp));
+       serializer->mywrite(&size, sizeof(uint));
+       for(uint i=0; i<size; i++){
+               Set *domain = domains.get(i);
+               serializer->mywrite(&domain, sizeof(Set *));
+       }
+       serializer->mywrite(&range, sizeof(Set *));
+       serializer->mywrite(&overflowbehavior, sizeof(OverFlowBehavior));
+}
\ No newline at end of file

diff --git a/src/AST/function.h b/src/AST/function.h
index f34c02eaa5b062fc02ad0928cee839dcc93c7d14..98ef53641b926a0b78132e5ee65ffcfd3cce95a6 100644 (file)
--- a/src/AST/function.h
+++ b/src/AST/function.h
@@ -12,6 +12,7 @@ public:
        FunctionType type;
        virtual ~Function() {}
        virtual Function *clone(CSolver *solver, CloneMap *map) {ASSERT(0); return NULL;}
+       virtual void serialize(Serializer* serialiezr) =0;
        virtual Set * getRange() = 0;
        CMEMALLOC;
 };
@@ -26,6 +27,7 @@ public:
        uint64_t applyFunctionOperator(uint numVals, uint64_t *values);
        bool isInRangeFunction(uint64_t val);
        Function *clone(CSolver *solver, CloneMap *map);
+       virtual void serialize(Serializer* serialiezr);
        Set * getRange() {return range;}
        CMEMALLOC;
 };
@@ -36,6 +38,7 @@ public:
        UndefinedBehavior undefBehavior;
        FunctionTable (Table *table, UndefinedBehavior behavior);
        Function *clone(CSolver *solver, CloneMap *map);
+       virtual void serialize(Serializer* serialiezr);
        Set * getRange();
        CMEMALLOC;
 };

diff --git a/src/AST/order.h b/src/AST/order.h
index 2301d47b41a6faac22d4f34a68aced8daf494a7f..b8ca724b3c33d2747ea9cb505d3ce34203e67256 100644 (file)
--- a/src/AST/order.h
+++ b/src/AST/order.h
@@ -7,9 +7,8 @@
 #include "orderencoding.h"
 #include "boolean.h"
 #include "orderpair.h"
-#include "serializable.h"
 
-class Order : public Serializable {
+class Order{
 public:
        Order(OrderType type, Set *set);
        virtual ~Order();

diff --git a/src/AST/predicate.cc b/src/AST/predicate.cc
index d359811663dedab5d83ecb35c7fb84db889548d7..7f63faa042fcd6da4924f1316586ecd49fd81d5c 100644 (file)
--- a/src/AST/predicate.cc
+++ b/src/AST/predicate.cc
@@ -50,3 +50,42 @@ Predicate *PredicateTable::clone(CSolver *solver, CloneMap *map) {
        map->put(this, p);
        return p;
 }
+
+void PredicateTable::serialize(Serializer* serializer){        
+       if(serializer->isSerialized(this))
+               return;
+       serializer->addObject(this);
+       
+       table->serialize(serializer);
+       
+       ASTNodeType type = PREDTABLETYPE;       
+       serializer->mywrite(&type, sizeof(ASTNodeType));
+       PredicateTable* This = this;
+       serializer->mywrite(&This, sizeof(PredicateTable*));
+       serializer->mywrite(&table, sizeof(Table *));
+       serializer->mywrite(&undefinedbehavior, sizeof(UndefinedBehavior));
+}
+
+void PredicateOperator::serialize(Serializer* serializer){     
+       if(serializer->isSerialized(this))
+               return;
+       serializer->addObject(this);
+       
+       uint size = domains.getSize();
+       for(uint i=0; i<size; i++){
+               Set* domain = domains.get(i);
+               domain->serialize(serializer);
+       }
+               
+       ASTNodeType type = PREDOPERTYPE;        
+       serializer->mywrite(&type, sizeof(ASTNodeType));
+       PredicateOperator* This = this;
+       serializer->mywrite(&This, sizeof(PredicateOperator*));
+       serializer->mywrite(&op, sizeof(CompOp));
+       serializer->mywrite(&size, sizeof(uint));
+       for(uint i=0; i<size; i++){
+               Set* domain = domains.get(i);
+               serializer->mywrite(&domain, sizeof(Set*));
+       }
+}
+

diff --git a/src/AST/predicate.h b/src/AST/predicate.h
index 183a96099c9d69157f8a63dc7d4c6bd323a91f36..2f292b21c37741b3d9e3815bcffed27091278f41 100644 (file)
--- a/src/AST/predicate.h
+++ b/src/AST/predicate.h
@@ -12,6 +12,7 @@ public:
        Predicate(PredicateType _type) : type(_type) {}
        virtual ~Predicate() {}
        virtual Predicate *clone(CSolver *solver, CloneMap *map) {ASSERT(0); return NULL;}
+       virtual void serialize(Serializer* serializer) = 0;
        PredicateType type;
        CMEMALLOC;
 };
@@ -21,6 +22,7 @@ public:
        PredicateOperator(CompOp op, Set **domain, uint numDomain);
        bool evalPredicateOperator(uint64_t *inputs);
        Predicate *clone(CSolver *solver, CloneMap *map);
+       virtual void serialize(Serializer* serializer);
        CompOp op;
        Array<Set *> domains;
        CMEMALLOC;
@@ -30,6 +32,7 @@ class PredicateTable : public Predicate {
 public:
        PredicateTable(Table *table, UndefinedBehavior undefBehavior);
        Predicate *clone(CSolver *solver, CloneMap *map);
+       virtual void serialize(Serializer* serializer);
        Table *table;
        UndefinedBehavior undefinedbehavior;
        CMEMALLOC;

diff --git a/src/AST/set.h b/src/AST/set.h
index 6a41815cfe401eabdfbb0c2814dd1b398c125e9f..6dbeac063f999b3e611cc3816f36b15eb87d5050 100644 (file)
--- a/src/AST/set.h
+++ b/src/AST/set.h
@@ -11,9 +11,8 @@
 #include "classlist.h"
 #include "structs.h"
 #include "mymemory.h"
-#include "serializable.h"
 
-class Set : public Serializable {
+class Set {
 public:
        Set(VarType t);
        Set(VarType t, uint64_t *elements, uint num);

diff --git a/src/AST/table.cc b/src/AST/table.cc
index e0f735f0d21c5cd9110a41e4a42fdfae94da592d..4ce62701d5446f1b676d47608e1036b8338918b4 100644 (file)
--- a/src/AST/table.cc
+++ b/src/AST/table.cc
@@ -5,6 +5,7 @@
 #include "set.h"
 #include "mutableset.h"
 #include "csolver.h"
+#include "serializer.h"
 
 Table::Table(Set **_domains, uint numDomain, Set *_range) :
        domains(_domains, numDomain),
@@ -58,3 +59,40 @@ Table::~Table() {
        delete entries;
 }
 
+
+
+void Table::serialize(Serializer* serializer){
+       if(serializer->isSerialized(this))
+               return;
+       serializer->addObject(this);
+       
+       uint size = domains.getSize();
+       for(uint i=0; i<size; i++){
+               Set* domain = domains.get(i);
+               domain->serialize(serializer);
+       }
+       range->serialize(serializer);
+       
+       ASTNodeType type = TABLETYPE;   
+       serializer->mywrite(&type, sizeof(ASTNodeType));
+       Table* This = this;
+       serializer->mywrite(&This, sizeof(Table*));
+       serializer->mywrite(&size, sizeof(uint));
+       for(uint i=0; i<size; i++){
+               Set* domain = domains.get(i);
+               serializer->mywrite(&domain, sizeof(Set*));
+       }
+       serializer->mywrite(&range, sizeof(Set*));
+       size = entries->getSize();
+       serializer->mywrite(&size, sizeof(uint));
+       SetIteratorTableEntry* iterator = getEntries();
+       while(iterator->hasNext()){
+               TableEntry* entry = iterator->next();
+               serializer->mywrite(&entry->output, sizeof(uint64_t));
+               serializer->mywrite(&entry->inputSize, sizeof(uint));
+               serializer->mywrite(entry->inputs, sizeof(uint64_t) * entry->inputSize);
+               ASSERT(0);
+       }
+}
+
+

diff --git a/src/AST/table.h b/src/AST/table.h
index 6c7926e80e04f42c1437b9d10df5132198efb3a8..db8d188f9669476b1cce78698f7e80076c497ca8 100644 (file)
--- a/src/AST/table.h
+++ b/src/AST/table.h
@@ -10,6 +10,7 @@ public:
        void addNewTableEntry(uint64_t *inputs, uint inputSize, uint64_t result);
        TableEntry *getTableEntry(uint64_t *inputs, uint inputSize);
        Table *clone(CSolver *solver, CloneMap *map);
+       void serialize(Serializer *serializer);
        ~Table();
        Set * getRange() {return range;}
        

diff --git a/src/Serialize/deserializer.cc b/src/Serialize/deserializer.cc
index 7616cd7e31a9186b6424eb06bb25704a61fe9c0c..2b431debcafeeca4e1fb15f989f2b6c339532cc1 100644 (file)
--- a/src/Serialize/deserializer.cc
+++ b/src/Serialize/deserializer.cc
@@ -10,6 +10,9 @@
 #include "csolver.h"
 #include "unistd.h"
 #include "fcntl.h"
+#include "predicate.h"
+#include "table.h"
+#include "element.h"
 
 Deserializer::Deserializer(const char* file):
        solver(new CSolver())
@@ -48,6 +51,36 @@ CSolver * Deserializer::deserialize(){
                        case SETTYPE:
                                deserializeSet();
                                break;
+                       case LOGICOP:
+                               deserializeBooleanLogic();
+                               break;
+                       case PREDICATEOP:
+                               deserializeBooleanPredicate();
+                               break;
+                       case PREDTABLETYPE:
+                               deserializePredicateTable();
+                               break;
+                       case PREDOPERTYPE:
+                               deserializePredicateOperator();
+                               break;
+                       case TABLETYPE:
+                               deserializeTable();
+                               break;
+                       case ELEMSET:
+                               deserializeElementSet();
+                               break;
+                       case ELEMCONST:
+                               deserializeElementConst();
+                               break;
+                       case ELEMFUNCRETURN:
+                               deserializeElementFunction();
+                               break;
+                       case FUNCOPTYPE:
+                               deserializeFunctionOperator();
+                               break;
+                       case FUNCTABLETYPE:
+                               deserializeFunctionTable();
+                               break;
                        default:
                                ASSERT(0);
                }
@@ -123,3 +156,202 @@ void Deserializer::deserializeSet(){
                solver->createSet(type, members.expose(), size);
        map.put(s_ptr, set);
 }
+
+void Deserializer::deserializeBooleanLogic(){
+       BooleanLogic *bl_ptr;
+       myread(&bl_ptr, sizeof(BooleanLogic *));
+       LogicOp op;
+       myread(&op, sizeof(LogicOp));
+       uint size;
+       myread(&size, sizeof(uint));
+       Vector<BooleanEdge> members;
+       for(uint i=0; i<size; i++){
+               
+       }
+       map.put(bl_ptr, solver->applyLogicalOperation(op, members.expose(), size).getBoolean());
+}
+
+void Deserializer::deserializeBooleanPredicate(){
+       BooleanPredicate *bp_ptr;
+       myread(&bp_ptr, sizeof(BooleanPredicate *));
+       Predicate* predicate;
+       myread(&predicate, sizeof(Predicate*));
+       ASSERT(map.contains(predicate));
+       predicate = (Predicate*) map.get(predicate);
+       uint size;
+       myread(&size, sizeof(uint));
+       Vector<Element*> members;
+       for(uint i=0; i<size; i++){
+               Element* input;
+               myread(&input, sizeof(Element *));
+               ASSERT(map.contains(input));
+               input = (Element*) map.get(input);
+               members.push(input);
+       }
+       
+       Boolean* stat_ptr;
+       myread(&stat_ptr, sizeof(Boolean *));
+       BooleanEdge tmp(stat_ptr);
+       bool isNegated = tmp.isNegated();
+       ASSERT(map.contains(tmp.getBoolean()));
+       stat_ptr = (Boolean*) map.get(tmp.getBoolean());
+       BooleanEdge res(stat_ptr);
+       BooleanEdge undefStatus = isNegated?res.negate():res;
+       
+       map.put(bp_ptr, solver->applyPredicateTable(predicate, members.expose(), size, undefStatus).getBoolean());
+}
+
+void Deserializer::deserializePredicateTable(){
+       PredicateTable *pt_ptr;
+       myread(&pt_ptr, sizeof(PredicateTable *));
+       Table* table;
+       myread(&table, sizeof(Table*));
+       ASSERT(map.contains(table));
+       table = (Table*) map.get(table);
+       UndefinedBehavior undefinedbehavior;
+       myread(&undefinedbehavior, sizeof(UndefinedBehavior));
+       
+       map.put(pt_ptr, solver->createPredicateTable(table, undefinedbehavior));
+}
+
+void Deserializer::deserializePredicateOperator(){
+       PredicateOperator *po_ptr;
+       myread(&po_ptr, sizeof(PredicateOperator *));
+       CompOp op;
+       myread(&op, sizeof(CompOp));
+       uint size;
+       myread(&size, sizeof(uint));
+       Vector<Set*> domains;
+       for(uint i=0; i<size; i++){
+               Set* domain;
+               myread(&domain, sizeof(Set*));
+               ASSERT(map.contains(domain));
+               domain = (Set*) map.get(domain);
+               domains.push(domain);
+       }
+
+       map.put(po_ptr, solver->createPredicateOperator(op, domains.expose(), size));
+}
+
+void Deserializer::deserializeTable(){
+       Table *t_ptr;
+       myread(&t_ptr, sizeof(Table *));
+       uint size;
+       myread(&size, sizeof(uint));
+       Vector<Set*> domains;
+       for(uint i=0; i<size; i++){
+               Set* domain;
+               myread(&domain, sizeof(Set*));
+               ASSERT(map.contains(domain));
+               domain = (Set*) map.get(domain);
+               domains.push(domain);
+       }
+       Set* range;
+       myread(&range, sizeof(Set*));
+       ASSERT(map.contains(range));
+       range = (Set*) map.get(range);
+       Table* table = solver->createTable(domains.expose(), size, range);
+       myread(&size, sizeof(uint));
+       for(uint i=0; i<size; i++){
+               uint64_t output;
+               myread(&output, sizeof(uint64_t));
+               uint inputSize;
+               myread(&inputSize, sizeof(uint));
+               Vector<uint64_t> inputs;
+               inputs.setSize(inputSize);
+               myread(inputs.expose(), sizeof(uint64_t)*inputSize);
+               ASSERT(0);
+               table->addNewTableEntry(inputs.expose(), inputSize, output);
+       }
+       
+       map.put(t_ptr, table);
+}
+
+
+void Deserializer::deserializeElementSet(){
+       ElementSet* es_ptr;
+       myread(&es_ptr, sizeof(ElementSet*));
+       Set * set;
+       myread(&set, sizeof(Set *));
+       ASSERT(map.contains(set));
+       set  = (Set*) map.get(set);
+       map.put(es_ptr, solver->getElementVar(set));
+}
+
+void Deserializer::deserializeElementConst(){
+       ElementSet* es_ptr;
+       myread(&es_ptr, sizeof(ElementSet*));
+       VarType type;
+       myread(&type, sizeof(VarType));
+       uint64_t value;
+       myread(&value, sizeof(uint64_t));
+       map.put(es_ptr, solver->getElementConst(type, value));
+}
+
+void Deserializer::deserializeElementFunction(){
+       ElementFunction *ef_ptr;
+       myread(&ef_ptr, sizeof(ElementFunction *));
+       Function *function;
+       myread(&function, sizeof(Function*));
+       ASSERT(map.contains(function));
+       function = (Function*) map.get(function);
+       uint size;
+       myread(&size, sizeof(uint));
+       Vector<Element*> members;
+       for(uint i=0; i<size; i++){
+               Element* input;
+               myread(&input, sizeof(Element *));
+               ASSERT(map.contains(input));
+               input = (Element*) map.get(input);
+               members.push(input);
+       }
+       
+       Boolean* overflowstatus;
+       myread(&overflowstatus, sizeof(Boolean *));
+       BooleanEdge tmp(overflowstatus);
+       bool isNegated = tmp.isNegated();
+       ASSERT(map.contains(tmp.getBoolean()));
+       overflowstatus = (Boolean*) map.get(tmp.getBoolean());
+       BooleanEdge res(overflowstatus);
+       BooleanEdge undefStatus = isNegated?res.negate():res;
+       
+       map.put(ef_ptr, solver->applyFunction(function, members.expose(), size, undefStatus));
+}
+
+
+void Deserializer::deserializeFunctionOperator(){
+       FunctionOperator *fo_ptr;
+       myread(&fo_ptr, sizeof(FunctionOperator *));
+       ArithOp op;
+       myread(&op, sizeof(ArithOp));
+       uint size;
+       myread(&size, sizeof(uint));
+       Vector<Set*> domains;
+       for(uint i=0; i<size; i++){
+               Set* domain;
+               myread(&domain, sizeof(Set*));
+               ASSERT(map.contains(domain));
+               domain = (Set*) map.get(domain);
+               domains.push(domain);
+       }
+       Set* range;
+       myread(&range, sizeof(Set*));
+       ASSERT(map.contains(range));
+       range = (Set*) map.get(range);
+       OverFlowBehavior overflowbehavior;
+       myread(&overflowbehavior, sizeof(OverFlowBehavior));
+       map.put(fo_ptr, solver->createFunctionOperator(op, domains.expose(), size, range, overflowbehavior));
+}
+
+void Deserializer::deserializeFunctionTable(){
+       FunctionTable *ft_ptr;
+       myread(&ft_ptr, sizeof(FunctionTable *));
+       Table* table;
+       myread(&table, sizeof(Table*));
+       ASSERT(map.contains(table));
+       table = (Table*) map.get(table);
+       UndefinedBehavior undefinedbehavior;
+       myread(&undefinedbehavior, sizeof(UndefinedBehavior));
+       
+       map.put(ft_ptr, solver->completeTable(table, undefinedbehavior));
+}
\ No newline at end of file

diff --git a/src/Serialize/deserializer.h b/src/Serialize/deserializer.h
index 7c7d39a9b598353b1d57b135038082b7692c7b1a..057346d4cbca9652d34118f708e52c24d227cf79 100644 (file)
--- a/src/Serialize/deserializer.h
+++ b/src/Serialize/deserializer.h
@@ -29,6 +29,16 @@ private:
        void deserializeBooleanOrder();
        void deserializeOrder();
        void deserializeSet();
+       void deserializeBooleanLogic();
+       void deserializeBooleanPredicate();
+       void deserializePredicateTable();
+       void deserializePredicateOperator();
+       void deserializeTable();
+       void deserializeElementSet();
+       void deserializeElementConst();
+       void deserializeElementFunction();
+       void deserializeFunctionOperator();
+       void deserializeFunctionTable();
        CSolver *solver;
        int filedesc;
        CloneMap map;

diff --git a/src/Serialize/serializable.h b/src/Serialize/serializable.h
deleted file mode 100644 (file)
index a5e769d..0000000
--- a/src/Serialize/serializable.h
+++ /dev/null
@@ -1,17 +0,0 @@
-
-/* 
- * File:   serializable.h
- * Author: hamed
- *
- * Created on September 7, 2017, 3:39 PM
- */
-
-#ifndef SERIALIZABLE_H
-#define SERIALIZABLE_H
-
-class Serializable{
-       virtual void serialize(Serializer* ) = 0;
-};
-
-#endif /* SERIALIZABLE_H */
-

diff --git a/src/Serialize/serializer.cc b/src/Serialize/serializer.cc
index 783cf88a8f91aaa46b2ea837a567c984e197e77d..524f9eedd9ee01e19c86524b0d68e13d7f584124 100644 (file)
--- a/src/Serialize/serializer.cc
+++ b/src/Serialize/serializer.cc
@@ -30,7 +30,7 @@ void Serializer::mywrite(const void *__buf, size_t __n){
 }
 
 
-void serializeBooleanEdge(Serializer* serializer, BooleanEdge& be){
+void serializeBooleanEdge(Serializer* serializer, BooleanEdge be){
        be.getBoolean()->serialize(serializer);
        ASTNodeType type = BOOLEANEDGE;
        serializer->mywrite(&type, sizeof(ASTNodeType));

diff --git a/src/Serialize/serializer.h b/src/Serialize/serializer.h
index eb114dc85088d87dbf7dfbeb8f6f934b62161ae7..12bff1306ecd9b47c7e77753bd23fbbab3a2e338 100644 (file)
--- a/src/Serialize/serializer.h
+++ b/src/Serialize/serializer.h
@@ -31,7 +31,7 @@ inline bool Serializer::isSerialized(void* obj){
 
 
 
-void serializeBooleanEdge(Serializer* serializer, BooleanEdge& be);
+void serializeBooleanEdge(Serializer* serializer, BooleanEdge be);
 
 #endif /* SERIALIZER_H */
 

diff --git a/src/Test/buildconstraintstest.cc b/src/Test/buildconstraintstest.cc
index 46bc2a302d5885e4428374c3f8f476aa0fe4ea88..e01fb8f8e315aeb7032f7a6345948b8a2fed2ce9 100644 (file)
--- a/src/Test/buildconstraintstest.cc
+++ b/src/Test/buildconstraintstest.cc
@@ -50,7 +50,7 @@ int main(int numargs, char **argv) {
        Element *inputs2 [] = {e4, e3};
        BooleanEdge pred = solver->applyPredicate(equal2, inputs2, 2);
        solver->addConstraint(pred);
-//     solver->serialize();
+       solver->serialize();
        if (solver->solve() == 1)
                printf("e1=%" PRIu64 " e2=%" PRIu64 " \n", solver->getElementValue(e1), solver->getElementValue(e2));
        else

diff --git a/src/Test/elemequalsattest.cc b/src/Test/elemequalsattest.cc
index aeab4a51f434a322c3041d84835ba0a277a6928b..e041cb0a1dd2155a689cdcb69d070e800657f518 100644 (file)
--- a/src/Test/elemequalsattest.cc
+++ b/src/Test/elemequalsattest.cc
@@ -24,6 +24,7 @@ int main(int numargs, char **argv) {
        Element *inputs[] = {e1, e2};
        BooleanEdge b = solver->applyPredicate(equals, inputs, 2);
        solver->addConstraint(b);
+       solver->serialize();
 
        if (solver->solve() == 1)
                printf("e1=%" PRIu64 " e2=%" PRIu64 "\n", solver->getElementValue(e1), solver->getElementValue(e2));

diff --git a/src/Test/elemequalunsattest.cc b/src/Test/elemequalunsattest.cc
index 6a7a067be2279cb9ab252829557b38b036134d7d..123d6cd5916a7b5f207b9ddb9064d7d17daed0ed 100644 (file)
--- a/src/Test/elemequalunsattest.cc
+++ b/src/Test/elemequalunsattest.cc
@@ -19,7 +19,7 @@ int main(int numargs, char **argv) {
        Element *inputs[] = {e1, e2};
        BooleanEdge b = solver->applyPredicate(equals, inputs, 2);
        solver->addConstraint(b);
-
+       solver->serialize();
        if (solver->solve() == 1)
                printf("e1=%" PRIu64 " e2=%" PRIu64 "\n", solver->getElementValue(e1), solver->getElementValue(e2));
        else

diff --git a/src/Test/funcencodingtest.cc b/src/Test/funcencodingtest.cc
index e3baeb95799c8f81d53e4152834fa1f93bad9bf9..72a0a8389a2540069d6e00ac8a705c67f8379cb0 100644 (file)
--- a/src/Test/funcencodingtest.cc
+++ b/src/Test/funcencodingtest.cc
@@ -72,6 +72,7 @@ int main(int numargs, char **argv) {
        Element *inputs2 [] = {e7, e6};
        BooleanEdge pred = solver->applyPredicate(gt, inputs2, 2);
        solver->addConstraint(pred);
+       solver->serialize();
 
        if (solver->solve() == 1)
                printf("e1=%" PRIu64 " e2=%" PRIu64 " e7=%" PRIu64 "\n",

diff --git a/src/Test/logicopstest.cc b/src/Test/logicopstest.cc
index 9b2001596d03783e66321176f74993d6f2720805..7b30f80dc3af3168acd2fe9a807dfa83589a2a33 100644 (file)
--- a/src/Test/logicopstest.cc
+++ b/src/Test/logicopstest.cc
@@ -24,6 +24,7 @@ int main(int numargs, char **argv) {
        solver->addConstraint(solver->applyLogicalOperation(SATC_OR, barray4, 2));
        BooleanEdge barray5[] = {b1, b4};
        solver->addConstraint(solver->applyLogicalOperation(SATC_XOR, barray5, 2));
+       solver->serialize();
        if (solver->solve() == 1)
                printf("b1=%d b2=%d b3=%d b4=%d\n",
                                         solver->getBooleanValue(b1), solver->getBooleanValue(b2),

diff --git a/src/Test/ltelemconsttest.cc b/src/Test/ltelemconsttest.cc
index d666833912576a3f27f3bafcd2153e999e1e9c62..11a315c8ddaeda1f2ca1f9e53f4b2e3e92702397 100644 (file)
--- a/src/Test/ltelemconsttest.cc
+++ b/src/Test/ltelemconsttest.cc
@@ -18,6 +18,7 @@ int main(int numargs, char **argv) {
        Element *inputs2[] = {e1, e2};
        BooleanEdge b = solver->applyPredicate(lt, inputs2, 2);
        solver->addConstraint(b);
+       solver->serialize();
        if (solver->solve() == 1)
                printf("e1=%" PRIu64 " e2=%" PRIu64 "\n", solver->getElementValue(e1), solver->getElementValue(e2));
        else

diff --git a/src/Test/ordergraphtest.cc b/src/Test/ordergraphtest.cc
index 80a57ff66d44e0fe52c8eb1306eb499da501aacb..fea3a9ff72838807f8c81de2228e67a1e0793411 100644 (file)
--- a/src/Test/ordergraphtest.cc
+++ b/src/Test/ordergraphtest.cc
@@ -45,7 +45,7 @@ int main(int numargs, char **argv) {
 
        BooleanEdge array12[] = {o58, o81};
        solver->addConstraint(solver->applyLogicalOperation(SATC_AND, array12, 2) );
-
+       solver->serialize();
        /*      if (solver->solve() == 1)
           printf("SAT\n");
           else

diff --git a/src/Test/tablefuncencodetest.cc b/src/Test/tablefuncencodetest.cc
index 11017c60b6085bbeec097f01c148633ca67d6164..680d1c64fc47bf47db01593827a05d168d42196f 100644 (file)
--- a/src/Test/tablefuncencodetest.cc
+++ b/src/Test/tablefuncencodetest.cc
@@ -49,6 +49,7 @@ int main(int numargs, char **argv) {
        Element *inputs2 [] = {e4, e3};
        BooleanEdge pred = solver->applyPredicate(lte, inputs2, 2);
        solver->addConstraint(pred);
+       solver->serialize();
 
        if (solver->solve() == 1)
                printf("e1=%" PRIu64 " e2=%" PRIu64 " e3=%" PRIu64 " e4=%" PRIu64 " overFlow:%d\n",

diff --git a/src/Test/tablepredicencodetest.cc b/src/Test/tablepredicencodetest.cc
index 47113fd1fbc0155f88540e8ed55271c2c68e5f43..4007e2539016798e72843e68ad89b0f6c57d14a1 100644 (file)
--- a/src/Test/tablepredicencodetest.cc
+++ b/src/Test/tablepredicencodetest.cc
@@ -57,6 +57,7 @@ int main(int numargs, char **argv) {
        Element *tmparray2[] = {e1, e2};
        BooleanEdge pred2 = solver->applyPredicate(eq, tmparray2, 2);
        solver->addConstraint(pred2);
+       solver->serialize();
 
        if (solver->solve() == 1)
                printf("e1=%" PRIu64 " e2=%" PRIu64 " e3=%" PRIu64 " undefFlag:%d\n",