Fixing bugs ...

diff --git a/src/AST/element.h b/src/AST/element.h
index c6436036b59a38c0acbc6b3023bbac8678cee9e8..1b790848518c7a146707fc9a51627051d89cef02 100644 (file)
--- a/src/AST/element.h
+++ b/src/AST/element.h
@@ -26,6 +26,7 @@ public:
 class ElementSet : public Element {
 public:
        ElementSet(ASTNodeType type, Set *s);
+        virtual ~ElementSet(){}
        ElementSet(Set *s);
        virtual Element *clone(CSolver *solver, CloneMap *map);
        virtual void serialize(Serializer* serializer);
@@ -40,6 +41,7 @@ public:
 class ElementConst : public ElementSet {
 public:
        ElementConst(uint64_t value, Set *_set);
+        virtual ~ElementConst(){}
        uint64_t value;
        virtual void serialize(Serializer* serializer);
         virtual void print();
@@ -49,6 +51,7 @@ public:
 
 class ElementFunction : public Element {
 public:
+        virtual ~ElementFunction(){}
        ElementFunction(Function *function, Element **array, uint numArrays, BooleanEdge overflowstatus);
        Array<Element *> inputs;
        BooleanEdge overflowstatus;

diff --git a/src/AST/set.cc b/src/AST/set.cc
index 25ccd05e67d6d9e480d45346735ea40ef4d1ed6f..5c07ac5ce49ef59b37a431bd19d5e613e7759daf 100644 (file)
--- a/src/AST/set.cc
+++ b/src/AST/set.cc
@@ -131,16 +131,19 @@ void Set::serialize(Serializer* serializer){
        serializer->mywrite(&This, sizeof(Set*));
        serializer->mywrite(&type, sizeof(VarType));
        serializer->mywrite(&isRange, sizeof(bool));
-       serializer->mywrite(&low, sizeof(uint64_t));
-       serializer->mywrite(&high, sizeof(uint64_t));
-       bool isMutable = isMutableSet();
+        bool isMutable = isMutableSet();
        serializer->mywrite(&isMutable, sizeof(bool));
-       uint size = members->getSize();
-       serializer->mywrite(&size, sizeof(uint));
-       for(uint i=0; i<size; i++){
-               uint64_t mem = members->get(i);
-               serializer->mywrite(&mem, sizeof(uint64_t));
-       }
+        if(isRange){
+                serializer->mywrite(&low, sizeof(uint64_t));
+                serializer->mywrite(&high, sizeof(uint64_t));
+        }else {
+                uint size = members->getSize();
+                serializer->mywrite(&size, sizeof(uint));
+                for(uint i=0; i<size; i++){
+                        uint64_t mem = members->get(i);
+                        serializer->mywrite(&mem, sizeof(uint64_t));
+                }
+        }
 }
 
 void Set::print(){

diff --git a/src/Serialize/deserializer.cc b/src/Serialize/deserializer.cc
index fc4cd7bab1faa3f30191d05c9ebe8385830b57f4..bffb901153216f812f6797d3265618e5c48b4196 100644 (file)
--- a/src/Serialize/deserializer.cc
+++ b/src/Serialize/deserializer.cc
@@ -145,33 +145,37 @@ void Deserializer::deserializeSet(){
        myread(&type, sizeof(VarType));
        bool isRange;
        myread(&isRange, sizeof(bool));
-       uint64_t low;
-       myread(&low, sizeof(uint64_t));
-       uint64_t high;
-       myread(&high, sizeof(uint64_t));
-       bool isMutable;
+        bool isMutable;
        myread(&isMutable, sizeof(bool));
-       Set *set;
-       if(isMutable){
-               set = new MutableSet(type);
-       }
-       uint size;
-       myread(&size, sizeof(uint));
-       Vector<uint64_t> members;
-       for(uint i=0; i<size; i++){
-               uint64_t mem;
-               myread(&mem, sizeof(uint64_t));
-               if(isMutable) {
-                       ((MutableSet*) set)->addElementMSet(mem);
-               }else {
-                       members.push(mem);
-               }
-       }
-       if(!isMutable){
-               set = isRange? solver->createRangeSet(type, low, high):
-                       solver->createSet(type, members.expose(), size);
-       }
-       map.put(s_ptr, set);
+        if(isRange){
+                uint64_t low;
+                myread(&low, sizeof(uint64_t));
+                uint64_t high;
+                myread(&high, sizeof(uint64_t));
+                map.put(s_ptr, new Set(type, low, high));
+        } else{
+                Set *set;
+                if(isMutable){
+                        set = new MutableSet(type);
+                }
+                uint size;
+                myread(&size, sizeof(uint));
+                Vector<uint64_t> members;
+                for(uint i=0; i<size; i++){
+                        uint64_t mem;
+                        myread(&mem, sizeof(uint64_t));
+                        if(isMutable) {
+                                ((MutableSet*) set)->addElementMSet(mem);
+                        }else {
+                                members.push(mem);
+                        }
+                }
+                if(!isMutable){
+                        set = solver->createSet(type, members.expose(), size);
+                }
+                map.put(s_ptr, set);
+        }
+       
 }
 
 void Deserializer::deserializeBooleanLogic(){

diff --git a/src/csolver.cc b/src/csolver.cc
index f1c39e0e33229648c39e97bf02460c0e0271c52a..48668879610388b54f8ebe8574532ae13fb80ff0 100644 (file)
--- a/src/csolver.cc
+++ b/src/csolver.cc
@@ -36,6 +36,7 @@ CSolver::CSolver() :
 /** This function tears down the solver and the entire AST */
 
 CSolver::~CSolver() {
+        this->serialize();
        uint size = allBooleans.getSize();
        for (uint i = 0; i < size; i++) {
                delete allBooleans.get(i);
@@ -48,7 +49,10 @@ CSolver::~CSolver() {
 
        size = allElements.getSize();
        for (uint i = 0; i < size; i++) {
-               delete allElements.get(i);
+                Element* el = allElements.get(i);
+                model_print("deleting ...%u", i);
+                ASSERT(el != NULL);
+               delete el;
        }
 
        size = allTables.getSize();
@@ -98,11 +102,11 @@ void CSolver::serialize() {
                }
                delete it;
        }
-       model_print("deserializing ...\n");
-       {
-               Deserializer deserializer("dump");
-               deserializer.deserialize();
-       }
+//     model_print("deserializing ...\n");
+//     {
+//             Deserializer deserializer("dump");
+//             deserializer.deserialize();
+//     }
        
 }
 
@@ -149,6 +153,7 @@ void CSolver::finalizeMutableSet(MutableSet* set){
 
 Element *CSolver::getElementVar(Set *set) {
        Element *element = new ElementSet(set);
+        model_println("%%%%ElementVar:%u", allElements.getSize());
        allElements.push(element);
        return element;
 }
@@ -165,6 +170,7 @@ Element *CSolver::getElementConst(VarType type, uint64_t value) {
        Element *e = elemMap.get(element);
        if (e == NULL) {
                allSets.push(set);
+                model_println("%%%%ElementConst:%u", allElements.getSize());
                allElements.push(element);
                elemMap.put(element, element);
                return element;
@@ -180,6 +186,7 @@ Element *CSolver::applyFunction(Function *function, Element **array, uint numArr
        Element *e = elemMap.get(element);
        if (e == NULL) {
                element->updateParents();
+                model_println("%%%%ElementFunction:%u", allElements.getSize());
                allElements.push(element);
                elemMap.put(element, element);
                return element;