chromium/third_party/angle/src/compiler/translator/tree_util/IntermTraverse.cpp

//
// Copyright 2002 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.
//

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

#include "compiler/translator/Compiler.h"
#include "compiler/translator/InfoSink.h"
#include "compiler/translator/SymbolTable.h"
#include "compiler/translator/tree_util/IntermNode_util.h"
#include "compiler/translator/util.h"

namespace sh
{

// Traverse the intermediate representation tree, and call a node type specific visit function for
// each node. Traversal is done recursively through the node member function traverse(). Nodes with
// children can have their whole subtree skipped if preVisit is turned on and the type specific
// function returns false.
template <typename T>
void TIntermTraverser::traverse(T *node)
{ … }

// Instantiate template for RewriteAtomicFunctionExpressions, in case this gets inlined thus not
// exported from the TU.
template void TIntermTraverser::traverse(TIntermNode *);

void TIntermNode::traverse(TIntermTraverser *it)
{ … }

void TIntermSymbol::traverse(TIntermTraverser *it)
{ … }

void TIntermConstantUnion::traverse(TIntermTraverser *it)
{ … }

void TIntermFunctionPrototype::traverse(TIntermTraverser *it)
{ … }

void TIntermBinary::traverse(TIntermTraverser *it)
{ … }

void TIntermUnary::traverse(TIntermTraverser *it)
{ … }

void TIntermFunctionDefinition::traverse(TIntermTraverser *it)
{ … }

void TIntermBlock::traverse(TIntermTraverser *it)
{ … }

void TIntermAggregate::traverse(TIntermTraverser *it)
{ … }

void TIntermLoop::traverse(TIntermTraverser *it)
{ … }

void TIntermPreprocessorDirective::traverse(TIntermTraverser *it)
{ … }

bool TIntermSymbol::visit(Visit visit, TIntermTraverser *it)
{ … }

bool TIntermConstantUnion::visit(Visit visit, TIntermTraverser *it)
{ … }

bool TIntermFunctionPrototype::visit(Visit visit, TIntermTraverser *it)
{ … }

bool TIntermFunctionDefinition::visit(Visit visit, TIntermTraverser *it)
{ … }

bool TIntermUnary::visit(Visit visit, TIntermTraverser *it)
{ … }

bool TIntermSwizzle::visit(Visit visit, TIntermTraverser *it)
{ … }

bool TIntermBinary::visit(Visit visit, TIntermTraverser *it)
{ … }

bool TIntermTernary::visit(Visit visit, TIntermTraverser *it)
{ … }

bool TIntermAggregate::visit(Visit visit, TIntermTraverser *it)
{ … }

bool TIntermDeclaration::visit(Visit visit, TIntermTraverser *it)
{ … }

bool TIntermGlobalQualifierDeclaration::visit(Visit visit, TIntermTraverser *it)
{ … }

bool TIntermBlock::visit(Visit visit, TIntermTraverser *it)
{ … }

bool TIntermIfElse::visit(Visit visit, TIntermTraverser *it)
{ … }

bool TIntermLoop::visit(Visit visit, TIntermTraverser *it)
{ … }

bool TIntermBranch::visit(Visit visit, TIntermTraverser *it)
{ … }

bool TIntermSwitch::visit(Visit visit, TIntermTraverser *it)
{ … }

bool TIntermCase::visit(Visit visit, TIntermTraverser *it)
{ … }

bool TIntermPreprocessorDirective::visit(Visit visit, TIntermTraverser *it)
{ … }

TIntermTraverser::TIntermTraverser(bool preVisit,
                                   bool inVisit,
                                   bool postVisit,
                                   TSymbolTable *symbolTable)
    : … { … }

TIntermTraverser::~TIntermTraverser() { … }

void TIntermTraverser::setMaxAllowedDepth(int depth)
{ … }

const TIntermBlock *TIntermTraverser::getParentBlock() const
{ … }

void TIntermTraverser::pushParentBlock(TIntermBlock *node)
{ … }

void TIntermTraverser::incrementParentBlockPos()
{ … }

void TIntermTraverser::popParentBlock()
{ … }

void TIntermTraverser::insertStatementsInParentBlock(const TIntermSequence &insertions)
{ … }

void TIntermTraverser::insertStatementsInParentBlock(const TIntermSequence &insertionsBefore,
                                                     const TIntermSequence &insertionsAfter)
{ … }

void TIntermTraverser::insertStatementInParentBlock(TIntermNode *statement)
{ … }

void TIntermTraverser::insertStatementsInBlockAtPosition(TIntermBlock *parent,
                                                         size_t position,
                                                         const TIntermSequence &insertionsBefore,
                                                         const TIntermSequence &insertionsAfter)
{ … }

void TLValueTrackingTraverser::setInFunctionCallOutParameter(bool inOutParameter)
{ … }

bool TLValueTrackingTraverser::isInFunctionCallOutParameter() const
{ … }

void TIntermTraverser::traverseBinary(TIntermBinary *node)
{ … }

void TLValueTrackingTraverser::traverseBinary(TIntermBinary *node)
{ … }

void TIntermTraverser::traverseUnary(TIntermUnary *node)
{ … }

void TLValueTrackingTraverser::traverseUnary(TIntermUnary *node)
{ … }

// Traverse a function definition node. This keeps track of global scope.
void TIntermTraverser::traverseFunctionDefinition(TIntermFunctionDefinition *node)
{ … }

// Traverse a block node. This keeps track of the position of traversed child nodes within the block
// so that nodes may be inserted before or after them.
void TIntermTraverser::traverseBlock(TIntermBlock *node)
{ … }

void TIntermTraverser::traverseAggregate(TIntermAggregate *node)
{ … }

bool TIntermTraverser::CompareInsertion(const NodeInsertMultipleEntry &a,
                                        const NodeInsertMultipleEntry &b)
{ … }

bool TIntermTraverser::updateTree(TCompiler *compiler, TIntermNode *node)
{ … }

void TIntermTraverser::clearReplacementQueue()
{ … }

void TIntermTraverser::queueReplacement(TIntermNode *replacement, OriginalNode originalStatus)
{ … }

void TIntermTraverser::queueReplacementWithParent(TIntermNode *parent,
                                                  TIntermNode *original,
                                                  TIntermNode *replacement,
                                                  OriginalNode originalStatus)
{ … }

void TIntermTraverser::queueAccessChainReplacement(TIntermTyped *replacement)
{ … }

TLValueTrackingTraverser::TLValueTrackingTraverser(bool preVisitIn,
                                                   bool inVisitIn,
                                                   bool postVisitIn,
                                                   TSymbolTable *symbolTable)
    : … { … }

void TLValueTrackingTraverser::traverseAggregate(TIntermAggregate *node)
{ … }

void TIntermTraverser::traverseLoop(TIntermLoop *node)
{ … }
}  // namespace sh