Fixing compile bugs

diff --git a/src/Collections/structs.h b/src/Collections/structs.h
index dc6d66573c4f3c10bd355136dc493dab327941ca..b026357c85f160505502c3981c59bebc1fd5af8d 100644 (file)
--- a/src/Collections/structs.h
+++ b/src/Collections/structs.h
@@ -35,9 +35,6 @@ inline bool Ptr_equals(void * key1, void * key2) {
 }
 
 HashTableDef(Void, void *, void *, Ptr_hash_function, Ptr_equals);
-HashTableDef(ElemToEncod, Element *, ElementEncoding *, Ptr_hash_function, Ptr_equals);
-HashTableDef(VoidToFuncEncod, void *, FunctionEncoding *, Ptr_hash_function, Ptr_equals);
-
 HashSetDef(Void, void *, Ptr_hash_function, Ptr_equals);
 
 

diff --git a/src/Encoders/elementencoding.c b/src/Encoders/elementencoding.c
index 217327d346ec2b753cca3d059e6638d1c1055139..4a4bc89670583334c61bfd7adf8208bbd4fb401d 100644 (file)
--- a/src/Encoders/elementencoding.c
+++ b/src/Encoders/elementencoding.c
@@ -25,3 +25,7 @@ void allocEncodingArrayElement(ElementEncoding *This, uint size) {
 void allocInUseArrayElement(ElementEncoding *This, uint size) {
        This->inUseArray=ourcalloc(1, size >> 6);
 }
+
+void setElementEncodingType(ElementEncoding* This, ElementEncodingType type){
+       This->type = type;
+}

diff --git a/src/Encoders/elementencoding.h b/src/Encoders/elementencoding.h
index 1af74beb9c92eb635e0a53c1a19b961c1a70ca09..03040ed9103fd03a7f2f55948aff3a3ed0ab03ba 100644 (file)
--- a/src/Encoders/elementencoding.h
+++ b/src/Encoders/elementencoding.h
@@ -18,6 +18,7 @@ struct ElementEncoding {
 };
 
 void initElementEncoding(ElementEncoding *This, Element *element);
+void setElementEncodingType(ElementEncoding* This, ElementEncodingType type);
 void deleteElementEncoding(ElementEncoding *This);
 void baseBinaryIndexElementAssign(ElementEncoding *This);
 void allocEncodingArrayElement(ElementEncoding *This, uint size);

diff --git a/src/Encoders/encodings.c b/src/Encoders/encodings.c
deleted file mode 100644 (file)
index 27d393e..0000000
--- a/src/Encoders/encodings.c
+++ /dev/null
@@ -1,57 +0,0 @@
-#include "encodings.h"
-#include "elementencoding.h"
-#include "functionencoding.h"
-#include "element.h"
-#include "common.h"
-#include "boolean.h"
-#include "naiveencoder.h"
-
-Encodings* allocEncodings(){
-       Encodings* This = (Encodings*) ourmalloc(sizeof(Encodings));
-       allocInlineDefVectorElementEncoding(GETVECTORELEMENTENCODING(This));
-       allocInlineDefVectorFunctionEncoding(GETVECTORFUNCTIONENCODING(This));
-       This->elemToEncode= allocHashTableElemToEncod(HT_INITIAL_CAPACITY, HT_DEFAULT_FACTOR);
-       This->voidToFuncEncode= allocHashTableVoidToFuncEncod(HT_INITIAL_CAPACITY, HT_DEFAULT_FACTOR);
-       return This;
-}
-
-void deleteEncodings(Encodings* This){
-       deleteVectorArrayFunctionEncoding(GETVECTORFUNCTIONENCODING(This));
-       deleteVectorArrayElementEncoding(GETVECTORELEMENTENCODING(This));
-       deleteHashTableElemToEncod(This->elemToEncode);
-       deleteHashTableVoidToFuncEncod(This->voidToFuncEncode);
-       ourfree(This);
-}
-
-void assignEncoding(CSolver* csolver, Encodings* This){
-       uint size = getSizeVectorElement(csolver->allElements);
-       for(uint i=0; i<size; i++){
-               Element* element = getVectorElement(csolver->allElements, i);
-               if(GETELEMENTTYPE(element)==ELEMSET){
-                       ElementEncoding* eencoding = allocElementEncoding( BINARYINDEX, element);
-                       baseBinaryIndexElementAssign(eencoding);
-                       pushVectorElementEncoding(GETVECTORELEMENTENCODING(This) , eencoding);
-                       putElemToEncod(This->elemToEncode, element, eencoding); 
-               }else if (GETELEMENTTYPE(element)==ELEMFUNCRETURN){
-                       FunctionEncoding* fencoding = allocFunctionEncoding( ENUMERATEIMPLICATIONS, element);
-                       pushVectorFunctionEncoding(GETVECTORFUNCTIONENCODING(This) , fencoding);
-                       putVoidToFuncEncod(This->voidToFuncEncode,element, fencoding);
-               }else
-                       ASSERT(0);
-       }
-       
-       size = getSizeVectorBoolean(csolver->allBooleans);
-       for(uint i=0; i<size; i++){
-               Boolean* predicate = getVectorBoolean(csolver->allBooleans, i);
-               if(GETBOOLEANTYPE(predicate)==PREDICATEOP){
-                       FunctionEncoding* fencoding = allocPredicateEncoding(ENUMERATEIMPLICATIONS, predicate);
-                       pushVectorFunctionEncoding(GETVECTORFUNCTIONENCODING(This), fencoding);
-                       putVoidToFuncEncod(This->voidToFuncEncode, predicate,fencoding);
-               }else 
-                       ASSERT(0);
-       }
-}
-
-void encodeFunctionsElements(Encodings* This){
-       //call encoding for each element/predicate
-}
\ No newline at end of file

diff --git a/src/Encoders/encodings.h b/src/Encoders/encodings.h
deleted file mode 100644 (file)
index 30c611c..0000000
--- a/src/Encoders/encodings.h
+++ /dev/null
@@ -1,29 +0,0 @@
-
-#ifndef NAIVEENCODINGASSIGNMENT_H
-#define NAIVEENCODINGASSIGNMENT_H
-#include "classlist.h"
-#include "structs.h"
-#include "csolver.h"
-#include "mymemory.h"
-
-
-#define GETVECTORFUNCTIONENCODING(o) (&((Encodings*)o)->funcEncoding)
-#define GETVECTORELEMENTENCODING(o) (&((Encodings*)o)->elemEncoding)
-
-struct Encodings{
-       HashTableVoidToFuncEncod* voidToFuncEncode;
-       HashTableElemToEncod* elemToEncode;
-       VectorFunctionEncoding funcEncoding;
-       VectorElementEncoding elemEncoding;
-};
-
-Encodings* allocEncodings();
-
-//For now, This function just simply goes through elements/functions and 
-//assigns a predefined Encoding to each of them
-void assignEncoding(CSolver* csolver, Encodings* This);
-void encodeFunctionsElements(Encodings* This);
-void deleteEncodings(Encodings* This);
-
-#endif /* NAIVEENCODINGASSIGNMENT_H */
-

diff --git a/src/Encoders/functionencoding.c b/src/Encoders/functionencoding.c
index 32be4ab93e24876483f496d49cea6f2e5afba3b7..7e0a746639ecd4a2cde0046f1bcad152a78f9304 100644 (file)
--- a/src/Encoders/functionencoding.c
+++ b/src/Encoders/functionencoding.c
@@ -11,4 +11,9 @@ void initPredicateEncoding(FunctionEncoding *This,  Boolean *predicate) {
 }
 
 void deleteFunctionEncoding(FunctionEncoding *This) {
+       ourfree(This);
+}
+
+void setFunctionEncodingType(FunctionEncoding* encoding, FunctionEncodingType type){
+       encoding->type=type;
 }

diff --git a/src/Encoders/functionencoding.h b/src/Encoders/functionencoding.h
index c7cf27e3c0743cf17b26225f614518195f00cd8f..a3521396f04abef9689b7371f4905e88b430dd14 100644 (file)
--- a/src/Encoders/functionencoding.h
+++ b/src/Encoders/functionencoding.h
@@ -23,6 +23,7 @@ struct FunctionEncoding {
 
 void initFunctionEncoding(FunctionEncoding *encoding, Element *function);
 void initPredicateEncoding(FunctionEncoding *encoding, Boolean *predicate);
+void setFunctionEncodingType(FunctionEncoding* encoding, FunctionEncodingType type);
 void deleteFunctionEncoding(FunctionEncoding *This);
 
 #endif

diff --git a/src/Encoders/naiveencoder.c b/src/Encoders/naiveencoder.c
index ca83383b33ec4f2275b373dffa115aec79ff7d63..81d77146c473c1414f02c31f262927d07bd99442 100644 (file)
--- a/src/Encoders/naiveencoder.c
+++ b/src/Encoders/naiveencoder.c
@@ -6,8 +6,41 @@
 #include "set.h"
 #include "common.h"
 #include "structs.h"
+#include "csolver.h"
+#include "boolean.h"
+#include "table.h"
 #include <strings.h>
 
+void assignEncoding(CSolver* csolver){
+       uint size = getSizeVectorElement(csolver->allElements);
+       for(uint i=0; i<size; i++){
+               Element* element = getVectorElement(csolver->allElements, i);
+               switch(GETELEMENTTYPE(element)){
+                       case ELEMSET:
+                               setElementEncodingType(&((ElementSet*)element)->encoding, BINARYINDEX);
+                               baseBinaryIndexElementAssign(&((ElementSet*)element)->encoding);
+                               break;
+                       case ELEMFUNCRETURN: 
+                               setFunctionEncodingType(&((ElementFunction*)element)->functionencoding, ENUMERATEIMPLICATIONS);
+                               break;
+                       default:
+                               ASSERT(0);
+               }
+       }
+       
+       size = getSizeVectorBoolean(csolver->allBooleans);
+       for(uint i=0; i<size; i++){
+               Boolean* predicate = getVectorBoolean(csolver->allBooleans, i);
+               switch(GETBOOLEANTYPE(predicate)){
+                       case PREDICATEOP:
+                               setFunctionEncodingType(&((BooleanPredicate*)predicate)->encoding, ENUMERATEIMPLICATIONS);
+                               break;
+                       default:
+                               continue;
+               } 
+       }
+}
+
 void baseBinaryIndexElementAssign(ElementEncoding *This) {
        Element * element=This->element;
        ASSERT(element->type == ELEMSET);
@@ -25,16 +58,45 @@ void baseBinaryIndexElementAssign(ElementEncoding *This) {
 }
 
 
-void naiveEncodeFunctionPredicate(Encodings* encodings, FunctionEncoding *This){
+void encode(CSolver* csolver){
+       uint size = getSizeVectorElement(csolver->allElements);
+       for(uint i=0; i<size; i++){
+               Element* element = getVectorElement(csolver->allElements, i);
+               switch(GETELEMENTTYPE(element)){
+                       case ELEMFUNCRETURN: 
+                               naiveEncodeFunctionPredicate(&((ElementFunction*)element)->functionencoding);
+                               break;
+                       default:
+                               continue;
+               }
+       }
+       
+       size = getSizeVectorBoolean(csolver->allBooleans);
+       for(uint i=0; i<size; i++){
+               Boolean* predicate = getVectorBoolean(csolver->allBooleans, i);
+               switch(GETBOOLEANTYPE(predicate)){
+                       case PREDICATEOP:
+                               naiveEncodeFunctionPredicate(&((BooleanPredicate*)predicate)->encoding);
+                               break;
+                       default:
+                               continue;
+               } 
+       }
+}
+
+void naiveEncodeFunctionPredicate(FunctionEncoding *This){
        if(This->isFunction) {
                ASSERT(GETELEMENTTYPE(This->op.function)==ELEMFUNCRETURN);
-               if(This->type==CIRCUIT){
-                       naiveEncodeCircuitFunction(encodings, This);
-               } else if( This->type == ENUMERATEIMPLICATIONS){
-                       naiveEncodeEnumeratedFunction(encodings, This);
-               } else
-                       ASSERT(0);
-                       
+               switch(This->type){
+                       case ENUMERATEIMPLICATIONS:
+                               naiveEncodeEnumeratedFunction(This);
+                               break;
+                       case CIRCUIT:
+                               naiveEncodeCircuitFunction(This);
+                               break;
+                       default:
+                               ASSERT(0);
+               }
        }else {
                ASSERT(GETBOOLEANTYPE(This->op.predicate) == PREDICATEOP);
                BooleanPredicate* predicate = (BooleanPredicate*)This->op.predicate;
@@ -44,22 +106,26 @@ void naiveEncodeFunctionPredicate(Encodings* encodings, FunctionEncoding *This){
 }
 
 
-void naiveEncodeCircuitFunction(Encodings* encodings, FunctionEncoding* This){
+void naiveEncodeCircuitFunction(FunctionEncoding* This){
        
 }
 
-void naiveEncodeEnumeratedFunction(Encodings* encodings, FunctionEncoding* This){
+void naiveEncodeEnumeratedFunction(FunctionEncoding* This){
        ElementFunction* ef =(ElementFunction*)This->op.function;
        Function * function = ef->function;
-       if(GETFUNCTIONTYPE(function)==TABLEFUNC){
-               naiveEncodeEnumTableFunc(encodings, ef);
-       }else if (GETFUNCTIONTYPE(function)== OPERATORFUNC){
-               naiveEncodeEnumOperatingFunc(encodings, ef);
-       }else 
-               ASSERT(0);
+       switch(GETFUNCTIONTYPE(function)){
+               case TABLEFUNC:
+                       naiveEncodeEnumTableFunc(ef);
+                       break;
+               case OPERATORFUNC:
+                       naiveEncodeEnumOperatingFunc(ef);
+                       break;
+               default:
+                       ASSERT(0);
+       } 
 }
 
-void naiveEncodeEnumTableFunc(Encodings* encodings, ElementFunction* This){
+void naiveEncodeEnumTableFunc(ElementFunction* This){
        ASSERT(GETFUNCTIONTYPE(This->function)==TABLEFUNC);
        ArrayElement* elements= &This->inputs;
        Table* table = ((FunctionTable*) (This->function))->table;
@@ -71,6 +137,6 @@ void naiveEncodeEnumTableFunc(Encodings* encodings, ElementFunction* This){
        
 }
 
-void naiveEncodeEnumOperatingFunc(Encodings* encodings, ElementFunction* This){
+void naiveEncodeEnumOperatingFunc(ElementFunction* This){
        
 }
\ No newline at end of file

diff --git a/src/Encoders/naiveencoder.h b/src/Encoders/naiveencoder.h
index d3df611a51c177462633c9e5b78ea63323f48c47..226b5fd325acd2d4e6c268c1c56b6a3c59ce4151 100644 (file)
--- a/src/Encoders/naiveencoder.h
+++ b/src/Encoders/naiveencoder.h
@@ -1,10 +1,15 @@
 #ifndef NAIVEELEMENTENCODER_H
 #define NAIVEELEMENTENCODER_H
 #include "classlist.h"
+
+//For now, This function just simply goes through elements/functions and 
+//assigns a predefined Encoding to each of them
+void assignEncoding(CSolver* csolver);
+void encode(CSolver* csolver);
 void baseBinaryIndexElementAssign(ElementEncoding *This);
-void naiveEncodeFunctionPredicate(Encodings* encodings, FunctionEncoding *This);
-void naiveEncodeCircuitFunction(Encodings* encodings,FunctionEncoding* This);
-void naiveEncodeEnumeratedFunction(Encodings* encodings, FunctionEncoding* This);
-void naiveEncodeEnumTableFunc(Encodings* encodings, ElementFunction* This);
-void naiveEncodeEnumOperatingFunc(Encodings* encodings, ElementFunction* This);
+void naiveEncodeFunctionPredicate( FunctionEncoding *This);
+void naiveEncodeCircuitFunction(FunctionEncoding* This);
+void naiveEncodeEnumeratedFunction(FunctionEncoding* This);
+void naiveEncodeEnumTableFunc(ElementFunction* This);
+void naiveEncodeEnumOperatingFunc(ElementFunction* This);
 #endif

diff --git a/src/classlist.h b/src/classlist.h
index f9aa831660e074755b9773d518af5bfff4569b81..3c7d071a66221d25dffd679d5465284efe7cc769 100644 (file)
--- a/src/classlist.h
+++ b/src/classlist.h
@@ -82,9 +82,6 @@ typedef struct OrderEncoding OrderEncoding;
 struct TableEntry;
 typedef struct TableEntry TableEntry;
 
-struct Encodings;
-typedef struct Encodings Encodings;
-
 typedef unsigned int uint;
 typedef uint64_t VarType;
 #endif