chromium/third_party/angle/src/compiler/translator/IntermNode.h

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

//
// Definition of the in-memory high-level intermediate representation
// of shaders.  This is a tree that parser creates.
//
// Nodes in the tree are defined as a hierarchy of classes derived from
// TIntermNode. Each is a node in a tree.  There is no preset branching factor;
// each node can have it's own type of list of children.
//

#ifndef COMPILER_TRANSLATOR_INTERMNODE_H_
#define COMPILER_TRANSLATOR_INTERMNODE_H_

#include "GLSLANG/ShaderLang.h"

#include <algorithm>
#include <queue>

#include "common/angleutils.h"
#include "compiler/translator/Common.h"
#include "compiler/translator/ConstantUnion.h"
#include "compiler/translator/ImmutableString.h"
#include "compiler/translator/Operator_autogen.h"
#include "compiler/translator/SymbolUniqueId.h"
#include "compiler/translator/Types.h"
#include "compiler/translator/tree_util/Visit.h"

namespace sh
{

class TDiagnostics;

class TIntermTraverser;
class TIntermAggregate;
class TIntermBlock;
class TIntermGlobalQualifierDeclaration;
class TIntermDeclaration;
class TIntermFunctionPrototype;
class TIntermFunctionDefinition;
class TIntermSwizzle;
class TIntermBinary;
class TIntermUnary;
class TIntermConstantUnion;
class TIntermTernary;
class TIntermIfElse;
class TIntermSwitch;
class TIntermCase;
class TIntermTyped;
class TIntermSymbol;
class TIntermLoop;
class TInfoSink;
class TInfoSinkBase;
class TIntermBranch;
class TIntermPreprocessorDirective;

class TSymbolTable;
class TFunction;
class TVariable;

//
// Base class for the tree nodes
//
class TIntermNode : angle::NonCopyable
{ … };

//
// This is just to help yacc.
//
struct TIntermNodePair
{ … };

//
// Intermediate class for nodes that have a type.
//
class TIntermTyped : public TIntermNode
{ … };

//
// Handle for, do-while, and while loops.
//
enum TLoopType
{ … };

class TIntermLoop : public TIntermNode
{ … };

//
// Handle break, continue, return, and kill.
//
class TIntermBranch : public TIntermNode
{ … };

// Nodes that correspond to variable symbols in the source code. These may be regular variables or
// interface block instances. In declarations that only declare a struct type but no variables, a
// TIntermSymbol node with an empty variable is used to store the type.
class TIntermSymbol : public TIntermTyped
{ … };

// A typed expression that is not just representing a symbol table symbol.
class TIntermExpression : public TIntermTyped
{ … };

// Constant folded node.
// Note that nodes may be constant folded and not be constant expressions with the EvqConst
// qualifier. This happens for example when the following expression is processed:
// "true ? 1.0 : non_constant"
// Other nodes than TIntermConstantUnion may also be constant expressions.
//
class TIntermConstantUnion : public TIntermExpression
{ … };

//
// Intermediate class for node types that hold operators.
//
class TIntermOperator : public TIntermExpression
{ … };

// Node for vector swizzles.
class TIntermSwizzle : public TIntermExpression
{ … };

//
// Nodes for all the basic binary math operators.
//
class TIntermBinary : public TIntermOperator
{ … };

//
// Nodes for unary math operators.
//
class TIntermUnary : public TIntermOperator
{ … };

TIntermSequence;
TQualifierList;

// Interface for node classes that have an arbitrarily sized set of children.
class TIntermAggregateBase
{ … };

//
// Nodes that operate on an arbitrary sized set of children.
//
class TIntermAggregate : public TIntermOperator, public TIntermAggregateBase
{ … };

// A list of statements. Either the root node which contains declarations and function definitions,
// or a block that can be marked with curly braces {}.
class TIntermBlock : public TIntermNode, public TIntermAggregateBase
{ … };

// Function prototype. May be in the AST either as a function prototype declaration or as a part of
// a function definition. The type of the node is the function return type.
class TIntermFunctionPrototype : public TIntermTyped
{ … };

// Node for function definitions. The prototype child node stores the function header including
// parameters, and the body child node stores the function body.
class TIntermFunctionDefinition : public TIntermNode
{ … };

// Struct, interface block or variable declaration. Can contain multiple variable declarators.
class TIntermDeclaration : public TIntermNode, public TIntermAggregateBase
{ … };

// Specialized declarations for attributing invariance.
class TIntermGlobalQualifierDeclaration : public TIntermNode
{ … };

// For ternary operators like a ? b : c.
class TIntermTernary : public TIntermExpression
{ … };

class TIntermIfElse : public TIntermNode
{ … };

//
// Switch statement.
//
class TIntermSwitch : public TIntermNode
{ … };

//
// Case label.
//
class TIntermCase : public TIntermNode
{ … };

//
// Preprocessor Directive.
//  #ifdef, #define, #if, #endif, etc.
//

enum class PreprocessorDirective
{ … };

class TIntermPreprocessorDirective final : public TIntermNode
{ … };

inline TIntermBlock *TIntermLoop::EnsureBody(TIntermBlock *body)
{ … }

}  // namespace sh

#endif  // COMPILER_TRANSLATOR_INTERMNODE_H_