Fix tabbing

[satune.git] / src / ASTTransform / elementopt.cc

diff --git a/src/ASTTransform/elementopt.cc b/src/ASTTransform/elementopt.cc
old mode 100755 (executable)
new mode 100644 (file)
index 3f1f892..6fec155
--- a/src/ASTTransform/elementopt.cc
+++ b/src/ASTTransform/elementopt.cc
@@ -9,7 +9,7 @@
 
 ElementOpt::ElementOpt(CSolver *_solver)
        : Transform(_solver),
-               updateSets(solver->getTuner()->getTunable(ELEMENTOPTSETS, &onoff) == 1)
+       updateSets(solver->getTuner()->getTunable(ELEMENTOPTSETS, &onoff) == 1)
 {
 }
 
@@ -19,7 +19,7 @@ ElementOpt::~ElementOpt() {
 void ElementOpt::doTransform() {
        if (solver->getTuner()->getTunable(ELEMENTOPT, &onoff) == 0)
                return;
-       
+
        SetIteratorBooleanEdge *iterator = solver->getConstraints();
        while (iterator->hasNext()) {
                BooleanEdge constraint = iterator->next();
@@ -27,38 +27,38 @@ void ElementOpt::doTransform() {
                        workList.push((BooleanPredicate *)constraint.getBoolean());
        }
        while (workList.getSize() != 0) {
-               BooleanPredicate * pred = workList.last(); workList.pop();
+               BooleanPredicate *pred = workList.last(); workList.pop();
                processPredicate(pred);
        }
        delete iterator;
 }
 
-void ElementOpt::processPredicate(BooleanPredicate * pred) {
+void ElementOpt::processPredicate(BooleanPredicate *pred) {
        uint numInputs = pred->inputs.getSize();
        if (numInputs != 2)
                return;
 
-       Predicate * p = pred->getPredicate();
+       Predicate *p = pred->getPredicate();
        if (p->type == TABLEPRED)
-                       return;
+               return;
 
-       PredicateOperator * pop = (PredicateOperator *) p;
+       PredicateOperator *pop = (PredicateOperator *) p;
        CompOp op = pop->getOp();
 
-       Element * left = pred->inputs.get(0);
-       Element * right = pred->inputs.get(1);
+       Element *left = pred->inputs.get(0);
+       Element *right = pred->inputs.get(1);
 
        if (left->type == ELEMCONST) {
-               Element * tmp = left;
+               Element *tmp = left;
                left = right;
                right = tmp;
                op = flipOp(op);
        } else if (right->type != ELEMCONST)
                return;
 
-       if (left->type !=ELEMSET)
+       if (left->type != ELEMSET)
                return;
-       
+
        if (op == SATC_EQUALS) {
                handlePredicateEquals(pred, (ElementSet *) left, (ElementConst *) right);
        } else if (updateSets) {
@@ -75,8 +75,8 @@ void ElementOpt::handlePredicateEquals(BooleanPredicate *pred, ElementSet *left,
 }
 
 void ElementOpt::handlePredicateInequality(BooleanPredicate *pred, ElementSet *var, ElementConst *value) {
-       Predicate * p = pred->getPredicate();
-       PredicateOperator * pop = (PredicateOperator *) p;
+       Predicate *p = pred->getPredicate();
+       PredicateOperator *pop = (PredicateOperator *) p;
        CompOp op = pop->getOp();
 
        if (pred->isFalse()) {
@@ -85,18 +85,18 @@ void ElementOpt::handlePredicateInequality(BooleanPredicate *pred, ElementSet *v
                ASSERT(0);
        }
 
-       Set * s = var->getRange();
+       Set *s = var->getRange();
        if (s->isRange)
                return;
-       
+
        uint size = s->getSize();
        uint64_t elemArray[size];
        uint count = 0;
        uint64_t cvalue = value->value;
 
-       switch(op) {
+       switch (op) {
        case SATC_LT: {
-               for(uint i=0; i<size; i++) {
+               for (uint i = 0; i < size; i++) {
                        uint64_t val = s->getElement(i);
                        if (val < cvalue)
                                elemArray[count++] = val;
@@ -104,7 +104,7 @@ void ElementOpt::handlePredicateInequality(BooleanPredicate *pred, ElementSet *v
                break;
        }
        case SATC_GT: {
-               for(uint i=0; i<size; i++) {
+               for (uint i = 0; i < size; i++) {
                        uint64_t val = s->getElement(i);
                        if (val > cvalue)
                                elemArray[count++] = val;
@@ -112,7 +112,7 @@ void ElementOpt::handlePredicateInequality(BooleanPredicate *pred, ElementSet *v
                break;
        }
        case SATC_LTE: {
-               for(uint i=0; i<size; i++) {
+               for (uint i = 0; i < size; i++) {
                        uint64_t val = s->getElement(i);
                        if (val <= cvalue)
                                elemArray[count++] = val;
@@ -120,40 +120,40 @@ void ElementOpt::handlePredicateInequality(BooleanPredicate *pred, ElementSet *v
                break;
        }
        case SATC_GTE: {
-               for(uint i=0; i<size; i++) {
+               for (uint i = 0; i < size; i++) {
                        uint64_t val = s->getElement(i);
                        if (val >= cvalue)
                                elemArray[count++] = val;
                }
                break;
        }
-               
+
        default:
                ASSERT(0);
        }
        if (size == count)
                return;
-       
+
        Set *newset = solver->createSet(s->type, elemArray, count);
        solver->elemMap.remove(var);
        var->set = newset;
        solver->elemMap.put(var, var);
 
        if (count == 1) {
-               ElementConst * elemconst = (ElementConst *) solver->getElementConst(s->type, elemArray[0]);
+               ElementConst *elemconst = (ElementConst *) solver->getElementConst(s->type, elemArray[0]);
                replaceVarWithConst(pred, var, elemconst);
        }
 }
 
 void ElementOpt::constrainVarWithConst(BooleanPredicate *pred, ElementSet *var, ElementConst *value) {
-       Set * s = var->getRange();
+       Set *s = var->getRange();
        if (s->isRange)
                return;
        uint size = s->getSize();
        uint64_t elemArray[size];
        uint count = 0;
        uint64_t cvalue = value->value;
-       for(uint i=0; i<size; i++) {
+       for (uint i = 0; i < size; i++) {
                uint64_t val = s->getElement(i);
                if (val != cvalue)
                        elemArray[count++] = val;
@@ -167,19 +167,19 @@ void ElementOpt::constrainVarWithConst(BooleanPredicate *pred, ElementSet *var,
        solver->elemMap.put(var, var);
 
        if (count == 1) {
-               ElementConst * elemconst = (ElementConst *) solver->getElementConst(s->type, elemArray[0]);
+               ElementConst *elemconst = (ElementConst *) solver->getElementConst(s->type, elemArray[0]);
                replaceVarWithConst(pred, var, elemconst);
        }
 }
 
-void ElementOpt::replaceVarWithConst(BooleanPredicate * pred, ElementSet *var, ElementConst * value) {
+void ElementOpt::replaceVarWithConst(BooleanPredicate *pred, ElementSet *var, ElementConst *value) {
        uint size = var->parents.getSize();
-       for(uint i=0; i < size; i++) {
-               ASTNode * parent = var->parents.get(i);
+       for (uint i = 0; i < size; i++) {
+               ASTNode *parent = var->parents.get(i);
                if (parent->type == PREDICATEOP && pred != parent) {
-                       BooleanPredicate * newpred = (BooleanPredicate *) parent;
-                       for(uint j=0; j < newpred->inputs.getSize(); j++) {
-                               Element * e = newpred->inputs.get(j);
+                       BooleanPredicate *newpred = (BooleanPredicate *) parent;
+                       for (uint j = 0; j < newpred->inputs.getSize(); j++) {
+                               Element *e = newpred->inputs.get(j);
                                if (e == var) {
                                        solver->boolMap.remove(newpred);
                                        newpred->inputs.set(j, value);