1 files changed, 51 insertions, 755 deletions

diff --git a/src/3rdparty/angle/src/compiler/translator/intermediate.h b/src/3rdparty/angle/src/compiler/translator/intermediate.h
index 892f2849e0..3b7e7bd802 100644
--- a/src/3rdparty/angle/src/compiler/translator/intermediate.h
+++ b/src/3rdparty/angle/src/compiler/translator/intermediate.h
@@ -4,768 +4,64 @@
 // 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_INTERMEDIATE_H_
-#define COMPILER_TRANSLATOR_INTERMEDIATE_H_
-
-#include "GLSLANG/ShaderLang.h"
-
-#include <algorithm>
-#include <queue>
-
-#include "compiler/translator/Common.h"
-#include "compiler/translator/Types.h"
-#include "compiler/translator/ConstantUnion.h"
-
-//
-// Operators used by the high-level (parse tree) representation.
-//
-enum TOperator
-{
-    EOpNull,            // if in a node, should only mean a node is still being built
-    EOpSequence,        // denotes a list of statements, or parameters, etc.
-    EOpFunctionCall,
-    EOpFunction,        // For function definition
-    EOpParameters,      // an aggregate listing the parameters to a function
-
-    EOpDeclaration,
-    EOpPrototype,
-
-    //
-    // Unary operators
-    //
-
-    EOpNegative,
-    EOpLogicalNot,
-    EOpVectorLogicalNot,
-
-    EOpPostIncrement,
-    EOpPostDecrement,
-    EOpPreIncrement,
-    EOpPreDecrement,
-
-    //
-    // binary operations
-    //
-
-    EOpAdd,
-    EOpSub,
-    EOpMul,
-    EOpDiv,
-    EOpEqual,
-    EOpNotEqual,
-    EOpVectorEqual,
-    EOpVectorNotEqual,
-    EOpLessThan,
-    EOpGreaterThan,
-    EOpLessThanEqual,
-    EOpGreaterThanEqual,
-    EOpComma,
-
-    EOpVectorTimesScalar,
-    EOpVectorTimesMatrix,
-    EOpMatrixTimesVector,
-    EOpMatrixTimesScalar,
-
-    EOpLogicalOr,
-    EOpLogicalXor,
-    EOpLogicalAnd,
-
-    EOpIndexDirect,
-    EOpIndexIndirect,
-    EOpIndexDirectStruct,
-    EOpIndexDirectInterfaceBlock,
-
-    EOpVectorSwizzle,
-
-    //
-    // Built-in functions potentially mapped to operators
-    //
-
-    EOpRadians,
-    EOpDegrees,
-    EOpSin,
-    EOpCos,
-    EOpTan,
-    EOpAsin,
-    EOpAcos,
-    EOpAtan,
-
-    EOpPow,
-    EOpExp,
-    EOpLog,
-    EOpExp2,
-    EOpLog2,
-    EOpSqrt,
-    EOpInverseSqrt,
-
-    EOpAbs,
-    EOpSign,
-    EOpFloor,
-    EOpCeil,
-    EOpFract,
-    EOpMod,
-    EOpMin,
-    EOpMax,
-    EOpClamp,
-    EOpMix,
-    EOpStep,
-    EOpSmoothStep,
-
-    EOpLength,
-    EOpDistance,
-    EOpDot,
-    EOpCross,
-    EOpNormalize,
-    EOpFaceForward,
-    EOpReflect,
-    EOpRefract,
-
-    EOpDFdx,            // Fragment only, OES_standard_derivatives extension
-    EOpDFdy,            // Fragment only, OES_standard_derivatives extension
-    EOpFwidth,          // Fragment only, OES_standard_derivatives extension
-
-    EOpMatrixTimesMatrix,
-
-    EOpAny,
-    EOpAll,
-
-    //
-    // Branch
-    //
-
-    EOpKill,            // Fragment only
-    EOpReturn,
-    EOpBreak,
-    EOpContinue,
-
-    //
-    // Constructors
-    //
-
-    EOpConstructInt,
-    EOpConstructUInt,
-    EOpConstructBool,
-    EOpConstructFloat,
-    EOpConstructVec2,
-    EOpConstructVec3,
-    EOpConstructVec4,
-    EOpConstructBVec2,
-    EOpConstructBVec3,
-    EOpConstructBVec4,
-    EOpConstructIVec2,
-    EOpConstructIVec3,
-    EOpConstructIVec4,
-    EOpConstructUVec2,
-    EOpConstructUVec3,
-    EOpConstructUVec4,
-    EOpConstructMat2,
-    EOpConstructMat3,
-    EOpConstructMat4,
-    EOpConstructStruct,
-
-    //
-    // moves
-    //
-
-    EOpAssign,
-    EOpInitialize,
-    EOpAddAssign,
-    EOpSubAssign,
-    EOpMulAssign,
-    EOpVectorTimesMatrixAssign,
-    EOpVectorTimesScalarAssign,
-    EOpMatrixTimesScalarAssign,
-    EOpMatrixTimesMatrixAssign,
-    EOpDivAssign
-};
-
-class TIntermTraverser;
-class TIntermAggregate;
-class TIntermBinary;
-class TIntermUnary;
-class TIntermConstantUnion;
-class TIntermSelection;
-class TIntermTyped;
-class TIntermSymbol;
-class TIntermLoop;
-class TInfoSink;
-class TIntermRaw;
-
-//
-// Base class for the tree nodes
-//
-class TIntermNode
-{
-  public:
-    POOL_ALLOCATOR_NEW_DELETE();
-    TIntermNode()
-    {
-        // TODO: Move this to TSourceLoc constructor
-        // after getting rid of TPublicType.
-        mLine.first_file = mLine.last_file = 0;
-        mLine.first_line = mLine.last_line = 0;
-    }
-    virtual ~TIntermNode() { }
-
-    const TSourceLoc &getLine() const { return mLine; }
-    void setLine(const TSourceLoc &l) { mLine = l; }
-
-    virtual void traverse(TIntermTraverser *) = 0;
-    virtual TIntermTyped *getAsTyped() { return 0; }
-    virtual TIntermConstantUnion *getAsConstantUnion() { return 0; }
-    virtual TIntermAggregate *getAsAggregate() { return 0; }
-    virtual TIntermBinary *getAsBinaryNode() { return 0; }
-    virtual TIntermUnary *getAsUnaryNode() { return 0; }
-    virtual TIntermSelection *getAsSelectionNode() { return 0; }
-    virtual TIntermSymbol *getAsSymbolNode() { return 0; }
-    virtual TIntermLoop *getAsLoopNode() { return 0; }
-    virtual TIntermRaw *getAsRawNode() { return 0; }
-
-    // Replace a child node. Return true if |original| is a child
-    // node and it is replaced; otherwise, return false.
-    virtual bool replaceChildNode(
-        TIntermNode *original, TIntermNode *replacement) = 0;
-
-    // For traversing a tree in no particular order, but using
-    // heap memory.
-    virtual void enqueueChildren(std::queue<TIntermNode *> *nodeQueue) const = 0;
-
-  protected:
-    TSourceLoc mLine;
-};
-
-//
-// This is just to help yacc.
-//
-struct TIntermNodePair
-{
-    TIntermNode *node1;
-    TIntermNode *node2;
-};
-
-//
-// Intermediate class for nodes that have a type.
-//
-class TIntermTyped : public TIntermNode
-{
-  public:
-    TIntermTyped(const TType &t) : mType(t)  { }
-    virtual TIntermTyped *getAsTyped() { return this; }
+#ifndef COMPILER_TRANSLATOR_LOCAL_INTERMEDIATE_H_
+#define COMPILER_TRANSLATOR_LOCAL_INTERMEDIATE_H_
 
-    virtual bool hasSideEffects() const = 0;
+#include "compiler/translator/IntermNode.h"
 
-    void setType(const TType &t) { mType = t; }
-    const TType &getType() const { return mType; }
-    TType *getTypePointer() { return &mType; }
-
-    TBasicType getBasicType() const { return mType.getBasicType(); }
-    TQualifier getQualifier() const { return mType.getQualifier(); }
-    TPrecision getPrecision() const { return mType.getPrecision(); }
-    int getCols() const { return mType.getCols(); }
-    int getRows() const { return mType.getRows(); }
-    int getNominalSize() const { return mType.getNominalSize(); }
-    int getSecondarySize() const { return mType.getSecondarySize(); }
-
-    bool isInterfaceBlock() const { return mType.isInterfaceBlock(); }
-    bool isMatrix() const { return mType.isMatrix(); }
-    bool isArray()  const { return mType.isArray(); }
-    bool isVector() const { return mType.isVector(); }
-    bool isScalar() const { return mType.isScalar(); }
-    bool isScalarInt() const { return mType.isScalarInt(); }
-    const char *getBasicString() const { return mType.getBasicString(); }
-    const char *getQualifierString() const { return mType.getQualifierString(); }
-    TString getCompleteString() const { return mType.getCompleteString(); }
-
-    int getArraySize() const { return mType.getArraySize(); }
-
-  protected:
-    TType mType;
-};
-
-//
-// Handle for, do-while, and while loops.
-//
-enum TLoopType
+struct TVectorFields
 {
-    ELoopFor,
-    ELoopWhile,
-    ELoopDoWhile
-};
-
-class TIntermLoop : public TIntermNode
-{
-  public:
-    TIntermLoop(TLoopType type,
-                TIntermNode *init, TIntermTyped *cond, TIntermTyped *expr,
-                TIntermNode *body)
-        : mType(type),
-          mInit(init),
-          mCond(cond),
-          mExpr(expr),
-          mBody(body),
-          mUnrollFlag(false) { }
-
-    virtual TIntermLoop *getAsLoopNode() { return this; }
-    virtual void traverse(TIntermTraverser *);
-    virtual bool replaceChildNode(
-        TIntermNode *original, TIntermNode *replacement);
-
-    TLoopType getType() const { return mType; }
-    TIntermNode *getInit() { return mInit; }
-    TIntermTyped *getCondition() { return mCond; }
-    TIntermTyped *getExpression() { return mExpr; }
-    TIntermNode *getBody() { return mBody; }
-
-    void setUnrollFlag(bool flag) { mUnrollFlag = flag; }
-    bool getUnrollFlag() const { return mUnrollFlag; }
-
-    virtual void enqueueChildren(std::queue<TIntermNode *> *nodeQueue) const;
-
-  protected:
-    TLoopType mType;
-    TIntermNode *mInit;  // for-loop initialization
-    TIntermTyped *mCond; // loop exit condition
-    TIntermTyped *mExpr; // for-loop expression
-    TIntermNode *mBody;  // loop body
-
-    bool mUnrollFlag; // Whether the loop should be unrolled or not.
+    int offsets[4];
+    int num;
 };
 
 //
-// Handle break, continue, return, and kill.
+// Set of helper functions to help parse and build the tree.
 //
-class TIntermBranch : public TIntermNode
-{
-  public:
-    TIntermBranch(TOperator op, TIntermTyped *e)
-        : mFlowOp(op),
-          mExpression(e) { }
-
-    virtual void traverse(TIntermTraverser *);
-    virtual bool replaceChildNode(
-        TIntermNode *original, TIntermNode *replacement);
-
-    TOperator getFlowOp() { return mFlowOp; }
-    TIntermTyped* getExpression() { return mExpression; }
-
-    virtual void enqueueChildren(std::queue<TIntermNode *> *nodeQueue) const;
-
-protected:
-    TOperator mFlowOp;
-    TIntermTyped *mExpression;  // non-zero except for "return exp;" statements
-};
-
-//
-// Nodes that correspond to symbols or constants in the source code.
-//
-class TIntermSymbol : public TIntermTyped
-{
-  public:
-    // if symbol is initialized as symbol(sym), the memory comes from the poolallocator of sym.
-    // If sym comes from per process globalpoolallocator, then it causes increased memory usage
-    // per compile it is essential to use "symbol = sym" to assign to symbol
-    TIntermSymbol(int id, const TString &symbol, const TType &type)
-        : TIntermTyped(type),
-          mId(id)
-    {
-        mSymbol = symbol;
-    }
-
-    virtual bool hasSideEffects() const { return false; }
-
-    int getId() const { return mId; }
-    const TString &getSymbol() const { return mSymbol; }
-
-    void setId(int newId) { mId = newId; }
-
-    virtual void traverse(TIntermTraverser *);
-    virtual TIntermSymbol *getAsSymbolNode() { return this; }
-    virtual bool replaceChildNode(TIntermNode *, TIntermNode *) { return false; }
-
-    virtual void enqueueChildren(std::queue<TIntermNode *> *nodeQueue) const {}
-
-  protected:
-    int mId;
-    TString mSymbol;
-};
-
-// A Raw node stores raw code, that the translator will insert verbatim
-// into the output stream. Useful for transformation operations that make
-// complex code that might not fit naturally into the GLSL model.
-class TIntermRaw : public TIntermTyped
-{
-  public:
-    TIntermRaw(const TType &type, const TString &rawText)
-        : TIntermTyped(type),
-          mRawText(rawText) { }
-
-    virtual bool hasSideEffects() const { return false; }
-
-    TString getRawText() const { return mRawText; }
-
-    virtual void traverse(TIntermTraverser *);
-
-    virtual TIntermRaw *getAsRawNode() { return this; }
-    virtual bool replaceChildNode(TIntermNode *, TIntermNode *) { return false; }
-    virtual void enqueueChildren(std::queue<TIntermNode *> *nodeQueue) const {}
-
-  protected:
-    TString mRawText;
-};
-
-class TIntermConstantUnion : public TIntermTyped
-{
-  public:
-    TIntermConstantUnion(ConstantUnion *unionPointer, const TType &type)
-        : TIntermTyped(type),
-          mUnionArrayPointer(unionPointer) { }
-
-    virtual bool hasSideEffects() const { return false; }
-
-    ConstantUnion *getUnionArrayPointer() const { return mUnionArrayPointer; }
-
-    int getIConst(size_t index) const
-    {
-        return mUnionArrayPointer ? mUnionArrayPointer[index].getIConst() : 0;
-    }
-    unsigned int getUConst(size_t index) const
-    {
-        return mUnionArrayPointer ? mUnionArrayPointer[index].getUConst() : 0;
-    }
-    float getFConst(size_t index) const
-    {
-        return mUnionArrayPointer ? mUnionArrayPointer[index].getFConst() : 0.0f;
-    }
-    bool getBConst(size_t index) const
-    {
-        return mUnionArrayPointer ? mUnionArrayPointer[index].getBConst() : false;
-    }
-
-    virtual TIntermConstantUnion *getAsConstantUnion()  { return this; }
-    virtual void traverse(TIntermTraverser *);
-    virtual bool replaceChildNode(TIntermNode *, TIntermNode *) { return false; }
-
-    TIntermTyped *fold(TOperator, TIntermTyped *, TInfoSink &);
-
-    virtual void enqueueChildren(std::queue<TIntermNode *> *nodeQueue) const {}
-
-  protected:
-    ConstantUnion *mUnionArrayPointer;
-};
-
-//
-// Intermediate class for node types that hold operators.
-//
-class TIntermOperator : public TIntermTyped
-{
-  public:
-    TOperator getOp() const { return mOp; }
-    void setOp(TOperator op) { mOp = op; }
-
-    bool isAssignment() const;
-    bool isConstructor() const;
-
-    virtual bool hasSideEffects() const { return isAssignment(); }
-
-  protected:
-    TIntermOperator(TOperator op)
-        : TIntermTyped(TType(EbtFloat, EbpUndefined)),
-          mOp(op) {}
-    TIntermOperator(TOperator op, const TType &type)
-        : TIntermTyped(type),
-          mOp(op) {}
-
-    TOperator mOp;
-};
-
-//
-// Nodes for all the basic binary math operators.
-//
-class TIntermBinary : public TIntermOperator
-{
-  public:
-    TIntermBinary(TOperator op)
-        : TIntermOperator(op),
-          mAddIndexClamp(false) {}
-
-    virtual TIntermBinary *getAsBinaryNode() { return this; }
-    virtual void traverse(TIntermTraverser *);
-    virtual bool replaceChildNode(
-        TIntermNode *original, TIntermNode *replacement);
-
-    virtual bool hasSideEffects() const
-    {
-        return isAssignment() || mLeft->hasSideEffects() || mRight->hasSideEffects();
-    }
-
-    void setLeft(TIntermTyped *node) { mLeft = node; }
-    void setRight(TIntermTyped *node) { mRight = node; }
-    TIntermTyped *getLeft() const { return mLeft; }
-    TIntermTyped *getRight() const { return mRight; }
-    bool promote(TInfoSink &);
-
-    void setAddIndexClamp() { mAddIndexClamp = true; }
-    bool getAddIndexClamp() { return mAddIndexClamp; }
-
-    virtual void enqueueChildren(std::queue<TIntermNode *> *nodeQueue) const;
-
-  protected:
-    TIntermTyped* mLeft;
-    TIntermTyped* mRight;
-
-    // If set to true, wrap any EOpIndexIndirect with a clamp to bounds.
-    bool mAddIndexClamp;
-};
-
-//
-// Nodes for unary math operators.
-//
-class TIntermUnary : public TIntermOperator
-{
-  public:
-    TIntermUnary(TOperator op, const TType &type)
-        : TIntermOperator(op, type),
-          mOperand(NULL),
-          mUseEmulatedFunction(false) {}
-    TIntermUnary(TOperator op)
-        : TIntermOperator(op),
-          mOperand(NULL),
-          mUseEmulatedFunction(false) {}
-
-    virtual void traverse(TIntermTraverser *);
-    virtual TIntermUnary *getAsUnaryNode() { return this; }
-    virtual bool replaceChildNode(
-        TIntermNode *original, TIntermNode *replacement);
-
-    virtual bool hasSideEffects() const
-    {
-        return isAssignment() || mOperand->hasSideEffects();
-    }
-
-    void setOperand(TIntermTyped *operand) { mOperand = operand; }
-    TIntermTyped *getOperand() { return mOperand; }
-    bool promote(TInfoSink &);
-
-    void setUseEmulatedFunction() { mUseEmulatedFunction = true; }
-    bool getUseEmulatedFunction() { return mUseEmulatedFunction; }
-
-    virtual void enqueueChildren(std::queue<TIntermNode *> *nodeQueue) const;
-
-  protected:
-    TIntermTyped *mOperand;
-
-    // If set to true, replace the built-in function call with an emulated one
-    // to work around driver bugs.
-    bool mUseEmulatedFunction;
-};
-
-typedef TVector<TIntermNode *> TIntermSequence;
-typedef TVector<int> TQualifierList;
-
-//
-// Nodes that operate on an arbitrary sized set of children.
-//
-class TIntermAggregate : public TIntermOperator
-{
-  public:
-    TIntermAggregate()
-        : TIntermOperator(EOpNull),
-          mUserDefined(false),
-          mUseEmulatedFunction(false) { }
-    TIntermAggregate(TOperator op)
-        : TIntermOperator(op),
-          mUseEmulatedFunction(false) { }
-    ~TIntermAggregate() { }
-
-    virtual TIntermAggregate *getAsAggregate() { return this; }
-    virtual void traverse(TIntermTraverser *);
-    virtual bool replaceChildNode(
-        TIntermNode *original, TIntermNode *replacement);
-
-    // Conservatively assume function calls and other aggregate operators have side-effects
-    virtual bool hasSideEffects() const { return true; }
-
-    TIntermSequence *getSequence() { return &mSequence; }
-
-    void setName(const TString &name) { mName = name; }
-    const TString &getName() const { return mName; }
-
-    void setUserDefined() { mUserDefined = true; }
-    bool isUserDefined() const { return mUserDefined; }
-
-    void setOptimize(bool optimize) { mOptimize = optimize; }
-    bool getOptimize() const { return mOptimize; }
-    void setDebug(bool debug) { mDebug = debug; }
-    bool getDebug() const { return mDebug; }
-
-    void setUseEmulatedFunction() { mUseEmulatedFunction = true; }
-    bool getUseEmulatedFunction() { return mUseEmulatedFunction; }
-
-    virtual void enqueueChildren(std::queue<TIntermNode *> *nodeQueue) const;
-
-  protected:
-    TIntermAggregate(const TIntermAggregate &); // disallow copy constructor
-    TIntermAggregate &operator=(const TIntermAggregate &); // disallow assignment operator
-    TIntermSequence mSequence;
-    TString mName;
-    bool mUserDefined; // used for user defined function names
-
-    bool mOptimize;
-    bool mDebug;
-
-    // If set to true, replace the built-in function call with an emulated one
-    // to work around driver bugs.
-    bool mUseEmulatedFunction;
-};
-
-//
-// For if tests.  Simplified since there is no switch statement.
-//
-class TIntermSelection : public TIntermTyped
-{
-  public:
-    TIntermSelection(TIntermTyped *cond, TIntermNode *trueB, TIntermNode *falseB)
-        : TIntermTyped(TType(EbtVoid, EbpUndefined)),
-          mCondition(cond),
-          mTrueBlock(trueB),
-          mFalseBlock(falseB) {}
-    TIntermSelection(TIntermTyped *cond, TIntermNode *trueB, TIntermNode *falseB,
-                     const TType &type)
-        : TIntermTyped(type),
-          mCondition(cond),
-          mTrueBlock(trueB),
-          mFalseBlock(falseB) {}
-
-    virtual void traverse(TIntermTraverser *);
-    virtual bool replaceChildNode(
-        TIntermNode *original, TIntermNode *replacement);
-
-    // Conservatively assume selections have side-effects
-    virtual bool hasSideEffects() const { return true; }
-
-    bool usesTernaryOperator() const { return getBasicType() != EbtVoid; }
-    TIntermNode *getCondition() const { return mCondition; }
-    TIntermNode *getTrueBlock() const { return mTrueBlock; }
-    TIntermNode *getFalseBlock() const { return mFalseBlock; }
-    TIntermSelection *getAsSelectionNode() { return this; }
-
-    virtual void enqueueChildren(std::queue<TIntermNode *> *nodeQueue) const;
-
-protected:
-    TIntermTyped *mCondition;
-    TIntermNode *mTrueBlock;
-    TIntermNode *mFalseBlock;
-};
-
-enum Visit
-{
-    PreVisit,
-    InVisit,
-    PostVisit
-};
-
-//
-// For traversing the tree.  User should derive from this,
-// put their traversal specific data in it, and then pass
-// it to a Traverse method.
-//
-// When using this, just fill in the methods for nodes you want visited.
-// Return false from a pre-visit to skip visiting that node's subtree.
-//
-class TIntermTraverser
-{
-  public:
-    POOL_ALLOCATOR_NEW_DELETE();
-    // TODO(zmo): remove default values.
-    TIntermTraverser(bool preVisit = true, bool inVisit = false, bool postVisit = false,
-                     bool rightToLeft = false)
-        : preVisit(preVisit),
-          inVisit(inVisit),
-          postVisit(postVisit),
-          rightToLeft(rightToLeft),
-          mDepth(0),
-          mMaxDepth(0) {}
-    virtual ~TIntermTraverser() {}
-
-    virtual void visitSymbol(TIntermSymbol *) {}
-    virtual void visitRaw(TIntermRaw *) {}
-    virtual void visitConstantUnion(TIntermConstantUnion *) {}
-    virtual bool visitBinary(Visit, TIntermBinary *) { return true; }
-    virtual bool visitUnary(Visit, TIntermUnary *) { return true; }
-    virtual bool visitSelection(Visit, TIntermSelection *) { return true; }
-    virtual bool visitAggregate(Visit, TIntermAggregate *) { return true; }
-    virtual bool visitLoop(Visit, TIntermLoop *) { return true; }
-    virtual bool visitBranch(Visit, TIntermBranch *) { return true; }
-
-    int getMaxDepth() const { return mMaxDepth; }
-
-    void incrementDepth(TIntermNode *current)
-    {
-        mDepth++;
-        mMaxDepth = std::max(mMaxDepth, mDepth);
-        mPath.push_back(current);
-    }
-
-    void decrementDepth()
-    {
-        mDepth--;
-        mPath.pop_back();
-    }
-
-    TIntermNode *getParentNode()
-    {
-        return mPath.size() == 0 ? NULL : mPath.back();
-    }
-
-    // Return the original name if hash function pointer is NULL;
-    // otherwise return the hashed name.
-    static TString hash(const TString& name, ShHashFunction64 hashFunction);
-
-    const bool preVisit;
-    const bool inVisit;
-    const bool postVisit;
-    const bool rightToLeft;
-
-  protected:
-    int mDepth;
-    int mMaxDepth;
-
-    // All the nodes from root to the current node's parent during traversing.
-    TVector<TIntermNode *> mPath;
-};
-
-//
-// For traversing the tree, and computing max depth.
-// Takes a maximum depth limit to prevent stack overflow.
-//
-class TMaxDepthTraverser : public TIntermTraverser
+class TInfoSink;
+class TIntermediate
 {
   public:
     POOL_ALLOCATOR_NEW_DELETE();
-    TMaxDepthTraverser(int depthLimit)
-        : TIntermTraverser(true, true, false, false),
-          mDepthLimit(depthLimit) { }
-
-    virtual bool visitBinary(Visit, TIntermBinary *) { return depthCheck(); }
-    virtual bool visitUnary(Visit, TIntermUnary *) { return depthCheck(); }
-    virtual bool visitSelection(Visit, TIntermSelection *) { return depthCheck(); }
-    virtual bool visitAggregate(Visit, TIntermAggregate *) { return depthCheck(); }
-    virtual bool visitLoop(Visit, TIntermLoop *) { return depthCheck(); }
-    virtual bool visitBranch(Visit, TIntermBranch *) { return depthCheck(); }
-
-protected:
-    bool depthCheck() const { return mMaxDepth < mDepthLimit; }
-
-    int mDepthLimit;
-};
-
-#endif  // COMPILER_TRANSLATOR_INTERMEDIATE_H_
+    TIntermediate(TInfoSink &i)
+        : mInfoSink(i) { }
+
+    TIntermSymbol *addSymbol(
+        int id, const TString &, const TType &, const TSourceLoc &);
+    TIntermTyped *addBinaryMath(
+        TOperator op, TIntermTyped *left, TIntermTyped *right, const TSourceLoc &);
+    TIntermTyped *addAssign(
+        TOperator op, TIntermTyped *left, TIntermTyped *right, const TSourceLoc &);
+    TIntermTyped *addIndex(
+        TOperator op, TIntermTyped *base, TIntermTyped *index, const TSourceLoc &);
+    TIntermTyped *addUnaryMath(
+        TOperator op, TIntermNode *child, const TSourceLoc &);
+    TIntermAggregate *growAggregate(
+        TIntermNode *left, TIntermNode *right, const TSourceLoc &);
+    TIntermAggregate *makeAggregate(TIntermNode *node, const TSourceLoc &);
+    TIntermAggregate *setAggregateOperator(TIntermNode *, TOperator, const TSourceLoc &);
+    TIntermNode *addSelection(TIntermTyped *cond, TIntermNodePair code, const TSourceLoc &);
+    TIntermTyped *addSelection(
+        TIntermTyped *cond, TIntermTyped *trueBlock, TIntermTyped *falseBlock, const TSourceLoc &);
+    TIntermTyped *addComma(
+        TIntermTyped *left, TIntermTyped *right, const TSourceLoc &);
+    TIntermConstantUnion *addConstantUnion(ConstantUnion *, const TType &, const TSourceLoc &);
+    // TODO(zmo): Get rid of default value.
+    bool parseConstTree(const TSourceLoc &, TIntermNode *, ConstantUnion *,
+                        TOperator, TType, bool singleConstantParam = false);
+    TIntermNode *addLoop(TLoopType, TIntermNode *, TIntermTyped *, TIntermTyped *,
+                         TIntermNode *, const TSourceLoc &);
+    TIntermBranch *addBranch(TOperator, const TSourceLoc &);
+    TIntermBranch *addBranch(TOperator, TIntermTyped *, const TSourceLoc &);
+    TIntermTyped *addSwizzle(TVectorFields &, const TSourceLoc &);
+    bool postProcess(TIntermNode *);
+    void remove(TIntermNode *);
+    void outputTree(TIntermNode *);
+
+  private:
+    void operator=(TIntermediate &); // prevent assignments
+
+    TInfoSink & mInfoSink;
+};
+
+#endif  // COMPILER_TRANSLATOR_LOCAL_INTERMEDIATE_H_