Removed tabs. Fixed formatting. Only white-space changes.

src/compiler/Intermediate.cpp

@@ -30,10 +30,10 @@ bool CompareStructure(const TType& leftNodeType, constUnion* rightUnionArray, co
 //
 TIntermSymbol* TIntermediate::addSymbol(int id, const TString& name, const TType& type, TSourceLoc line)
 {
-	TIntermSymbol* node = new TIntermSymbol(id, name, type);
-	node->setLine(line);
+    TIntermSymbol* node = new TIntermSymbol(id, name, type);
+    node->setLine(line);
 
-	return node;
+    return node;
 }
 
 //
@@ -43,88 +43,88 @@ TIntermSymbol* TIntermediate::addSymbol(int id, const TString& name, const TType
 //
 TIntermTyped* TIntermediate::addBinaryMath(TOperator op, TIntermTyped* left, TIntermTyped* right, TSourceLoc line, TSymbolTable& symbolTable)
 {
-	switch (op) {
-	case EOpLessThan:
-	case EOpGreaterThan:
-	case EOpLessThanEqual:
-	case EOpGreaterThanEqual:
-		if (left->getType().isMatrix() || left->getType().isArray() || left->getType().isVector() || left->getType().getBasicType() == EbtStruct) {
-			return 0;
-		}
-		break;
-	case EOpLogicalOr:
-	case EOpLogicalXor:
-	case EOpLogicalAnd:
-		if (left->getType().getBasicType() != EbtBool || left->getType().isMatrix() || left->getType().isArray() || left->getType().isVector()) {
-			return 0;
-		}
-		break;
-	case EOpAdd:
-	case EOpSub:
-	case EOpDiv:
-	case EOpMul:
-		if (left->getType().getBasicType() == EbtStruct || left->getType().getBasicType() == EbtBool)
-			return 0;
-	default: break;
-	}
-
-	//
-	// First try converting the children to compatible types.
-	//
-
-	if (!(left->getType().getStruct() && right->getType().getStruct())) {
-		TIntermTyped* child = addConversion(op, left->getType(), right);
-		if (child)
-			right = child;
-		else {
-			child = addConversion(op, right->getType(), left);
-			if (child)
-				left = child;
-			else
-				return 0;
-		}
-	} else {
-		if (left->getType() != right->getType())
-			return 0;
-	}
-
-
-	//
-	// Need a new node holding things together then.  Make
-	// one and promote it to the right type.
-	//
-	TIntermBinary* node = new TIntermBinary(op);
-	if (line == 0)
-		line = right->getLine();
-	node->setLine(line);
-
-	node->setLeft(left);
-	node->setRight(right);
-	if (! node->promote(infoSink))
-		return 0;
-
-	TIntermConstantUnion *leftTempConstant = left->getAsConstantUnion();
-	TIntermConstantUnion *rightTempConstant = right->getAsConstantUnion();
-
-	if (leftTempConstant)
-		leftTempConstant = left->getAsConstantUnion();
-
-	if (rightTempConstant)
-		rightTempConstant = right->getAsConstantUnion();
-
-	//
-	// See if we can fold constants.
-	//
-
-	TIntermTyped* typedReturnNode = 0;
-	if ( leftTempConstant && rightTempConstant) {
-		typedReturnNode = leftTempConstant->fold(node->getOp(), rightTempConstant, infoSink);
-
-		if (typedReturnNode)
-			return typedReturnNode;
-	}
-
-	return node;
+    switch (op) {
+        case EOpLessThan:
+        case EOpGreaterThan:
+        case EOpLessThanEqual:
+        case EOpGreaterThanEqual:
+            if (left->getType().isMatrix() || left->getType().isArray() || left->getType().isVector() || left->getType().getBasicType() == EbtStruct) {
+                return 0;
+            }
+            break;
+        case EOpLogicalOr:
+        case EOpLogicalXor:
+        case EOpLogicalAnd:
+            if (left->getType().getBasicType() != EbtBool || left->getType().isMatrix() || left->getType().isArray() || left->getType().isVector()) {
+                return 0;
+            }
+            break;
+        case EOpAdd:
+        case EOpSub:
+        case EOpDiv:
+        case EOpMul:
+            if (left->getType().getBasicType() == EbtStruct || left->getType().getBasicType() == EbtBool)
+                return 0;
+        default: break;
+    }
+
+    //
+    // First try converting the children to compatible types.
+    //
+
+    if (!(left->getType().getStruct() && right->getType().getStruct())) {
+        TIntermTyped* child = addConversion(op, left->getType(), right);
+        if (child)
+            right = child;
+        else {
+            child = addConversion(op, right->getType(), left);
+            if (child)
+                left = child;
+            else
+                return 0;
+        }
+    } else {
+        if (left->getType() != right->getType())
+            return 0;
+    }
+
+
+    //
+    // Need a new node holding things together then.  Make
+    // one and promote it to the right type.
+    //
+    TIntermBinary* node = new TIntermBinary(op);
+    if (line == 0)
+        line = right->getLine();
+    node->setLine(line);
+
+    node->setLeft(left);
+    node->setRight(right);
+    if (! node->promote(infoSink))
+        return 0;
+
+    TIntermConstantUnion *leftTempConstant = left->getAsConstantUnion();
+    TIntermConstantUnion *rightTempConstant = right->getAsConstantUnion();
+
+    if (leftTempConstant)
+        leftTempConstant = left->getAsConstantUnion();
+
+    if (rightTempConstant)
+        rightTempConstant = right->getAsConstantUnion();
+
+    //
+    // See if we can fold constants.
+    //
+
+    TIntermTyped* typedReturnNode = 0;
+    if ( leftTempConstant && rightTempConstant) {
+        typedReturnNode = leftTempConstant->fold(node->getOp(), rightTempConstant, infoSink);
+
+        if (typedReturnNode)
+            return typedReturnNode;
+    }
+
+    return node;
 }
 
 //
@@ -134,25 +134,25 @@ TIntermTyped* TIntermediate::addBinaryMath(TOperator op, TIntermTyped* left, TIn
 //
 TIntermTyped* TIntermediate::addAssign(TOperator op, TIntermTyped* left, TIntermTyped* right, TSourceLoc line)
 {
-	//
-	// Like adding binary math, except the conversion can only go
-	// from right to left.
-	//
-	TIntermBinary* node = new TIntermBinary(op);
-	if (line == 0)
-		line = left->getLine();
-	node->setLine(line);
-
-	TIntermTyped* child = addConversion(op, left->getType(), right);
-	if (child == 0)
-		return 0;
-
-	node->setLeft(left);
-	node->setRight(child);
-	if (! node->promote(infoSink))
-		return 0;
-
-	return node;
+    //
+    // Like adding binary math, except the conversion can only go
+    // from right to left.
+    //
+    TIntermBinary* node = new TIntermBinary(op);
+    if (line == 0)
+        line = left->getLine();
+    node->setLine(line);
+
+    TIntermTyped* child = addConversion(op, left->getType(), right);
+    if (child == 0)
+        return 0;
+
+    node->setLeft(left);
+    node->setRight(child);
+    if (! node->promote(infoSink))
+        return 0;
+
+    return node;
 }
 
 //
@@ -164,16 +164,16 @@ TIntermTyped* TIntermediate::addAssign(TOperator op, TIntermTyped* left, TInterm
 //
 TIntermTyped* TIntermediate::addIndex(TOperator op, TIntermTyped* base, TIntermTyped* index, TSourceLoc line)
 {
-	TIntermBinary* node = new TIntermBinary(op);
-	if (line == 0)
-		line = index->getLine();
-	node->setLine(line);
-	node->setLeft(base);
-	node->setRight(index);
+    TIntermBinary* node = new TIntermBinary(op);
+    if (line == 0)
+        line = index->getLine();
+    node->setLine(line);
+    node->setLeft(base);
+    node->setRight(index);
 
-	// caller should set the type
+    // caller should set the type
 
-	return node;
+    return node;
 }
 
 //
@@ -183,88 +183,88 @@ TIntermTyped* TIntermediate::addIndex(TOperator op, TIntermTyped* base, TIntermT
 //
 TIntermTyped* TIntermediate::addUnaryMath(TOperator op, TIntermNode* childNode, TSourceLoc line, TSymbolTable& symbolTable)
 {
-	TIntermUnary* node;
-	TIntermTyped* child = childNode->getAsTyped();
-
-	if (child == 0) {
-		infoSink.info.message(EPrefixInternalError, "Bad type in AddUnaryMath", line);
-		return 0;
-	}
-
-	switch (op) {
-	case EOpLogicalNot:
-		if (child->getType().getBasicType() != EbtBool || child->getType().isMatrix() || child->getType().isArray() || child->getType().isVector()) {
-			return 0;
-		}
-		break;
-
-	case EOpPostIncrement:
-	case EOpPreIncrement:
-	case EOpPostDecrement:
-	case EOpPreDecrement:
-	case EOpNegative:
-		if (child->getType().getBasicType() == EbtStruct || child->getType().isArray())
-			return 0;
-	default: break;
-	}
-
-	//
-	// Do we need to promote the operand?
-	//
-	// Note: Implicit promotions were removed from the language.
-	//
-	TBasicType newType = EbtVoid;
-	switch (op) {
-	case EOpConstructInt:   newType = EbtInt;   break;
-	case EOpConstructBool:  newType = EbtBool;  break;
-	case EOpConstructFloat: newType = EbtFloat; break;
-	default: break;
-	}
-
-	if (newType != EbtVoid) {
-		child = addConversion(op, TType(newType, EvqTemporary, child->getNominalSize(),
-															   child->isMatrix(),
-															   child->isArray()),
-							  child);
-		if (child == 0)
-			return 0;
-	}
-
-	//
-	// For constructors, we are now done, it's all in the conversion.
-	//
-	switch (op) {
-	case EOpConstructInt:
-	case EOpConstructBool:
-	case EOpConstructFloat:
-		return child;
-	default: break;
-	}
-
-	TIntermConstantUnion *childTempConstant = 0;
-	if (child->getAsConstantUnion())
-		childTempConstant = child->getAsConstantUnion();
-
-	//
-	// Make a new node for the operator.
-	//
-	node = new TIntermUnary(op);
-	if (line == 0)
-		line = child->getLine();
-	node->setLine(line);
-	node->setOperand(child);
-
-	if (! node->promote(infoSink))
-		return 0;
-
-	if (childTempConstant)  {
-		TIntermTyped* newChild = childTempConstant->fold(op, 0, infoSink);
-
-		if (newChild)
-			return newChild;
-	}
-
-	return node;
+    TIntermUnary* node;
+    TIntermTyped* child = childNode->getAsTyped();
+
+    if (child == 0) {
+        infoSink.info.message(EPrefixInternalError, "Bad type in AddUnaryMath", line);
+        return 0;
+    }
+
+    switch (op) {
+        case EOpLogicalNot:
+            if (child->getType().getBasicType() != EbtBool || child->getType().isMatrix() || child->getType().isArray() || child->getType().isVector()) {
+                return 0;
+            }
+            break;
+
+        case EOpPostIncrement:
+        case EOpPreIncrement:
+        case EOpPostDecrement:
+        case EOpPreDecrement:
+        case EOpNegative:
+            if (child->getType().getBasicType() == EbtStruct || child->getType().isArray())
+                return 0;
+        default: break;
+    }
+
+    //
+    // Do we need to promote the operand?
+    //
+    // Note: Implicit promotions were removed from the language.
+    //
+    TBasicType newType = EbtVoid;
+    switch (op) {
+        case EOpConstructInt:   newType = EbtInt;   break;
+        case EOpConstructBool:  newType = EbtBool;  break;
+        case EOpConstructFloat: newType = EbtFloat; break;
+        default: break;
+    }
+
+    if (newType != EbtVoid) {
+        child = addConversion(op, TType(newType, EvqTemporary, child->getNominalSize(),
+            child->isMatrix(),
+            child->isArray()),
+            child);
+        if (child == 0)
+            return 0;
+    }
+
+    //
+    // For constructors, we are now done, it's all in the conversion.
+    //
+    switch (op) {
+        case EOpConstructInt:
+        case EOpConstructBool:
+        case EOpConstructFloat:
+            return child;
+        default: break;
+    }
+
+    TIntermConstantUnion *childTempConstant = 0;
+    if (child->getAsConstantUnion())
+        childTempConstant = child->getAsConstantUnion();
+
+    //
+    // Make a new node for the operator.
+    //
+    node = new TIntermUnary(op);
+    if (line == 0)
+        line = child->getLine();
+    node->setLine(line);
+    node->setOperand(child);
+
+    if (! node->promote(infoSink))
+        return 0;
+
+    if (childTempConstant)  {
+        TIntermTyped* newChild = childTempConstant->fold(op, 0, infoSink);
+
+        if (newChild)
+            return newChild;
+    }
+
+    return node;
 }
 
 //
@@ -279,33 +279,33 @@ TIntermTyped* TIntermediate::addUnaryMath(TOperator op, TIntermNode* childNode,
 //
 TIntermAggregate* TIntermediate::setAggregateOperator(TIntermNode* node, TOperator op, TSourceLoc line)
 {
-	TIntermAggregate* aggNode;
-
-	//
-	// Make sure we have an aggregate.  If not turn it into one.
-	//
-	if (node) {
-		aggNode = node->getAsAggregate();
-		if (aggNode == 0 || aggNode->getOp() != EOpNull) {
-			//
-			// Make an aggregate containing this node.
-			//
-			aggNode = new TIntermAggregate();
-			aggNode->getSequence().push_back(node);
-			if (line == 0)
-				line = node->getLine();
-		}
-	} else
-		aggNode = new TIntermAggregate();
-
-	//
-	// Set the operator.
-	//
-	aggNode->setOperator(op);
-	if (line != 0)
-		aggNode->setLine(line);
-
-	return aggNode;
+    TIntermAggregate* aggNode;
+
+    //
+    // Make sure we have an aggregate.  If not turn it into one.
+    //
+    if (node) {
+        aggNode = node->getAsAggregate();
+        if (aggNode == 0 || aggNode->getOp() != EOpNull) {
+            //
+            // Make an aggregate containing this node.
+            //
+            aggNode = new TIntermAggregate();
+            aggNode->getSequence().push_back(node);
+            if (line == 0)
+                line = node->getLine();
+        }
+    } else
+        aggNode = new TIntermAggregate();
+
+    //
+    // Set the operator.
+    //
+    aggNode->setOperator(op);
+    if (line != 0)
+        aggNode->setLine(line);
+
+    return aggNode;
 }
 
 //
@@ -318,114 +318,114 @@ TIntermAggregate* TIntermediate::setAggregateOperator(TIntermNode* node, TOperat
 //
 TIntermTyped* TIntermediate::addConversion(TOperator op, const TType& type, TIntermTyped* node)
 {
-	//
-	// Does the base type allow operation?
-	//
-	switch (node->getBasicType()) {
-	case EbtVoid:
-	case EbtSampler2D:
-	case EbtSamplerCube:
-		return 0;
-	default: break;
-	}
-
-	//
-	// Otherwise, if types are identical, no problem
-	//
-	if (type == node->getType())
-		return node;
-
-	//
-	// If one's a structure, then no conversions.
-	//
-	if (type.getStruct() || node->getType().getStruct())
-		return 0;
-
-	//
-	// If one's an array, then no conversions.
-	//
-	if (type.isArray() || node->getType().isArray())
-		return 0;
-
-	TBasicType promoteTo;
-
-	switch (op) {
-	//
-	// Explicit conversions
-	//
-	case EOpConstructBool:
-		promoteTo = EbtBool;
-		break;
-	case EOpConstructFloat:
-		promoteTo = EbtFloat;
-		break;
-	case EOpConstructInt:
-		promoteTo = EbtInt;
-		break;
-	default:
-		//
-		// implicit conversions were removed from the language.
-		//
-		if (type.getBasicType() != node->getType().getBasicType())
-			return 0;
-		//
-		// Size and structure could still differ, but that's
-		// handled by operator promotion.
-		//
-		return node;
-	}
-
-	if (node->getAsConstantUnion()) {
-
-		return (promoteConstantUnion(promoteTo, node->getAsConstantUnion()));
-	} else {
-
-		//
-		// Add a new newNode for the conversion.
-		//
-		TIntermUnary* newNode = 0;
-
-		TOperator newOp = EOpNull;
-		switch (promoteTo) {
-		case EbtFloat:
-			switch (node->getBasicType()) {
-			case EbtInt:   newOp = EOpConvIntToFloat;  break;
-			case EbtBool:  newOp = EOpConvBoolToFloat; break;
-			default:
-				infoSink.info.message(EPrefixInternalError, "Bad promotion node", node->getLine());
-				return 0;
-			}
-			break;
-		case EbtBool:
-			switch (node->getBasicType()) {
-			case EbtInt:   newOp = EOpConvIntToBool;   break;
-			case EbtFloat: newOp = EOpConvFloatToBool; break;
-			default:
-				infoSink.info.message(EPrefixInternalError, "Bad promotion node", node->getLine());
-				return 0;
-			}
-			break;
-		case EbtInt:
-			switch (node->getBasicType()) {
-			case EbtBool:   newOp = EOpConvBoolToInt;  break;
-			case EbtFloat:  newOp = EOpConvFloatToInt; break;
-			default:
-				infoSink.info.message(EPrefixInternalError, "Bad promotion node", node->getLine());
-				return 0;
-			}
-			break;
-		default:
-			infoSink.info.message(EPrefixInternalError, "Bad promotion type", node->getLine());
-			return 0;
-		}
-
-		TType type(promoteTo, EvqTemporary, node->getNominalSize(), node->isMatrix(), node->isArray());
-		newNode = new TIntermUnary(newOp, type);
-		newNode->setLine(node->getLine());
-		newNode->setOperand(node);
-
-		return newNode;
-	}
+    //
+    // Does the base type allow operation?
+    //
+    switch (node->getBasicType()) {
+        case EbtVoid:
+        case EbtSampler2D:
+        case EbtSamplerCube:
+            return 0;
+        default: break;
+    }
+
+    //
+    // Otherwise, if types are identical, no problem
+    //
+    if (type == node->getType())
+        return node;
+
+    //
+    // If one's a structure, then no conversions.
+    //
+    if (type.getStruct() || node->getType().getStruct())
+        return 0;
+
+    //
+    // If one's an array, then no conversions.
+    //
+    if (type.isArray() || node->getType().isArray())
+        return 0;
+
+    TBasicType promoteTo;
+
+    switch (op) {
+        //
+        // Explicit conversions
+        //
+        case EOpConstructBool:
+            promoteTo = EbtBool;
+            break;
+        case EOpConstructFloat:
+            promoteTo = EbtFloat;
+            break;
+        case EOpConstructInt:
+            promoteTo = EbtInt;
+            break;
+        default:
+            //
+            // implicit conversions were removed from the language.
+            //
+            if (type.getBasicType() != node->getType().getBasicType())
+                return 0;
+            //
+            // Size and structure could still differ, but that's
+            // handled by operator promotion.
+            //
+            return node;
+    }
+
+    if (node->getAsConstantUnion()) {
+
+        return (promoteConstantUnion(promoteTo, node->getAsConstantUnion()));
+    } else {
+
+        //
+        // Add a new newNode for the conversion.
+        //
+        TIntermUnary* newNode = 0;
+
+        TOperator newOp = EOpNull;
+        switch (promoteTo) {
+            case EbtFloat:
+                switch (node->getBasicType()) {
+                    case EbtInt:   newOp = EOpConvIntToFloat;  break;
+                    case EbtBool:  newOp = EOpConvBoolToFloat; break;
+                    default:
+                        infoSink.info.message(EPrefixInternalError, "Bad promotion node", node->getLine());
+                        return 0;
+                }
+                break;
+            case EbtBool:
+                switch (node->getBasicType()) {
+                    case EbtInt:   newOp = EOpConvIntToBool;   break;
+                    case EbtFloat: newOp = EOpConvFloatToBool; break;
+                    default:
+                        infoSink.info.message(EPrefixInternalError, "Bad promotion node", node->getLine());
+                        return 0;
+                }
+                break;
+            case EbtInt:
+                switch (node->getBasicType()) {
+                    case EbtBool:   newOp = EOpConvBoolToInt;  break;
+                    case EbtFloat:  newOp = EOpConvFloatToInt; break;
+                    default:
+                        infoSink.info.message(EPrefixInternalError, "Bad promotion node", node->getLine());
+                        return 0;
+                }
+                break;
+            default:
+                infoSink.info.message(EPrefixInternalError, "Bad promotion type", node->getLine());
+                return 0;
+        }
+
+        TType type(promoteTo, EvqTemporary, node->getNominalSize(), node->isMatrix(), node->isArray());
+        newNode = new TIntermUnary(newOp, type);
+        newNode->setLine(node->getLine());
+        newNode->setOperand(node);
+
+        return newNode;
+    }
 }
 
 //
@@ -437,25 +437,25 @@ TIntermTyped* TIntermediate::addConversion(TOperator op, const TType& type, TInt
 //
 TIntermAggregate* TIntermediate::growAggregate(TIntermNode* left, TIntermNode* right, TSourceLoc line)
 {
-	if (left == 0 && right == 0)
-		return 0;
+    if (left == 0 && right == 0)
+        return 0;
 
-	TIntermAggregate* aggNode = 0;
-	if (left)
-		aggNode = left->getAsAggregate();
-	if (!aggNode || aggNode->getOp() != EOpNull) {
-		aggNode = new TIntermAggregate;
-		if (left)
-			aggNode->getSequence().push_back(left);
-	}
+    TIntermAggregate* aggNode = 0;
+    if (left)
+        aggNode = left->getAsAggregate();
+    if (!aggNode || aggNode->getOp() != EOpNull) {
+        aggNode = new TIntermAggregate;
+        if (left)
+            aggNode->getSequence().push_back(left);
+    }
 
-	if (right)
-		aggNode->getSequence().push_back(right);
+    if (right)
+        aggNode->getSequence().push_back(right);
 
-	if (line != 0)
-		aggNode->setLine(line);
+    if (line != 0)
+        aggNode->setLine(line);
 
-	return aggNode;
+    return aggNode;
 }
 
 //
@@ -465,18 +465,18 @@ TIntermAggregate* TIntermediate::growAggregate(TIntermNode* left, TIntermNode* r
 //
 TIntermAggregate* TIntermediate::makeAggregate(TIntermNode* node, TSourceLoc line)
 {
-	if (node == 0)
-		return 0;
+    if (node == 0)
+        return 0;
 
-	TIntermAggregate* aggNode = new TIntermAggregate;
-	aggNode->getSequence().push_back(node);
+    TIntermAggregate* aggNode = new TIntermAggregate;
+    aggNode->getSequence().push_back(node);
 
-	if (line != 0)
-		aggNode->setLine(line);
-	else
-		aggNode->setLine(node->getLine());
+    if (line != 0)
+        aggNode->setLine(line);
+    else
+        aggNode->setLine(node->getLine());
 
-	return aggNode;
+    return aggNode;
 }
 
 //
@@ -488,36 +488,36 @@ TIntermAggregate* TIntermediate::makeAggregate(TIntermNode* node, TSourceLoc lin
 //
 TIntermNode* TIntermediate::addSelection(TIntermTyped* cond, TIntermNodePair nodePair, TSourceLoc line)
 {
-	//
-	// For compile time constant selections, prune the code and
-	// test now.
-	//
-
-	if (cond->getAsTyped() && cond->getAsTyped()->getAsConstantUnion()) {
-		if (cond->getAsTyped()->getAsConstantUnion()->getUnionArrayPointer()->getBConst())
-			return nodePair.node1;
-		else
-			return nodePair.node2;
-	}
-
-	TIntermSelection* node = new TIntermSelection(cond, nodePair.node1, nodePair.node2);
-	node->setLine(line);
-
-	return node;
+    //
+    // For compile time constant selections, prune the code and
+    // test now.
+    //
+
+    if (cond->getAsTyped() && cond->getAsTyped()->getAsConstantUnion()) {
+        if (cond->getAsTyped()->getAsConstantUnion()->getUnionArrayPointer()->getBConst())
+            return nodePair.node1;
+        else
+            return nodePair.node2;
+    }
+
+    TIntermSelection* node = new TIntermSelection(cond, nodePair.node1, nodePair.node2);
+    node->setLine(line);
+
+    return node;
 }
 
 
 TIntermTyped* TIntermediate::addComma(TIntermTyped* left, TIntermTyped* right, TSourceLoc line)
 {
-	if (left->getType().getQualifier() == EvqConst && right->getType().getQualifier() == EvqConst) {
-		return right;
-	} else {
-		TIntermTyped *commaAggregate = growAggregate(left, right, line);
-		commaAggregate->getAsAggregate()->setOperator(EOpComma);
-		commaAggregate->setType(right->getType());
-		commaAggregate->getTypePointer()->changeQualifier(EvqTemporary);
-		return commaAggregate;
-	}
+    if (left->getType().getQualifier() == EvqConst && right->getType().getQualifier() == EvqConst) {
+        return right;
+    } else {
+        TIntermTyped *commaAggregate = growAggregate(left, right, line);
+        commaAggregate->getAsAggregate()->setOperator(EOpComma);
+        commaAggregate->setType(right->getType());
+        commaAggregate->getTypePointer()->changeQualifier(EvqTemporary);
+        return commaAggregate;
+    }
 }
 
 //
@@ -529,38 +529,38 @@ TIntermTyped* TIntermediate::addComma(TIntermTyped* left, TIntermTyped* right, T
 //
 TIntermTyped* TIntermediate::addSelection(TIntermTyped* cond, TIntermTyped* trueBlock, TIntermTyped* falseBlock, TSourceLoc line)
 {
-	//
-	// Get compatible types.
-	//
-	TIntermTyped* child = addConversion(EOpSequence, trueBlock->getType(), falseBlock);
-	if (child)
-		falseBlock = child;
-	else {
-		child = addConversion(EOpSequence, falseBlock->getType(), trueBlock);
-		if (child)
-			trueBlock = child;
-		else
-			return 0;
-	}
-
-	//
-	// See if all the operands are constant, then fold it otherwise not.
-	//
-
-	if (cond->getAsConstantUnion() && trueBlock->getAsConstantUnion() && falseBlock->getAsConstantUnion()) {
-		if (cond->getAsConstantUnion()->getUnionArrayPointer()->getBConst())
-			return trueBlock;
-		else
-			return falseBlock;
-	}
-
-	//
-	// Make a selection node.
-	//
-	TIntermSelection* node = new TIntermSelection(cond, trueBlock, falseBlock, trueBlock->getType());
-	node->setLine(line);
-
-	return node;
+    //
+    // Get compatible types.
+    //
+    TIntermTyped* child = addConversion(EOpSequence, trueBlock->getType(), falseBlock);
+    if (child)
+        falseBlock = child;
+    else {
+        child = addConversion(EOpSequence, falseBlock->getType(), trueBlock);
+        if (child)
+            trueBlock = child;
+        else
+            return 0;
+    }
+
+    //
+    // See if all the operands are constant, then fold it otherwise not.
+    //
+
+    if (cond->getAsConstantUnion() && trueBlock->getAsConstantUnion() && falseBlock->getAsConstantUnion()) {
+        if (cond->getAsConstantUnion()->getUnionArrayPointer()->getBConst())
+            return trueBlock;
+        else
+            return falseBlock;
+    }
+
+    //
+    // Make a selection node.
+    //
+    TIntermSelection* node = new TIntermSelection(cond, trueBlock, falseBlock, trueBlock->getType());
+    node->setLine(line);
+
+    return node;
 }
 
 //
@@ -571,30 +571,30 @@ TIntermTyped* TIntermediate::addSelection(TIntermTyped* cond, TIntermTyped* true
 
 TIntermConstantUnion* TIntermediate::addConstantUnion(constUnion* unionArrayPointer, const TType& t, TSourceLoc line)
 {
-	TIntermConstantUnion* node = new TIntermConstantUnion(unionArrayPointer, t);
-	node->setLine(line);
+    TIntermConstantUnion* node = new TIntermConstantUnion(unionArrayPointer, t);
+    node->setLine(line);
 
-	return node;
+    return node;
 }
 
 TIntermTyped* TIntermediate::addSwizzle(TVectorFields& fields, TSourceLoc line)
 {
 
-	TIntermAggregate* node = new TIntermAggregate(EOpSequence);
+    TIntermAggregate* node = new TIntermAggregate(EOpSequence);
 
-	node->setLine(line);
-	TIntermConstantUnion* constIntNode;
-	TIntermSequence &sequenceVector = node->getSequence();
-	constUnion* unionArray;
+    node->setLine(line);
+    TIntermConstantUnion* constIntNode;
+    TIntermSequence &sequenceVector = node->getSequence();
+    constUnion* unionArray;
 
-	for (int i = 0; i < fields.num; i++) {
-		unionArray = new constUnion[1];
-		unionArray->setIConst(fields.offsets[i]);
-		constIntNode = addConstantUnion(unionArray, TType(EbtInt, EvqConst), line);
-		sequenceVector.push_back(constIntNode);
-	}
+    for (int i = 0; i < fields.num; i++) {
+        unionArray = new constUnion[1];
+        unionArray->setIConst(fields.offsets[i]);
+        constIntNode = addConstantUnion(unionArray, TType(EbtInt, EvqConst), line);
+        sequenceVector.push_back(constIntNode);
+    }
 
-	return node;
+    return node;
 }
 
 //
@@ -602,10 +602,10 @@ TIntermTyped* TIntermediate::addSwizzle(TVectorFields& fields, TSourceLoc line)
 //
 TIntermNode* TIntermediate::addLoop(TIntermNode *init, TIntermNode* body, TIntermTyped* test, TIntermTyped* terminal, bool testFirst, TSourceLoc line)
 {
-	TIntermNode* node = new TIntermLoop(init, body, test, terminal, testFirst);
-	node->setLine(line);
+    TIntermNode* node = new TIntermLoop(init, body, test, terminal, testFirst);
+    node->setLine(line);
 
-	return node;
+    return node;
 }
 
 //
@@ -613,15 +613,15 @@ TIntermNode* TIntermediate::addLoop(TIntermNode *init, TIntermNode* body, TInter
 //
 TIntermBranch* TIntermediate::addBranch(TOperator branchOp, TSourceLoc line)
 {
-	return addBranch(branchOp, 0, line);
+    return addBranch(branchOp, 0, line);
 }
 
 TIntermBranch* TIntermediate::addBranch(TOperator branchOp, TIntermTyped* expression, TSourceLoc line)
 {
-	TIntermBranch* node = new TIntermBranch(branchOp, expression);
-	node->setLine(line);
+    TIntermBranch* node = new TIntermBranch(branchOp, expression);
+    node->setLine(line);
 
-	return node;
+    return node;
 }
 
 //
@@ -630,17 +630,17 @@ TIntermBranch* TIntermediate::addBranch(TOperator branchOp, TIntermTyped* expres
 //
 bool TIntermediate::postProcess(TIntermNode* root, EShLanguage language)
 {
-	if (root == 0)
-		return true;
+    if (root == 0)
+        return true;
 
-	//
-	// First, finish off the top level sequence, if any
-	//
-	TIntermAggregate* aggRoot = root->getAsAggregate();
-	if (aggRoot && aggRoot->getOp() == EOpNull)
-		aggRoot->setOperator(EOpSequence);
+    //
+    // First, finish off the top level sequence, if any
+    //
+    TIntermAggregate* aggRoot = root->getAsAggregate();
+    if (aggRoot && aggRoot->getOp() == EOpNull)
+        aggRoot->setOperator(EOpSequence);
 
-	return true;
+    return true;
 }
 
 //
@@ -648,8 +648,8 @@ bool TIntermediate::postProcess(TIntermNode* root, EShLanguage language)
 //
 void TIntermediate::remove(TIntermNode* root)
 {
-	if (root)
-		RemoveAllTreeNodes(root);
+    if (root)
+        RemoveAllTreeNodes(root);
 }
 
 ////////////////////////////////////////////////////////////////
@@ -665,24 +665,24 @@ void TIntermediate::remove(TIntermNode* root)
 //
 bool TIntermOperator::modifiesState() const
 {
-	switch (op) {
-	case EOpPostIncrement:
-	case EOpPostDecrement:
-	case EOpPreIncrement:
-	case EOpPreDecrement:
-	case EOpAssign:
-	case EOpAddAssign:
-	case EOpSubAssign:
-	case EOpMulAssign:
-	case EOpVectorTimesMatrixAssign:
-	case EOpVectorTimesScalarAssign:
-	case EOpMatrixTimesScalarAssign:
-	case EOpMatrixTimesMatrixAssign:
-	case EOpDivAssign:
-		return true;
-	default:
-		return false;
-	}
+    switch (op) {
+        case EOpPostIncrement:
+        case EOpPostDecrement:
+        case EOpPreIncrement:
+        case EOpPreDecrement:
+        case EOpAssign:
+        case EOpAddAssign:
+        case EOpSubAssign:
+        case EOpMulAssign:
+        case EOpVectorTimesMatrixAssign:
+        case EOpVectorTimesScalarAssign:
+        case EOpMatrixTimesScalarAssign:
+        case EOpMatrixTimesMatrixAssign:
+        case EOpDivAssign:
+            return true;
+        default:
+            return false;
+    }
 }
 
 //
@@ -690,27 +690,27 @@ bool TIntermOperator::modifiesState() const
 //
 bool TIntermOperator::isConstructor() const
 {
-	switch (op) {
-	case EOpConstructVec2:
-	case EOpConstructVec3:
-	case EOpConstructVec4:
-	case EOpConstructMat2:
-	case EOpConstructMat3:
-	case EOpConstructMat4:
-	case EOpConstructFloat:
-	case EOpConstructIVec2:
-	case EOpConstructIVec3:
-	case EOpConstructIVec4:
-	case EOpConstructInt:
-	case EOpConstructBVec2:
-	case EOpConstructBVec3:
-	case EOpConstructBVec4:
-	case EOpConstructBool:
-	case EOpConstructStruct:
-		return true;
-	default:
-		return false;
-	}
+    switch (op) {
+        case EOpConstructVec2:
+        case EOpConstructVec3:
+        case EOpConstructVec4:
+        case EOpConstructMat2:
+        case EOpConstructMat3:
+        case EOpConstructMat4:
+        case EOpConstructFloat:
+        case EOpConstructIVec2:
+        case EOpConstructIVec3:
+        case EOpConstructIVec4:
+        case EOpConstructInt:
+        case EOpConstructBVec2:
+        case EOpConstructBVec3:
+        case EOpConstructBVec4:
+        case EOpConstructBool:
+        case EOpConstructStruct:
+            return true;
+        default:
+            return false;
+    }
 }
 //
 // Make sure the type of a unary operator is appropriate for its
@@ -720,34 +720,34 @@ bool TIntermOperator::isConstructor() const
 //
 bool TIntermUnary::promote(TInfoSink&)
 {
-	switch (op) {
-	case EOpLogicalNot:
-		if (operand->getBasicType() != EbtBool)
-			return false;
-		break;
-	case EOpNegative:
-	case EOpPostIncrement:
-	case EOpPostDecrement:
-	case EOpPreIncrement:
-	case EOpPreDecrement:
-		if (operand->getBasicType() == EbtBool)
-			return false;
-		break;
-
-	// operators for built-ins are already type checked against their prototype
-	case EOpAny:
-	case EOpAll:
-	case EOpVectorLogicalNot:
-		return true;
-
-	default:
-		if (operand->getBasicType() != EbtFloat)
-			return false;
-	}
-
-	setType(operand->getType());
-
-	return true;
+    switch (op) {
+        case EOpLogicalNot:
+            if (operand->getBasicType() != EbtBool)
+                return false;
+            break;
+        case EOpNegative:
+        case EOpPostIncrement:
+        case EOpPostDecrement:
+        case EOpPreIncrement:
+        case EOpPreDecrement:
+            if (operand->getBasicType() == EbtBool)
+                return false;
+            break;
+
+            // operators for built-ins are already type checked against their prototype
+        case EOpAny:
+        case EOpAll:
+        case EOpVectorLogicalNot:
+            return true;
+
+        default:
+            if (operand->getBasicType() != EbtFloat)
+                return false;
+    }
+
+    setType(operand->getType());
+
+    return true;
 }
 
 //
@@ -758,261 +758,261 @@ bool TIntermUnary::promote(TInfoSink&)
 //
 bool TIntermBinary::promote(TInfoSink& infoSink)
 {
-	int size = left->getNominalSize();
-	if (right->getNominalSize() > size)
-		size = right->getNominalSize();
-
-	TBasicType type = left->getBasicType();
-
-	//
-	// Arrays have to be exact matches.
-	//
-	if ((left->isArray() || right->isArray()) && (left->getType() != right->getType()))
-		return false;
-
-	//
-	// Base assumption:  just make the type the same as the left
-	// operand.  Then only deviations from this need be coded.
-	//
-	setType(TType(type, EvqTemporary, left->getNominalSize(), left->isMatrix()));
-
-	//
-	// Array operations.
-	//
-	if (left->isArray()) {
-
-		switch (op) {
-
-		//
-		// Promote to conditional
-		//
-		case EOpEqual:
-		case EOpNotEqual:
-			setType(TType(EbtBool));
-			break;
-
-		//
-		// Set array information.
-		//
-		case EOpAssign:
-                case EOpInitialize:
-                        getTypePointer()->setArraySize(left->getType().getArraySize());
-			getTypePointer()->setArrayInformationType(left->getType().getArrayInformationType());
-			break;
-
-		default:
-			return false;
-		}
-
-		return true;
-	}
-
-	//
-	// All scalars.  Code after this test assumes this case is removed!
-	//
-	if (size == 1) {
-
-		switch (op) {
-
-		//
-		// Promote to conditional
-		//
-		case EOpEqual:
-		case EOpNotEqual:
-		case EOpLessThan:
-		case EOpGreaterThan:
-		case EOpLessThanEqual:
-		case EOpGreaterThanEqual:
-			setType(TType(EbtBool));
-			break;
-
-		//
-		// And and Or operate on conditionals
-		//
-		case EOpLogicalAnd:
-		case EOpLogicalOr:
-			if (left->getBasicType() != EbtBool || right->getBasicType() != EbtBool)
-				return false;
-			setType(TType(EbtBool));
-			break;
-
-		//
-		// Everything else should have matching types
-		//
-		default:
-			if (left->getBasicType() != right->getBasicType() ||
-				left->isMatrix()     != right->isMatrix())
-				return false;
-		}
-
-		return true;
-	}
-
-	//
-	// Are the sizes compatible?
-	//
-	if ( left->getNominalSize() != size &&  left->getNominalSize() != 1 ||
-		right->getNominalSize() != size && right->getNominalSize() != 1)
-		return false;
-
-	//
-	// Can these two operands be combined?
-	//
-	switch (op) {
-	case EOpMul:
-		if (!left->isMatrix() && right->isMatrix()) {
-			if (left->isVector())
-				op = EOpVectorTimesMatrix;
-			else {
-				op = EOpMatrixTimesScalar;
-				setType(TType(type, EvqTemporary, size, true));
-			}
-		} else if (left->isMatrix() && !right->isMatrix()) {
-			if (right->isVector()) {
-				op = EOpMatrixTimesVector;
-				setType(TType(type, EvqTemporary, size, false));
-			} else {
-				op = EOpMatrixTimesScalar;
-			}
-		} else if (left->isMatrix() && right->isMatrix()) {
-			op = EOpMatrixTimesMatrix;
-		} else if (!left->isMatrix() && !right->isMatrix()) {
-			if (left->isVector() && right->isVector()) {
-				// leave as component product
-			} else if (left->isVector() || right->isVector()) {
-				op = EOpVectorTimesScalar;
-				setType(TType(type, EvqTemporary, size, false));
-			}
-		} else {
-			infoSink.info.message(EPrefixInternalError, "Missing elses", getLine());
-			return false;
-		}
-		break;
-	case EOpMulAssign:
-		if (!left->isMatrix() && right->isMatrix()) {
-			if (left->isVector())
-				op = EOpVectorTimesMatrixAssign;
-			else {
-				return false;
-			}
-		} else if (left->isMatrix() && !right->isMatrix()) {
-			if (right->isVector()) {
-				return false;
-			} else {
-				op = EOpMatrixTimesScalarAssign;
-			}
-		} else if (left->isMatrix() && right->isMatrix()) {
-			op = EOpMatrixTimesMatrixAssign;
-		} else if (!left->isMatrix() && !right->isMatrix()) {
-			if (left->isVector() && right->isVector()) {
-				// leave as component product
-			} else if (left->isVector() || right->isVector()) {
-				if (! left->isVector())
-					return false;
-				op = EOpVectorTimesScalarAssign;
-				setType(TType(type, EvqTemporary, size, false));
-			}
-		} else {
-			infoSink.info.message(EPrefixInternalError, "Missing elses", getLine());
-			return false;
-		}
-		break;
-	case EOpAssign:
-	case EOpInitialize:
-		if (left->getNominalSize() != right->getNominalSize())
-			return false;
-		// fall through
-	case EOpAdd:
-	case EOpSub:
-	case EOpDiv:
-	case EOpAddAssign:
-	case EOpSubAssign:
-	case EOpDivAssign:
-		if (left->isMatrix() && right->isVector() ||
-			left->isVector() && right->isMatrix() ||
-			left->getBasicType() != right->getBasicType())
-			return false;
-		setType(TType(type, EvqTemporary, size, left->isMatrix() || right->isMatrix()));
-		break;
-
-	case EOpEqual:
-	case EOpNotEqual:
-	case EOpLessThan:
-	case EOpGreaterThan:
-	case EOpLessThanEqual:
-	case EOpGreaterThanEqual:
-		if (left->isMatrix() && right->isVector() ||
-			left->isVector() && right->isMatrix() ||
-			left->getBasicType() != right->getBasicType())
-			return false;
-		setType(TType(EbtBool));
-		break;
-
-default:
-		return false;
-	}
-
-	//
-	// One more check for assignment.  The Resulting type has to match the left operand.
-	//
-	switch (op) {
-	case EOpAssign:
-	case EOpInitialize:
-	case EOpAddAssign:
-	case EOpSubAssign:
-	case EOpMulAssign:
-	case EOpDivAssign:
-		if (getType() != left->getType())
-			return false;
-		break;
-	default:
-		break;
-	}
-
-	return true;
+    int size = left->getNominalSize();
+    if (right->getNominalSize() > size)
+        size = right->getNominalSize();
+
+    TBasicType type = left->getBasicType();
+
+    //
+    // Arrays have to be exact matches.
+    //
+    if ((left->isArray() || right->isArray()) && (left->getType() != right->getType()))
+        return false;
+
+    //
+    // Base assumption:  just make the type the same as the left
+    // operand.  Then only deviations from this need be coded.
+    //
+    setType(TType(type, EvqTemporary, left->getNominalSize(), left->isMatrix()));
+
+    //
+    // Array operations.
+    //
+    if (left->isArray()) {
+
+        switch (op) {
+
+            //
+            // Promote to conditional
+            //
+            case EOpEqual:
+            case EOpNotEqual:
+                setType(TType(EbtBool));
+                break;
+
+            //
+            // Set array information.
+            //
+            case EOpAssign:
+            case EOpInitialize:
+                getTypePointer()->setArraySize(left->getType().getArraySize());
+                getTypePointer()->setArrayInformationType(left->getType().getArrayInformationType());
+                break;
+
+            default:
+                return false;
+        }
+
+        return true;
+    }
+
+    //
+    // All scalars.  Code after this test assumes this case is removed!
+    //
+    if (size == 1) {
+
+        switch (op) {
+
+            //
+            // Promote to conditional
+            //
+            case EOpEqual:
+            case EOpNotEqual:
+            case EOpLessThan:
+            case EOpGreaterThan:
+            case EOpLessThanEqual:
+            case EOpGreaterThanEqual:
+                setType(TType(EbtBool));
+                break;
+
+            //
+            // And and Or operate on conditionals
+            //
+            case EOpLogicalAnd:
+            case EOpLogicalOr:
+                if (left->getBasicType() != EbtBool || right->getBasicType() != EbtBool)
+                    return false;
+                setType(TType(EbtBool));
+                break;
+
+            //
+            // Everything else should have matching types
+            //
+            default:
+                if (left->getBasicType() != right->getBasicType() ||
+                    left->isMatrix()     != right->isMatrix())
+                    return false;
+        }
+
+        return true;
+    }
+
+    //
+    // Are the sizes compatible?
+    //
+    if ( left->getNominalSize() != size &&  left->getNominalSize() != 1 ||
+        right->getNominalSize() != size && right->getNominalSize() != 1)
+        return false;
+
+    //
+    // Can these two operands be combined?
+    //
+    switch (op) {
+        case EOpMul:
+            if (!left->isMatrix() && right->isMatrix()) {
+                if (left->isVector())
+                    op = EOpVectorTimesMatrix;
+                else {
+                    op = EOpMatrixTimesScalar;
+                    setType(TType(type, EvqTemporary, size, true));
+                }
+            } else if (left->isMatrix() && !right->isMatrix()) {
+                if (right->isVector()) {
+                    op = EOpMatrixTimesVector;
+                    setType(TType(type, EvqTemporary, size, false));
+                } else {
+                    op = EOpMatrixTimesScalar;
+                }
+            } else if (left->isMatrix() && right->isMatrix()) {
+                op = EOpMatrixTimesMatrix;
+            } else if (!left->isMatrix() && !right->isMatrix()) {
+                if (left->isVector() && right->isVector()) {
+                    // leave as component product
+                } else if (left->isVector() || right->isVector()) {
+                    op = EOpVectorTimesScalar;
+                    setType(TType(type, EvqTemporary, size, false));
+                }
+            } else {
+                infoSink.info.message(EPrefixInternalError, "Missing elses", getLine());
+                return false;
+            }
+            break;
+        case EOpMulAssign:
+            if (!left->isMatrix() && right->isMatrix()) {
+                if (left->isVector())
+                    op = EOpVectorTimesMatrixAssign;
+                else {
+                    return false;
+                }
+            } else if (left->isMatrix() && !right->isMatrix()) {
+                if (right->isVector()) {
+                    return false;
+                } else {
+                    op = EOpMatrixTimesScalarAssign;
+                }
+            } else if (left->isMatrix() && right->isMatrix()) {
+                op = EOpMatrixTimesMatrixAssign;
+            } else if (!left->isMatrix() && !right->isMatrix()) {
+                if (left->isVector() && right->isVector()) {
+                    // leave as component product
+                } else if (left->isVector() || right->isVector()) {
+                    if (! left->isVector())
+                        return false;
+                    op = EOpVectorTimesScalarAssign;
+                    setType(TType(type, EvqTemporary, size, false));
+                }
+            } else {
+                infoSink.info.message(EPrefixInternalError, "Missing elses", getLine());
+                return false;
+            }
+            break;
+        case EOpAssign:
+        case EOpInitialize:
+            if (left->getNominalSize() != right->getNominalSize())
+                return false;
+            // fall through
+        case EOpAdd:
+        case EOpSub:
+        case EOpDiv:
+        case EOpAddAssign:
+        case EOpSubAssign:
+        case EOpDivAssign:
+            if (left->isMatrix() && right->isVector() ||
+                left->isVector() && right->isMatrix() ||
+                left->getBasicType() != right->getBasicType())
+                return false;
+            setType(TType(type, EvqTemporary, size, left->isMatrix() || right->isMatrix()));
+            break;
+
+        case EOpEqual:
+        case EOpNotEqual:
+        case EOpLessThan:
+        case EOpGreaterThan:
+        case EOpLessThanEqual:
+        case EOpGreaterThanEqual:
+            if (left->isMatrix() && right->isVector() ||
+                left->isVector() && right->isMatrix() ||
+                left->getBasicType() != right->getBasicType())
+                return false;
+            setType(TType(EbtBool));
+            break;
+
+        default:
+            return false;
+    }
+
+    //
+    // One more check for assignment.  The Resulting type has to match the left operand.
+    //
+    switch (op) {
+        case EOpAssign:
+        case EOpInitialize:
+        case EOpAddAssign:
+        case EOpSubAssign:
+        case EOpMulAssign:
+        case EOpDivAssign:
+            if (getType() != left->getType())
+                return false;
+            break;
+        default:
+            break;
+    }
+
+    return true;
 }
 
 bool CompareStruct(const TType& leftNodeType, constUnion* rightUnionArray, constUnion* leftUnionArray)
 {
-	TTypeList* fields = leftNodeType.getStruct();
-
-	size_t structSize = fields->size();
-	int index = 0;
-
-	for (size_t j = 0; j < structSize; j++) {
-		int size = (*fields)[j].type->getObjectSize();
-		for (int i = 0; i < size; i++) {
-			if ((*fields)[j].type->getBasicType() == EbtStruct) {
-				if (!CompareStructure(*(*fields)[j].type, &rightUnionArray[index], &leftUnionArray[index]))
-					return false;
-			} else {
-				if (leftUnionArray[index] != rightUnionArray[index])
-					return false;
-				index++;
-			}
-
-		}
-	}
-	return true;
+    TTypeList* fields = leftNodeType.getStruct();
+
+    size_t structSize = fields->size();
+    int index = 0;
+
+    for (size_t j = 0; j < structSize; j++) {
+        int size = (*fields)[j].type->getObjectSize();
+        for (int i = 0; i < size; i++) {
+            if ((*fields)[j].type->getBasicType() == EbtStruct) {
+                if (!CompareStructure(*(*fields)[j].type, &rightUnionArray[index], &leftUnionArray[index]))
+                    return false;
+            } else {
+                if (leftUnionArray[index] != rightUnionArray[index])
+                    return false;
+                index++;
+            }
+
+        }
+    }
+    return true;
 }
 
 bool CompareStructure(const TType& leftNodeType, constUnion* rightUnionArray, constUnion* leftUnionArray)
 {
-	if (leftNodeType.isArray()) {
-		TType typeWithoutArrayness = leftNodeType;
-		typeWithoutArrayness.clearArrayness();
+    if (leftNodeType.isArray()) {
+        TType typeWithoutArrayness = leftNodeType;
+        typeWithoutArrayness.clearArrayness();
 
-		int arraySize = leftNodeType.getArraySize();
+        int arraySize = leftNodeType.getArraySize();
 
-		for (int i = 0; i < arraySize; ++i) {
-			int offset = typeWithoutArrayness.getObjectSize() * i;
-			if (!CompareStruct(typeWithoutArrayness, &rightUnionArray[offset], &leftUnionArray[offset]))
-				return false;
-		}
-	} else
-		return CompareStruct(leftNodeType, rightUnionArray, leftUnionArray);
+        for (int i = 0; i < arraySize; ++i) {
+            int offset = typeWithoutArrayness.getObjectSize() * i;
+            if (!CompareStruct(typeWithoutArrayness, &rightUnionArray[offset], &leftUnionArray[offset]))
+                return false;
+        }
+    } else
+        return CompareStruct(leftNodeType, rightUnionArray, leftUnionArray);
 
-	return true;
+    return true;
 }
 
 //
@@ -1024,374 +1024,374 @@ bool CompareStructure(const TType& leftNodeType, constUnion* rightUnionArray, co
 
 TIntermTyped* TIntermConstantUnion::fold(TOperator op, TIntermTyped* constantNode, TInfoSink& infoSink)
 {
-	constUnion *unionArray = getUnionArrayPointer();
-	int objectSize = getType().getObjectSize();
-
-	if (constantNode) {  // binary operations
-		TIntermConstantUnion *node = constantNode->getAsConstantUnion();
-		constUnion *rightUnionArray = node->getUnionArrayPointer();
-		TType returnType = getType();
-
-		// for a case like float f = 1.2 + vec4(2,3,4,5);
-		if (constantNode->getType().getObjectSize() == 1 && objectSize > 1) {
-			rightUnionArray = new constUnion[objectSize];
-			for (int i = 0; i < objectSize; ++i)
-				rightUnionArray[i] = *node->getUnionArrayPointer();
-			returnType = getType();
-		} else if (constantNode->getType().getObjectSize() > 1 && objectSize == 1) {
-			// for a case like float f = vec4(2,3,4,5) + 1.2;
-			unionArray = new constUnion[constantNode->getType().getObjectSize()];
-			for (int i = 0; i < constantNode->getType().getObjectSize(); ++i)
-				unionArray[i] = *getUnionArrayPointer();
-			returnType = node->getType();
-			objectSize = constantNode->getType().getObjectSize();
-		}
-
-		constUnion* tempConstArray = 0;
-		TIntermConstantUnion *tempNode;
-
-		bool boolNodeFlag = false;
-		switch(op) {
-		case EOpAdd:
-			tempConstArray = new constUnion[objectSize];
-			{// support MSVC++6.0
-				for (int i = 0; i < objectSize; i++)
-					tempConstArray[i] = unionArray[i] + rightUnionArray[i];
-			}
-			break;
-		case EOpSub:
-			tempConstArray = new constUnion[objectSize];
-			{// support MSVC++6.0
-				for (int i = 0; i < objectSize; i++)
-					tempConstArray[i] = unionArray[i] - rightUnionArray[i];
-			}
-			break;
-
-		case EOpMul:
-		case EOpVectorTimesScalar:
-		case EOpMatrixTimesScalar:
-			tempConstArray = new constUnion[objectSize];
-			{// support MSVC++6.0
-				for (int i = 0; i < objectSize; i++)
-					tempConstArray[i] = unionArray[i] * rightUnionArray[i];
-			}
-			break;
-		case EOpMatrixTimesMatrix:
-			if (getType().getBasicType() != EbtFloat || node->getBasicType() != EbtFloat) {
-				infoSink.info.message(EPrefixInternalError, "Constant Folding cannot be done for matrix multiply", getLine());
-				return 0;
-			}
-			{// support MSVC++6.0
-				int size = getNominalSize();
-				tempConstArray = new constUnion[size*size];
-				for (int row = 0; row < size; row++) {
-					for (int column = 0; column < size; column++) {
-						tempConstArray[size * column + row].setFConst(0.0f);
-						for (int i = 0; i < size; i++) {
-							tempConstArray[size * column + row].setFConst(tempConstArray[size * column + row].getFConst() + unionArray[i * size + row].getFConst() * (rightUnionArray[column * size + i].getFConst()));
-						}
-					}
-				}
-			}
-			break;
-		case EOpDiv:
-			tempConstArray = new constUnion[objectSize];
-			{// support MSVC++6.0
-				for (int i = 0; i < objectSize; i++) {
-					switch (getType().getBasicType()) {
-					case EbtFloat:
-						if (rightUnionArray[i] == 0.0f) {
-							infoSink.info.message(EPrefixWarning, "Divide by zero error during constant folding", getLine());
-							tempConstArray[i].setFConst(FLT_MAX);
-						} else
-							tempConstArray[i].setFConst(unionArray[i].getFConst() / rightUnionArray[i].getFConst());
-					break;
-
-					case EbtInt:
-						if (rightUnionArray[i] == 0) {
-							infoSink.info.message(EPrefixWarning, "Divide by zero error during constant folding", getLine());
-							tempConstArray[i].setIConst(INT_MAX);
-						} else
-							tempConstArray[i].setIConst(unionArray[i].getIConst() / rightUnionArray[i].getIConst());
-						break;
-					default:
-						infoSink.info.message(EPrefixInternalError, "Constant folding cannot be done for \"/\"", getLine());
-						return 0;
-					}
-				}
-			}
-			break;
-
-		case EOpMatrixTimesVector:
-			if (node->getBasicType() != EbtFloat) {
-				infoSink.info.message(EPrefixInternalError, "Constant Folding cannot be done for matrix times vector", getLine());
-				return 0;
-			}
-			tempConstArray = new constUnion[getNominalSize()];
-
-			{// support MSVC++6.0
-				for (int size = getNominalSize(), i = 0; i < size; i++) {
-					tempConstArray[i].setFConst(0.0f);
-					for (int j = 0; j < size; j++) {
-						tempConstArray[i].setFConst(tempConstArray[i].getFConst() + ((unionArray[j*size + i].getFConst()) * rightUnionArray[j].getFConst()));
-					}
-				}
-			}
-
-			tempNode = new TIntermConstantUnion(tempConstArray, node->getType());
-			tempNode->setLine(getLine());
-
-			return tempNode;
-
-		case EOpVectorTimesMatrix:
-			if (getType().getBasicType() != EbtFloat) {
-				infoSink.info.message(EPrefixInternalError, "Constant Folding cannot be done for vector times matrix", getLine());
-				return 0;
-			}
-
-			tempConstArray = new constUnion[getNominalSize()];
-			{// support MSVC++6.0
-				for (int size = getNominalSize(), i = 0; i < size; i++) {
-					tempConstArray[i].setFConst(0.0f);
-					for (int j = 0; j < size; j++) {
-						tempConstArray[i].setFConst(tempConstArray[i].getFConst() + ((unionArray[j].getFConst()) * rightUnionArray[i*size + j].getFConst()));
-					}
-				}
-			}
-			break;
-
-		case EOpLogicalAnd: // this code is written for possible future use, will not get executed currently
-			tempConstArray = new constUnion[objectSize];
-			{// support MSVC++6.0
-				for (int i = 0; i < objectSize; i++)
-					tempConstArray[i] = unionArray[i] && rightUnionArray[i];
-			}
-			break;
-
-		case EOpLogicalOr: // this code is written for possible future use, will not get executed currently
-			tempConstArray = new constUnion[objectSize];
-			{// support MSVC++6.0
-				for (int i = 0; i < objectSize; i++)
-					tempConstArray[i] = unionArray[i] || rightUnionArray[i];
-			}
-			break;
-
-		case EOpLogicalXor:
-			tempConstArray = new constUnion[objectSize];
-			{// support MSVC++6.0
-				for (int i = 0; i < objectSize; i++)
-					switch (getType().getBasicType()) {
-					case EbtBool: tempConstArray[i].setBConst((unionArray[i] == rightUnionArray[i]) ? false : true); break;
-					default: assert(false && "Default missing");
-					}
-			}
-			break;
-
-		case EOpLessThan:
-			assert(objectSize == 1);
-			tempConstArray = new constUnion[1];
-			tempConstArray->setBConst(*unionArray < *rightUnionArray);
-			returnType = TType(EbtBool, EvqConst);
-			break;
-		case EOpGreaterThan:
-			assert(objectSize == 1);
-			tempConstArray = new constUnion[1];
-			tempConstArray->setBConst(*unionArray > *rightUnionArray);
-			returnType = TType(EbtBool, EvqConst);
-			break;
-		case EOpLessThanEqual:
-		{
-			assert(objectSize == 1);
-			constUnion constant;
-			constant.setBConst(*unionArray > *rightUnionArray);
-			tempConstArray = new constUnion[1];
-			tempConstArray->setBConst(!constant.getBConst());
-			returnType = TType(EbtBool, EvqConst);
-			break;
-		}
-		case EOpGreaterThanEqual:
-		{
-			assert(objectSize == 1);
-			constUnion constant;
-			constant.setBConst(*unionArray < *rightUnionArray);
-			tempConstArray = new constUnion[1];
-			tempConstArray->setBConst(!constant.getBConst());
-			returnType = TType(EbtBool, EvqConst);
-			break;
-		}
-
-		case EOpEqual:
-			if (getType().getBasicType() == EbtStruct) {
-				if (!CompareStructure(node->getType(), node->getUnionArrayPointer(), unionArray))
-					boolNodeFlag = true;
-			} else {
-				for (int i = 0; i < objectSize; i++) {
-					if (unionArray[i] != rightUnionArray[i]) {
-						boolNodeFlag = true;
-						break;  // break out of for loop
-					}
-				}
-			}
-
-			tempConstArray = new constUnion[1];
-			if (!boolNodeFlag) {
-				tempConstArray->setBConst(true);
-			}
-			else {
-				tempConstArray->setBConst(false);
-			}
-
-			tempNode = new TIntermConstantUnion(tempConstArray, TType(EbtBool, EvqConst));
-			tempNode->setLine(getLine());
-
-			return tempNode;
-
-		case EOpNotEqual:
-			if (getType().getBasicType() == EbtStruct) {
-				if (CompareStructure(node->getType(), node->getUnionArrayPointer(), unionArray))
-					boolNodeFlag = true;
-			} else {
-				for (int i = 0; i < objectSize; i++) {
-					if (unionArray[i] == rightUnionArray[i]) {
-						boolNodeFlag = true;
-						break;  // break out of for loop
-					}
-				}
-			}
-
-			tempConstArray = new constUnion[1];
-			if (!boolNodeFlag) {
-				tempConstArray->setBConst(true);
-			}
-			else {
-				tempConstArray->setBConst(false);
-			}
-
-			tempNode = new TIntermConstantUnion(tempConstArray, TType(EbtBool, EvqConst));
-			tempNode->setLine(getLine());
-
-			return tempNode;
-
-		default:
-			infoSink.info.message(EPrefixInternalError, "Invalid operator for constant folding", getLine());
-			return 0;
-		}
-		tempNode = new TIntermConstantUnion(tempConstArray, returnType);
-		tempNode->setLine(getLine());
-
-		return tempNode;
-	} else {
-		//
-		// Do unary operations
-		//
-		TIntermConstantUnion *newNode = 0;
-		constUnion* tempConstArray = new constUnion[objectSize];
-		for (int i = 0; i < objectSize; i++) {
-			switch(op) {
-			case EOpNegative:
-				switch (getType().getBasicType()) {
-				case EbtFloat: tempConstArray[i].setFConst(-unionArray[i].getFConst()); break;
-				case EbtInt:   tempConstArray[i].setIConst(-unionArray[i].getIConst()); break;
-				default:
-					infoSink.info.message(EPrefixInternalError, "Unary operation not folded into constant", getLine());
-					return 0;
-				}
-				break;
-			case EOpLogicalNot: // this code is written for possible future use, will not get executed currently
-				switch (getType().getBasicType()) {
-				case EbtBool:  tempConstArray[i].setBConst(!unionArray[i].getBConst()); break;
-				default:
-					infoSink.info.message(EPrefixInternalError, "Unary operation not folded into constant", getLine());
-					return 0;
-				}
-				break;
-			default:
-				return 0;
-			}
-		}
-		newNode = new TIntermConstantUnion(tempConstArray, getType());
-		newNode->setLine(getLine());
-		return newNode;
-	}
-
-	return this;
+    constUnion *unionArray = getUnionArrayPointer();
+    int objectSize = getType().getObjectSize();
+
+    if (constantNode) {  // binary operations
+        TIntermConstantUnion *node = constantNode->getAsConstantUnion();
+        constUnion *rightUnionArray = node->getUnionArrayPointer();
+        TType returnType = getType();
+
+        // for a case like float f = 1.2 + vec4(2,3,4,5);
+        if (constantNode->getType().getObjectSize() == 1 && objectSize > 1) {
+            rightUnionArray = new constUnion[objectSize];
+            for (int i = 0; i < objectSize; ++i)
+                rightUnionArray[i] = *node->getUnionArrayPointer();
+            returnType = getType();
+        } else if (constantNode->getType().getObjectSize() > 1 && objectSize == 1) {
+            // for a case like float f = vec4(2,3,4,5) + 1.2;
+            unionArray = new constUnion[constantNode->getType().getObjectSize()];
+            for (int i = 0; i < constantNode->getType().getObjectSize(); ++i)
+                unionArray[i] = *getUnionArrayPointer();
+            returnType = node->getType();
+            objectSize = constantNode->getType().getObjectSize();
+        }
+
+        constUnion* tempConstArray = 0;
+        TIntermConstantUnion *tempNode;
+
+        bool boolNodeFlag = false;
+        switch(op) {
+            case EOpAdd:
+                tempConstArray = new constUnion[objectSize];
+                {// support MSVC++6.0
+                    for (int i = 0; i < objectSize; i++)
+                        tempConstArray[i] = unionArray[i] + rightUnionArray[i];
+                }
+                break;
+            case EOpSub:
+                tempConstArray = new constUnion[objectSize];
+                {// support MSVC++6.0
+                    for (int i = 0; i < objectSize; i++)
+                        tempConstArray[i] = unionArray[i] - rightUnionArray[i];
+                }
+                break;
+
+            case EOpMul:
+            case EOpVectorTimesScalar:
+            case EOpMatrixTimesScalar:
+                tempConstArray = new constUnion[objectSize];
+                {// support MSVC++6.0
+                    for (int i = 0; i < objectSize; i++)
+                        tempConstArray[i] = unionArray[i] * rightUnionArray[i];
+                }
+                break;
+            case EOpMatrixTimesMatrix:
+                if (getType().getBasicType() != EbtFloat || node->getBasicType() != EbtFloat) {
+                    infoSink.info.message(EPrefixInternalError, "Constant Folding cannot be done for matrix multiply", getLine());
+                    return 0;
+                }
+                {// support MSVC++6.0
+                    int size = getNominalSize();
+                    tempConstArray = new constUnion[size*size];
+                    for (int row = 0; row < size; row++) {
+                        for (int column = 0; column < size; column++) {
+                            tempConstArray[size * column + row].setFConst(0.0f);
+                            for (int i = 0; i < size; i++) {
+                                tempConstArray[size * column + row].setFConst(tempConstArray[size * column + row].getFConst() + unionArray[i * size + row].getFConst() * (rightUnionArray[column * size + i].getFConst()));
+                            }
+                        }
+                    }
+                }
+                break;
+            case EOpDiv:
+                tempConstArray = new constUnion[objectSize];
+                {// support MSVC++6.0
+                    for (int i = 0; i < objectSize; i++) {
+                        switch (getType().getBasicType()) {
+            case EbtFloat:
+                if (rightUnionArray[i] == 0.0f) {
+                    infoSink.info.message(EPrefixWarning, "Divide by zero error during constant folding", getLine());
+                    tempConstArray[i].setFConst(FLT_MAX);
+                } else
+                    tempConstArray[i].setFConst(unionArray[i].getFConst() / rightUnionArray[i].getFConst());
+                break;
+
+            case EbtInt:
+                if (rightUnionArray[i] == 0) {
+                    infoSink.info.message(EPrefixWarning, "Divide by zero error during constant folding", getLine());
+                    tempConstArray[i].setIConst(INT_MAX);
+                } else
+                    tempConstArray[i].setIConst(unionArray[i].getIConst() / rightUnionArray[i].getIConst());
+                break;
+            default:
+                infoSink.info.message(EPrefixInternalError, "Constant folding cannot be done for \"/\"", getLine());
+                return 0;
+                        }
+                    }
+                }
+                break;
+
+            case EOpMatrixTimesVector:
+                if (node->getBasicType() != EbtFloat) {
+                    infoSink.info.message(EPrefixInternalError, "Constant Folding cannot be done for matrix times vector", getLine());
+                    return 0;
+                }
+                tempConstArray = new constUnion[getNominalSize()];
+
+                {// support MSVC++6.0
+                    for (int size = getNominalSize(), i = 0; i < size; i++) {
+                        tempConstArray[i].setFConst(0.0f);
+                        for (int j = 0; j < size; j++) {
+                            tempConstArray[i].setFConst(tempConstArray[i].getFConst() + ((unionArray[j*size + i].getFConst()) * rightUnionArray[j].getFConst()));
+                        }
+                    }
+                }
+
+                tempNode = new TIntermConstantUnion(tempConstArray, node->getType());
+                tempNode->setLine(getLine());
+
+                return tempNode;
+
+            case EOpVectorTimesMatrix:
+                if (getType().getBasicType() != EbtFloat) {
+                    infoSink.info.message(EPrefixInternalError, "Constant Folding cannot be done for vector times matrix", getLine());
+                    return 0;
+                }
+
+                tempConstArray = new constUnion[getNominalSize()];
+                {// support MSVC++6.0
+                    for (int size = getNominalSize(), i = 0; i < size; i++) {
+                        tempConstArray[i].setFConst(0.0f);
+                        for (int j = 0; j < size; j++) {
+                            tempConstArray[i].setFConst(tempConstArray[i].getFConst() + ((unionArray[j].getFConst()) * rightUnionArray[i*size + j].getFConst()));
+                        }
+                    }
+                }
+                break;
+
+            case EOpLogicalAnd: // this code is written for possible future use, will not get executed currently
+                tempConstArray = new constUnion[objectSize];
+                {// support MSVC++6.0
+                    for (int i = 0; i < objectSize; i++)
+                        tempConstArray[i] = unionArray[i] && rightUnionArray[i];
+                }
+                break;
+
+            case EOpLogicalOr: // this code is written for possible future use, will not get executed currently
+                tempConstArray = new constUnion[objectSize];
+                {// support MSVC++6.0
+                    for (int i = 0; i < objectSize; i++)
+                        tempConstArray[i] = unionArray[i] || rightUnionArray[i];
+                }
+                break;
+
+            case EOpLogicalXor:
+                tempConstArray = new constUnion[objectSize];
+                {// support MSVC++6.0
+                    for (int i = 0; i < objectSize; i++)
+                        switch (getType().getBasicType()) {
+            case EbtBool: tempConstArray[i].setBConst((unionArray[i] == rightUnionArray[i]) ? false : true); break;
+            default: assert(false && "Default missing");
+                    }
+                }
+                break;
+
+            case EOpLessThan:
+                assert(objectSize == 1);
+                tempConstArray = new constUnion[1];
+                tempConstArray->setBConst(*unionArray < *rightUnionArray);
+                returnType = TType(EbtBool, EvqConst);
+                break;
+            case EOpGreaterThan:
+                assert(objectSize == 1);
+                tempConstArray = new constUnion[1];
+                tempConstArray->setBConst(*unionArray > *rightUnionArray);
+                returnType = TType(EbtBool, EvqConst);
+                break;
+            case EOpLessThanEqual:
+                {
+                    assert(objectSize == 1);
+                    constUnion constant;
+                    constant.setBConst(*unionArray > *rightUnionArray);
+                    tempConstArray = new constUnion[1];
+                    tempConstArray->setBConst(!constant.getBConst());
+                    returnType = TType(EbtBool, EvqConst);
+                    break;
+                }
+            case EOpGreaterThanEqual:
+                {
+                    assert(objectSize == 1);
+                    constUnion constant;
+                    constant.setBConst(*unionArray < *rightUnionArray);
+                    tempConstArray = new constUnion[1];
+                    tempConstArray->setBConst(!constant.getBConst());
+                    returnType = TType(EbtBool, EvqConst);
+                    break;
+                }
+
+            case EOpEqual:
+                if (getType().getBasicType() == EbtStruct) {
+                    if (!CompareStructure(node->getType(), node->getUnionArrayPointer(), unionArray))
+                        boolNodeFlag = true;
+                } else {
+                    for (int i = 0; i < objectSize; i++) {
+                        if (unionArray[i] != rightUnionArray[i]) {
+                            boolNodeFlag = true;
+                            break;  // break out of for loop
+                        }
+                    }
+                }
+
+                tempConstArray = new constUnion[1];
+                if (!boolNodeFlag) {
+                    tempConstArray->setBConst(true);
+                }
+                else {
+                    tempConstArray->setBConst(false);
+                }
+
+                tempNode = new TIntermConstantUnion(tempConstArray, TType(EbtBool, EvqConst));
+                tempNode->setLine(getLine());
+
+                return tempNode;
+
+            case EOpNotEqual:
+                if (getType().getBasicType() == EbtStruct) {
+                    if (CompareStructure(node->getType(), node->getUnionArrayPointer(), unionArray))
+                        boolNodeFlag = true;
+                } else {
+                    for (int i = 0; i < objectSize; i++) {
+                        if (unionArray[i] == rightUnionArray[i]) {
+                            boolNodeFlag = true;
+                            break;  // break out of for loop
+                        }
+                    }
+                }
+
+                tempConstArray = new constUnion[1];
+                if (!boolNodeFlag) {
+                    tempConstArray->setBConst(true);
+                }
+                else {
+                    tempConstArray->setBConst(false);
+                }
+
+                tempNode = new TIntermConstantUnion(tempConstArray, TType(EbtBool, EvqConst));
+                tempNode->setLine(getLine());
+
+                return tempNode;
+
+            default:
+                infoSink.info.message(EPrefixInternalError, "Invalid operator for constant folding", getLine());
+                return 0;
+        }
+        tempNode = new TIntermConstantUnion(tempConstArray, returnType);
+        tempNode->setLine(getLine());
+
+        return tempNode;
+    } else {
+        //
+        // Do unary operations
+        //
+        TIntermConstantUnion *newNode = 0;
+        constUnion* tempConstArray = new constUnion[objectSize];
+        for (int i = 0; i < objectSize; i++) {
+            switch(op) {
+                case EOpNegative:
+                    switch (getType().getBasicType()) {
+                        case EbtFloat: tempConstArray[i].setFConst(-unionArray[i].getFConst()); break;
+                        case EbtInt:   tempConstArray[i].setIConst(-unionArray[i].getIConst()); break;
+                        default:
+                            infoSink.info.message(EPrefixInternalError, "Unary operation not folded into constant", getLine());
+                            return 0;
+                    }
+                    break;
+                case EOpLogicalNot: // this code is written for possible future use, will not get executed currently
+                    switch (getType().getBasicType()) {
+                        case EbtBool:  tempConstArray[i].setBConst(!unionArray[i].getBConst()); break;
+                        default:
+                            infoSink.info.message(EPrefixInternalError, "Unary operation not folded into constant", getLine());
+                            return 0;
+                    }
+                    break;
+                default:
+                    return 0;
+            }
+        }
+        newNode = new TIntermConstantUnion(tempConstArray, getType());
+        newNode->setLine(getLine());
+        return newNode;
+    }
+
+    return this;
 }
 
 TIntermTyped* TIntermediate::promoteConstantUnion(TBasicType promoteTo, TIntermConstantUnion* node)
 {
-	constUnion *rightUnionArray = node->getUnionArrayPointer();
-	int size = node->getType().getObjectSize();
-
-	constUnion *leftUnionArray = new constUnion[size];
-
-	for (int i=0; i < size; i++) {
-
-		switch (promoteTo) {
-		case EbtFloat:
-			switch (node->getType().getBasicType()) {
-			case EbtInt:
-				leftUnionArray[i].setFConst(static_cast<float>(rightUnionArray[i].getIConst()));
-				break;
-			case EbtBool:
-				leftUnionArray[i].setFConst(static_cast<float>(rightUnionArray[i].getBConst()));
-				break;
-			case EbtFloat:
-				leftUnionArray[i] = rightUnionArray[i];
-				break;
-			default:
-				infoSink.info.message(EPrefixInternalError, "Cannot promote", node->getLine());
-				return 0;
-			}
-			break;
-		case EbtInt:
-			switch (node->getType().getBasicType()) {
-			case EbtInt:
-				leftUnionArray[i] = rightUnionArray[i];
-				break;
-			case EbtBool:
-				leftUnionArray[i].setIConst(static_cast<int>(rightUnionArray[i].getBConst()));
-				break;
-			case EbtFloat:
-				leftUnionArray[i].setIConst(static_cast<int>(rightUnionArray[i].getFConst()));
-				break;
-			default:
-				infoSink.info.message(EPrefixInternalError, "Cannot promote", node->getLine());
-				return 0;
-			}
-			break;
-		case EbtBool:
-			switch (node->getType().getBasicType()) {
-			case EbtInt:
-				leftUnionArray[i].setBConst(rightUnionArray[i].getIConst() != 0);
-				break;
-			case EbtBool:
-				leftUnionArray[i] = rightUnionArray[i];
-				break;
-			case EbtFloat:
-				leftUnionArray[i].setBConst(rightUnionArray[i].getFConst() != 0.0f);
-				break;
-			default:
-				infoSink.info.message(EPrefixInternalError, "Cannot promote", node->getLine());
-				return 0;
-			}
-
-			break;
-		default:
-			infoSink.info.message(EPrefixInternalError, "Incorrect data type found", node->getLine());
-			return 0;
-		}
-
-	}
-
-	const TType& t = node->getType();
-
-	return addConstantUnion(leftUnionArray, TType(promoteTo, t.getQualifier(), t.getNominalSize(), t.isMatrix(), t.isArray()), node->getLine());
+    constUnion *rightUnionArray = node->getUnionArrayPointer();
+    int size = node->getType().getObjectSize();
+
+    constUnion *leftUnionArray = new constUnion[size];
+
+    for (int i=0; i < size; i++) {
+
+        switch (promoteTo) {
+            case EbtFloat:
+                switch (node->getType().getBasicType()) {
+                    case EbtInt:
+                        leftUnionArray[i].setFConst(static_cast<float>(rightUnionArray[i].getIConst()));
+                        break;
+                    case EbtBool:
+                        leftUnionArray[i].setFConst(static_cast<float>(rightUnionArray[i].getBConst()));
+                        break;
+                    case EbtFloat:
+                        leftUnionArray[i] = rightUnionArray[i];
+                        break;
+                    default:
+                        infoSink.info.message(EPrefixInternalError, "Cannot promote", node->getLine());
+                        return 0;
+                }
+                break;
+            case EbtInt:
+                switch (node->getType().getBasicType()) {
+                    case EbtInt:
+                        leftUnionArray[i] = rightUnionArray[i];
+                        break;
+                    case EbtBool:
+                        leftUnionArray[i].setIConst(static_cast<int>(rightUnionArray[i].getBConst()));
+                        break;
+                    case EbtFloat:
+                        leftUnionArray[i].setIConst(static_cast<int>(rightUnionArray[i].getFConst()));
+                        break;
+                    default:
+                        infoSink.info.message(EPrefixInternalError, "Cannot promote", node->getLine());
+                        return 0;
+                }
+                break;
+            case EbtBool:
+                switch (node->getType().getBasicType()) {
+                    case EbtInt:
+                        leftUnionArray[i].setBConst(rightUnionArray[i].getIConst() != 0);
+                        break;
+                    case EbtBool:
+                        leftUnionArray[i] = rightUnionArray[i];
+                        break;
+                    case EbtFloat:
+                        leftUnionArray[i].setBConst(rightUnionArray[i].getFConst() != 0.0f);
+                        break;
+                    default:
+                        infoSink.info.message(EPrefixInternalError, "Cannot promote", node->getLine());
+                        return 0;
+                }
+
+                break;
+            default:
+                infoSink.info.message(EPrefixInternalError, "Incorrect data type found", node->getLine());
+                return 0;
+        }
+
+    }
+
+    const TType& t = node->getType();
+
+    return addConstantUnion(leftUnionArray, TType(promoteTo, t.getQualifier(), t.getNominalSize(), t.isMatrix(), t.isArray()), node->getLine());
 }
 
 void TIntermAggregate::addToPragmaTable(const TPragmaTable& pTable)
 {
-	assert(!pragmaTable);
-	pragmaTable = new TPragmaTable();
-	*pragmaTable = pTable;
+    assert(!pragmaTable);
+    pragmaTable = new TPragmaTable();
+    *pragmaTable = pTable;
 }
 

src/compiler/intermediate.h

@@ -24,162 +24,162 @@
 // 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,
-
-	//
-	// Unary operators
-	//
-	
-	EOpNegative,
-	EOpLogicalNot,
-	EOpVectorLogicalNot,
-
-	EOpPostIncrement,
-	EOpPostDecrement,
-	EOpPreIncrement,
-	EOpPreDecrement,
-
-	EOpConvIntToBool,
-	EOpConvFloatToBool,
-	EOpConvBoolToFloat,
-	EOpConvIntToFloat,
-	EOpConvFloatToInt,
-	EOpConvBoolToInt,
-
-	//
-	// 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,
-
-	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,
-
-//	EOpDPdx,            // Fragment only, OES_standard_derivatives extension
-//	EOpDPdy,            // 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,
-	EOpConstructBool,
-	EOpConstructFloat,
-	EOpConstructVec2,
-	EOpConstructVec3,
-	EOpConstructVec4,
-	EOpConstructBVec2,
-	EOpConstructBVec3,
-	EOpConstructBVec4,
-	EOpConstructIVec2,
-	EOpConstructIVec3,
-	EOpConstructIVec4,
-	EOpConstructMat2,
-	EOpConstructMat3,
-	EOpConstructMat4,
-	EOpConstructStruct,
-
-	//
-	// moves
-	//
-
-	EOpAssign,
-	EOpInitialize,
-	EOpAddAssign,
-	EOpSubAssign,
-	EOpMulAssign,
-	EOpVectorTimesMatrixAssign,
-	EOpVectorTimesScalarAssign,
-	EOpMatrixTimesScalarAssign,
-	EOpMatrixTimesMatrixAssign,
-	EOpDivAssign,
+    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,
+
+    //
+    // Unary operators
+    //
+
+    EOpNegative,
+    EOpLogicalNot,
+    EOpVectorLogicalNot,
+
+    EOpPostIncrement,
+    EOpPostDecrement,
+    EOpPreIncrement,
+    EOpPreDecrement,
+
+    EOpConvIntToBool,
+    EOpConvFloatToBool,
+    EOpConvBoolToFloat,
+    EOpConvIntToFloat,
+    EOpConvFloatToInt,
+    EOpConvBoolToInt,
+
+    //
+    // 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,
+
+    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,
+
+    //EOpDPdx,            // Fragment only, OES_standard_derivatives extension
+    //EOpDPdy,            // 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,
+    EOpConstructBool,
+    EOpConstructFloat,
+    EOpConstructVec2,
+    EOpConstructVec3,
+    EOpConstructVec4,
+    EOpConstructBVec2,
+    EOpConstructBVec3,
+    EOpConstructBVec4,
+    EOpConstructIVec2,
+    EOpConstructIVec3,
+    EOpConstructIVec4,
+    EOpConstructMat2,
+    EOpConstructMat3,
+    EOpConstructMat4,
+    EOpConstructStruct,
+
+    //
+    // moves
+    //
+
+    EOpAssign,
+    EOpInitialize,
+    EOpAddAssign,
+    EOpSubAssign,
+    EOpMulAssign,
+    EOpVectorTimesMatrixAssign,
+    EOpVectorTimesScalarAssign,
+    EOpMatrixTimesScalarAssign,
+    EOpMatrixTimesMatrixAssign,
+    EOpDivAssign,
 };
 
 class TIntermTraverser;
@@ -196,29 +196,29 @@ class TInfoSink;
 //
 class TIntermNode {
 public:
-	POOL_ALLOCATOR_NEW_DELETE(GlobalPoolAllocator)
-
-	TIntermNode() : line(0) {}
-	virtual TSourceLoc getLine() const { return line; }
-	virtual void setLine(TSourceLoc l) { line = 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 TIntermSelection* getAsSelectionNode() { return 0; }
-	virtual TIntermSymbol*    getAsSymbolNode()    { return 0; }
-	virtual ~TIntermNode() { }
+    POOL_ALLOCATOR_NEW_DELETE(GlobalPoolAllocator)
+
+    TIntermNode() : line(0) {}
+    virtual TSourceLoc getLine() const { return line; }
+    virtual void setLine(TSourceLoc l) { line = 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 TIntermSelection* getAsSelectionNode() { return 0; }
+    virtual TIntermSymbol*    getAsSymbolNode()    { return 0; }
+    virtual ~TIntermNode() { }
 protected:
-	TSourceLoc line;
+    TSourceLoc line;
 };
 
 //
 // This is just to help yacc.
 //
 struct TIntermNodePair {
-	TIntermNode* node1;
-	TIntermNode* node2;
+    TIntermNode* node1;
+    TIntermNode* node2;
 };
 
 class TIntermSymbol;
@@ -229,25 +229,25 @@ class TIntermBinary;
 //
 class TIntermTyped : public TIntermNode {
 public:
-	TIntermTyped(const TType& t) : type(t)  { }
-	virtual TIntermTyped* getAsTyped()         { return this; }
-	virtual void setType(const TType& t) { type = t; }
-	virtual const TType& getType() const { return type; }
-	virtual TType* getTypePointer() { return &type; }
-
-	virtual TBasicType getBasicType() const { return type.getBasicType(); }
-	virtual TQualifier getQualifier() const { return type.getQualifier(); }
-	virtual int getNominalSize() const { return type.getNominalSize(); }
-	virtual int getSize() const { return type.getInstanceSize(); }
-	virtual bool isMatrix() const { return type.isMatrix(); }
-	virtual bool isArray()  const { return type.isArray(); }
-	virtual bool isVector() const { return type.isVector(); }
-	const char* getBasicString()      const { return type.getBasicString(); }
-	const char* getQualifierString()  const { return type.getQualifierString(); }
-	TString getCompleteString() const { return type.getCompleteString(); }
+    TIntermTyped(const TType& t) : type(t)  { }
+    virtual TIntermTyped* getAsTyped()         { return this; }
+    virtual void setType(const TType& t) { type = t; }
+    virtual const TType& getType() const { return type; }
+    virtual TType* getTypePointer() { return &type; }
+
+    virtual TBasicType getBasicType() const { return type.getBasicType(); }
+    virtual TQualifier getQualifier() const { return type.getQualifier(); }
+    virtual int getNominalSize() const { return type.getNominalSize(); }
+    virtual int getSize() const { return type.getInstanceSize(); }
+    virtual bool isMatrix() const { return type.isMatrix(); }
+    virtual bool isArray()  const { return type.isArray(); }
+    virtual bool isVector() const { return type.isVector(); }
+    const char* getBasicString()      const { return type.getBasicString(); }
+    const char* getQualifierString()  const { return type.getQualifierString(); }
+    TString getCompleteString() const { return type.getCompleteString(); }
 
 protected:
-	TType type;
+    TType type;
 };
 
 //
@@ -255,24 +255,24 @@ protected:
 //
 class TIntermLoop : public TIntermNode {
 public:
-	TIntermLoop(TIntermNode *init, TIntermNode* aBody, TIntermTyped* aTest, TIntermTyped* aTerminal, bool testFirst) : 
-	    init(init),
-		body(aBody),
-		test(aTest),
-		terminal(aTerminal),
-		first(testFirst) { }
-	virtual void traverse(TIntermTraverser*);
-	TIntermNode *getInit() { return init; }
-	TIntermNode *getBody() { return body; }
-	TIntermTyped *getTest() { return test; }
-	TIntermTyped *getTerminal() { return terminal; }
-	bool testFirst() { return first; }
+    TIntermLoop(TIntermNode *init, TIntermNode* aBody, TIntermTyped* aTest, TIntermTyped* aTerminal, bool testFirst) : 
+            init(init),
+            body(aBody),
+            test(aTest),
+            terminal(aTerminal),
+            first(testFirst) { }
+    virtual void traverse(TIntermTraverser*);
+    TIntermNode *getInit() { return init; }
+    TIntermNode *getBody() { return body; }
+    TIntermTyped *getTest() { return test; }
+    TIntermTyped *getTerminal() { return terminal; }
+    bool testFirst() { return first; }
 protected:
-	TIntermNode *init;
-	TIntermNode *body;       // code to loop over
-	TIntermTyped *test;      // exit condition associated with loop, could be 0 for 'for' loops
-	TIntermTyped *terminal;  // exists for for-loops
-	bool first;              // true for while and for, not for do-while
+    TIntermNode *init;
+    TIntermNode *body;       // code to loop over
+    TIntermTyped *test;      // exit condition associated with loop, could be 0 for 'for' loops
+    TIntermTyped *terminal;  // exists for for-loops
+    bool first;              // true for while and for, not for do-while
 };
 
 //
@@ -280,15 +280,15 @@ protected:
 //
 class TIntermBranch : public TIntermNode {
 public:
-	TIntermBranch(TOperator op, TIntermTyped* e) :
-		flowOp(op),
-		expression(e) { }
-	virtual void traverse(TIntermTraverser*);
-	TOperator getFlowOp() { return flowOp; }
-	TIntermTyped* getExpression() { return expression; }
+    TIntermBranch(TOperator op, TIntermTyped* e) :
+            flowOp(op),
+            expression(e) { }
+    virtual void traverse(TIntermTraverser*);
+    TOperator getFlowOp() { return flowOp; }
+    TIntermTyped* getExpression() { return expression; }
 protected:
-	TOperator flowOp;
-	TIntermTyped* expression;  // non-zero except for "return exp;" statements
+    TOperator flowOp;
+    TIntermTyped* expression;  // non-zero except for "return exp;" statements
 };
 
 //
@@ -296,30 +296,30 @@ protected:
 //
 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 i, const TString& sym, const TType& t) : 
-		TIntermTyped(t), id(i)  { symbol = sym;} 
-	virtual int getId() const { return id; }
-	virtual const TString& getSymbol() const { return symbol;  }
-	virtual void traverse(TIntermTraverser*);
-	virtual TIntermSymbol* getAsSymbolNode() { return this; }
+    // 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 i, const TString& sym, const TType& t) : 
+            TIntermTyped(t), id(i)  { symbol = sym;} 
+    virtual int getId() const { return id; }
+    virtual const TString& getSymbol() const { return symbol;  }
+    virtual void traverse(TIntermTraverser*);
+    virtual TIntermSymbol* getAsSymbolNode() { return this; }
 protected:
-	int id;
-	TString symbol;
+    int id;
+    TString symbol;
 };
 
 class TIntermConstantUnion : public TIntermTyped {
 public:
-	TIntermConstantUnion(constUnion *unionPointer, const TType& t) : TIntermTyped(t), unionArrayPointer(unionPointer) { }
-	constUnion* getUnionArrayPointer() const { return unionArrayPointer; }
-	void setUnionArrayPointer(constUnion *c) { unionArrayPointer = c; }
-	virtual TIntermConstantUnion* getAsConstantUnion()  { return this; }
-	virtual void traverse(TIntermTraverser* );
-	virtual TIntermTyped* fold(TOperator, TIntermTyped*, TInfoSink&);
+    TIntermConstantUnion(constUnion *unionPointer, const TType& t) : TIntermTyped(t), unionArrayPointer(unionPointer) { }
+    constUnion* getUnionArrayPointer() const { return unionArrayPointer; }
+    void setUnionArrayPointer(constUnion *c) { unionArrayPointer = c; }
+    virtual TIntermConstantUnion* getAsConstantUnion()  { return this; }
+    virtual void traverse(TIntermTraverser* );
+    virtual TIntermTyped* fold(TOperator, TIntermTyped*, TInfoSink&);
 protected:
-	constUnion *unionArrayPointer;
+    constUnion *unionArrayPointer;
 };
 
 //
@@ -327,14 +327,14 @@ protected:
 //
 class TIntermOperator : public TIntermTyped {
 public:
-	TOperator getOp() const { return op; }
-	bool modifiesState() const;
-	bool isConstructor() const;
-	virtual bool promote(TInfoSink&) { return true; }
+    TOperator getOp() const { return op; }
+    bool modifiesState() const;
+    bool isConstructor() const;
+    virtual bool promote(TInfoSink&) { return true; }
 protected:
-	TIntermOperator(TOperator o) : TIntermTyped(TType(EbtFloat)), op(o) {}
-	TIntermOperator(TOperator o, TType& t) : TIntermTyped(t), op(o) {}   
-	TOperator op;
+    TIntermOperator(TOperator o) : TIntermTyped(TType(EbtFloat)), op(o) {}
+    TIntermOperator(TOperator o, TType& t) : TIntermTyped(t), op(o) {}   
+    TOperator op;
 };
 
 //
@@ -342,17 +342,17 @@ protected:
 //
 class TIntermBinary : public TIntermOperator {
 public:
-	TIntermBinary(TOperator o) : TIntermOperator(o) {}
-	virtual void traverse(TIntermTraverser*);
-	virtual void setLeft(TIntermTyped* n) { left = n; }
-	virtual void setRight(TIntermTyped* n) { right = n; }
-	virtual TIntermTyped* getLeft() const { return left; }
-	virtual TIntermTyped* getRight() const { return right; }
-	virtual TIntermBinary* getAsBinaryNode() { return this; }
-	virtual bool promote(TInfoSink&);
+    TIntermBinary(TOperator o) : TIntermOperator(o) {}
+    virtual void traverse(TIntermTraverser*);
+    virtual void setLeft(TIntermTyped* n) { left = n; }
+    virtual void setRight(TIntermTyped* n) { right = n; }
+    virtual TIntermTyped* getLeft() const { return left; }
+    virtual TIntermTyped* getRight() const { return right; }
+    virtual TIntermBinary* getAsBinaryNode() { return this; }
+    virtual bool promote(TInfoSink&);
 protected:
-	TIntermTyped* left;
-	TIntermTyped* right;
+    TIntermTyped* left;
+    TIntermTyped* right;
 };
 
 //
@@ -360,14 +360,14 @@ protected:
 //
 class TIntermUnary : public TIntermOperator {
 public:
-	TIntermUnary(TOperator o, TType& t) : TIntermOperator(o, t), operand(0) {}
-	TIntermUnary(TOperator o) : TIntermOperator(o), operand(0) {}
-	virtual void traverse(TIntermTraverser*);
-	virtual void setOperand(TIntermTyped* o) { operand = o; }
-	virtual TIntermTyped* getOperand() { return operand; }
-	virtual bool promote(TInfoSink&);
+    TIntermUnary(TOperator o, TType& t) : TIntermOperator(o, t), operand(0) {}
+    TIntermUnary(TOperator o) : TIntermOperator(o), operand(0) {}
+    virtual void traverse(TIntermTraverser*);
+    virtual void setOperand(TIntermTyped* o) { operand = o; }
+    virtual TIntermTyped* getOperand() { return operand; }
+    virtual bool promote(TInfoSink&);
 protected:
-	TIntermTyped* operand;
+    TIntermTyped* operand;
 };
 
 typedef TVector<TIntermNode*> TIntermSequence;
@@ -377,34 +377,34 @@ typedef TVector<int> TQualifierList;
 //
 class TIntermAggregate : public TIntermOperator {
 public:
-	TIntermAggregate() : TIntermOperator(EOpNull), userDefined(false), pragmaTable(0) { }
-	TIntermAggregate(TOperator o) : TIntermOperator(o), pragmaTable(0) { }
-	~TIntermAggregate() { delete pragmaTable; }
-	virtual TIntermAggregate* getAsAggregate() { return this; }
-	virtual void setOperator(TOperator o) { op = o; }
-	virtual TIntermSequence& getSequence() { return sequence; }
-	virtual void setName(const TString& n) { name = n; }
-	virtual const TString& getName() const { return name; }
-	virtual void traverse(TIntermTraverser*);
-	virtual void setUserDefined() { userDefined = true; }
-	virtual bool isUserDefined() { return userDefined; }
-	virtual TQualifierList& getQualifier() { return qualifier; }
-	void setOptimize(bool o) { optimize = o; }
-	void setDebug(bool d) { debug = d; }
-	bool getOptimize() { return optimize; }
-	bool getDebug() { return debug; }
-	void addToPragmaTable(const TPragmaTable& pTable);
-	const TPragmaTable& getPragmaTable() const { return *pragmaTable; }
+    TIntermAggregate() : TIntermOperator(EOpNull), userDefined(false), pragmaTable(0) { }
+    TIntermAggregate(TOperator o) : TIntermOperator(o), pragmaTable(0) { }
+    ~TIntermAggregate() { delete pragmaTable; }
+    virtual TIntermAggregate* getAsAggregate() { return this; }
+    virtual void setOperator(TOperator o) { op = o; }
+    virtual TIntermSequence& getSequence() { return sequence; }
+    virtual void setName(const TString& n) { name = n; }
+    virtual const TString& getName() const { return name; }
+    virtual void traverse(TIntermTraverser*);
+    virtual void setUserDefined() { userDefined = true; }
+    virtual bool isUserDefined() { return userDefined; }
+    virtual TQualifierList& getQualifier() { return qualifier; }
+    void setOptimize(bool o) { optimize = o; }
+    void setDebug(bool d) { debug = d; }
+    bool getOptimize() { return optimize; }
+    bool getDebug() { return debug; }
+    void addToPragmaTable(const TPragmaTable& pTable);
+    const TPragmaTable& getPragmaTable() const { return *pragmaTable; }
 protected:
-	TIntermAggregate(const TIntermAggregate&); // disallow copy constructor
-	TIntermAggregate& operator=(const TIntermAggregate&); // disallow assignment operator
-	TIntermSequence sequence;
-	TQualifierList qualifier;
-	TString name;
-	bool userDefined; // used for user defined function names
-	bool optimize;
-	bool debug;
-	TPragmaTable *pragmaTable;
+    TIntermAggregate(const TIntermAggregate&); // disallow copy constructor
+    TIntermAggregate& operator=(const TIntermAggregate&); // disallow assignment operator
+    TIntermSequence sequence;
+    TQualifierList qualifier;
+    TString name;
+    bool userDefined; // used for user defined function names
+    bool optimize;
+    bool debug;
+    TPragmaTable *pragmaTable;
 };
 
 //
@@ -412,27 +412,27 @@ protected:
 //
 class TIntermSelection : public TIntermTyped {
 public:
-	TIntermSelection(TIntermTyped* cond, TIntermNode* trueB, TIntermNode* falseB) :
-		TIntermTyped(TType(EbtVoid)), condition(cond), trueBlock(trueB), falseBlock(falseB) {}
-	TIntermSelection(TIntermTyped* cond, TIntermNode* trueB, TIntermNode* falseB, const TType& type) :
-		TIntermTyped(type), condition(cond), trueBlock(trueB), falseBlock(falseB) {}
-	virtual void traverse(TIntermTraverser*);
-        bool usesTernaryOperator() const { return getBasicType() != EbtVoid; }
-	virtual TIntermNode* getCondition() const { return condition; }
-	virtual TIntermNode* getTrueBlock() const { return trueBlock; }
-	virtual TIntermNode* getFalseBlock() const { return falseBlock; }
-	virtual TIntermSelection* getAsSelectionNode() { return this; }
+    TIntermSelection(TIntermTyped* cond, TIntermNode* trueB, TIntermNode* falseB) :
+            TIntermTyped(TType(EbtVoid)), condition(cond), trueBlock(trueB), falseBlock(falseB) {}
+    TIntermSelection(TIntermTyped* cond, TIntermNode* trueB, TIntermNode* falseB, const TType& type) :
+            TIntermTyped(type), condition(cond), trueBlock(trueB), falseBlock(falseB) {}
+    virtual void traverse(TIntermTraverser*);
+    bool usesTernaryOperator() const { return getBasicType() != EbtVoid; }
+    virtual TIntermNode* getCondition() const { return condition; }
+    virtual TIntermNode* getTrueBlock() const { return trueBlock; }
+    virtual TIntermNode* getFalseBlock() const { return falseBlock; }
+    virtual TIntermSelection* getAsSelectionNode() { return this; }
 protected:
-	TIntermTyped* condition;
-	TIntermNode* trueBlock;
-	TIntermNode* falseBlock;
+    TIntermTyped* condition;
+    TIntermNode* trueBlock;
+    TIntermNode* falseBlock;
 };
 
 enum Visit
 {
-	PreVisit,
-	InVisit,
-	PostVisit
+    PreVisit,
+    InVisit,
+    PostVisit
 };
 
 //
@@ -446,36 +446,34 @@ enum Visit
 class TIntermTraverser
 {
 public:
-	POOL_ALLOCATOR_NEW_DELETE(GlobalPoolAllocator)
-
-	TIntermTraverser(bool preVisit = true, bool inVisit = false, bool postVisit = false, bool rightToLeft = false) : 
-		preVisit(preVisit),
-		inVisit(inVisit),
-		postVisit(postVisit),
-		rightToLeft(rightToLeft)
-	{
-		depth = 0;
-	}
-
-	virtual void visitSymbol(TIntermSymbol*) {}
-	virtual void visitConstantUnion(TIntermConstantUnion*) {}
-	virtual bool visitBinary(Visit visit, TIntermBinary*) {return true;}
-	virtual bool visitUnary(Visit visit, TIntermUnary*) {return true;}
-	virtual bool visitSelection(Visit visit, TIntermSelection*) {return true;}
-	virtual bool visitAggregate(Visit visit, TIntermAggregate*) {return true;}
-	virtual bool visitLoop(Visit visit, TIntermLoop*) {return true;}
-	virtual bool visitBranch(Visit visit, TIntermBranch*) {return true;}
-
-	void incrementDepth() {depth++;}
-	void decrementDepth() {depth--;}
-
-	const bool preVisit;
-	const bool inVisit;
-	const bool postVisit;
-	const bool rightToLeft;
+    POOL_ALLOCATOR_NEW_DELETE(GlobalPoolAllocator)
+
+    TIntermTraverser(bool preVisit = true, bool inVisit = false, bool postVisit = false, bool rightToLeft = false) : 
+            preVisit(preVisit),
+            inVisit(inVisit),
+            postVisit(postVisit),
+            rightToLeft(rightToLeft),
+            depth(0) {}
+
+    virtual void visitSymbol(TIntermSymbol*) {}
+    virtual void visitConstantUnion(TIntermConstantUnion*) {}
+    virtual bool visitBinary(Visit visit, TIntermBinary*) {return true;}
+    virtual bool visitUnary(Visit visit, TIntermUnary*) {return true;}
+    virtual bool visitSelection(Visit visit, TIntermSelection*) {return true;}
+    virtual bool visitAggregate(Visit visit, TIntermAggregate*) {return true;}
+    virtual bool visitLoop(Visit visit, TIntermLoop*) {return true;}
+    virtual bool visitBranch(Visit visit, TIntermBranch*) {return true;}
+
+    void incrementDepth() {depth++;}
+    void decrementDepth() {depth--;}
+
+    const bool preVisit;
+    const bool inVisit;
+    const bool postVisit;
+    const bool rightToLeft;
 
 protected:
-	int depth;
+    int depth;
 };
 
 #endif // __INTERMEDIATE_H