tabbing

diff --git a/src/ASTAnalyses/Encoding/encodinggraph.cc b/src/ASTAnalyses/Encoding/encodinggraph.cc
index f0cd8300b44bad06889287b3625c23784a6c8b3e..5c758c3e0ad3eb63dcdd920435953ecc476291d2 100644 (file)
--- a/src/ASTAnalyses/Encoding/encodinggraph.cc
+++ b/src/ASTAnalyses/Encoding/encodinggraph.cc
@@ -79,7 +79,7 @@ void EncodingGraph::encode() {
                                        EncodingSubGraph *subgraph = graphMap.get(n);
                                        if (subgraph == NULL)
                                                continue;
                                        EncodingSubGraph *subgraph = graphMap.get(n);
                                        if (subgraph == NULL)
                                                continue;

-                                       uint encodingSize = subgraph->getEncodingMaxVal(n)+1;
+                                       uint encodingSize = subgraph->getEncodingMaxVal(n) + 1;

                                        uint paddedSize = encoding->getSizeEncodingArray(encodingSize);
                                        encoding->allocInUseArrayElement(paddedSize);
                                        encoding->allocEncodingArrayElement(paddedSize);
                                        uint paddedSize = encoding->getSizeEncodingArray(encodingSize);
                                        encoding->allocInUseArrayElement(paddedSize);
                                        encoding->allocEncodingArrayElement(paddedSize);

diff --git a/src/ASTAnalyses/Order/ordergraph.h b/src/ASTAnalyses/Order/ordergraph.h
index e7e958ee63311917bea1f29f569fb1a8bca39937..2b2fc59aa9cb0924ea0dbe1378c4a0855730fcef 100644 (file)
--- a/src/ASTAnalyses/Order/ordergraph.h
+++ b/src/ASTAnalyses/Order/ordergraph.h
@@ -35,7 +35,7 @@ public:
        void computeStronglyConnectedComponentGraph();
        void resetNodeInfoStatusSCC();
        void completePartialOrderGraph();
        void computeStronglyConnectedComponentGraph();
        void resetNodeInfoStatusSCC();
        void completePartialOrderGraph();

-       
+

        CMEMALLOC;
 private:
        HashsetOrderNode nodes;
        CMEMALLOC;
 private:
        HashsetOrderNode nodes;

diff --git a/src/ASTTransform/decomposeordertransform.cc b/src/ASTTransform/decomposeordertransform.cc
index 4c95db88c3196cf0db0559422affd7d01fd26c07..1e0426c32a00d33eb284f059269b3fbad594c50a 100644 (file)
--- a/src/ASTTransform/decomposeordertransform.cc
+++ b/src/ASTTransform/decomposeordertransform.cc
@@ -36,9 +36,9 @@ void DecomposeOrderTransform::doTransform() {
                        continue;
                }
 
                        continue;
                }
 

-               DecomposeOrderResolver *dor=new DecomposeOrderResolver(order);
+               DecomposeOrderResolver *dor = new DecomposeOrderResolver(order);

                order->setOrderResolver(dor);
                order->setOrderResolver(dor);

-               
+

                OrderGraph *graph = buildOrderGraph(order);
                if (order->type == SATC_PARTIAL) {
                        //Required to do SCC analysis for partial order graphs.  It
                OrderGraph *graph = buildOrderGraph(order);
                if (order->type == SATC_PARTIAL) {
                        //Required to do SCC analysis for partial order graphs.  It


@@ -108,7 +108,7 @@ void DecomposeOrderTransform::decomposeOrder(Order *currOrder, OrderGraph *currG
                                        dor->mustOrderEdge(from->getID(), to->getID());
                                        solver->replaceBooleanWithTrue(orderconstraint);
                                } else if (edge->polNeg) {
                                        dor->mustOrderEdge(from->getID(), to->getID());
                                        solver->replaceBooleanWithTrue(orderconstraint);
                                } else if (edge->polNeg) {

-                                       if (currOrder->type == SATC_TOTAL)                                      
+                                       if (currOrder->type == SATC_TOTAL)

                                                dor->mustOrderEdge(to->getID(), from->getID());
                                        solver->replaceBooleanWithFalse(orderconstraint);
                                } else {
                                                dor->mustOrderEdge(to->getID(), from->getID());
                                        solver->replaceBooleanWithFalse(orderconstraint);
                                } else {

diff --git a/src/Collections/structs.cc b/src/Collections/structs.cc
index 09dc41922a2f9d6511b4288b1bdeaeaf7acac519..20012421f8eab831957682b8cff4fbf65dfc08a4 100644 (file)
--- a/src/Collections/structs.cc
+++ b/src/Collections/structs.cc
@@ -64,5 +64,5 @@ unsigned int doredge_hash_function(DOREdge *key) {
 
 bool doredge_equals(DOREdge *key1, DOREdge *key2) {
        return key1->newfirst == key2->newfirst &&
 
 bool doredge_equals(DOREdge *key1, DOREdge *key2) {
        return key1->newfirst == key2->newfirst &&

-               key1->newsecond == key2->newsecond;
+                                key1->newsecond == key2->newsecond;

 }
 }

diff --git a/src/Test/constraint.cc b/src/Test/constraint.cc
index 60dd586c01b50a1adf0f275f98bb008be9b2f7e4..b270524b70785ffc4ccbad6b0377e664d69a88f9 100644 (file)
--- a/src/Test/constraint.cc
+++ b/src/Test/constraint.cc
@@ -2,14 +2,14 @@
 
 int main(int numargs, char **argv) {
        CSolver *solver = new CSolver();
 
 int main(int numargs, char **argv) {
        CSolver *solver = new CSolver();

-       uint64_t elements[]={0, 1};
-       Set * s = solver->createSet(1, elements, 2);
-       Element * e1=solver->getElementVar(s);
-       Element * e2=solver->getElementVar(s);
-       Set * sarray[]={s, s};
-       Predicate *p=solver->createPredicateOperator(SATC_LT, sarray, 2);
-       Element *earray[]={e1, e2};
-       BooleanEdge be=solver->applyPredicate(p, earray, 2);
+       uint64_t elements[] = {0, 1};
+       Set *s = solver->createSet(1, elements, 2);
+       Element *e1 = solver->getElementVar(s);
+       Element *e2 = solver->getElementVar(s);
+       Set *sarray[] = {s, s};
+       Predicate *p = solver->createPredicateOperator(SATC_LT, sarray, 2);
+       Element *earray[] = {e1, e2};
+       BooleanEdge be = solver->applyPredicate(p, earray, 2);

        solver->addConstraint(be);
 
        if (solver->solve() == 1) {
        solver->addConstraint(be);
 
        if (solver->solve() == 1) {

diff --git a/src/Translator/decomposeorderresolver.cc b/src/Translator/decomposeorderresolver.cc
index c2e9db45dc0ccb4ff8d9fe4aa1eb605873e958d8..a9c062f3169f52181a69ca830ab7cfaf1955a1aa 100644 (file)
--- a/src/Translator/decomposeorderresolver.cc
+++ b/src/Translator/decomposeorderresolver.cc
@@ -11,7 +11,7 @@
 #include "ordernode.h"
 #include "ordergraph.h"
 
 #include "ordernode.h"
 #include "ordergraph.h"
 

-DecomposeOrderResolver::DecomposeOrderResolver(Order * _order) :
+DecomposeOrderResolver::DecomposeOrderResolver(Order *_order) :

        graph(NULL),
        order(_order)
 {
        graph(NULL),
        order(_order)
 {


@@ -26,32 +26,32 @@ DecomposeOrderResolver::~DecomposeOrderResolver() {
 void DecomposeOrderResolver::mustOrderEdge(uint64_t first, uint64_t second) {
        DOREdge edge(first, second, 0, first, second);
        if (!edges.contains(&edge)) {
 void DecomposeOrderResolver::mustOrderEdge(uint64_t first, uint64_t second) {
        DOREdge edge(first, second, 0, first, second);
        if (!edges.contains(&edge)) {

-               DOREdge *newedge=new DOREdge(first, second, 0, first, second);
+               DOREdge *newedge = new DOREdge(first, second, 0, first, second);

                edges.add(newedge);
        }
 }
 
 void DecomposeOrderResolver::remapEdge(uint64_t first, uint64_t second, uint64_t newfirst, uint64_t newsecond) {
        DOREdge edge(first, second, 0, first, second);
                edges.add(newedge);
        }
 }
 
 void DecomposeOrderResolver::remapEdge(uint64_t first, uint64_t second, uint64_t newfirst, uint64_t newsecond) {
        DOREdge edge(first, second, 0, first, second);

-       DOREdge *oldedge=edges.get(&edge);
+       DOREdge *oldedge = edges.get(&edge);

        if (oldedge != NULL) {
                edges.remove(oldedge);
        if (oldedge != NULL) {
                edges.remove(oldedge);

-               oldedge->newfirst=newfirst;
-               oldedge->newsecond=newsecond;
+               oldedge->newfirst = newfirst;
+               oldedge->newsecond = newsecond;

                edges.add(oldedge);
        } else {
                edges.add(oldedge);
        } else {

-               DOREdge *newedge=new DOREdge(first, second, 0, newfirst, newsecond);
+               DOREdge *newedge = new DOREdge(first, second, 0, newfirst, newsecond);

                edges.add(newedge);
        }
 }
 
 void DecomposeOrderResolver::setEdgeOrder(uint64_t first, uint64_t second, uint sccNum) {
        DOREdge edge(first, second, 0, first, second);
                edges.add(newedge);
        }
 }
 
 void DecomposeOrderResolver::setEdgeOrder(uint64_t first, uint64_t second, uint sccNum) {
        DOREdge edge(first, second, 0, first, second);

-       DOREdge *oldedge=edges.get(&edge);
+       DOREdge *oldedge = edges.get(&edge);

        if (oldedge != NULL) {
        if (oldedge != NULL) {

-               oldedge->orderindex=sccNum;
+               oldedge->orderindex = sccNum;

        } else {
        } else {

-               DOREdge *newedge=new DOREdge(first, second, sccNum, first, second);
+               DOREdge *newedge = new DOREdge(first, second, sccNum, first, second);

                edges.add(newedge);
        }
 }
                edges.add(newedge);
        }
 }


@@ -60,7 +60,7 @@ void DecomposeOrderResolver::setOrder(uint sccNum, Order *neworder) {
        orders.setExpand(sccNum, neworder);
 }
 
        orders.setExpand(sccNum, neworder);
 }
 

-Order * DecomposeOrderResolver::getOrder(uint sccNum) {
+Order *DecomposeOrderResolver::getOrder(uint sccNum) {

        Order *neworder = NULL;
        if (orders.getSize() > sccNum)
                neworder = orders.get(sccNum);
        Order *neworder = NULL;
        if (orders.getSize() > sccNum)
                neworder = orders.get(sccNum);


@@ -70,12 +70,12 @@ Order * DecomposeOrderResolver::getOrder(uint sccNum) {
 void DecomposeOrderResolver::buildGraph() {
        graph = new OrderGraph(order);
        SetIteratorDOREdge *iterator = edges.iterator();
 void DecomposeOrderResolver::buildGraph() {
        graph = new OrderGraph(order);
        SetIteratorDOREdge *iterator = edges.iterator();

-       while(iterator->hasNext()) {
-               DOREdge * doredge = iterator->next();
+       while (iterator->hasNext()) {
+               DOREdge *doredge = iterator->next();

                if (doredge->orderindex == 0) {
                        graph->addEdge(doredge->origfirst, doredge->origsecond);
                } else {
                if (doredge->orderindex == 0) {
                        graph->addEdge(doredge->origfirst, doredge->origsecond);
                } else {

-                       Order * suborder = orders.get(doredge->orderindex);
+                       Order *suborder = orders.get(doredge->orderindex);

                        bool isEdge = suborder->encoding.resolver->resolveOrder(doredge->newfirst, doredge->newsecond);
                        if (isEdge)
                                graph->addEdge(doredge->origfirst, doredge->origsecond);
                        bool isEdge = suborder->encoding.resolver->resolveOrder(doredge->newfirst, doredge->newsecond);
                        if (isEdge)
                                graph->addEdge(doredge->origfirst, doredge->origsecond);

diff --git a/src/Translator/decomposeorderresolver.h b/src/Translator/decomposeorderresolver.h
index a6bf955d8c64a5635651c565fb9b604775183f42..a2603096d036efbc2aaf38ae110c0d3cbacc6dcf 100644 (file)
--- a/src/Translator/decomposeorderresolver.h
+++ b/src/Translator/decomposeorderresolver.h
@@ -14,14 +14,14 @@
 #include "orderresolver.h"
 
 class DOREdge {
 #include "orderresolver.h"
 
 class DOREdge {

- public:
- DOREdge(uint64_t _origfirst, uint64_t _origsecond, uint _orderindex, uint64_t _newfirst, uint64_t _newsecond) :
-         origfirst(_origfirst),
+public:
+       DOREdge(uint64_t _origfirst, uint64_t _origsecond, uint _orderindex, uint64_t _newfirst, uint64_t _newsecond) :
+               origfirst(_origfirst),

                origsecond(_origsecond),
                orderindex(_orderindex),
                newfirst(_newfirst),
                newsecond(_newsecond) {
                origsecond(_origsecond),
                orderindex(_orderindex),
                newfirst(_newfirst),
                newsecond(_newsecond) {

-       }               
+       }

        uint64_t origfirst;
        uint64_t origsecond;
        uint orderindex;
        uint64_t origfirst;
        uint64_t origsecond;
        uint orderindex;


@@ -39,10 +39,10 @@ public:
        void remapEdge(uint64_t oldfirst, uint64_t oldsecond, uint64_t newfirst, uint64_t newsecond);
        void setEdgeOrder(uint64_t first, uint64_t second, uint sccNum);
        void setOrder(uint sccNum, Order *order);
        void remapEdge(uint64_t oldfirst, uint64_t oldsecond, uint64_t newfirst, uint64_t newsecond);
        void setEdgeOrder(uint64_t first, uint64_t second, uint sccNum);
        void setOrder(uint sccNum, Order *order);

-       Order * getOrder(uint sccNum);
+       Order *getOrder(uint sccNum);

        CMEMALLOC;
        CMEMALLOC;

-       
- private:
+
+private:

        bool resolvePartialOrder(OrderNode *first, OrderNode *second);
        void buildGraph();
        OrderGraph *graph;
        bool resolvePartialOrder(OrderNode *first, OrderNode *second);
        void buildGraph();
        OrderGraph *graph;