FoldExpressions.cpp

Enable keyboard shortcuts

//

// Copyright 2018 The ANGLE Project Authors. All rights reserved.

// Use of this source code is governed by a BSD-style license that can be

// found in the LICENSE file.

//

// FoldExpressions.cpp: Fold expressions. This may fold expressions so that the qualifier of the

// folded node differs from the qualifier of the original expression, so it needs to be done after

// parsing and validation of qualifiers is complete. Expressions that are folded:

//  1. Ternary ops with a constant condition.

//  2. Sequence aka comma ops where the left side has no side effects.

//  3. Any expressions containing any of the above.

#include "compiler/translator/tree_ops/FoldExpressions.h"

#include "compiler/translator/Diagnostics.h"

#include "compiler/translator/IntermNode.h"

#include "compiler/translator/tree_util/IntermTraverse.h"

namespace sh

namespace

class FoldExpressionsTraverser : public TIntermTraverser

  public:

    FoldExpressionsTraverser(TDiagnostics *diagnostics)

        : TIntermTraverser(true, false, false), mDiagnostics(diagnostics), mDidReplace(false)

{}

    bool didReplace() { return mDidReplace; }

    void nextIteration() { mDidReplace = false; }

  protected:

    bool visitTernary(Visit visit, TIntermTernary *node) override

        TIntermTyped *folded = node->fold(mDiagnostics);

        if (folded != node)

            queueReplacement(folded, OriginalNode::IS_DROPPED);

            mDidReplace = true;

            return false;

        return true;

    bool visitAggregate(Visit visit, TIntermAggregate *node) override

        TIntermTyped *folded = node->fold(mDiagnostics);

        if (folded != node)

            queueReplacement(folded, OriginalNode::IS_DROPPED);

            mDidReplace = true;

            return false;

        return true;

    bool visitBinary(Visit visit, TIntermBinary *node) override

        TIntermTyped *folded = node->fold(mDiagnostics);

        if (folded != node)

            queueReplacement(folded, OriginalNode::IS_DROPPED);

            mDidReplace = true;

            return false;

        return true;

    bool visitUnary(Visit visit, TIntermUnary *node) override

        TIntermTyped *folded = node->fold(mDiagnostics);

        if (folded != node)

            queueReplacement(folded, OriginalNode::IS_DROPPED);

            mDidReplace = true;

            return false;

        return true;

    bool visitSwizzle(Visit visit, TIntermSwizzle *node) override

        TIntermTyped *folded = node->fold(mDiagnostics);

        if (folded != node)

            queueReplacement(folded, OriginalNode::IS_DROPPED);

            mDidReplace = true;

            return false;

        return true;

  private:

    TDiagnostics *mDiagnostics;

    bool mDidReplace;

};

}  // anonymous namespace

bool FoldExpressions(TCompiler *compiler, TIntermBlock *root, TDiagnostics *diagnostics)

    FoldExpressionsTraverser traverser(diagnostics);

do

        traverser.nextIteration();

        root->traverse(&traverser);

        if (!traverser.updateTree(compiler, root))

            return false;

    } while (traverser.didReplace());

    return true;

}  // namespace sh