Inline Encoding Structs into appropriate AST Nodes

diff --git a/src/AST/boolean.c b/src/AST/boolean.c
index 8a47f72ee36f8e33557674331c57c2730fdbc8a7..0432b4395cd772f9eb7a11abc8dd9ae5379b0f96 100644 (file)
--- a/src/AST/boolean.c
+++ b/src/AST/boolean.c
@@ -32,6 +32,8 @@ Boolean * allocBooleanPredicate(Predicate * predicate, Element ** inputs, uint n
        for(uint i=0;i<numInputs;i++) {
                pushVectorASTNode(GETELEMENTPARENTS(inputs[i]), (ASTNode *)This);
        }
+       initPredicateEncoding(&This->encoding, (Boolean *) This);
+
        return & This->base;
 }
 
@@ -45,11 +47,14 @@ Boolean * allocBooleanLogicArray(CSolver *solver, LogicOp op, Boolean ** array,
 
 void deleteBoolean(Boolean * This) {
        switch(GETBOOLEANTYPE(This)){
-               case PREDICATEOP:
-                       deleteInlineArrayElement(& ((BooleanPredicate*)This)->inputs );
-                       break;
-               default:
-                       break;
+       case PREDICATEOP: {
+               BooleanPredicate *bp=(BooleanPredicate *)This;
+               deleteInlineArrayElement(& bp->inputs );
+               deleteFunctionEncoding(& bp->encoding);
+               break;
+       }
+       default:
+               break;
        }
        deleteVectorArrayBoolean(GETBOOLEANPARENTS(This));
        ourfree(This);

diff --git a/src/AST/boolean.h b/src/AST/boolean.h
index a9d07026820c867ae32c69cd5a00fcc08552d411..411af2604b771835682316e1d191c7d56c1b600d 100644 (file)
--- a/src/AST/boolean.h
+++ b/src/AST/boolean.h
@@ -5,6 +5,7 @@
 #include "ops.h"
 #include "structs.h"
 #include "astnode.h"
+#include "functionencoding.h"
 
 /**
     This is a little sketchy, but apparently legit.
@@ -40,6 +41,7 @@ struct BooleanLogic {
 struct BooleanPredicate {
        Boolean base;
        Predicate * predicate;
+       FunctionEncoding encoding;
        ArrayElement inputs;
 };
 

diff --git a/src/AST/element.c b/src/AST/element.c
index 7401173ba806df7f9648ae8a81a957883764502c..a94db4b8d8ac27fbe812a6c44c1c0e2f650553ca 100644 (file)
--- a/src/AST/element.c
+++ b/src/AST/element.c
@@ -5,8 +5,8 @@ Element *allocElementSet(Set * s) {
        ElementSet * tmp=(ElementSet *)ourmalloc(sizeof(ElementSet));
        GETELEMENTTYPE(tmp)= ELEMSET;
        tmp->set=s;
-       tmp->encoding=NULL;
        allocInlineDefVectorASTNode(GETELEMENTPARENTS(tmp));
+       initElementEncoding(&tmp->encoding, (Element *) tmp);
        return &tmp->base;
 }
 
@@ -19,17 +19,29 @@ Element* allocElementFunction(Function * function, Element ** array, uint numArr
        allocInlineDefVectorASTNode(GETELEMENTPARENTS(tmp));
        for(uint i=0;i<numArrays;i++)
                pushVectorASTNode(GETELEMENTPARENTS(array[i]), (ASTNode *) tmp);
+       initElementEncoding(&tmp->domainencoding, (Element *) tmp);
+       initFunctionEncoding(&tmp->functionencoding, (Element *) tmp);
        return &tmp->base;
 }
 
 void deleteElement(Element *This) {
        switch(GETELEMENTTYPE(This)) {
-       case ELEMFUNCRETURN:
-               deleteInlineArrayElement(&((ElementFunction *)This)->inputs);
+       case ELEMFUNCRETURN: {
+               ElementFunction *ef = (ElementFunction *) This;
+               deleteInlineArrayElement(&ef->inputs);
+               deleteElementEncoding(&ef->domainencoding);
+               deleteFunctionEncoding(&ef->functionencoding);
                break;
+       }
+       case ELEMSET: {
+               ElementSet *es = (ElementSet *) This;
+               deleteElementEncoding(&es->encoding);
+               break;
+       }
        default:
                ;
        }
        deleteVectorArrayASTNode(GETELEMENTPARENTS(This));
+
        ourfree(This);
 }

diff --git a/src/AST/element.h b/src/AST/element.h
index 7886e4cc8d3073eb307851b24be86a0a5eff9204..b5bc9c1fdfcb7ce5bb21ec1d497a09af33771a50 100644 (file)
--- a/src/AST/element.h
+++ b/src/AST/element.h
@@ -4,6 +4,8 @@
 #include "mymemory.h"
 #include "structs.h"
 #include "astnode.h"
+#include "functionencoding.h"
+#include "elementencoding.h"
 
 #define GETELEMENTTYPE(o) GETASTNODETYPE(o)
 #define GETELEMENTPARENTS(o) (&((Element*)o)->parents)
@@ -16,7 +18,7 @@ struct Element {
 struct ElementSet {
        Element base;
        Set * set;
-       ElementEncoding * encoding;
+       ElementEncoding encoding;
 };
 
 struct ElementFunction {
@@ -24,6 +26,8 @@ struct ElementFunction {
        Function * function;
        ArrayElement inputs;
        Boolean * overflowstatus;
+       FunctionEncoding functionencoding;
+       ElementEncoding domainencoding;
 };
 
 Element * allocElementSet(Set *s);

diff --git a/src/Encoders/elementencoding.c b/src/Encoders/elementencoding.c
index 08385db6921096a5bb6b3fcd3c010ae4f3360c7b..ecabd1bfcd239fc9bcf3238c272365714d5ba063 100644 (file)
--- a/src/Encoders/elementencoding.c
+++ b/src/Encoders/elementencoding.c
@@ -1,13 +1,11 @@
 #include "elementencoding.h"
 
-ElementEncoding * allocElementEncoding(ElementEncodingType type, Element *element) {
-       ElementEncoding * This=ourmalloc(sizeof(ElementEncoding));
+void initElementEncoding(ElementEncoding * This, Element *element) {
        This->element=element;
-       This->type=type;
+       This->type=ELEM_UNASSIGNED;
        This->variables=NULL;
        This->encodingArray=NULL;
        This->numVars=0;
-       return This;
 }
 
 void deleteElementEncoding(ElementEncoding *This) {
@@ -17,7 +15,6 @@ void deleteElementEncoding(ElementEncoding *This) {
                ourfree(This->encodingArray);
        if (This->inUseArray!=NULL)
                ourfree(This->inUseArray);
-       ourfree(This);
 }
 
 void allocEncodingArrayElement(ElementEncoding *This, uint size) {

diff --git a/src/Encoders/elementencoding.h b/src/Encoders/elementencoding.h
index bc173eaaaeb44d3b22e2b424d91f741bcad44a87..3ade03b14ff760dcafbc25c756b5a17603e2da15 100644 (file)
--- a/src/Encoders/elementencoding.h
+++ b/src/Encoders/elementencoding.h
@@ -3,7 +3,7 @@
 #include "classlist.h"
 
 enum ElementEncodingType {
-       ONEHOT, UNARY, BINARYINDEX, ONEHOTBINARY, BINARYVAL
+       ELEM_UNASSIGNED, ONEHOT, UNARY, BINARYINDEX, ONEHOTBINARY, BINARYVAL
 };
 
 typedef enum ElementEncodingType ElementEncodingType;
@@ -17,7 +17,7 @@ struct ElementEncoding {
        uint numVars;   /* Number of variables */
 };
 
-ElementEncoding * allocElementEncoding(ElementEncodingType type, Element *element);
+void initElementEncoding(ElementEncoding *This, Element *element);
 void deleteElementEncoding(ElementEncoding *This);
 void baseBinaryIndexElementAssign(ElementEncoding *This);
 void allocEncodingArrayElement(ElementEncoding *This, uint size);

diff --git a/src/Encoders/functionencoding.c b/src/Encoders/functionencoding.c
index d0f8c3dc09984560ab3ecad6d63943e654b54e3e..32be4ab93e24876483f496d49cea6f2e5afba3b7 100644 (file)
--- a/src/Encoders/functionencoding.c
+++ b/src/Encoders/functionencoding.c
@@ -1,19 +1,14 @@
 #include "functionencoding.h"
 
-FunctionEncoding * allocFunctionEncoding(FunctionEncodingType type, Element *function) {
-       FunctionEncoding * This=ourmalloc(sizeof(FunctionEncoding));
+void initFunctionEncoding(FunctionEncoding *This, Element *function) {
        This->op.function=function;
-       This->type=type;
-       return This;
+       This->type=FUNC_UNASSIGNED;
 }
 
-FunctionEncoding * allocPredicateEncoding(FunctionEncodingType type, Boolean *predicate) {
-       FunctionEncoding * This=ourmalloc(sizeof(FunctionEncoding));
+void initPredicateEncoding(FunctionEncoding *This,  Boolean *predicate) {
        This->op.predicate=predicate;
-       This->type=type;
-       return This;
+       This->type=FUNC_UNASSIGNED;
 }
 
-void deleteFunctionEncoding(FunctionEncoding *fe) {
-       ourfree(fe);
+void deleteFunctionEncoding(FunctionEncoding *This) {
 }

diff --git a/src/Encoders/functionencoding.h b/src/Encoders/functionencoding.h
index 63583b64cf2148620a453b43b68469b7fe53aa30..486d5eb13baf64d4a8bbdb751ef294ae5b06e688 100644 (file)
--- a/src/Encoders/functionencoding.h
+++ b/src/Encoders/functionencoding.h
@@ -3,7 +3,7 @@
 #include "classlist.h"
 
 enum FunctionEncodingType {
-       ENUMERATEIMPLICATIONS, CIRCUIT
+       FUNC_UNASSIGNED, ENUMERATEIMPLICATIONS, CIRCUIT
 };
 
 typedef enum FunctionEncodingType FunctionEncodingType;
@@ -21,7 +21,7 @@ struct FunctionEncoding {
        ElementPredicate op;
 };
 
-FunctionEncoding * allocFunctionEncoding(FunctionEncodingType type, Element *function);
-FunctionEncoding * allocPredicateEncoding(FunctionEncodingType type, Boolean *predicate);
+void initFunctionEncoding(FunctionEncoding *encoding, Element *function);
+void initPredicateEncoding(FunctionEncoding *encoding, Boolean *predicate);
 void deleteFunctionEncoding(FunctionEncoding *This);
 #endif

diff --git a/src/Encoders/naiveelementencoder.c b/src/Encoders/naiveelementencoder.c
deleted file mode 100644 (file)
index 242a4e7..0000000
--- a/src/Encoders/naiveelementencoder.c
+++ /dev/null
@@ -1,24 +0,0 @@
-#include "naiveelementencoder.h"
-#include "elementencoding.h"
-#include "element.h"
-#include "set.h"
-#include "common.h"
-#include "structs.h"
-#include <strings.h>
-
-void baseBinaryIndexElementAssign(ElementEncoding *This) {
-       Element * element=This->element;
-       ASSERT(element->type == ELEMSET);
-       Set * set= ((ElementSet*)element)->set;
-       ASSERT(set->isRange==false);
-       uint size=getSizeVectorInt(set->members);
-       uint encSize=NEXTPOW2(size);
-       allocEncodingArrayElement(This, encSize);
-       allocInUseArrayElement(This, encSize);
-
-       for(uint i=0;i<size;i++) {
-               This->encodingArray[i]=getVectorInt(set->members, i);
-               setInUseElement(This, i);
-       }
-}
-

diff --git a/src/Encoders/naiveelementencoder.h b/src/Encoders/naiveelementencoder.h
deleted file mode 100644 (file)
index db4aeb9..0000000
--- a/src/Encoders/naiveelementencoder.h
+++ /dev/null
@@ -1,5 +0,0 @@
-#ifndef NAIVEELEMENTENCODER_H
-#define NAIVEELEMENTENCODER_H
-#include "classlist.h"
-void baseBinaryIndexElementAssign(ElementEncoding *This);
-#endif

diff --git a/src/Encoders/naiveencoder.c b/src/Encoders/naiveencoder.c
new file mode 100644 (file)
index 0000000..ad8a650
--- /dev/null
+++ b/src/Encoders/naiveencoder.c
@@ -0,0 +1,25 @@
+#include "naiveencoder.h"
+#include "elementencoding.h"
+#include "element.h"
+#include "functionencoding.h"
+#include "function.h"
+#include "set.h"
+#include "common.h"
+#include "structs.h"
+#include <strings.h>
+
+void baseBinaryIndexElementAssign(ElementEncoding *This) {
+       Element * element=This->element;
+       ASSERT(element->type == ELEMSET);
+       Set * set= ((ElementSet*)element)->set;
+       ASSERT(set->isRange==false);
+       uint size=getSizeVectorInt(set->members);
+       uint encSize=NEXTPOW2(size);
+       allocEncodingArrayElement(This, encSize);
+       allocInUseArrayElement(This, encSize);
+
+       for(uint i=0;i<size;i++) {
+               This->encodingArray[i]=getVectorInt(set->members, i);
+               setInUseElement(This, i);
+       }
+}

diff --git a/src/Encoders/naiveencoder.h b/src/Encoders/naiveencoder.h
new file mode 100644 (file)
index 0000000..db4aeb9
--- /dev/null
+++ b/src/Encoders/naiveencoder.h
@@ -0,0 +1,5 @@
+#ifndef NAIVEELEMENTENCODER_H
+#define NAIVEELEMENTENCODER_H
+#include "classlist.h"
+void baseBinaryIndexElementAssign(ElementEncoding *This);
+#endif