Merge

diff --git a/src/AST/mutableset.cc b/src/AST/mutableset.cc
index d6657c550df8432f4cfd577fea379450243396a0..3d9db49b2ab6e4a117bcf1f3f4ab16e8fcb1aa20 100644 (file)
--- a/src/AST/mutableset.cc
+++ b/src/AST/mutableset.cc
@@ -1,5 +1,6 @@
 #include "mutableset.h"
 #include "csolver.h"
+#include "qsort.h"
 
 MutableSet::MutableSet(VarType t) : Set(t) {
 }
@@ -15,8 +16,13 @@ Set *MutableSet::clone(CSolver *solver, CloneMap *map) {
        s = solver->createMutableSet(type);
        for (uint i = 0; i < members->getSize(); i++) {
                ((MutableSet *)s)->addElementMSet(members->get(i));
-               //              solver->addItem((MutableSet *) s, members->get(i));
+                               solver->addItem((MutableSet *) s, members->get(i));
        }
+       ((MutableSet*)s)->finalize();
        map->put(this, s);
        return s;
 }
+
+void MutableSet::finalize(){
+       bsdqsort(members->expose(), members->getSize(), sizeof(uint64_t), intcompare);
+}
\ No newline at end of file

diff --git a/src/AST/mutableset.h b/src/AST/mutableset.h
index 568678f5cea381f9e66840f56f174bda088e6b73..9cfa9e6a5acce23e4aab7360c43d72abaf4b2177 100644 (file)
--- a/src/AST/mutableset.h
+++ b/src/AST/mutableset.h
@@ -7,6 +7,8 @@ public:
        MutableSet(VarType t);
        void addElementMSet(uint64_t element);
        Set *clone(CSolver *solver, CloneMap *map);
+       bool isMutableSet() {return true;}
+       void finalize();
        CMEMALLOC;
 };
 #endif

diff --git a/src/AST/set.cc b/src/AST/set.cc
index c3050ec3f0c0e83ee24d87beb70466c59e8a4cf9..bd1b3d6e431f013a32ce4bc43123c22bcb68c775 100644 (file)
--- a/src/AST/set.cc
+++ b/src/AST/set.cc
@@ -4,10 +4,6 @@
 #include "serializer.h"
 #include "qsort.h"
 
-Set::Set(VarType t) : type(t), isRange(false), low(0), high(0) {
-       members = new Vector<uint64_t>();
-}
-
 int intcompare(const void *p1, const void *p2) {
        uint64_t a=*(uint64_t const *) p1;
        uint64_t b=*(uint64_t const *) p2;
@@ -19,6 +15,11 @@ int intcompare(const void *p1, const void *p2) {
                return 1;
 }
 
+Set::Set(VarType t) : type(t), isRange(false), low(0), high(0) {
+       members = new Vector<uint64_t>();
+}
+
+
 Set::Set(VarType t, uint64_t *elements, uint num) : type(t), isRange(false), low(0), high(0) {
        members = new Vector<uint64_t>(num, elements);
        bsdqsort(members->expose(), members->getSize(), sizeof(uint64_t), intcompare);
@@ -132,6 +133,8 @@ void Set::serialize(Serializer* serializer){
        serializer->mywrite(&isRange, sizeof(bool));
        serializer->mywrite(&low, sizeof(uint64_t));
        serializer->mywrite(&high, sizeof(uint64_t));
+       bool isMutable = isMutableSet();
+       serializer->mywrite(&isMutable, sizeof(bool));
        uint size = members->getSize();
        serializer->mywrite(&size, sizeof(uint));
        for(uint i=0; i<size; i++){

diff --git a/src/AST/set.h b/src/AST/set.h
index 088eca577cd7b75611d9c4095dbd87625e7395b2..ad89504db94e76170464d1eb5c29c943dd1106c3 100644 (file)
--- a/src/AST/set.h
+++ b/src/AST/set.h
@@ -25,6 +25,7 @@ public:
        uint64_t getMemberAt(uint index);
        uint64_t getElement(uint index);
        uint getUnionSize(Set *s);
+       virtual bool isMutableSet() {return false;}
        virtual Set *clone(CSolver *solver, CloneMap *map);
        virtual void serialize(Serializer* serializer);
        CMEMALLOC;
@@ -36,5 +37,6 @@ protected:
        Vector<uint64_t> *members;
 };
 
+int intcompare(const void *p1, const void *p2);
 #endif/* SET_H */
 

diff --git a/src/Serialize/deserializer.cc b/src/Serialize/deserializer.cc
index 71191198ee10781658094602f0dbbd10620ca40c..fc4cd7bab1faa3f30191d05c9ebe8385830b57f4 100644 (file)
--- a/src/Serialize/deserializer.cc
+++ b/src/Serialize/deserializer.cc
@@ -13,6 +13,7 @@
 #include "predicate.h"
 #include "table.h"
 #include "element.h"
+#include "mutableset.h"
 
 Deserializer::Deserializer(const char* file):
        solver(new CSolver())
@@ -148,16 +149,28 @@ void Deserializer::deserializeSet(){
        myread(&low, sizeof(uint64_t));
        uint64_t high;
        myread(&high, sizeof(uint64_t));
+       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));
-               members.push(mem);
+               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);
        }
-       Set *set = isRange? solver->createRangeSet(type, low, high):
-               solver->createSet(type, members.expose(), size);
        map.put(s_ptr, set);
 }
 

diff --git a/src/csolver.cc b/src/csolver.cc
index ea4b92465f873dd8a59cb5fce07751512f6a5eb8..575a12b6f347714e5711eccd08c6131ec381de81 100644 (file)
--- a/src/csolver.cc
+++ b/src/csolver.cc
@@ -128,9 +128,9 @@ MutableSet *CSolver::createMutableSet(VarType type) {
        return set;
 }
 
-//void CSolver::addItem(MutableSet *set, uint64_t element) {
-//     set->addElementMSet(element);
-//}
+void CSolver::addItem(MutableSet *set, uint64_t element) {
+       set->addElementMSet(element);
+}
 
 uint64_t CSolver::createUniqueItem(MutableSet *set) {
        uint64_t element = set->getNewUniqueItem();
@@ -138,6 +138,10 @@ uint64_t CSolver::createUniqueItem(MutableSet *set) {
        return element;
 }
 
+void CSolver::finalizeMutableSet(MutableSet* set){
+       set->finalize();
+}
+
 Element *CSolver::getElementVar(Set *set) {
        Element *element = new ElementSet(set);
        allElements.push(element);

diff --git a/src/csolver.h b/src/csolver.h
index 480790832fbfea2d46875394e4bbe529e2e68e20..e49278116f5a00119ee9f8091b3aaa21b2ee80e9 100644 (file)
--- a/src/csolver.h
+++ b/src/csolver.h
@@ -27,13 +27,18 @@ public:
        /** This function adds a new item to a set. */
 
        //Deprecating this unless we need it...
-       //      void addItem(MutableSet *set, uint64_t element);
+       void addItem(MutableSet *set, uint64_t element);
 
        /** This function adds a new unique item to the set and returns it.
            This function cannot be used in conjunction with manually adding
            items to the set. */
 
        uint64_t createUniqueItem(MutableSet *set);
+       
+       /**
+        * Freeze and finalize the mutableSet ...
+        */
+       void finalizeMutableSet(MutableSet* set);
 
        /** This function creates an element variable over a set. */
 

diff --git a/src/mymemory.h b/src/mymemory.h
index 7c63aa11c10edb99f259ab9a11fffcae8df89794..e0a60bd13294b871199b826e88c0ea13261c1b3d 100644 (file)
--- a/src/mymemory.h
+++ b/src/mymemory.h
@@ -26,7 +26,7 @@
    void * ourrealloc(void *ptr, size_t size);
 */
 
-#if 0
+#if 1
 void * model_malloc(size_t size);
 void model_free(void *ptr);
 void * model_calloc(size_t count, size_t size);