Fixing bugs ...

diff --git a/src/AST/boolean.cc b/src/AST/boolean.cc
index 565e0efa9417d62c7fce30f57758a5847363d2db..8a6f0d31b7f10d79c4dd44b358d6ed02a3a18a3e 100644 (file)
--- a/src/AST/boolean.cc
+++ b/src/AST/boolean.cc
@@ -114,6 +114,7 @@ void BooleanOrder::serialize(Serializer* serializer){
                return;
        serializer->addObject(this);
        order->serialize(serializer);
+       
        serializer->mywrite(&type, sizeof(ASTNodeType));
        BooleanOrder* This = this;
        serializer->mywrite(&This, sizeof(BooleanOrder*));
@@ -144,7 +145,7 @@ void BooleanPredicate::serialize(Serializer* serializer){
                Element *input = inputs.get(i);
                serializer->mywrite(&input, sizeof(Element *));
        }
-       Boolean* undefStat = undefStatus.getRaw();
+       Boolean* undefStat = undefStatus!= BooleanEdge(NULL)?undefStatus.getRaw() : NULL;
        serializer->mywrite(&undefStat, sizeof(Boolean*));
 }
 

diff --git a/src/AST/table.cc b/src/AST/table.cc
index 4ce62701d5446f1b676d47608e1036b8338918b4..828cd79af944634c006f7b6efc81b3e9034d3bbf 100644 (file)
--- a/src/AST/table.cc
+++ b/src/AST/table.cc
@@ -71,7 +71,8 @@ void Table::serialize(Serializer* serializer){
                Set* domain = domains.get(i);
                domain->serialize(serializer);
        }
-       range->serialize(serializer);
+       if(range!= NULL)
+               range->serialize(serializer);
        
        ASTNodeType type = TABLETYPE;   
        serializer->mywrite(&type, sizeof(ASTNodeType));
@@ -91,7 +92,6 @@ void Table::serialize(Serializer* serializer){
                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/Serialize/deserializer.cc b/src/Serialize/deserializer.cc
index 2b431debcafeeca4e1fb15f989f2b6c339532cc1..0e6839dae9136f68621a02fa838bf4dd3d7c8604 100644 (file)
--- a/src/Serialize/deserializer.cc
+++ b/src/Serialize/deserializer.cc
@@ -110,14 +110,14 @@ void Deserializer::deserializeBooleanVar(){
 void Deserializer::deserializeBooleanOrder(){
        BooleanOrder* bo_ptr;
        myread(&bo_ptr, sizeof(BooleanOrder*));
-       Order* optr;
-       myread(&optr, sizeof(Order*));
+       Order* order;
+       myread(&order, sizeof(Order*));
+       ASSERT(map.contains(order));
+       order  = (Order*) map.get(order);
        uint64_t first;
        myread(&first, sizeof(uint64_t));
        uint64_t second;
        myread(&second, sizeof(uint64_t));
-       ASSERT(map.contains(optr));
-       Order* order  = (Order*) map.get(optr);
        map.put(bo_ptr, solver->orderConstraint(order, first, second).getBoolean());
 }
 
@@ -191,13 +191,17 @@ void Deserializer::deserializeBooleanPredicate(){
        
        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;
-       
+       BooleanEdge undefStatus;
+       if(stat_ptr != NULL){
+               BooleanEdge tmp(stat_ptr);
+               bool isNegated = tmp.isNegated();
+               ASSERT(map.contains(tmp.getBoolean()));
+               stat_ptr = (Boolean*) map.get(tmp.getBoolean());
+               BooleanEdge res(stat_ptr);
+               undefStatus = isNegated?res.negate():res;
+       } else {
+               undefStatus = NULL;
+       }
        map.put(bp_ptr, solver->applyPredicateTable(predicate, members.expose(), size, undefStatus).getBoolean());
 }
 
@@ -248,8 +252,10 @@ void Deserializer::deserializeTable(){
        }
        Set* range;
        myread(&range, sizeof(Set*));
-       ASSERT(map.contains(range));
-       range = (Set*) map.get(range);
+       if(range != NULL){
+               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++){
@@ -260,7 +266,6 @@ void Deserializer::deserializeTable(){
                Vector<uint64_t> inputs;
                inputs.setSize(inputSize);
                myread(inputs.expose(), sizeof(uint64_t)*inputSize);
-               ASSERT(0);
                table->addNewTableEntry(inputs.expose(), inputSize, output);
        }
        

diff --git a/src/Serialize/serializer.cc b/src/Serialize/serializer.cc
index 524f9eedd9ee01e19c86524b0d68e13d7f584124..96e81aa8e82a5e167e5fb2bb44e314fc81ad0a77 100644 (file)
--- a/src/Serialize/serializer.cc
+++ b/src/Serialize/serializer.cc
@@ -31,6 +31,8 @@ void Serializer::mywrite(const void *__buf, size_t __n){
 
 
 void serializeBooleanEdge(Serializer* serializer, BooleanEdge be){
+       if(be == BooleanEdge(NULL))
+               return;
        be.getBoolean()->serialize(serializer);
        ASTNodeType type = BOOLEANEDGE;
        serializer->mywrite(&type, sizeof(ASTNodeType));

diff --git a/src/csolver.cc b/src/csolver.cc
index ce749b13c27b20d1645383f86e27f5101e3a6234..0eebb1759e8fde28ae529b403e853ad8e0f3202d 100644 (file)
--- a/src/csolver.cc
+++ b/src/csolver.cc
@@ -228,7 +228,7 @@ BooleanEdge CSolver::getBooleanFalse() {
 }
 
 BooleanEdge CSolver::applyPredicate(Predicate *predicate, Element **inputs, uint numInputs) {
-       return applyPredicateTable(predicate, inputs, numInputs, NULL);
+       return applyPredicateTable(predicate, inputs, numInputs, BooleanEdge(NULL));
 }
 
 BooleanEdge CSolver::applyPredicateTable(Predicate *predicate, Element **inputs, uint numInputs, BooleanEdge undefinedStatus) {