Fix up translator style.
Using git cl format.
BUG=angleproject:650
Change-Id: I7d3f98d2b0dcfb0a8de6c35327db74e55c28d761
Reviewed-on: https://chromium-review.googlesource.com/419059
Reviewed-by: Jamie Madill <jmadill@chromium.org>
Commit-Queue: Jamie Madill <jmadill@chromium.org>
diff --git a/src/compiler/translator/IntermNode.cpp b/src/compiler/translator/IntermNode.cpp
index 9d4cbbb..1299048 100644
--- a/src/compiler/translator/IntermNode.cpp
+++ b/src/compiler/translator/IntermNode.cpp
@@ -29,7 +29,7 @@
namespace
{
-const float kPi = 3.14159265358979323846f;
+const float kPi = 3.14159265358979323846f;
const float kDegreesToRadiansMultiplier = kPi / 180.0f;
const float kRadiansToDegreesMultiplier = 180.0f / kPi;
@@ -42,7 +42,7 @@
{
TConstantUnion *constUnion = new TConstantUnion[size];
for (unsigned int i = 0; i < size; ++i)
- constUnion[i] = constant;
+ constUnion[i] = constant;
return constUnion;
}
@@ -58,20 +58,20 @@
switch (basicType)
{
- case EbtFloat :
- result->setFConst(0.0f);
- break;
- case EbtInt:
- result->setIConst(0);
- break;
- case EbtUInt:
- result->setUConst(0u);
- break;
- case EbtBool:
- result->setBConst(false);
- break;
- default:
- break;
+ case EbtFloat:
+ result->setFConst(0.0f);
+ break;
+ case EbtInt:
+ result->setIConst(0);
+ break;
+ case EbtUInt:
+ result->setUConst(0u);
+ break;
+ case EbtBool:
+ result->setBConst(false);
+ break;
+ default:
+ break;
}
}
@@ -137,7 +137,7 @@
{
// Transpose is used since the input Matrix is in row-major order,
// whereas the actual result should be in column-major order.
- angle::Matrix<float> result = m.transpose();
+ angle::Matrix<float> result = m.transpose();
std::vector<float> resultElements = result.elements();
for (size_t i = 0; i < resultElements.size(); i++)
resultArray[i].setFConst(resultElements[i]);
@@ -145,7 +145,6 @@
} // namespace anonymous
-
////////////////////////////////////////////////////////////////
//
// Member functions of the nodes used for building the tree.
@@ -155,19 +154,19 @@
void TIntermTyped::setTypePreservePrecision(const TType &t)
{
TPrecision precision = getPrecision();
- mType = t;
+ mType = t;
ASSERT(mType.getBasicType() != EbtBool || precision == EbpUndefined);
mType.setPrecision(precision);
}
#define REPLACE_IF_IS(node, type, original, replacement) \
- if (node == original) { \
- node = static_cast<type *>(replacement); \
- return true; \
+ if (node == original) \
+ { \
+ node = static_cast<type *>(replacement); \
+ return true; \
}
-bool TIntermLoop::replaceChildNode(
- TIntermNode *original, TIntermNode *replacement)
+bool TIntermLoop::replaceChildNode(TIntermNode *original, TIntermNode *replacement)
{
ASSERT(original != nullptr); // This risks replacing multiple children.
REPLACE_IF_IS(mInit, TIntermNode, original, replacement);
@@ -177,8 +176,7 @@
return false;
}
-bool TIntermBranch::replaceChildNode(
- TIntermNode *original, TIntermNode *replacement)
+bool TIntermBranch::replaceChildNode(TIntermNode *original, TIntermNode *replacement)
{
REPLACE_IF_IS(mExpression, TIntermTyped, original, replacement);
return false;
@@ -191,16 +189,14 @@
return false;
}
-bool TIntermBinary::replaceChildNode(
- TIntermNode *original, TIntermNode *replacement)
+bool TIntermBinary::replaceChildNode(TIntermNode *original, TIntermNode *replacement)
{
REPLACE_IF_IS(mLeft, TIntermTyped, original, replacement);
REPLACE_IF_IS(mRight, TIntermTyped, original, replacement);
return false;
}
-bool TIntermUnary::replaceChildNode(
- TIntermNode *original, TIntermNode *replacement)
+bool TIntermUnary::replaceChildNode(TIntermNode *original, TIntermNode *replacement)
{
ASSERT(original->getAsTyped()->getType() == replacement->getAsTyped()->getType());
REPLACE_IF_IS(mOperand, TIntermTyped, original, replacement);
@@ -214,8 +210,7 @@
return false;
}
-bool TIntermAggregate::replaceChildNode(
- TIntermNode *original, TIntermNode *replacement)
+bool TIntermAggregate::replaceChildNode(TIntermNode *original, TIntermNode *replacement)
{
return replaceChildNodeInternal(original, replacement);
}
@@ -288,7 +283,7 @@
return;
}
- TPrecision precision = EbpUndefined;
+ TPrecision precision = EbpUndefined;
TIntermSequence::iterator childIter = mSequence.begin();
while (childIter != mSequence.end())
{
@@ -305,7 +300,7 @@
// All built-ins returning bool should be handled as ops, not functions.
ASSERT(getBasicType() != EbtBool);
- TPrecision precision = EbpUndefined;
+ TPrecision precision = EbpUndefined;
TIntermSequence::iterator childIter = mSequence.begin();
while (childIter != mSequence.end())
{
@@ -364,16 +359,14 @@
return false;
}
-bool TIntermSwitch::replaceChildNode(
- TIntermNode *original, TIntermNode *replacement)
+bool TIntermSwitch::replaceChildNode(TIntermNode *original, TIntermNode *replacement)
{
REPLACE_IF_IS(mInit, TIntermTyped, original, replacement);
REPLACE_IF_IS(mStatementList, TIntermBlock, original, replacement);
return false;
}
-bool TIntermCase::replaceChildNode(
- TIntermNode *original, TIntermNode *replacement)
+bool TIntermCase::replaceChildNode(TIntermNode *original, TIntermNode *replacement)
{
REPLACE_IF_IS(mCondition, TIntermTyped, original, replacement);
return false;
@@ -562,15 +555,15 @@
{
switch (mOp)
{
- case EOpMul:
- case EOpMatrixTimesMatrix:
- case EOpMatrixTimesVector:
- case EOpMatrixTimesScalar:
- case EOpVectorTimesMatrix:
- case EOpVectorTimesScalar:
- return true;
- default:
- return false;
+ case EOpMul:
+ case EOpMatrixTimesMatrix:
+ case EOpMatrixTimesVector:
+ case EOpMatrixTimesScalar:
+ case EOpVectorTimesMatrix:
+ case EOpVectorTimesScalar:
+ return true;
+ default:
+ return false;
}
}
@@ -581,35 +574,35 @@
{
switch (mOp)
{
- case EOpConstructVec2:
- case EOpConstructVec3:
- case EOpConstructVec4:
- case EOpConstructMat2:
- case EOpConstructMat2x3:
- case EOpConstructMat2x4:
- case EOpConstructMat3x2:
- case EOpConstructMat3:
- case EOpConstructMat3x4:
- case EOpConstructMat4x2:
- case EOpConstructMat4x3:
- case EOpConstructMat4:
- case EOpConstructFloat:
- case EOpConstructIVec2:
- case EOpConstructIVec3:
- case EOpConstructIVec4:
- case EOpConstructInt:
- case EOpConstructUVec2:
- case EOpConstructUVec3:
- case EOpConstructUVec4:
- case EOpConstructUInt:
- case EOpConstructBVec2:
- case EOpConstructBVec3:
- case EOpConstructBVec4:
- case EOpConstructBool:
- case EOpConstructStruct:
- return true;
- default:
- return false;
+ case EOpConstructVec2:
+ case EOpConstructVec3:
+ case EOpConstructVec4:
+ case EOpConstructMat2:
+ case EOpConstructMat2x3:
+ case EOpConstructMat2x4:
+ case EOpConstructMat3x2:
+ case EOpConstructMat3:
+ case EOpConstructMat3x4:
+ case EOpConstructMat4x2:
+ case EOpConstructMat4x3:
+ case EOpConstructMat4:
+ case EOpConstructFloat:
+ case EOpConstructIVec2:
+ case EOpConstructIVec3:
+ case EOpConstructIVec4:
+ case EOpConstructInt:
+ case EOpConstructUVec2:
+ case EOpConstructUVec3:
+ case EOpConstructUVec4:
+ case EOpConstructUInt:
+ case EOpConstructBVec2:
+ case EOpConstructBVec3:
+ case EOpConstructBVec4:
+ case EOpConstructBool:
+ case EOpConstructStruct:
+ return true;
+ default:
+ return false;
}
}
@@ -838,20 +831,20 @@
{
switch (offset)
{
- case 0:
- *out << "x";
- break;
- case 1:
- *out << "y";
- break;
- case 2:
- *out << "z";
- break;
- case 3:
- *out << "w";
- break;
- default:
- UNREACHABLE();
+ case 0:
+ *out << "x";
+ break;
+ case 1:
+ *out << "y";
+ break;
+ case 2:
+ *out << "z";
+ break;
+ case 3:
+ *out << "w";
+ break;
+ default:
+ UNREACHABLE();
}
}
}
@@ -944,8 +937,7 @@
TPrecision higherPrecision = GetHigherPrecision(mLeft->getPrecision(), mRight->getPrecision());
getTypePointer()->setPrecision(higherPrecision);
- const int nominalSize =
- std::max(mLeft->getNominalSize(), mRight->getNominalSize());
+ const int nominalSize = std::max(mLeft->getNominalSize(), mRight->getNominalSize());
//
// All scalars or structs. Code after this test assumes this case is removed!
@@ -954,30 +946,30 @@
{
switch (mOp)
{
- //
- // Promote to conditional
- //
- case EOpEqual:
- case EOpNotEqual:
- case EOpLessThan:
- case EOpGreaterThan:
- case EOpLessThanEqual:
- case EOpGreaterThanEqual:
- setType(TType(EbtBool, EbpUndefined, resultQualifier));
- break;
+ //
+ // Promote to conditional
+ //
+ case EOpEqual:
+ case EOpNotEqual:
+ case EOpLessThan:
+ case EOpGreaterThan:
+ case EOpLessThanEqual:
+ case EOpGreaterThanEqual:
+ setType(TType(EbtBool, EbpUndefined, resultQualifier));
+ break;
- //
- // And and Or operate on conditionals
- //
- case EOpLogicalAnd:
- case EOpLogicalXor:
- case EOpLogicalOr:
- ASSERT(mLeft->getBasicType() == EbtBool && mRight->getBasicType() == EbtBool);
- setType(TType(EbtBool, EbpUndefined, resultQualifier));
- break;
+ //
+ // And and Or operate on conditionals
+ //
+ case EOpLogicalAnd:
+ case EOpLogicalXor:
+ case EOpLogicalOr:
+ ASSERT(mLeft->getBasicType() == EbtBool && mRight->getBasicType() == EbtBool);
+ setType(TType(EbtBool, EbpUndefined, resultQualifier));
+ break;
- default:
- break;
+ default:
+ break;
}
return;
}
@@ -1187,23 +1179,23 @@
TConstantUnion *constArray = nullptr;
switch (mOp)
{
- case EOpAny:
- case EOpAll:
- case EOpLength:
- case EOpTranspose:
- case EOpDeterminant:
- case EOpInverse:
- case EOpPackSnorm2x16:
- case EOpUnpackSnorm2x16:
- case EOpPackUnorm2x16:
- case EOpUnpackUnorm2x16:
- case EOpPackHalf2x16:
- case EOpUnpackHalf2x16:
- constArray = operandConstant->foldUnaryNonComponentWise(mOp);
- break;
- default:
- constArray = operandConstant->foldUnaryComponentWise(mOp, diagnostics);
- break;
+ case EOpAny:
+ case EOpAll:
+ case EOpLength:
+ case EOpTranspose:
+ case EOpDeterminant:
+ case EOpInverse:
+ case EOpPackSnorm2x16:
+ case EOpUnpackSnorm2x16:
+ case EOpPackUnorm2x16:
+ case EOpUnpackUnorm2x16:
+ case EOpPackHalf2x16:
+ case EOpUnpackHalf2x16:
+ constArray = operandConstant->foldUnaryNonComponentWise(mOp);
+ break;
+ default:
+ constArray = operandConstant->foldUnaryComponentWise(mOp, diagnostics);
+ break;
}
// Nodes may be constant folded without being qualified as constant.
@@ -1257,42 +1249,45 @@
else if (rightNode->getType().getObjectSize() > 1 && objectSize == 1)
{
// for a case like float f = 1.2 + vec4(2, 3, 4, 5);
- leftArray = Vectorize(*getUnionArrayPointer(), rightNode->getType().getObjectSize());
+ leftArray = Vectorize(*getUnionArrayPointer(), rightNode->getType().getObjectSize());
objectSize = rightNode->getType().getObjectSize();
}
TConstantUnion *resultArray = nullptr;
- switch(op)
+ switch (op)
{
- case EOpAdd:
- resultArray = new TConstantUnion[objectSize];
- for (size_t i = 0; i < objectSize; i++)
- resultArray[i] = TConstantUnion::add(leftArray[i], rightArray[i], diagnostics, line);
- break;
- case EOpSub:
- resultArray = new TConstantUnion[objectSize];
- for (size_t i = 0; i < objectSize; i++)
- resultArray[i] = TConstantUnion::sub(leftArray[i], rightArray[i], diagnostics, line);
- break;
+ case EOpAdd:
+ resultArray = new TConstantUnion[objectSize];
+ for (size_t i = 0; i < objectSize; i++)
+ resultArray[i] =
+ TConstantUnion::add(leftArray[i], rightArray[i], diagnostics, line);
+ break;
+ case EOpSub:
+ resultArray = new TConstantUnion[objectSize];
+ for (size_t i = 0; i < objectSize; i++)
+ resultArray[i] =
+ TConstantUnion::sub(leftArray[i], rightArray[i], diagnostics, line);
+ break;
- case EOpMul:
- case EOpVectorTimesScalar:
- case EOpMatrixTimesScalar:
- resultArray = new TConstantUnion[objectSize];
- for (size_t i = 0; i < objectSize; i++)
- resultArray[i] = TConstantUnion::mul(leftArray[i], rightArray[i], diagnostics, line);
- break;
+ case EOpMul:
+ case EOpVectorTimesScalar:
+ case EOpMatrixTimesScalar:
+ resultArray = new TConstantUnion[objectSize];
+ for (size_t i = 0; i < objectSize; i++)
+ resultArray[i] =
+ TConstantUnion::mul(leftArray[i], rightArray[i], diagnostics, line);
+ break;
- case EOpMatrixTimesMatrix:
+ case EOpMatrixTimesMatrix:
{
// TODO(jmadll): This code should check for overflows.
ASSERT(getType().getBasicType() == EbtFloat && rightNode->getBasicType() == EbtFloat);
- const int leftCols = getCols();
- const int leftRows = getRows();
- const int rightCols = rightNode->getType().getCols();
- const int rightRows = rightNode->getType().getRows();
+ const int leftCols = getCols();
+ const int leftRows = getRows();
+ const int rightCols = rightNode->getType().getCols();
+ const int rightRows = rightNode->getType().getRows();
const int resultCols = rightCols;
const int resultRows = leftRows;
@@ -1307,146 +1302,152 @@
resultArray[resultRows * column + row].setFConst(
resultArray[resultRows * column + row].getFConst() +
leftArray[i * leftRows + row].getFConst() *
- rightArray[column * rightRows + i].getFConst());
+ rightArray[column * rightRows + i].getFConst());
}
}
}
}
break;
- case EOpDiv:
- case EOpIMod:
+ case EOpDiv:
+ case EOpIMod:
{
resultArray = new TConstantUnion[objectSize];
for (size_t i = 0; i < objectSize; i++)
{
switch (getType().getBasicType())
{
- case EbtFloat:
- {
- ASSERT(op == EOpDiv);
- float dividend = leftArray[i].getFConst();
- float divisor = rightArray[i].getFConst();
- if (divisor == 0.0f)
- {
- if (dividend == 0.0f)
- {
- diagnostics->warning(
- getLine(),
- "Zero divided by zero during constant folding generated NaN", "/",
- "");
- resultArray[i].setFConst(std::numeric_limits<float>::quiet_NaN());
- }
- else
- {
- diagnostics->warning(
- getLine(), "Divide by zero during constant folding", "/", "");
- bool negativeResult = std::signbit(dividend) != std::signbit(divisor);
- resultArray[i].setFConst(
- negativeResult ? -std::numeric_limits<float>::infinity()
- : std::numeric_limits<float>::infinity());
- }
- }
- else if (gl::isInf(dividend) && gl::isInf(divisor))
- {
- diagnostics->warning(
- getLine(),
- "Infinity divided by infinity during constant folding generated NaN",
- "/", "");
- resultArray[i].setFConst(std::numeric_limits<float>::quiet_NaN());
- }
- else
- {
- float result = dividend / divisor;
- if (!gl::isInf(dividend) && gl::isInf(result))
- {
- diagnostics->warning(
- getLine(), "Constant folded division overflowed to infinity", "/",
- "");
- }
- resultArray[i].setFConst(result);
- }
- break;
- }
- case EbtInt:
- if (rightArray[i] == 0)
+ case EbtFloat:
{
- diagnostics->warning(
- getLine(), "Divide by zero error during constant folding", "/", "");
- resultArray[i].setIConst(INT_MAX);
- }
- else
- {
- int lhs = leftArray[i].getIConst();
- int divisor = rightArray[i].getIConst();
- if (op == EOpDiv)
+ ASSERT(op == EOpDiv);
+ float dividend = leftArray[i].getFConst();
+ float divisor = rightArray[i].getFConst();
+ if (divisor == 0.0f)
{
- // Check for the special case where the minimum representable number is
- // divided by -1. If left alone this leads to integer overflow in C++.
- // ESSL 3.00.6 section 4.1.3 Integers:
- // "However, for the case where the minimum representable value is
- // divided by -1, it is allowed to return either the minimum
- // representable value or the maximum representable value."
- if (lhs == -0x7fffffff - 1 && divisor == -1)
+ if (dividend == 0.0f)
{
- resultArray[i].setIConst(0x7fffffff);
+ diagnostics->warning(
+ getLine(),
+ "Zero divided by zero during constant folding generated NaN",
+ "/", "");
+ resultArray[i].setFConst(std::numeric_limits<float>::quiet_NaN());
}
else
{
- resultArray[i].setIConst(lhs / divisor);
+ diagnostics->warning(
+ getLine(), "Divide by zero during constant folding", "/", "");
+ bool negativeResult =
+ std::signbit(dividend) != std::signbit(divisor);
+ resultArray[i].setFConst(
+ negativeResult ? -std::numeric_limits<float>::infinity()
+ : std::numeric_limits<float>::infinity());
}
}
+ else if (gl::isInf(dividend) && gl::isInf(divisor))
+ {
+ diagnostics->warning(getLine(),
+ "Infinity divided by infinity during constant "
+ "folding generated NaN",
+ "/", "");
+ resultArray[i].setFConst(std::numeric_limits<float>::quiet_NaN());
+ }
else
{
- ASSERT(op == EOpIMod);
- if (lhs < 0 || divisor < 0)
+ float result = dividend / divisor;
+ if (!gl::isInf(dividend) && gl::isInf(result))
{
- // ESSL 3.00.6 section 5.9: Results of modulus are undefined when
- // either one of the operands is negative.
- diagnostics->warning(getLine(),
- "Negative modulus operator operand "
- "encountered during constant folding",
- "%", "");
- resultArray[i].setIConst(0);
+ diagnostics->warning(
+ getLine(), "Constant folded division overflowed to infinity",
+ "/", "");
+ }
+ resultArray[i].setFConst(result);
+ }
+ break;
+ }
+ case EbtInt:
+ if (rightArray[i] == 0)
+ {
+ diagnostics->warning(
+ getLine(), "Divide by zero error during constant folding", "/", "");
+ resultArray[i].setIConst(INT_MAX);
+ }
+ else
+ {
+ int lhs = leftArray[i].getIConst();
+ int divisor = rightArray[i].getIConst();
+ if (op == EOpDiv)
+ {
+ // Check for the special case where the minimum representable number
+ // is
+ // divided by -1. If left alone this leads to integer overflow in
+ // C++.
+ // ESSL 3.00.6 section 4.1.3 Integers:
+ // "However, for the case where the minimum representable value is
+ // divided by -1, it is allowed to return either the minimum
+ // representable value or the maximum representable value."
+ if (lhs == -0x7fffffff - 1 && divisor == -1)
+ {
+ resultArray[i].setIConst(0x7fffffff);
+ }
+ else
+ {
+ resultArray[i].setIConst(lhs / divisor);
+ }
}
else
{
- resultArray[i].setIConst(lhs % divisor);
+ ASSERT(op == EOpIMod);
+ if (lhs < 0 || divisor < 0)
+ {
+ // ESSL 3.00.6 section 5.9: Results of modulus are undefined
+ // when
+ // either one of the operands is negative.
+ diagnostics->warning(getLine(),
+ "Negative modulus operator operand "
+ "encountered during constant folding",
+ "%", "");
+ resultArray[i].setIConst(0);
+ }
+ else
+ {
+ resultArray[i].setIConst(lhs % divisor);
+ }
}
}
- }
- break;
+ break;
- case EbtUInt:
- if (rightArray[i] == 0)
- {
- diagnostics->warning(
- getLine(), "Divide by zero error during constant folding", "/", "");
- resultArray[i].setUConst(UINT_MAX);
- }
- else
- {
- if (op == EOpDiv)
+ case EbtUInt:
+ if (rightArray[i] == 0)
{
- resultArray[i].setUConst(leftArray[i].getUConst() / rightArray[i].getUConst());
+ diagnostics->warning(
+ getLine(), "Divide by zero error during constant folding", "/", "");
+ resultArray[i].setUConst(UINT_MAX);
}
else
{
- ASSERT(op == EOpIMod);
- resultArray[i].setUConst(leftArray[i].getUConst() % rightArray[i].getUConst());
+ if (op == EOpDiv)
+ {
+ resultArray[i].setUConst(leftArray[i].getUConst() /
+ rightArray[i].getUConst());
+ }
+ else
+ {
+ ASSERT(op == EOpIMod);
+ resultArray[i].setUConst(leftArray[i].getUConst() %
+ rightArray[i].getUConst());
+ }
}
- }
- break;
+ break;
- default:
- UNREACHABLE();
- return nullptr;
+ default:
+ UNREACHABLE();
+ return nullptr;
}
}
}
break;
- case EOpMatrixTimesVector:
+ case EOpMatrixTimesVector:
{
// TODO(jmadll): This code should check for overflows.
ASSERT(rightNode->getBasicType() == EbtFloat);
@@ -1461,15 +1462,16 @@
resultArray[matrixRow].setFConst(0.0f);
for (int col = 0; col < matrixCols; col++)
{
- resultArray[matrixRow].setFConst(resultArray[matrixRow].getFConst() +
- leftArray[col * matrixRows + matrixRow].getFConst() *
- rightArray[col].getFConst());
+ resultArray[matrixRow].setFConst(
+ resultArray[matrixRow].getFConst() +
+ leftArray[col * matrixRows + matrixRow].getFConst() *
+ rightArray[col].getFConst());
}
}
}
break;
- case EOpVectorTimesMatrix:
+ case EOpVectorTimesMatrix:
{
// TODO(jmadll): This code should check for overflows.
ASSERT(getType().getBasicType() == EbtFloat);
@@ -1484,15 +1486,16 @@
resultArray[matrixCol].setFConst(0.0f);
for (int matrixRow = 0; matrixRow < matrixRows; matrixRow++)
{
- resultArray[matrixCol].setFConst(resultArray[matrixCol].getFConst() +
- leftArray[matrixRow].getFConst() *
- rightArray[matrixCol * matrixRows + matrixRow].getFConst());
+ resultArray[matrixCol].setFConst(
+ resultArray[matrixCol].getFConst() +
+ leftArray[matrixRow].getFConst() *
+ rightArray[matrixCol * matrixRows + matrixRow].getFConst());
}
}
}
break;
- case EOpLogicalAnd:
+ case EOpLogicalAnd:
{
resultArray = new TConstantUnion[objectSize];
for (size_t i = 0; i < objectSize; i++)
@@ -1502,7 +1505,7 @@
}
break;
- case EOpLogicalOr:
+ case EOpLogicalOr:
{
resultArray = new TConstantUnion[objectSize];
for (size_t i = 0; i < objectSize; i++)
@@ -1512,7 +1515,7 @@
}
break;
- case EOpLogicalXor:
+ case EOpLogicalXor:
{
ASSERT(getType().getBasicType() == EbtBool);
resultArray = new TConstantUnion[objectSize];
@@ -1523,61 +1526,63 @@
}
break;
- case EOpBitwiseAnd:
- resultArray = new TConstantUnion[objectSize];
- for (size_t i = 0; i < objectSize; i++)
- resultArray[i] = leftArray[i] & rightArray[i];
- break;
- case EOpBitwiseXor:
- resultArray = new TConstantUnion[objectSize];
- for (size_t i = 0; i < objectSize; i++)
- resultArray[i] = leftArray[i] ^ rightArray[i];
- break;
- case EOpBitwiseOr:
- resultArray = new TConstantUnion[objectSize];
- for (size_t i = 0; i < objectSize; i++)
- resultArray[i] = leftArray[i] | rightArray[i];
- break;
- case EOpBitShiftLeft:
- resultArray = new TConstantUnion[objectSize];
- for (size_t i = 0; i < objectSize; i++)
- resultArray[i] = TConstantUnion::lshift(leftArray[i], rightArray[i], diagnostics, line);
- break;
- case EOpBitShiftRight:
- resultArray = new TConstantUnion[objectSize];
- for (size_t i = 0; i < objectSize; i++)
- resultArray[i] = TConstantUnion::rshift(leftArray[i], rightArray[i], diagnostics, line);
- break;
+ case EOpBitwiseAnd:
+ resultArray = new TConstantUnion[objectSize];
+ for (size_t i = 0; i < objectSize; i++)
+ resultArray[i] = leftArray[i] & rightArray[i];
+ break;
+ case EOpBitwiseXor:
+ resultArray = new TConstantUnion[objectSize];
+ for (size_t i = 0; i < objectSize; i++)
+ resultArray[i] = leftArray[i] ^ rightArray[i];
+ break;
+ case EOpBitwiseOr:
+ resultArray = new TConstantUnion[objectSize];
+ for (size_t i = 0; i < objectSize; i++)
+ resultArray[i] = leftArray[i] | rightArray[i];
+ break;
+ case EOpBitShiftLeft:
+ resultArray = new TConstantUnion[objectSize];
+ for (size_t i = 0; i < objectSize; i++)
+ resultArray[i] =
+ TConstantUnion::lshift(leftArray[i], rightArray[i], diagnostics, line);
+ break;
+ case EOpBitShiftRight:
+ resultArray = new TConstantUnion[objectSize];
+ for (size_t i = 0; i < objectSize; i++)
+ resultArray[i] =
+ TConstantUnion::rshift(leftArray[i], rightArray[i], diagnostics, line);
+ break;
- case EOpLessThan:
- ASSERT(objectSize == 1);
- resultArray = new TConstantUnion[1];
- resultArray->setBConst(*leftArray < *rightArray);
- break;
+ case EOpLessThan:
+ ASSERT(objectSize == 1);
+ resultArray = new TConstantUnion[1];
+ resultArray->setBConst(*leftArray < *rightArray);
+ break;
- case EOpGreaterThan:
- ASSERT(objectSize == 1);
- resultArray = new TConstantUnion[1];
- resultArray->setBConst(*leftArray > *rightArray);
- break;
+ case EOpGreaterThan:
+ ASSERT(objectSize == 1);
+ resultArray = new TConstantUnion[1];
+ resultArray->setBConst(*leftArray > *rightArray);
+ break;
- case EOpLessThanEqual:
- ASSERT(objectSize == 1);
- resultArray = new TConstantUnion[1];
- resultArray->setBConst(!(*leftArray > *rightArray));
- break;
+ case EOpLessThanEqual:
+ ASSERT(objectSize == 1);
+ resultArray = new TConstantUnion[1];
+ resultArray->setBConst(!(*leftArray > *rightArray));
+ break;
- case EOpGreaterThanEqual:
- ASSERT(objectSize == 1);
- resultArray = new TConstantUnion[1];
- resultArray->setBConst(!(*leftArray < *rightArray));
- break;
+ case EOpGreaterThanEqual:
+ ASSERT(objectSize == 1);
+ resultArray = new TConstantUnion[1];
+ resultArray->setBConst(!(*leftArray < *rightArray));
+ break;
- case EOpEqual:
- case EOpNotEqual:
+ case EOpEqual:
+ case EOpNotEqual:
{
resultArray = new TConstantUnion[1];
- bool equal = true;
+ bool equal = true;
for (size_t i = 0; i < objectSize; i++)
{
if (leftArray[i] != rightArray[i])
@@ -1597,9 +1602,9 @@
}
break;
- default:
- UNREACHABLE();
- return nullptr;
+ default:
+ UNREACHABLE();
+ return nullptr;
}
return resultArray;
}
@@ -1614,7 +1619,7 @@
const TConstantUnion *operandArray = getUnionArrayPointer();
ASSERT(operandArray);
- size_t objectSize = getType().getObjectSize();
+ size_t objectSize = getType().getObjectSize();
TConstantUnion *resultArray = nullptr;
switch (op)
{
@@ -1763,7 +1768,7 @@
TConstantUnion *resultArray = new TConstantUnion[objectSize];
for (size_t i = 0; i < objectSize; i++)
{
- switch(op)
+ switch (op)
{
case EOpNegative:
switch (getType().getBasicType())
@@ -2200,7 +2205,7 @@
int argumentCols = argumentConstant->getType().getCols();
int argumentRows = argumentConstant->getType().getRows();
int resultCols = aggregate->getType().getCols();
- int resultRows = aggregate->getType().getRows();
+ int resultRows = aggregate->getType().getRows();
for (int col = 0; col < resultCols; ++col)
{
for (int row = 0; row < resultRows; ++row)
@@ -2247,9 +2252,9 @@
TConstantUnion *TIntermConstantUnion::FoldAggregateBuiltIn(TIntermAggregate *aggregate,
TDiagnostics *diagnostics)
{
- TOperator op = aggregate->getOp();
+ TOperator op = aggregate->getOp();
TIntermSequence *sequence = aggregate->getSequence();
- unsigned int paramsCount = static_cast<unsigned int>(sequence->size());
+ unsigned int paramsCount = static_cast<unsigned int>(sequence->size());
std::vector<const TConstantUnion *> unionArrays(paramsCount);
std::vector<size_t> objectSizes(paramsCount);
size_t maxObjectSize = 0;
@@ -2258,12 +2263,12 @@
for (unsigned int i = 0; i < paramsCount; i++)
{
TIntermConstantUnion *paramConstant = (*sequence)[i]->getAsConstantUnion();
- ASSERT(paramConstant != nullptr); // Should be checked already.
+ ASSERT(paramConstant != nullptr); // Should be checked already.
if (i == 0)
{
basicType = paramConstant->getType().getBasicType();
- loc = paramConstant->getLine();
+ loc = paramConstant->getLine();
}
unionArrays[i] = paramConstant->getUnionArrayPointer();
objectSizes[i] = paramConstant->getType().getObjectSize();
@@ -2870,8 +2875,8 @@
{
const NodeUpdateEntry &replacement = mReplacements[ii];
ASSERT(replacement.parent);
- bool replaced = replacement.parent->replaceChildNode(
- replacement.original, replacement.replacement);
+ bool replaced =
+ replacement.parent->replaceChildNode(replacement.original, replacement.replacement);
ASSERT(replaced);
if (!replacement.originalBecomesChildOfReplacement)
@@ -2892,8 +2897,8 @@
{
const NodeReplaceWithMultipleEntry &replacement = mMultiReplacements[ii];
ASSERT(replacement.parent);
- bool replaced = replacement.parent->replaceChildNodeWithMultiple(
- replacement.original, replacement.replacements);
+ bool replaced = replacement.parent->replaceChildNodeWithMultiple(replacement.original,
+ replacement.replacements);
ASSERT(replaced);
}