renamed SkSL's assert macros
Since SkSL needs to run outside of Skia, it was originally using its
own ASSERT macro, which mapped to SkASSERT when inside of Skia. This is
causing conflicts with one or two other ASSERT macros defined around
Skia, so to avoid that I am switching SkSL over to just use Skia's
standard naming for these macros.
Bug: skia:
Change-Id: I115435d7282da03d076c6080f7b13d1972b9eb9f
Reviewed-on: https://skia-review.googlesource.com/134322
Reviewed-by: Greg Daniel <egdaniel@google.com>
Commit-Queue: Ethan Nicholas <ethannicholas@google.com>
diff --git a/src/sksl/SkSLCFGGenerator.cpp b/src/sksl/SkSLCFGGenerator.cpp
index 852f48d..c267058 100644
--- a/src/sksl/SkSLCFGGenerator.cpp
+++ b/src/sksl/SkSLCFGGenerator.cpp
@@ -89,7 +89,7 @@
}
bool result;
if ((*iter)->fKind == BasicBlock::Node::kExpression_Kind) {
- ASSERT((*iter)->expression()->get() != e);
+ SkASSERT((*iter)->expression()->get() != e);
Expression* old = (*iter)->expression()->get();
do {
if ((*iter) == fNodes.begin()) {
@@ -101,7 +101,7 @@
result = this->tryRemoveExpression(iter);
while ((*iter)->fKind != BasicBlock::Node::kExpression_Kind ||
(*iter)->expression()->get() != old) {
- ASSERT(*iter != fNodes.end());
+ SkASSERT(*iter != fNodes.end());
++(*iter);
}
} else {
@@ -116,7 +116,7 @@
result = this->tryRemoveExpression(iter);
while ((*iter)->fKind != BasicBlock::Node::kStatement_Kind ||
(*iter)->statement()->get() != old) {
- ASSERT(*iter != fNodes.end());
+ SkASSERT(*iter != fNodes.end());
++(*iter);
}
}
@@ -166,7 +166,7 @@
if (!this->tryRemoveExpressionBefore(iter, b->fRight.get())) {
return false;
}
- ASSERT((*iter)->expression()->get() == expr);
+ SkASSERT((*iter)->expression()->get() == expr);
*iter = fNodes.erase(*iter);
return true;
}
@@ -207,7 +207,7 @@
if (!this->tryRemoveExpressionBefore(iter, arg.get())) {
return false;
}
- ASSERT((*iter)->expression()->get() == expr);
+ SkASSERT((*iter)->expression()->get() == expr);
}
*iter = fNodes.erase(*iter);
return true;
@@ -218,7 +218,7 @@
if (!this->tryRemoveExpressionBefore(iter, arg.get())) {
return false;
}
- ASSERT((*iter)->expression()->get() == expr);
+ SkASSERT((*iter)->expression()->get() == expr);
}
*iter = fNodes.erase(*iter);
return true;
@@ -292,7 +292,7 @@
}
void CFGGenerator::addExpression(CFG& cfg, std::unique_ptr<Expression>* e, bool constantPropagate) {
- ASSERT(e);
+ SkASSERT(e);
switch ((*e)->fKind) {
case Expression::kBinary_Kind: {
BinaryExpression* b = (BinaryExpression*) e->get();
@@ -415,7 +415,7 @@
case Expression::kFunctionReference_Kind: // fall through
case Expression::kTypeReference_Kind: // fall through
case Expression::kDefined_Kind:
- ASSERT(false);
+ SkASSERT(false);
break;
}
}
@@ -445,7 +445,7 @@
break;
default:
// not an lvalue, can't happen
- ASSERT(false);
+ SkASSERT(false);
break;
}
}
diff --git a/src/sksl/SkSLCFGGenerator.h b/src/sksl/SkSLCFGGenerator.h
index 885d926..d8a4f82 100644
--- a/src/sksl/SkSLCFGGenerator.h
+++ b/src/sksl/SkSLCFGGenerator.h
@@ -34,22 +34,22 @@
, fStatement(statement) {}
std::unique_ptr<Expression>* expression() const {
- ASSERT(fKind == kExpression_Kind);
+ SkASSERT(fKind == kExpression_Kind);
return fExpression;
}
void setExpression(std::unique_ptr<Expression> expr) {
- ASSERT(fKind == kExpression_Kind);
+ SkASSERT(fKind == kExpression_Kind);
*fExpression = std::move(expr);
}
std::unique_ptr<Statement>* statement() const {
- ASSERT(fKind == kStatement_Kind);
+ SkASSERT(fKind == kStatement_Kind);
return fStatement;
}
void setStatement(std::unique_ptr<Statement> stmt) {
- ASSERT(fKind == kStatement_Kind);
+ SkASSERT(fKind == kStatement_Kind);
*fStatement = std::move(stmt);
}
@@ -57,7 +57,7 @@
if (fKind == kStatement_Kind) {
return (*fStatement)->description();
} else {
- ASSERT(fKind == kExpression_Kind);
+ SkASSERT(fKind == kExpression_Kind);
return (*fExpression)->description();
}
}
diff --git a/src/sksl/SkSLCPPCodeGenerator.cpp b/src/sksl/SkSLCPPCodeGenerator.cpp
index 851f8e8..fe2dc70 100644
--- a/src/sksl/SkSLCPPCodeGenerator.cpp
+++ b/src/sksl/SkSLCPPCodeGenerator.cpp
@@ -185,7 +185,7 @@
fFormatArgs.push_back(cppCode + ".bottom()");
} else {
printf("unsupported runtime value type '%s'\n", String(type.fName).c_str());
- ASSERT(false);
+ SkASSERT(false);
}
}
@@ -216,7 +216,7 @@
void CPPCodeGenerator::writeSwizzle(const Swizzle& swizzle) {
if (fCPPMode) {
- ASSERT(swizzle.fComponents.size() == 1); // no support for multiple swizzle components yet
+ SkASSERT(swizzle.fComponents.size() == 1); // no support for multiple swizzle components yet
this->writeExpression(*swizzle.fBase, kPostfix_Precedence);
switch (swizzle.fComponents[0]) {
case 0: this->write(".left()"); break;
@@ -291,8 +291,8 @@
void CPPCodeGenerator::writeFunctionCall(const FunctionCall& c) {
if (c.fFunction.fBuiltin && c.fFunction.fName == "process") {
- ASSERT(c.fArguments.size() == 1);
- ASSERT(Expression::kVariableReference_Kind == c.fArguments[0]->fKind);
+ SkASSERT(c.fArguments.size() == 1);
+ SkASSERT(Expression::kVariableReference_Kind == c.fArguments[0]->fKind);
int index = 0;
bool found = false;
for (const auto& p : fProgram) {
@@ -311,7 +311,7 @@
break;
}
}
- ASSERT(found);
+ SkASSERT(found);
String childName = "_child" + to_string(index);
fExtraEmitCodeCode += " SkString " + childName + "(\"" + childName + "\");\n" +
" this->emitChild(" + to_string(index) + ", &" + childName +
@@ -323,8 +323,8 @@
INHERITED::writeFunctionCall(c);
if (c.fFunction.fBuiltin && c.fFunction.fName == "texture") {
this->write(".%s");
- ASSERT(c.fArguments.size() >= 1);
- ASSERT(c.fArguments[0]->fKind == Expression::kVariableReference_Kind);
+ SkASSERT(c.fArguments.size() >= 1);
+ SkASSERT(c.fArguments[0]->fKind == Expression::kVariableReference_Kind);
String sampler = this->getSamplerHandle(((VariableReference&) *c.fArguments[0]).fVariable);
fFormatArgs.push_back("fragBuilder->getProgramBuilder()->samplerSwizzle(" + sampler +
").c_str()");
diff --git a/src/sksl/SkSLCompiler.cpp b/src/sksl/SkSLCompiler.cpp
index a5f5225..0cf55c2 100644
--- a/src/sksl/SkSLCompiler.cpp
+++ b/src/sksl/SkSLCompiler.cpp
@@ -213,7 +213,7 @@
if (fErrorCount) {
printf("Unexpected errors: %s\n", fErrorText.c_str());
}
- ASSERT(!fErrorCount);
+ SkASSERT(!fErrorCount);
Program::Settings settings;
fIRGenerator->start(&settings, nullptr);
@@ -289,7 +289,7 @@
break;
default:
// not an lvalue, can't happen
- ASSERT(false);
+ SkASSERT(false);
}
}
@@ -298,7 +298,7 @@
DefinitionMap* definitions) {
switch (node.fKind) {
case BasicBlock::Node::kExpression_Kind: {
- ASSERT(node.expression());
+ SkASSERT(node.expression());
const Expression* expr = (Expression*) node.expression()->get();
switch (expr->fKind) {
case Expression::kBinary_Kind: {
@@ -420,7 +420,7 @@
for (const auto& block : cfg.fBlocks) {
for (const auto& node : block.fNodes) {
if (node.fKind == BasicBlock::Node::kStatement_Kind) {
- ASSERT(node.statement());
+ SkASSERT(node.statement());
const Statement* s = node.statement()->get();
if (s->fKind == Statement::kVarDeclarations_Kind) {
const VarDeclarationsStatement* vd = (const VarDeclarationsStatement*) s;
@@ -539,9 +539,9 @@
bool* outNeedsRescan) {
*outUpdated = true;
std::unique_ptr<Expression>* target = (*iter)->expression();
- ASSERT((*target)->fKind == Expression::kBinary_Kind);
+ SkASSERT((*target)->fKind == Expression::kBinary_Kind);
BinaryExpression& bin = (BinaryExpression&) **target;
- ASSERT(!bin.fLeft->hasSideEffects());
+ SkASSERT(!bin.fLeft->hasSideEffects());
bool result;
if (bin.fOperator == Token::EQ) {
result = b->tryRemoveLValueBefore(iter, bin.fLeft.get());
@@ -564,7 +564,7 @@
return;
}
*iter = b->fNodes.erase(*iter);
- ASSERT((*iter)->expression() == target);
+ SkASSERT((*iter)->expression() == target);
}
/**
@@ -577,9 +577,9 @@
bool* outNeedsRescan) {
*outUpdated = true;
std::unique_ptr<Expression>* target = (*iter)->expression();
- ASSERT((*target)->fKind == Expression::kBinary_Kind);
+ SkASSERT((*target)->fKind == Expression::kBinary_Kind);
BinaryExpression& bin = (BinaryExpression&) **target;
- ASSERT(!bin.fRight->hasSideEffects());
+ SkASSERT(!bin.fRight->hasSideEffects());
if (!b->tryRemoveExpressionBefore(iter, bin.fRight.get())) {
*target = std::move(bin.fLeft);
*outNeedsRescan = true;
@@ -597,7 +597,7 @@
return;
}
*iter = b->fNodes.erase(*iter);
- ASSERT((*iter)->expression() == target);
+ SkASSERT((*iter)->expression() == target);
}
/**
@@ -620,9 +620,9 @@
std::unique_ptr<Expression>* otherExpression,
bool* outUpdated,
bool* outNeedsRescan) {
- ASSERT((*(*iter)->expression())->fKind == Expression::kBinary_Kind);
- ASSERT(type.kind() == Type::kVector_Kind);
- ASSERT((*otherExpression)->fType.kind() == Type::kScalar_Kind);
+ SkASSERT((*(*iter)->expression())->fKind == Expression::kBinary_Kind);
+ SkASSERT(type.kind() == Type::kVector_Kind);
+ SkASSERT((*otherExpression)->fType.kind() == Type::kScalar_Kind);
*outUpdated = true;
std::unique_ptr<Expression>* target = (*iter)->expression();
if (!b->tryRemoveExpression(iter)) {
@@ -689,7 +689,7 @@
bool* outUpdated,
bool* outNeedsRescan) {
Expression* expr = (*iter)->expression()->get();
- ASSERT(expr);
+ SkASSERT(expr);
if ((*iter)->fConstantPropagation) {
std::unique_ptr<Expression> optimized = expr->constantPropagate(*fIRGenerator, definitions);
if (optimized) {
@@ -698,7 +698,7 @@
*outNeedsRescan = true;
return;
}
- ASSERT((*iter)->fKind == BasicBlock::Node::kExpression_Kind);
+ SkASSERT((*iter)->fKind == BasicBlock::Node::kExpression_Kind);
expr = (*iter)->expression()->get();
}
}
@@ -972,7 +972,7 @@
(!varDecl.fValue ||
!varDecl.fValue->hasSideEffects())) {
if (varDecl.fValue) {
- ASSERT((*iter)->statement()->get() == stmt);
+ SkASSERT((*iter)->statement()->get() == stmt);
if (!b.tryRemoveExpressionBefore(iter, varDecl.fValue.get())) {
*outNeedsRescan = true;
}
@@ -987,7 +987,7 @@
if (i.fTest->fKind == Expression::kBoolLiteral_Kind) {
// constant if, collapse down to a single branch
if (((BoolLiteral&) *i.fTest).fValue) {
- ASSERT(i.fIfTrue);
+ SkASSERT(i.fIfTrue);
(*iter)->setStatement(std::move(i.fIfTrue));
} else {
if (i.fIfFalse) {
@@ -1033,7 +1033,7 @@
defaultCase = c.get();
continue;
}
- ASSERT(c->fValue->fKind == s.fValue->fKind);
+ SkASSERT(c->fValue->fKind == s.fValue->fKind);
found = c->fValue->compareConstant(*fContext, *s.fValue);
if (found) {
std::unique_ptr<Statement> newBlock = block_for_case(&s, c.get());
@@ -1075,13 +1075,13 @@
}
case Statement::kExpression_Kind: {
ExpressionStatement& e = (ExpressionStatement&) *stmt;
- ASSERT((*iter)->statement()->get() == &e);
+ SkASSERT((*iter)->statement()->get() == &e);
if (!e.fExpression->hasSideEffects()) {
// Expression statement with no side effects, kill it
if (!b.tryRemoveExpressionBefore(iter, e.fExpression.get())) {
*outNeedsRescan = true;
}
- ASSERT((*iter)->statement()->get() == stmt);
+ SkASSERT((*iter)->statement()->get() == stmt);
(*iter)->setStatement(std::unique_ptr<Statement>(new Nop()));
*outUpdated = true;
}
@@ -1146,7 +1146,7 @@
}
}
} while (updated);
- ASSERT(!needsRescan);
+ SkASSERT(!needsRescan);
// verify static ifs & switches, clean up dead variable decls
for (BasicBlock& b : cfg.fBlocks) {
@@ -1283,14 +1283,14 @@
if (result) {
spvtools::SpirvTools tools(SPV_ENV_VULKAN_1_0);
const String& data = buffer.str();
- ASSERT(0 == data.size() % 4);
+ SkASSERT(0 == data.size() % 4);
auto dumpmsg = [](spv_message_level_t, const char*, const spv_position_t&, const char* m) {
SkDebugf("SPIR-V validation error: %s\n", m);
};
tools.SetMessageConsumer(dumpmsg);
- // Verify that the SPIR-V we produced is valid. If this assert fails, check the logs prior
+ // Verify that the SPIR-V we produced is valid. If this SkASSERT fails, check the logs prior
// to the failure to see the validation errors.
- ASSERT_RESULT(tools.Validate((const uint32_t*) data.c_str(), data.size() / 4));
+ SkAssertResult(tools.Validate((const uint32_t*) data.c_str(), data.size() / 4));
out.write(data.c_str(), data.size());
}
#else
@@ -1424,7 +1424,7 @@
}
Position Compiler::position(int offset) {
- ASSERT(fSource);
+ SkASSERT(fSource);
int line = 1;
int column = 1;
for (int i = 0; i < offset; i++) {
diff --git a/src/sksl/SkSLFileOutputStream.h b/src/sksl/SkSLFileOutputStream.h
index 7d83941..94939f6 100644
--- a/src/sksl/SkSLFileOutputStream.h
+++ b/src/sksl/SkSLFileOutputStream.h
@@ -21,7 +21,7 @@
}
~FileOutputStream() override {
- ASSERT(!fOpen);
+ SkASSERT(!fOpen);
}
bool isValid() const override {
@@ -29,7 +29,7 @@
}
void write8(uint8_t b) override {
- ASSERT(fOpen);
+ SkASSERT(fOpen);
if (isValid()) {
if (EOF == fputc(b, fFile)) {
fFile = nullptr;
@@ -38,7 +38,7 @@
}
void writeText(const char* s) override {
- ASSERT(fOpen);
+ SkASSERT(fOpen);
if (isValid()) {
if (EOF == fputs(s, fFile)) {
fFile = nullptr;
diff --git a/src/sksl/SkSLGLSLCodeGenerator.cpp b/src/sksl/SkSLGLSLCodeGenerator.cpp
index 47fa721..aa4f825 100644
--- a/src/sksl/SkSLGLSLCodeGenerator.cpp
+++ b/src/sksl/SkSLGLSLCodeGenerator.cpp
@@ -233,7 +233,7 @@
// turns min(abs(x), y) into ((tmpVar1 = abs(x)) < (tmpVar2 = y) ? tmpVar1 : tmpVar2) to avoid a
// Tegra3 compiler bug.
void GLSLCodeGenerator::writeMinAbsHack(Expression& absExpr, Expression& otherExpr) {
- ASSERT(!fProgram.fSettings.fCaps->canUseMinAndAbsTogether());
+ SkASSERT(!fProgram.fSettings.fCaps->canUseMinAndAbsTogether());
String tmpVar1 = "minAbsHackVar" + to_string(fVarCount++);
String tmpVar2 = "minAbsHackVar" + to_string(fVarCount++);
this->fFunctionHeader += String(" ") + this->getTypePrecision(absExpr.fType) +
@@ -311,7 +311,7 @@
}
}
else {
- ASSERT(false);
+ SkASSERT(false);
}
this->write(name + "(");
this->writeExpression(mat, kTopLevel_Precedence);
@@ -398,7 +398,7 @@
}
}
else {
- ASSERT(false);
+ SkASSERT(false);
}
this->write(name + "(");
this->writeExpression(mat, kTopLevel_Precedence);
@@ -435,7 +435,7 @@
void GLSLCodeGenerator::writeFunctionCall(const FunctionCall& c) {
if (!fProgram.fSettings.fCaps->canUseMinAndAbsTogether() && c.fFunction.fName == "min" &&
c.fFunction.fBuiltin) {
- ASSERT(c.fArguments.size() == 2);
+ SkASSERT(c.fArguments.size() == 2);
if (is_abs(*c.fArguments[0])) {
this->writeMinAbsHack(*c.fArguments[0], *c.fArguments[1]);
return;
@@ -449,7 +449,7 @@
}
if (!fProgram.fSettings.fCaps->canUseFractForNegativeValues() && c.fFunction.fName == "fract" &&
c.fFunction.fBuiltin) {
- ASSERT(c.fArguments.size() == 1);
+ SkASSERT(c.fArguments.size() == 1);
this->write("(0.5 - sign(");
this->writeExpression(*c.fArguments[0], kSequence_Precedence);
@@ -475,31 +475,31 @@
}
if (c.fFunction.fBuiltin && c.fFunction.fName == "determinant" &&
fProgram.fSettings.fCaps->generation() < k150_GrGLSLGeneration) {
- ASSERT(c.fArguments.size() == 1);
+ SkASSERT(c.fArguments.size() == 1);
this->writeDeterminantHack(*c.fArguments[0]);
return;
}
if (c.fFunction.fBuiltin && c.fFunction.fName == "inverse" &&
fProgram.fSettings.fCaps->generation() < k140_GrGLSLGeneration) {
- ASSERT(c.fArguments.size() == 1);
+ SkASSERT(c.fArguments.size() == 1);
this->writeInverseHack(*c.fArguments[0]);
return;
}
if (c.fFunction.fBuiltin && c.fFunction.fName == "inverseSqrt" &&
fProgram.fSettings.fCaps->generation() < k130_GrGLSLGeneration) {
- ASSERT(c.fArguments.size() == 1);
+ SkASSERT(c.fArguments.size() == 1);
this->writeInverseSqrtHack(*c.fArguments[0]);
return;
}
if (c.fFunction.fBuiltin && c.fFunction.fName == "transpose" &&
fProgram.fSettings.fCaps->generation() < k130_GrGLSLGeneration) {
- ASSERT(c.fArguments.size() == 1);
+ SkASSERT(c.fArguments.size() == 1);
this->writeTransposeHack(*c.fArguments[0]);
return;
}
if (!fFoundDerivatives && (c.fFunction.fName == "dFdx" || c.fFunction.fName == "dFdy") &&
c.fFunction.fBuiltin && fProgram.fSettings.fCaps->shaderDerivativeExtensionString()) {
- ASSERT(fProgram.fSettings.fCaps->shaderDerivativeSupport());
+ SkASSERT(fProgram.fSettings.fCaps->shaderDerivativeSupport());
fHeader.writeText("#extension ");
fHeader.writeText(fProgram.fSettings.fCaps->shaderDerivativeExtensionString());
fHeader.writeText(" : require\n");
@@ -516,7 +516,7 @@
if (c.fArguments[1]->fType == *fContext.fFloat_Type) {
proj = false;
} else {
- ASSERT(c.fArguments[1]->fType == *fContext.fFloat2_Type);
+ SkASSERT(c.fArguments[1]->fType == *fContext.fFloat2_Type);
proj = true;
}
break;
@@ -528,7 +528,7 @@
if (c.fArguments[1]->fType == *fContext.fFloat2_Type) {
proj = false;
} else {
- ASSERT(c.fArguments[1]->fType == *fContext.fFloat3_Type);
+ SkASSERT(c.fArguments[1]->fType == *fContext.fFloat3_Type);
proj = true;
}
break;
@@ -538,7 +538,7 @@
if (c.fArguments[1]->fType == *fContext.fFloat3_Type) {
proj = false;
} else {
- ASSERT(c.fArguments[1]->fType == *fContext.fFloat4_Type);
+ SkASSERT(c.fArguments[1]->fType == *fContext.fFloat4_Type);
proj = true;
}
break;
@@ -552,12 +552,12 @@
proj = false;
break;
case SpvDimBuffer:
- ASSERT(false); // doesn't exist
+ SkASSERT(false); // doesn't exist
dim = "Buffer";
proj = false;
break;
case SpvDimSubpassData:
- ASSERT(false); // doesn't exist
+ SkASSERT(false); // doesn't exist
dim = "SubpassData";
proj = false;
break;
diff --git a/src/sksl/SkSLHCodeGenerator.cpp b/src/sksl/SkSLHCodeGenerator.cpp
index 2c406aa..d6a92d3 100644
--- a/src/sksl/SkSLHCodeGenerator.cpp
+++ b/src/sksl/SkSLHCodeGenerator.cpp
@@ -54,7 +54,7 @@
} else if (type == *context.fFragmentProcessor_Type) {
// we don't store fragment processors in fields, they get registered via
// registerChildProcessor instead
- ASSERT(false);
+ SkASSERT(false);
return "<error>";
}
return ParameterType(context, type, layout);
@@ -111,13 +111,13 @@
lastIdentifierLength = 0;
foundBreak = false;
}
- ASSERT(lastIdentifierLength < BUFFER_SIZE);
+ SkASSERT(lastIdentifierLength < BUFFER_SIZE);
lastIdentifier[lastIdentifierLength] = c;
++lastIdentifierLength;
} else {
foundBreak = true;
if (c == ',') {
- ASSERT(lastIdentifierLength < BUFFER_SIZE);
+ SkASSERT(lastIdentifierLength < BUFFER_SIZE);
lastIdentifier[lastIdentifierLength] = 0;
this->writef("%s%s", separator, lastIdentifier);
separator = ", ";
@@ -127,7 +127,7 @@
}
}
if (lastIdentifierLength) {
- ASSERT(lastIdentifierLength < BUFFER_SIZE);
+ SkASSERT(lastIdentifierLength < BUFFER_SIZE);
lastIdentifier[lastIdentifierLength] = 0;
this->writef("%s%s", separator, lastIdentifier);
}
diff --git a/src/sksl/SkSLIRGenerator.cpp b/src/sksl/SkSLIRGenerator.cpp
index c081fd7..5a54b07 100644
--- a/src/sksl/SkSLIRGenerator.cpp
+++ b/src/sksl/SkSLIRGenerator.cpp
@@ -67,7 +67,7 @@
~AutoSymbolTable() {
fIR->popSymbolTable();
- ASSERT(fPrevious == fIR->fSymbolTable);
+ SkASSERT(fPrevious == fIR->fSymbolTable);
}
IRGenerator* fIR;
@@ -160,7 +160,7 @@
if (e->fKind == ProgramElement::kInterfaceBlock_Kind) {
InterfaceBlock& intf = (InterfaceBlock&) *e;
if (intf.fVariable.fName == Compiler::PERVERTEX_NAME) {
- ASSERT(!fSkPerVertex);
+ SkASSERT(!fSkPerVertex);
fSkPerVertex = &intf.fVariable;
}
}
@@ -187,7 +187,7 @@
std::unique_ptr<Statement> result =
this->convertExpressionStatement((ASTExpressionStatement&) statement);
if (fRTAdjust && Program::kGeometry_Kind == fKind) {
- ASSERT(result->fKind == Statement::kExpression_Kind);
+ SkASSERT(result->fKind == Statement::kExpression_Kind);
Expression& expr = *((ExpressionStatement&) *result).fExpression;
if (expr.fKind == Expression::kFunctionCall_Kind) {
FunctionCall& fc = (FunctionCall&) expr;
@@ -294,8 +294,8 @@
auto var = std::unique_ptr<Variable>(new Variable(decl.fOffset, decl.fModifiers,
varDecl.fName, *type, storage));
if (var->fName == Compiler::RTADJUST_NAME) {
- ASSERT(!fRTAdjust);
- ASSERT(var->fType == *fContext.fFloat4_Type);
+ SkASSERT(!fRTAdjust);
+ SkASSERT(var->fType == *fContext.fFloat4_Type);
fRTAdjust = var.get();
}
std::unique_ptr<Expression> value;
@@ -339,7 +339,7 @@
if (fSettings->fCaps && !fSettings->fCaps->gsInvocationsSupport()) {
modifiers.fLayout.fInvocations = -1;
Variable* invocationId = (Variable*) (*fSymbolTable)["sk_InvocationID"];
- ASSERT(invocationId);
+ SkASSERT(invocationId);
invocationId->fModifiers.fFlags = 0;
invocationId->fModifiers.fLayout.fBuiltin = -1;
if (modifiers.fLayout.description() == "") {
@@ -516,11 +516,11 @@
}
std::unique_ptr<Statement> IRGenerator::convertReturn(const ASTReturnStatement& r) {
- ASSERT(fCurrentFunction);
+ SkASSERT(fCurrentFunction);
// early returns from a vertex main function will bypass the sk_Position normalization, so
- // assert that we aren't doing that. It is of course possible to fix this by adding a
+ // SkASSERT that we aren't doing that. It is of course possible to fix this by adding a
// normalization before each return, but it will probably never actually be necessary.
- ASSERT(Program::kVertex_Kind != fKind || !fRTAdjust || "main" != fCurrentFunction->fName);
+ SkASSERT(Program::kVertex_Kind != fKind || !fRTAdjust || "main" != fCurrentFunction->fName);
if (r.fExpression) {
std::unique_ptr<Expression> result = this->convertExpression(*r.fExpression);
if (!result) {
@@ -580,7 +580,7 @@
std::vector<std::unique_ptr<VarDeclaration>> variables;
Variable* loopIdx = (Variable*) (*fSymbolTable)["sk_InvocationID"];
- ASSERT(loopIdx);
+ SkASSERT(loopIdx);
std::unique_ptr<Expression> test(new BinaryExpression(-1,
std::unique_ptr<Expression>(new VariableReference(-1, *loopIdx)),
Token::LT,
@@ -594,7 +594,7 @@
Token::PLUSPLUS));
ASTIdentifier endPrimitiveID = ASTIdentifier(-1, "EndPrimitive");
std::unique_ptr<Expression> endPrimitive = this->convertExpression(endPrimitiveID);
- ASSERT(endPrimitive);
+ SkASSERT(endPrimitive);
std::vector<std::unique_ptr<Statement>> loopBody;
std::vector<std::unique_ptr<Expression>> invokeArgs;
@@ -628,7 +628,7 @@
// sk_Position = float4(sk_Position.xy * rtAdjust.xz + sk_Position.ww * rtAdjust.yw,
// 0,
// sk_Position.w);
- ASSERT(fSkPerVertex && fRTAdjust);
+ SkASSERT(fSkPerVertex && fRTAdjust);
#define REF(var) std::unique_ptr<Expression>(\
new VariableReference(-1, *var, VariableReference::kRead_RefKind))
#define FIELD(var, idx) std::unique_ptr<Expression>(\
@@ -699,7 +699,7 @@
return;
}
for (const auto& other : functions) {
- ASSERT(other->fName == f.fName);
+ SkASSERT(other->fName == f.fName);
if (parameters.size() == other->fParameters.size()) {
bool match = true;
for (size_t i = 0; i < parameters.size(); i++) {
@@ -747,7 +747,7 @@
fSymbolTable->add(decl->fName, std::move(newDecl));
}
if (f.fBody) {
- ASSERT(!fCurrentFunction);
+ SkASSERT(!fCurrentFunction);
fCurrentFunction = decl;
decl->fDefined = true;
std::shared_ptr<SymbolTable> old = fSymbolTable;
@@ -758,7 +758,7 @@
bool needInvocationIDWorkaround = fInvocations != -1 && f.fName == "main" &&
fSettings->fCaps &&
!fSettings->fCaps->gsInvocationsSupport();
- ASSERT(!fExtraVars.size());
+ SkASSERT(!fExtraVars.size());
std::unique_ptr<Block> body = this->convertBlock(*f.fBody);
for (auto& v : fExtraVars) {
body->fStatements.insert(body->fStatements.begin(), std::move(v));
@@ -804,7 +804,7 @@
}
if (vd.fVar == fRTAdjust) {
foundRTAdjust = true;
- ASSERT(vd.fVar->fType == *fContext.fFloat4_Type);
+ SkASSERT(vd.fVar->fType == *fContext.fFloat4_Type);
fRTAdjustFieldIndex = fields.size();
}
fields.push_back(Type::Field(vd.fVar->fModifiers, vd.fVar->fName,
@@ -1062,7 +1062,7 @@
args.push_back(std::move(expr));
ASTIdentifier id(-1, type.fName);
std::unique_ptr<Expression> ctor = this->convertIdentifier(id);
- ASSERT(ctor);
+ SkASSERT(ctor);
return this->call(-1, std::move(ctor), std::move(args));
}
std::vector<std::unique_ptr<Expression>> args;
@@ -1156,7 +1156,7 @@
// transpose it
rightColumns = right.rows();
rightRows = right.columns();
- ASSERT(rightColumns == 1);
+ SkASSERT(rightColumns == 1);
} else {
rightColumns = right.columns();
rightRows = right.rows();
@@ -1336,8 +1336,8 @@
if (left.fType.kind() == Type::kVector_Kind &&
left.fType.componentType() == *fContext.fFloat_Type &&
left.fType == right.fType) {
- ASSERT(left.fKind == Expression::kConstructor_Kind);
- ASSERT(right.fKind == Expression::kConstructor_Kind);
+ SkASSERT(left.fKind == Expression::kConstructor_Kind);
+ SkASSERT(right.fKind == Expression::kConstructor_Kind);
std::vector<std::unique_ptr<Expression>> args;
#define RETURN_VEC_COMPONENTWISE_RESULT(op) \
for (int i = 0; i < left.fType.columns(); i++) { \
@@ -1488,12 +1488,12 @@
// For float3coordinates, implements the transformation:
// texture(sampler, coord) -> texture(sampler, float3textureSize(sampler), 1.0) * coord))
void IRGenerator::fixRectSampling(std::vector<std::unique_ptr<Expression>>& arguments) {
- ASSERT(arguments.size() == 2);
- ASSERT(arguments[0]->fType == *fContext.fSampler2DRect_Type);
- ASSERT(arguments[0]->fKind == Expression::kVariableReference_Kind);
+ SkASSERT(arguments.size() == 2);
+ SkASSERT(arguments[0]->fType == *fContext.fSampler2DRect_Type);
+ SkASSERT(arguments[0]->fKind == Expression::kVariableReference_Kind);
const Variable& sampler = ((VariableReference&) *arguments[0]).fVariable;
const Symbol* textureSizeSymbol = (*fSymbolTable)["textureSize"];
- ASSERT(textureSizeSymbol->fKind == Symbol::kFunctionDeclaration_Kind);
+ SkASSERT(textureSizeSymbol->fKind == Symbol::kFunctionDeclaration_Kind);
const FunctionDeclaration& textureSize = (FunctionDeclaration&) *textureSizeSymbol;
std::vector<std::unique_ptr<Expression>> sizeArguments;
sizeArguments.emplace_back(new VariableReference(-1, sampler));
@@ -1503,7 +1503,7 @@
if (type == *fContext.fFloat2_Type) {
scale = std::move(float2ize);
} else {
- ASSERT(type == *fContext.fFloat3_Type);
+ SkASSERT(type == *fContext.fFloat3_Type);
std::vector<std::unique_ptr<Expression>> float3rguments;
float3rguments.push_back(std::move(float2ize));
float3rguments.emplace_back(new FloatLiteral(fContext, -1, 1.0));
@@ -1632,7 +1632,7 @@
int offset,
const Type& type,
std::vector<std::unique_ptr<Expression>> args) {
- ASSERT(type.isNumber());
+ SkASSERT(type.isNumber());
if (args.size() != 1) {
fErrors.error(offset, "invalid arguments to '" + type.description() +
"' constructor, (expected exactly 1 argument, but found " +
@@ -1691,7 +1691,7 @@
int offset,
const Type& type,
std::vector<std::unique_ptr<Expression>> args) {
- ASSERT(type.kind() == Type::kVector_Kind || type.kind() == Type::kMatrix_Kind);
+ SkASSERT(type.kind() == Type::kVector_Kind || type.kind() == Type::kMatrix_Kind);
if (type.kind() == Type::kMatrix_Kind && args.size() == 1 &&
args[0]->fType.kind() == Type::kMatrix_Kind) {
// matrix from matrix is always legal
@@ -1933,7 +1933,7 @@
return nullptr;
}
}
- ASSERT(swizzleComponents.size() > 0);
+ SkASSERT(swizzleComponents.size() > 0);
if (swizzleComponents.size() > 4) {
fErrors.error(base->fOffset, "too many components in swizzle mask '" + fields + "'");
return nullptr;
@@ -2062,7 +2062,7 @@
return std::unique_ptr<Expression>(new AppendStage(fContext, offset, stage,
std::move(stageArgs)));
#else
- ASSERT(false);
+ SkASSERT(false);
return nullptr;
#endif
}
@@ -2171,7 +2171,7 @@
static bool has_duplicates(const Swizzle& swizzle) {
int bits = 0;
for (int idx : swizzle.fComponents) {
- ASSERT(idx >= 0 && idx <= 3);
+ SkASSERT(idx >= 0 && idx <= 3);
int bit = 1 << idx;
if (bits & bit) {
return true;
diff --git a/src/sksl/SkSLInterpreter.cpp b/src/sksl/SkSLInterpreter.cpp
index 45e340a..5879274 100644
--- a/src/sksl/SkSLInterpreter.cpp
+++ b/src/sksl/SkSLInterpreter.cpp
@@ -38,7 +38,7 @@
}
}
}
- ASSERT(false);
+ SkASSERT(false);
}
static int SizeOf(const Type& type) {
@@ -87,7 +87,7 @@
if (!b.fStatements.size()) {
break;
}
- ASSERT(index < b.fStatements.size());
+ SkASSERT(index < b.fStatements.size());
if (index < b.fStatements.size() - 1) {
fCurrentIndex.push_back({ &b, index + 1 });
}
@@ -95,18 +95,18 @@
break;
}
case Statement::kBreak_Kind:
- ASSERT(index == 0);
+ SkASSERT(index == 0);
abort();
case Statement::kContinue_Kind:
- ASSERT(index == 0);
+ SkASSERT(index == 0);
abort();
case Statement::kDiscard_Kind:
- ASSERT(index == 0);
+ SkASSERT(index == 0);
abort();
case Statement::kDo_Kind:
abort();
case Statement::kExpression_Kind:
- ASSERT(index == 0);
+ SkASSERT(index == 0);
this->evaluate(*((const ExpressionStatement&) stmt).fExpression);
break;
case Statement::kFor_Kind: {
@@ -136,7 +136,7 @@
fCurrentIndex.push_back({ &f, 1 });
break;
default:
- ASSERT(false);
+ SkASSERT(false);
}
break;
}
@@ -152,15 +152,15 @@
break;
}
case Statement::kNop_Kind:
- ASSERT(index == 0);
+ SkASSERT(index == 0);
break;
case Statement::kReturn_Kind:
- ASSERT(index == 0);
+ SkASSERT(index == 0);
abort();
case Statement::kSwitch_Kind:
abort();
case Statement::kVarDeclarations_Kind:
- ASSERT(index == 0);
+ SkASSERT(index == 0);
for (const auto& decl :((const VarDeclarationsStatement&) stmt).fDeclaration->fVars) {
const Variable* var = ((VarDeclaration&) *decl).fVar;
StackIndex pos = this->stackAlloc(SizeOf(var->fType));
@@ -197,8 +197,8 @@
case Expression::kSwizzle_Kind:
break;
case Expression::kVariableReference_Kind:
- ASSERT(fVars.size());
- ASSERT(fVars.back().find(&((VariableReference&) expr).fVariable) !=
+ SkASSERT(fVars.size());
+ SkASSERT(fVars.back().find(&((VariableReference&) expr).fVariable) !=
fVars.back().end());
return fVars.back()[&((VariableReference&) expr).fVariable];
case Expression::kTernary_Kind: {
@@ -234,13 +234,13 @@
void Interpreter::appendStage(const AppendStage& a) {
switch (a.fStage) {
case SkRasterPipeline::matrix_4x5: {
- ASSERT(a.fArguments.size() == 1);
+ SkASSERT(a.fArguments.size() == 1);
StackIndex transpose = evaluate(*a.fArguments[0]).fInt;
fPipeline.append(SkRasterPipeline::matrix_4x5, &fStack[transpose]);
break;
}
case SkRasterPipeline::callback: {
- ASSERT(a.fArguments.size() == 1);
+ SkASSERT(a.fArguments.size() == 1);
CallbackCtx* ctx = new CallbackCtx();
ctx->fInterpreter = this;
ctx->fn = do_callback;
@@ -430,7 +430,7 @@
if (Token::PLUSPLUS == p.fOperator) {
++fStack[lvalue].fFloat;
} else {
- ASSERT(Token::MINUSMINUS == p.fOperator);
+ SkASSERT(Token::MINUSMINUS == p.fOperator);
--fStack[lvalue].fFloat;
}
break;
@@ -438,7 +438,7 @@
if (Token::PLUSPLUS == p.fOperator) {
++fStack[lvalue].fInt;
} else {
- ASSERT(Token::MINUSMINUS == p.fOperator);
+ SkASSERT(Token::MINUSMINUS == p.fOperator);
--fStack[lvalue].fInt;
}
break;
@@ -452,8 +452,8 @@
case Expression::kSwizzle_Kind:
break;
case Expression::kVariableReference_Kind:
- ASSERT(fVars.size());
- ASSERT(fVars.back().find(&((VariableReference&) expr).fVariable) !=
+ SkASSERT(fVars.size());
+ SkASSERT(fVars.back().find(&((VariableReference&) expr).fVariable) !=
fVars.back().end());
return fStack[fVars.back()[&((VariableReference&) expr).fVariable]];
case Expression::kTernary_Kind: {
diff --git a/src/sksl/SkSLJIT.cpp b/src/sksl/SkSLJIT.cpp
index 06b6e2c..57286b5 100644
--- a/src/sksl/SkSLJIT.cpp
+++ b/src/sksl/SkSLJIT.cpp
@@ -64,7 +64,7 @@
LLVMInitializeNativeTarget();
LLVMInitializeNativeAsmPrinter();
LLVMLinkInMCJIT();
- ASSERT(!SkCpu::Supports(SkCpu::SKX)); // not yet supported
+ SkASSERT(!SkCpu::Supports(SkCpu::SKX)); // not yet supported
if (SkCpu::Supports(SkCpu::HSW)) {
fVectorCount = 8;
fCPU = "haswell";
@@ -144,13 +144,13 @@
result = llvm::RTDyldMemoryManager::getSymbolAddressInProcess(name);
}
}
- ASSERT(result);
+ SkASSERT(result);
return result;
}
LLVMValueRef JIT::compileFunctionCall(LLVMBuilderRef builder, const FunctionCall& fc) {
LLVMValueRef func = fFunctions[&fc.fFunction];
- ASSERT(func);
+ SkASSERT(func);
std::vector<LLVMValueRef> parameters;
for (const auto& a : fc.fArguments) {
parameters.push_back(this->compileExpression(builder, *a));
@@ -164,7 +164,7 @@
if (type.name() == "void") {
return fVoidType;
}
- ASSERT(type.name() == "SkRasterPipeline");
+ SkASSERT(type.name() == "SkRasterPipeline");
return fInt8PtrType;
case Type::kScalar_Kind:
if (type.isSigned() || type.isUnsigned()) {
@@ -176,7 +176,7 @@
if (type.isFloat()) {
return fFloat32Type;
}
- ASSERT(type.name() == "bool");
+ SkASSERT(type.name() == "bool");
return fInt1Type;
case Type::kArray_Kind:
return LLVMPointerType(this->getType(type.componentType()), 0);
@@ -348,7 +348,7 @@
}
return result;
}
- ASSERT(fComponents.size() == 1);
+ SkASSERT(fComponents.size() == 1);
return LLVMBuildExtractElement(builder, base,
LLVMConstInt(fJIT.fInt32Type,
fComponents[0],
@@ -691,14 +691,14 @@
}
void JIT::appendStage(LLVMBuilderRef builder, const AppendStage& a) {
- ASSERT(a.fArguments.size() >= 1);
- ASSERT(a.fArguments[0]->fType == *fCompiler.context().fSkRasterPipeline_Type);
+ SkASSERT(a.fArguments.size() >= 1);
+ SkASSERT(a.fArguments[0]->fType == *fCompiler.context().fSkRasterPipeline_Type);
LLVMValueRef pipeline = this->compileExpression(builder, *a.fArguments[0]);
LLVMValueRef stage = LLVMConstInt(fInt32Type, a.fStage, 0);
switch (a.fStage) {
case SkRasterPipeline::callback: {
- ASSERT(a.fArguments.size() == 2);
- ASSERT(a.fArguments[1]->fKind == Expression::kFunctionReference_Kind);
+ SkASSERT(a.fArguments.size() == 2);
+ SkASSERT(a.fArguments[1]->fKind == Expression::kFunctionReference_Kind);
const FunctionDeclaration& functionDecl =
*((FunctionReference&) *a.fArguments[1]).fFunctions[0];
bool found = false;
@@ -717,7 +717,7 @@
}
}
}
- ASSERT(found);
+ SkASSERT(found);
break;
}
default: {
@@ -726,7 +726,7 @@
ctx = this->compileExpression(builder, *a.fArguments[1]);
ctx = LLVMBuildBitCast(builder, ctx, fInt8PtrType, "context cast");
} else {
- ASSERT(a.fArguments.size() == 1);
+ SkASSERT(a.fArguments.size() == 1);
ctx = LLVMConstNull(fInt8PtrType);
}
LLVMValueRef args[3] = {
@@ -743,7 +743,7 @@
LLVMValueRef JIT::compileConstructor(LLVMBuilderRef builder, const Constructor& c) {
switch (c.fType.kind()) {
case Type::kScalar_Kind: {
- ASSERT(c.fArguments.size() == 1);
+ SkASSERT(c.fArguments.size() == 1);
TypeKind from = this->typeKind(c.fArguments[0]->fType);
TypeKind to = this->typeKind(c.fType);
LLVMValueRef base = this->compileExpression(builder, *c.fArguments[0]);
@@ -783,7 +783,7 @@
"vec build");
}
} else {
- ASSERT(c.fArguments.size() == (size_t) c.fType.columns());
+ SkASSERT(c.fArguments.size() == (size_t) c.fType.columns());
for (int i = 0; i < c.fType.columns(); ++i) {
vec = LLVMBuildInsertElement(builder, vec,
this->compileExpression(builder,
@@ -818,7 +818,7 @@
}
return result;
}
- ASSERT(s.fComponents.size() == 1);
+ SkASSERT(s.fComponents.size() == 1);
return LLVMBuildExtractElement(builder, base,
LLVMConstInt(fInt32Type,
s.fComponents[0],
@@ -1292,7 +1292,7 @@
out[i] = floatOp(builder, left[i], right[i], "binary"); \
break; \
case kBool_TypeKind: \
- ASSERT(false); \
+ SkASSERT(false); \
break; \
} \
} \
@@ -1336,7 +1336,7 @@
LLVMValueRef out[CHANNELS]) {
switch (c.fType.kind()) {
case Type::kScalar_Kind: {
- ASSERT(c.fArguments.size() == 1);
+ SkASSERT(c.fArguments.size() == 1);
TypeKind from = this->typeKind(c.fArguments[0]->fType);
TypeKind to = this->typeKind(c.fType);
LLVMValueRef base[CHANNELS];
@@ -1392,7 +1392,7 @@
out[i] = base[0];
}
} else {
- ASSERT(c.fArguments.size() == (size_t) c.fType.columns());
+ SkASSERT(c.fArguments.size() == (size_t) c.fType.columns());
for (int i = 0; i < c.fType.columns(); ++i) {
LLVMValueRef base[CHANNELS];
if (!this->compileVectorExpression(builder, *c.fArguments[i], base)) {
@@ -1657,7 +1657,7 @@
false));
for (const auto& e : fProgram->fElements) {
- ASSERT(e->fKind == ProgramElement::kFunction_Kind);
+ SkASSERT(e->fKind == ProgramElement::kFunction_Kind);
this->compileFunction((FunctionDefinition&) *e);
}
}
diff --git a/src/sksl/SkSLMemoryLayout.h b/src/sksl/SkSLMemoryLayout.h
index 61712ec..c009773 100644
--- a/src/sksl/SkSLMemoryLayout.h
+++ b/src/sksl/SkSLMemoryLayout.h
@@ -107,11 +107,11 @@
if (total % alignment != 0) {
total += alignment - total % alignment;
}
- ASSERT(total % alignment == 0);
+ SkASSERT(total % alignment == 0);
total += this->size(*f.fType);
}
size_t alignment = this->alignment(type);
- ASSERT(!type.fields().size() ||
+ SkASSERT(!type.fields().size() ||
(0 == alignment % this->alignment(*type.fields()[0].fType)));
return (total + alignment - 1) & ~(alignment - 1);
}
diff --git a/src/sksl/SkSLMetalCodeGenerator.cpp b/src/sksl/SkSLMetalCodeGenerator.cpp
index 01f3220..af2366e 100644
--- a/src/sksl/SkSLMetalCodeGenerator.cpp
+++ b/src/sksl/SkSLMetalCodeGenerator.cpp
@@ -163,7 +163,7 @@
void MetalCodeGenerator::writeIntrinsicCall(const FunctionCall& c) {
auto i = fIntrinsicMap.find(c.fFunction.fName);
- ASSERT(i != fIntrinsicMap.end());
+ SkASSERT(i != fIntrinsicMap.end());
Intrinsic intrinsic = i->second;
int32_t intrinsicId = intrinsic.second;
switch (intrinsic.first) {
@@ -257,7 +257,7 @@
if (c.fArguments[1]->fType == *fContext.fFloat3_Type) {
this->write(".xy)"); // FIXME - add projection functionality
} else {
- ASSERT(c.fArguments[1]->fType == *fContext.fFloat2_Type);
+ SkASSERT(c.fArguments[1]->fType == *fContext.fFloat2_Type);
this->write(")");
}
break;
@@ -443,7 +443,7 @@
this->writeExpression(*b.fLeft, kAssignment_Precedence);
this->write(" ");
String op = Compiler::OperatorName(b.fOperator);
- ASSERT(op.endsWith("="));
+ SkASSERT(op.endsWith("="));
this->write(op.substr(0, op.size() - 1).c_str());
this->write(" ");
} else {
@@ -525,7 +525,7 @@
this->write("vertex Outputs main0");
break;
default:
- ASSERT(false);
+ SkASSERT(false);
}
this->write("(Inputs _in [[stage_in]]");
if (-1 != fUniformBuffer) {
@@ -627,7 +627,7 @@
}
this->writeLine(") {");
- ASSERT(!fProgram.fSettings.fFragColorIsInOut);
+ SkASSERT(!fProgram.fSettings.fFragColorIsInOut);
if ("main" == f.fDeclaration.fName) {
if (fNeedsGlobalStructInit) {
@@ -682,7 +682,7 @@
this->writeLine("return *_out;"); // FIXME - detect if function already has return
break;
default:
- ASSERT(false);
+ SkASSERT(false);
}
}
fIndentation--;
@@ -793,7 +793,7 @@
}
void MetalCodeGenerator::writeVarDeclarations(const VarDeclarations& decl, bool global) {
- ASSERT(decl.fVars.size() > 0);
+ SkASSERT(decl.fVars.size() > 0);
bool wroteType = false;
for (const auto& stmt : decl.fVars) {
VarDeclaration& var = (VarDeclaration&) *stmt;
diff --git a/src/sksl/SkSLParser.cpp b/src/sksl/SkSLParser.cpp
index 986d8c0..46dce11 100644
--- a/src/sksl/SkSLParser.cpp
+++ b/src/sksl/SkSLParser.cpp
@@ -133,7 +133,7 @@
}
void Parser::pushback(Token t) {
- ASSERT(fPushback.fKind == Token::INVALID);
+ SkASSERT(fPushback.fKind == Token::INVALID);
fPushback = std::move(t);
}
@@ -1198,7 +1198,7 @@
// parts of the compiler may rely upon this assumption.
if (this->peek().fKind == Token::DEFAULT) {
Token defaultStart;
- ASSERT_RESULT(this->expect(Token::DEFAULT, "'default'", &defaultStart));
+ SkAssertResult(this->expect(Token::DEFAULT, "'default'", &defaultStart));
if (!this->expect(Token::COLON, "':'")) {
return nullptr;
}
diff --git a/src/sksl/SkSLSPIRVCodeGenerator.cpp b/src/sksl/SkSLSPIRVCodeGenerator.cpp
index 0e20b93..fcee9ae 100644
--- a/src/sksl/SkSLSPIRVCodeGenerator.cpp
+++ b/src/sksl/SkSLSPIRVCodeGenerator.cpp
@@ -177,15 +177,15 @@
}
void SPIRVCodeGenerator::writeOpCode(SpvOp_ opCode, int length, OutputStream& out) {
- ASSERT(opCode != SpvOpLoad || &out != &fConstantBuffer);
- ASSERT(opCode != SpvOpUndef);
+ SkASSERT(opCode != SpvOpLoad || &out != &fConstantBuffer);
+ SkASSERT(opCode != SpvOpUndef);
switch (opCode) {
case SpvOpReturn: // fall through
case SpvOpReturnValue: // fall through
case SpvOpKill: // fall through
case SpvOpBranch: // fall through
case SpvOpBranchConditional:
- ASSERT(fCurrentBlock);
+ SkASSERT(fCurrentBlock);
fCurrentBlock = 0;
break;
case SpvOpConstant: // fall through
@@ -222,7 +222,7 @@
case SpvOpMemberDecorate:
break;
default:
- ASSERT(fCurrentBlock);
+ SkASSERT(fCurrentBlock);
}
this->writeWord((length << 16) | opCode, out);
}
@@ -474,7 +474,7 @@
} else if (type == *fContext.fDouble_Type) {
this->writeInstruction(SpvOpTypeFloat, result, 64, fConstantBuffer);
} else {
- ASSERT(false);
+ SkASSERT(false);
}
break;
case Type::kVector_Kind:
@@ -500,7 +500,7 @@
(int32_t) layout.stride(type),
fDecorationBuffer);
} else {
- ASSERT(false); // we shouldn't have any runtime-sized arrays right now
+ SkASSERT(false); // we shouldn't have any runtime-sized arrays right now
this->writeInstruction(SpvOpTypeRuntimeArray, result,
this->getType(type.componentType(), layout),
fConstantBuffer);
@@ -543,10 +543,10 @@
}
SpvId SPIRVCodeGenerator::getImageType(const Type& type) {
- ASSERT(type.kind() == Type::kSampler_Kind);
+ SkASSERT(type.kind() == Type::kSampler_Kind);
this->getType(type);
String key = type.name() + to_string((int) fDefaultLayout.fStd);
- ASSERT(fImageTypeMap.find(key) != fImageTypeMap.end());
+ SkASSERT(fImageTypeMap.find(key) != fImageTypeMap.end());
return fImageTypeMap[key];
}
@@ -662,7 +662,7 @@
SpvId SPIRVCodeGenerator::writeIntrinsicCall(const FunctionCall& c, OutputStream& out) {
auto intrinsic = fIntrinsicMap.find(c.fFunction.fName);
- ASSERT(intrinsic != fIntrinsicMap.end());
+ SkASSERT(intrinsic != fIntrinsicMap.end());
int32_t intrinsicId;
if (c.fArguments.size() > 0) {
const Type& type = c.fArguments[0]->fType;
@@ -737,7 +737,7 @@
for (const auto& a : args) {
if (a->fType.kind() == Type::kVector_Kind) {
if (vectorSize) {
- ASSERT(a->fType.columns() == vectorSize);
+ SkASSERT(a->fType.columns() == vectorSize);
}
else {
vectorSize = a->fType.columns();
@@ -779,7 +779,7 @@
} else if (is_unsigned(fContext, type)) {
this->writeWord(unsignedInst, out);
} else {
- ASSERT(false);
+ SkASSERT(false);
}
for (SpvId a : args) {
this->writeWord(a, out);
@@ -820,7 +820,7 @@
coords,
out);
} else {
- ASSERT(2 == c.fArguments.size());
+ SkASSERT(2 == c.fArguments.size());
SpvId sample = this->writeExpression(*c.fArguments[1], out);
this->writeInstruction(SpvOpImageRead,
this->getType(c.fType),
@@ -834,7 +834,7 @@
break;
}
case kTexelFetch_SpecialIntrinsic: {
- ASSERT(c.fArguments.size() == 2);
+ SkASSERT(c.fArguments.size() == 2);
SpvId image = this->nextId();
this->writeInstruction(SpvOpImage,
this->getImageType(c.fArguments[0]->fType),
@@ -856,21 +856,21 @@
if (c.fArguments[1]->fType == *fContext.fFloat2_Type) {
op = SpvOpImageSampleProjImplicitLod;
} else {
- ASSERT(c.fArguments[1]->fType == *fContext.fFloat_Type);
+ SkASSERT(c.fArguments[1]->fType == *fContext.fFloat_Type);
}
break;
case SpvDim2D:
if (c.fArguments[1]->fType == *fContext.fFloat3_Type) {
op = SpvOpImageSampleProjImplicitLod;
} else {
- ASSERT(c.fArguments[1]->fType == *fContext.fFloat2_Type);
+ SkASSERT(c.fArguments[1]->fType == *fContext.fFloat2_Type);
}
break;
case SpvDim3D:
if (c.fArguments[1]->fType == *fContext.fFloat4_Type) {
op = SpvOpImageSampleProjImplicitLod;
} else {
- ASSERT(c.fArguments[1]->fType == *fContext.fFloat3_Type);
+ SkASSERT(c.fArguments[1]->fType == *fContext.fFloat3_Type);
}
break;
case SpvDimCube: // fall through
@@ -888,7 +888,7 @@
this->writeExpression(*c.fArguments[2], out),
out);
} else {
- ASSERT(c.fArguments.size() == 2);
+ SkASSERT(c.fArguments.size() == 2);
if (fProgram.fSettings.fSharpenTextures) {
FloatLiteral lodBias(fContext, -1, -0.5);
this->writeInstruction(op, type, result, sampler, uv,
@@ -904,7 +904,7 @@
}
case kMod_SpecialIntrinsic: {
std::vector<SpvId> args = this->vectorize(c.fArguments, out);
- ASSERT(args.size() == 2);
+ SkASSERT(args.size() == 2);
const Type& operandType = c.fArguments[0]->fType;
SpvOp_ op;
if (is_float(fContext, operandType)) {
@@ -914,7 +914,7 @@
} else if (is_unsigned(fContext, operandType)) {
op = SpvOpUMod;
} else {
- ASSERT(false);
+ SkASSERT(false);
return 0;
}
this->writeOpCode(op, 5, out);
@@ -926,28 +926,28 @@
}
case kClamp_SpecialIntrinsic: {
std::vector<SpvId> args = this->vectorize(c.fArguments, out);
- ASSERT(args.size() == 3);
+ SkASSERT(args.size() == 3);
this->writeGLSLExtendedInstruction(c.fType, result, GLSLstd450FClamp, GLSLstd450SClamp,
GLSLstd450UClamp, args, out);
break;
}
case kMax_SpecialIntrinsic: {
std::vector<SpvId> args = this->vectorize(c.fArguments, out);
- ASSERT(args.size() == 2);
+ SkASSERT(args.size() == 2);
this->writeGLSLExtendedInstruction(c.fType, result, GLSLstd450FMax, GLSLstd450SMax,
GLSLstd450UMax, args, out);
break;
}
case kMin_SpecialIntrinsic: {
std::vector<SpvId> args = this->vectorize(c.fArguments, out);
- ASSERT(args.size() == 2);
+ SkASSERT(args.size() == 2);
this->writeGLSLExtendedInstruction(c.fType, result, GLSLstd450FMin, GLSLstd450SMin,
GLSLstd450UMin, args, out);
break;
}
case kMix_SpecialIntrinsic: {
std::vector<SpvId> args = this->vectorize(c.fArguments, out);
- ASSERT(args.size() == 3);
+ SkASSERT(args.size() == 3);
this->writeGLSLExtendedInstruction(c.fType, result, GLSLstd450FMix, SpvOpUndef,
SpvOpUndef, args, out);
break;
@@ -1018,7 +1018,7 @@
}
SpvId SPIRVCodeGenerator::writeConstantVector(const Constructor& c) {
- ASSERT(c.fType.kind() == Type::kVector_Kind && c.isConstant());
+ SkASSERT(c.fType.kind() == Type::kVector_Kind && c.isConstant());
SpvId result = this->nextId();
std::vector<SpvId> arguments;
for (size_t i = 0; i < c.fArguments.size(); i++) {
@@ -1046,16 +1046,16 @@
}
SpvId SPIRVCodeGenerator::writeFloatConstructor(const Constructor& c, OutputStream& out) {
- ASSERT(c.fType.isFloat());
- ASSERT(c.fArguments.size() == 1);
- ASSERT(c.fArguments[0]->fType.isNumber());
+ SkASSERT(c.fType.isFloat());
+ SkASSERT(c.fArguments.size() == 1);
+ SkASSERT(c.fArguments[0]->fType.isNumber());
SpvId result = this->nextId();
SpvId parameter = this->writeExpression(*c.fArguments[0], out);
if (c.fArguments[0]->fType.isSigned()) {
this->writeInstruction(SpvOpConvertSToF, this->getType(c.fType), result, parameter,
out);
} else {
- ASSERT(c.fArguments[0]->fType.isUnsigned());
+ SkASSERT(c.fArguments[0]->fType.isUnsigned());
this->writeInstruction(SpvOpConvertUToF, this->getType(c.fType), result, parameter,
out);
}
@@ -1063,9 +1063,9 @@
}
SpvId SPIRVCodeGenerator::writeIntConstructor(const Constructor& c, OutputStream& out) {
- ASSERT(c.fType.isSigned());
- ASSERT(c.fArguments.size() == 1);
- ASSERT(c.fArguments[0]->fType.isNumber());
+ SkASSERT(c.fType.isSigned());
+ SkASSERT(c.fArguments.size() == 1);
+ SkASSERT(c.fArguments[0]->fType.isNumber());
SpvId result = this->nextId();
SpvId parameter = this->writeExpression(*c.fArguments[0], out);
if (c.fArguments[0]->fType.isFloat()) {
@@ -1073,7 +1073,7 @@
out);
}
else {
- ASSERT(c.fArguments[0]->fType.isUnsigned());
+ SkASSERT(c.fArguments[0]->fType.isUnsigned());
this->writeInstruction(SpvOpBitcast, this->getType(c.fType), result, parameter,
out);
}
@@ -1081,16 +1081,16 @@
}
SpvId SPIRVCodeGenerator::writeUIntConstructor(const Constructor& c, OutputStream& out) {
- ASSERT(c.fType.isUnsigned());
- ASSERT(c.fArguments.size() == 1);
- ASSERT(c.fArguments[0]->fType.isNumber());
+ SkASSERT(c.fType.isUnsigned());
+ SkASSERT(c.fArguments.size() == 1);
+ SkASSERT(c.fArguments[0]->fType.isNumber());
SpvId result = this->nextId();
SpvId parameter = this->writeExpression(*c.fArguments[0], out);
if (c.fArguments[0]->fType.isFloat()) {
this->writeInstruction(SpvOpConvertFToU, this->getType(c.fType), result, parameter,
out);
} else {
- ASSERT(c.fArguments[0]->fType.isSigned());
+ SkASSERT(c.fArguments[0]->fType.isSigned());
this->writeInstruction(SpvOpBitcast, this->getType(c.fType), result, parameter,
out);
}
@@ -1125,9 +1125,9 @@
void SPIRVCodeGenerator::writeMatrixCopy(SpvId id, SpvId src, const Type& srcType,
const Type& dstType, OutputStream& out) {
- ASSERT(srcType.kind() == Type::kMatrix_Kind);
- ASSERT(dstType.kind() == Type::kMatrix_Kind);
- ASSERT(srcType.componentType() == dstType.componentType());
+ SkASSERT(srcType.kind() == Type::kMatrix_Kind);
+ SkASSERT(dstType.kind() == Type::kMatrix_Kind);
+ SkASSERT(srcType.componentType() == dstType.componentType());
SpvId srcColumnType = this->getType(srcType.componentType().toCompound(fContext,
srcType.rows(),
1));
@@ -1205,7 +1205,7 @@
}
SpvId SPIRVCodeGenerator::writeMatrixConstructor(const Constructor& c, OutputStream& out) {
- ASSERT(c.fType.kind() == Type::kMatrix_Kind);
+ SkASSERT(c.fType.kind() == Type::kMatrix_Kind);
// go ahead and write the arguments so we don't try to write new instructions in the middle of
// an instruction
std::vector<SpvId> arguments;
@@ -1220,8 +1220,8 @@
} else if (arguments.size() == 1 && c.fArguments[0]->fType.kind() == Type::kMatrix_Kind) {
this->writeMatrixCopy(result, arguments[0], c.fArguments[0]->fType, c.fType, out);
} else if (arguments.size() == 1 && c.fArguments[0]->fType.kind() == Type::kVector_Kind) {
- ASSERT(c.fType.rows() == 2 && c.fType.columns() == 2);
- ASSERT(c.fArguments[0]->fType.columns() == 4);
+ SkASSERT(c.fType.rows() == 2 && c.fType.columns() == 2);
+ SkASSERT(c.fArguments[0]->fType.columns() == 4);
SpvId componentType = this->getType(c.fType.componentType());
SpvId v[4];
for (int i = 0; i < 4; ++i) {
@@ -1245,7 +1245,7 @@
if (c.fArguments[i]->fType.kind() == Type::kVector_Kind &&
c.fArguments[i]->fType.columns() == c.fType.rows()) {
// this is a complete column by itself
- ASSERT(currentCount == 0);
+ SkASSERT(currentCount == 0);
columnIds.push_back(arguments[i]);
} else {
if (c.fArguments[i]->fType.columns() == 1) {
@@ -1274,10 +1274,10 @@
}
currentColumn.clear();
}
- ASSERT(currentCount < rows);
+ SkASSERT(currentCount < rows);
}
}
- ASSERT(columnIds.size() == (size_t) columns);
+ SkASSERT(columnIds.size() == (size_t) columns);
this->writeOpCode(SpvOpCompositeConstruct, 3 + columns, out);
this->writeWord(this->getType(c.fType), out);
this->writeWord(result, out);
@@ -1289,7 +1289,7 @@
}
SpvId SPIRVCodeGenerator::writeVectorConstructor(const Constructor& c, OutputStream& out) {
- ASSERT(c.fType.kind() == Type::kVector_Kind);
+ SkASSERT(c.fType.kind() == Type::kVector_Kind);
if (c.isConstant()) {
return this->writeConstantVector(c);
}
@@ -1317,7 +1317,7 @@
} else if (src == *fContext.fUInt_Type || src == *fContext.fUShort_Type) {
op = SpvOpConvertUToF;
} else {
- ASSERT(false);
+ SkASSERT(false);
}
} else if (dst == *fContext.fInt_Type || dst == *fContext.fShort_Type) {
if (src == *fContext.fFloat_Type || src == *fContext.fHalf_Type) {
@@ -1329,7 +1329,7 @@
} else if (src == *fContext.fUInt_Type || src == *fContext.fUShort_Type) {
op = SpvOpBitcast;
} else {
- ASSERT(false);
+ SkASSERT(false);
}
} else if (dst == *fContext.fUInt_Type || dst == *fContext.fUShort_Type) {
if (src == *fContext.fFloat_Type || src == *fContext.fHalf_Type) {
@@ -1341,7 +1341,7 @@
return vec;
}
} else {
- ASSERT(false);
+ SkASSERT(false);
}
}
for (int j = 0; j < c.fArguments[i]->fType.columns(); j++) {
@@ -1369,7 +1369,7 @@
this->writeWord(arguments[0], out);
}
} else {
- ASSERT(arguments.size() > 1);
+ SkASSERT(arguments.size() > 1);
this->writeOpCode(SpvOpCompositeConstruct, 3 + (int32_t) arguments.size(), out);
this->writeWord(this->getType(c.fType), out);
this->writeWord(result, out);
@@ -1381,7 +1381,7 @@
}
SpvId SPIRVCodeGenerator::writeArrayConstructor(const Constructor& c, OutputStream& out) {
- ASSERT(c.fType.kind() == Type::kArray_Kind);
+ SkASSERT(c.fType.kind() == Type::kArray_Kind);
// go ahead and write the arguments so we don't try to write new instructions in the middle of
// an instruction
std::vector<SpvId> arguments;
@@ -1424,10 +1424,10 @@
SpvStorageClass_ get_storage_class(const Modifiers& modifiers) {
if (modifiers.fFlags & Modifiers::kIn_Flag) {
- ASSERT(!(modifiers.fLayout.fFlags & Layout::kPushConstant_Flag));
+ SkASSERT(!(modifiers.fLayout.fFlags & Layout::kPushConstant_Flag));
return SpvStorageClassInput;
} else if (modifiers.fFlags & Modifiers::kOut_Flag) {
- ASSERT(!(modifiers.fLayout.fFlags & Layout::kPushConstant_Flag));
+ SkASSERT(!(modifiers.fLayout.fFlags & Layout::kPushConstant_Flag));
return SpvStorageClassOutput;
} else if (modifiers.fFlags & Modifiers::kUniform_Flag) {
if (modifiers.fLayout.fFlags & Layout::kPushConstant_Flag) {
@@ -1598,7 +1598,7 @@
type = this->getType(expr.fType);
}
auto entry = fVariableMap.find(&var);
- ASSERT(entry != fVariableMap.end());
+ SkASSERT(entry != fVariableMap.end());
return std::unique_ptr<SPIRVCodeGenerator::LValue>(new PointerLValue(*this,
entry->second,
type));
@@ -1622,7 +1622,7 @@
Swizzle& swizzle = (Swizzle&) expr;
size_t count = swizzle.fComponents.size();
SpvId base = this->getLValue(*swizzle.fBase, out)->getPointer();
- ASSERT(base);
+ SkASSERT(base);
if (count == 1) {
IntLiteral index(fContext, -1, swizzle.fComponents[0]);
SpvId member = this->nextId();
@@ -1656,11 +1656,11 @@
this->writeInstruction(SpvOpBranchConditional, test, ifTrueLabel, ifFalseLabel, out);
this->writeLabel(ifTrueLabel, out);
SpvId ifTrue = this->getLValue(*t.fIfTrue, out)->getPointer();
- ASSERT(ifTrue);
+ SkASSERT(ifTrue);
this->writeInstruction(SpvOpBranch, end, out);
ifTrueLabel = fCurrentBlock;
SpvId ifFalse = this->getLValue(*t.fIfFalse, out)->getPointer();
- ASSERT(ifFalse);
+ SkASSERT(ifFalse);
ifFalseLabel = fCurrentBlock;
this->writeInstruction(SpvOpBranch, end, out);
SpvId result = this->nextId();
@@ -1691,7 +1691,7 @@
SpvId SPIRVCodeGenerator::writeVariableReference(const VariableReference& ref, OutputStream& out) {
SpvId result = this->nextId();
auto entry = fVariableMap.find(&ref.fVariable);
- ASSERT(entry != fVariableMap.end());
+ SkASSERT(entry != fVariableMap.end());
SpvId var = entry->second;
this->writeInstruction(SpvOpLoad, this->getType(ref.fVariable.fType), result, var, out);
if (ref.fVariable.fModifiers.fLayout.fBuiltin == SK_FRAGCOORD_BUILTIN &&
@@ -1700,7 +1700,7 @@
if (fRTHeightStructId == (SpvId) -1) {
// height variable hasn't been written yet
std::shared_ptr<SymbolTable> st(new SymbolTable(&fErrors));
- ASSERT(fRTHeightFieldIndex == (SpvId) -1);
+ SkASSERT(fRTHeightFieldIndex == (SpvId) -1);
std::vector<Type::Field> fields;
fields.emplace_back(Modifiers(), SKSL_RTHEIGHT_NAME, fContext.fFloat_Type.get());
StringFragment name("sksl_synthetic_uniforms");
@@ -1719,7 +1719,7 @@
fRTHeightStructId = this->writeInterfaceBlock(intf);
fRTHeightFieldIndex = 0;
}
- ASSERT(fRTHeightFieldIndex != (SpvId) -1);
+ SkASSERT(fRTHeightFieldIndex != (SpvId) -1);
// write float4(gl_FragCoord.x, u_skRTHeight - gl_FragCoord.y, 0.0, 1.0)
SpvId xId = this->nextId();
this->writeInstruction(SpvOpCompositeExtract, this->getType(*fContext.fFloat_Type), xId,
@@ -1841,7 +1841,7 @@
SpvOp_ floatOperator, SpvOp_ intOperator,
OutputStream& out) {
SpvOp_ compareOp = is_float(fContext, operandType) ? floatOperator : intOperator;
- ASSERT(operandType.kind() == Type::kMatrix_Kind);
+ SkASSERT(operandType.kind() == Type::kMatrix_Kind);
SpvId rowType = this->getType(operandType.componentType().toCompound(fContext,
operandType.columns(),
1));
@@ -1933,7 +1933,7 @@
this->writeWord(lhs, out);
}
lhs = vec;
- ASSERT(!lvalue);
+ SkASSERT(!lvalue);
operandType = &b.fRight->fType;
} else if (b.fLeft->fType.kind() == Type::kMatrix_Kind) {
SpvOp_ op;
@@ -1942,7 +1942,7 @@
} else if (b.fRight->fType.kind() == Type::kVector_Kind) {
op = SpvOpMatrixTimesVector;
} else {
- ASSERT(b.fRight->fType.kind() == Type::kScalar_Kind);
+ SkASSERT(b.fRight->fType.kind() == Type::kScalar_Kind);
op = SpvOpMatrixTimesScalar;
}
SpvId result = this->nextId();
@@ -1950,7 +1950,7 @@
if (b.fOperator == Token::STAREQ) {
lvalue->store(result, out);
} else {
- ASSERT(b.fOperator == Token::STAR);
+ SkASSERT(b.fOperator == Token::STAR);
}
return result;
} else if (b.fRight->fType.kind() == Type::kMatrix_Kind) {
@@ -1959,14 +1959,14 @@
this->writeInstruction(SpvOpVectorTimesMatrix, this->getType(b.fType), result,
lhs, rhs, out);
} else {
- ASSERT(b.fLeft->fType.kind() == Type::kScalar_Kind);
+ SkASSERT(b.fLeft->fType.kind() == Type::kScalar_Kind);
this->writeInstruction(SpvOpMatrixTimesScalar, this->getType(b.fType), result, rhs,
lhs, out);
}
if (b.fOperator == Token::STAREQ) {
lvalue->store(result, out);
} else {
- ASSERT(b.fOperator == Token::STAR);
+ SkASSERT(b.fOperator == Token::STAR);
}
return result;
} else {
@@ -1975,7 +1975,7 @@
} else {
tmp = this->getActualType(b.fLeft->fType);
operandType = &tmp;
- ASSERT(*operandType == this->getActualType(b.fRight->fType));
+ SkASSERT(*operandType == this->getActualType(b.fRight->fType));
}
switch (b.fOperator) {
case Token::EQEQ: {
@@ -1983,7 +1983,7 @@
return this->writeMatrixComparison(*operandType, lhs, rhs, SpvOpFOrdEqual,
SpvOpIEqual, out);
}
- ASSERT(resultType == *fContext.fBool_Type);
+ SkASSERT(resultType == *fContext.fBool_Type);
const Type* tmpType;
if (operandType->kind() == Type::kVector_Kind) {
tmpType = &fContext.fBool_Type->toCompound(fContext,
@@ -2002,7 +2002,7 @@
return this->writeMatrixComparison(*operandType, lhs, rhs, SpvOpFOrdNotEqual,
SpvOpINotEqual, out);
}
- ASSERT(resultType == *fContext.fBool_Type);
+ SkASSERT(resultType == *fContext.fBool_Type);
const Type* tmpType;
if (operandType->kind() == Type::kVector_Kind) {
tmpType = &fContext.fBool_Type->toCompound(fContext,
@@ -2017,21 +2017,21 @@
out),
*operandType, SpvOpAny, out);
case Token::GT:
- ASSERT(resultType == *fContext.fBool_Type);
+ SkASSERT(resultType == *fContext.fBool_Type);
return this->writeBinaryOperation(resultType, *operandType, lhs, rhs,
SpvOpFOrdGreaterThan, SpvOpSGreaterThan,
SpvOpUGreaterThan, SpvOpUndef, out);
case Token::LT:
- ASSERT(resultType == *fContext.fBool_Type);
+ SkASSERT(resultType == *fContext.fBool_Type);
return this->writeBinaryOperation(resultType, *operandType, lhs, rhs, SpvOpFOrdLessThan,
SpvOpSLessThan, SpvOpULessThan, SpvOpUndef, out);
case Token::GTEQ:
- ASSERT(resultType == *fContext.fBool_Type);
+ SkASSERT(resultType == *fContext.fBool_Type);
return this->writeBinaryOperation(resultType, *operandType, lhs, rhs,
SpvOpFOrdGreaterThanEqual, SpvOpSGreaterThanEqual,
SpvOpUGreaterThanEqual, SpvOpUndef, out);
case Token::LTEQ:
- ASSERT(resultType == *fContext.fBool_Type);
+ SkASSERT(resultType == *fContext.fBool_Type);
return this->writeBinaryOperation(resultType, *operandType, lhs, rhs,
SpvOpFOrdLessThanEqual, SpvOpSLessThanEqual,
SpvOpULessThanEqual, SpvOpUndef, out);
@@ -2078,14 +2078,14 @@
case Token::PLUSEQ: {
SpvId result = this->writeBinaryOperation(resultType, *operandType, lhs, rhs, SpvOpFAdd,
SpvOpIAdd, SpvOpIAdd, SpvOpUndef, out);
- ASSERT(lvalue);
+ SkASSERT(lvalue);
lvalue->store(result, out);
return result;
}
case Token::MINUSEQ: {
SpvId result = this->writeBinaryOperation(resultType, *operandType, lhs, rhs, SpvOpFSub,
SpvOpISub, SpvOpISub, SpvOpUndef, out);
- ASSERT(lvalue);
+ SkASSERT(lvalue);
lvalue->store(result, out);
return result;
}
@@ -2096,27 +2096,27 @@
SpvId result = this->nextId();
this->writeInstruction(SpvOpMatrixTimesMatrix, this->getType(resultType), result,
lhs, rhs, out);
- ASSERT(lvalue);
+ SkASSERT(lvalue);
lvalue->store(result, out);
return result;
}
SpvId result = this->writeBinaryOperation(resultType, *operandType, lhs, rhs, SpvOpFMul,
SpvOpIMul, SpvOpIMul, SpvOpUndef, out);
- ASSERT(lvalue);
+ SkASSERT(lvalue);
lvalue->store(result, out);
return result;
}
case Token::SLASHEQ: {
SpvId result = this->writeBinaryOperation(resultType, *operandType, lhs, rhs, SpvOpFDiv,
SpvOpSDiv, SpvOpUDiv, SpvOpUndef, out);
- ASSERT(lvalue);
+ SkASSERT(lvalue);
lvalue->store(result, out);
return result;
}
case Token::PERCENTEQ: {
SpvId result = this->writeBinaryOperation(resultType, *operandType, lhs, rhs, SpvOpFMod,
SpvOpSMod, SpvOpUMod, SpvOpUndef, out);
- ASSERT(lvalue);
+ SkASSERT(lvalue);
lvalue->store(result, out);
return result;
}
@@ -2124,7 +2124,7 @@
SpvId result = this->writeBinaryOperation(resultType, *operandType, lhs, rhs,
SpvOpUndef, SpvOpShiftLeftLogical,
SpvOpShiftLeftLogical, SpvOpUndef, out);
- ASSERT(lvalue);
+ SkASSERT(lvalue);
lvalue->store(result, out);
return result;
}
@@ -2132,7 +2132,7 @@
SpvId result = this->writeBinaryOperation(resultType, *operandType, lhs, rhs,
SpvOpUndef, SpvOpShiftRightArithmetic,
SpvOpShiftRightLogical, SpvOpUndef, out);
- ASSERT(lvalue);
+ SkASSERT(lvalue);
lvalue->store(result, out);
return result;
}
@@ -2140,7 +2140,7 @@
SpvId result = this->writeBinaryOperation(resultType, *operandType, lhs, rhs,
SpvOpUndef, SpvOpBitwiseAnd, SpvOpBitwiseAnd,
SpvOpUndef, out);
- ASSERT(lvalue);
+ SkASSERT(lvalue);
lvalue->store(result, out);
return result;
}
@@ -2148,7 +2148,7 @@
SpvId result = this->writeBinaryOperation(resultType, *operandType, lhs, rhs,
SpvOpUndef, SpvOpBitwiseOr, SpvOpBitwiseOr,
SpvOpUndef, out);
- ASSERT(lvalue);
+ SkASSERT(lvalue);
lvalue->store(result, out);
return result;
}
@@ -2156,7 +2156,7 @@
SpvId result = this->writeBinaryOperation(resultType, *operandType, lhs, rhs,
SpvOpUndef, SpvOpBitwiseXor, SpvOpBitwiseXor,
SpvOpUndef, out);
- ASSERT(lvalue);
+ SkASSERT(lvalue);
lvalue->store(result, out);
return result;
}
@@ -2166,7 +2166,7 @@
}
SpvId SPIRVCodeGenerator::writeLogicalAnd(const BinaryExpression& a, OutputStream& out) {
- ASSERT(a.fOperator == Token::LOGICALAND);
+ SkASSERT(a.fOperator == Token::LOGICALAND);
BoolLiteral falseLiteral(fContext, -1, false);
SpvId falseConstant = this->writeBoolLiteral(falseLiteral);
SpvId lhs = this->writeExpression(*a.fLeft, out);
@@ -2187,7 +2187,7 @@
}
SpvId SPIRVCodeGenerator::writeLogicalOr(const BinaryExpression& o, OutputStream& out) {
- ASSERT(o.fOperator == Token::LOGICALOR);
+ SkASSERT(o.fOperator == Token::LOGICALOR);
BoolLiteral trueLiteral(fContext, -1, true);
SpvId trueConstant = this->writeBoolLiteral(trueLiteral);
SpvId lhs = this->writeExpression(*o.fLeft, out);
@@ -2287,7 +2287,7 @@
return result;
}
case Token::LOGICALNOT: {
- ASSERT(p.fOperand->fType == *fContext.fBool_Type);
+ SkASSERT(p.fOperand->fType == *fContext.fBool_Type);
SpvId result = this->nextId();
this->writeInstruction(SpvOpLogicalNot, this->getType(p.fOperand->fType), result,
this->writeExpression(*p.fOperand, out), out);
@@ -2356,7 +2356,7 @@
}
return entry->second;
} else {
- ASSERT(i.fType == *fContext.fUInt_Type);
+ SkASSERT(i.fType == *fContext.fUInt_Type);
auto entry = fUIntConstants.find(i.fValue);
if (entry == fUIntConstants.end()) {
SpvId result = this->nextId();
@@ -2376,7 +2376,7 @@
if (entry == fFloatConstants.end()) {
SpvId result = this->nextId();
uint32_t bits;
- ASSERT(sizeof(bits) == sizeof(value));
+ SkASSERT(sizeof(bits) == sizeof(value));
memcpy(&bits, &value, sizeof(bits));
this->writeInstruction(SpvOpConstant, this->getType(f.fType), result, bits,
fConstantBuffer);
@@ -2385,12 +2385,12 @@
}
return entry->second;
} else {
- ASSERT(f.fType == *fContext.fDouble_Type);
+ SkASSERT(f.fType == *fContext.fDouble_Type);
auto entry = fDoubleConstants.find(f.fValue);
if (entry == fDoubleConstants.end()) {
SpvId result = this->nextId();
uint64_t bits;
- ASSERT(sizeof(bits) == sizeof(f.fValue));
+ SkASSERT(sizeof(bits) == sizeof(f.fValue));
memcpy(&bits, &f.fValue, sizeof(bits));
this->writeInstruction(SpvOpConstant, this->getType(f.fType), result,
bits & 0xffffffff, bits >> 32, fConstantBuffer);
@@ -2504,8 +2504,8 @@
SpvId result = this->nextId();
const Type* type = &intf.fVariable.fType;
if (fProgram.fInputs.fRTHeight) {
- ASSERT(fRTHeightStructId == (SpvId) -1);
- ASSERT(fRTHeightFieldIndex == (SpvId) -1);
+ SkASSERT(fRTHeightStructId == (SpvId) -1);
+ SkASSERT(fRTHeightFieldIndex == (SpvId) -1);
std::vector<Type::Field> fields = type->fields();
fRTHeightStructId = result;
fRTHeightFieldIndex = fields.size();
@@ -2569,7 +2569,7 @@
const Variable* var = varDecl.fVar;
// These haven't been implemented in our SPIR-V generator yet and we only currently use them
// in the OpenGL backend.
- ASSERT(!(var->fModifiers.fFlags & (Modifiers::kReadOnly_Flag |
+ SkASSERT(!(var->fModifiers.fFlags & (Modifiers::kReadOnly_Flag |
Modifiers::kWriteOnly_Flag |
Modifiers::kCoherent_Flag |
Modifiers::kVolatile_Flag |
@@ -2579,7 +2579,7 @@
}
if (var->fModifiers.fLayout.fBuiltin == SK_FRAGCOLOR_BUILTIN &&
kind != Program::kFragment_Kind) {
- ASSERT(!fProgram.fSettings.fFragColorIsInOut);
+ SkASSERT(!fProgram.fSettings.fFragColorIsInOut);
continue;
}
if (!var->fReadCount && !var->fWriteCount &&
@@ -2619,7 +2619,7 @@
this->writeInstruction(SpvOpName, id, var->fName, fNameBuffer);
this->writePrecisionModifier(var->fModifiers, id);
if (varDecl.fValue) {
- ASSERT(!fCurrentBlock);
+ SkASSERT(!fCurrentBlock);
fCurrentBlock = -1;
SpvId value = this->writeExpression(*varDecl.fValue, fGlobalInitializersBuffer);
this->writeInstruction(SpvOpStore, id, value, fGlobalInitializersBuffer);
@@ -2638,12 +2638,12 @@
void SPIRVCodeGenerator::writeVarDeclarations(const VarDeclarations& decl, OutputStream& out) {
for (const auto& stmt : decl.fVars) {
- ASSERT(stmt->fKind == Statement::kVarDeclaration_Kind);
+ SkASSERT(stmt->fKind == Statement::kVarDeclaration_Kind);
VarDeclaration& varDecl = (VarDeclaration&) *stmt;
const Variable* var = varDecl.fVar;
// These haven't been implemented in our SPIR-V generator yet and we only currently use them
// in the OpenGL backend.
- ASSERT(!(var->fModifiers.fFlags & (Modifiers::kReadOnly_Flag |
+ SkASSERT(!(var->fModifiers.fFlags & (Modifiers::kReadOnly_Flag |
Modifiers::kWriteOnly_Flag |
Modifiers::kCoherent_Flag |
Modifiers::kVolatile_Flag |
@@ -2866,7 +2866,7 @@
if (!s.fCases[i]->fValue) {
continue;
}
- ASSERT(s.fCases[i]->fValue->fKind == Expression::kIntLiteral_Kind);
+ SkASSERT(s.fCases[i]->fValue->fKind == Expression::kIntLiteral_Kind);
this->writeWord(((IntLiteral&) *s.fCases[i]->fValue).fValue, out);
this->writeWord(labels[i], out);
}
@@ -2893,7 +2893,7 @@
}
void SPIRVCodeGenerator::writeGeometryShaderExecutionMode(SpvId entryPoint, OutputStream& out) {
- ASSERT(fProgram.fKind == Program::kGeometry_Kind);
+ SkASSERT(fProgram.fKind == Program::kGeometry_Kind);
int invocations = 1;
for (const auto& e : fProgram) {
if (e.fKind == ProgramElement::kModifiers_Kind) {
@@ -3000,7 +3000,7 @@
if (e.fKind == ProgramElement::kInterfaceBlock_Kind) {
InterfaceBlock& intf = (InterfaceBlock&) e;
if (SK_IN_BUILTIN == intf.fVariable.fModifiers.fLayout.fBuiltin) {
- ASSERT(skInSize != -1);
+ SkASSERT(skInSize != -1);
intf.fSizes.emplace_back(new IntLiteral(fContext, -1, skInSize));
}
SpvId id = this->writeInterfaceBlock(intf);
@@ -3027,7 +3027,7 @@
main = entry.first;
}
}
- ASSERT(main);
+ SkASSERT(main);
for (auto entry : fVariableMap) {
const Variable* var = entry.first;
if (var->fStorage == Variable::kGlobal_Storage &&
@@ -3084,7 +3084,7 @@
}
bool SPIRVCodeGenerator::generateCode() {
- ASSERT(!fErrors.errorCount());
+ SkASSERT(!fErrors.errorCount());
this->writeWord(SpvMagicNumber, *fOut);
this->writeWord(SpvVersion, *fOut);
this->writeWord(SKSL_MAGIC, *fOut);
diff --git a/src/sksl/SkSLSectionAndParameterHelper.h b/src/sksl/SkSLSectionAndParameterHelper.h
index 919cc78..e2c6512 100644
--- a/src/sksl/SkSLSectionAndParameterHelper.h
+++ b/src/sksl/SkSLSectionAndParameterHelper.h
@@ -83,12 +83,12 @@
}
const Section* getSection(const char* name) {
- ASSERT(!SectionPermitsDuplicates(name));
+ SkASSERT(!SectionPermitsDuplicates(name));
auto found = fSections.find(name);
if (found == fSections.end()) {
return nullptr;
}
- ASSERT(found->second.size() == 1);
+ SkASSERT(found->second.size() == 1);
return found->second[0];
}
diff --git a/src/sksl/SkSLString.cpp b/src/sksl/SkSLString.cpp
index c8ff15b..125dabb 100644
--- a/src/sksl/SkSLString.cpp
+++ b/src/sksl/SkSLString.cpp
@@ -210,8 +210,8 @@
#endif
#define MAX_DOUBLE_CHARS 25
char buffer[MAX_DOUBLE_CHARS];
- SKSL_DEBUGCODE(int len = )SNPRINTF(buffer, sizeof(buffer), "%.17g", value);
- ASSERT(len < MAX_DOUBLE_CHARS);
+ SkDEBUGCODE(int len = )SNPRINTF(buffer, sizeof(buffer), "%.17g", value);
+ SkASSERT(len < MAX_DOUBLE_CHARS);
String result(buffer);
if (!strchr(buffer, '.') && !strchr(buffer, 'e')) {
result += ".0";
@@ -223,10 +223,10 @@
int stoi(const String& s) {
char* p;
- SKSL_DEBUGCODE(errno = 0;)
+ SkDEBUGCODE(errno = 0;)
long result = strtoul(s.c_str(), &p, 0);
- ASSERT(*p == 0);
- ASSERT(!errno);
+ SkASSERT(*p == 0);
+ SkASSERT(!errno);
return (int) result;
}
@@ -236,16 +236,16 @@
std::stringstream buffer(str);
buffer.imbue(std::locale::classic());
buffer >> result;
- ASSERT(!buffer.fail());
+ SkASSERT(!buffer.fail());
return result;
}
long stol(const String& s) {
char* p;
- SKSL_DEBUGCODE(errno = 0;)
+ SkDEBUGCODE(errno = 0;)
long result = strtoul(s.c_str(), &p, 0);
- ASSERT(*p == 0);
- ASSERT(!errno);
+ SkASSERT(*p == 0);
+ SkASSERT(!errno);
return result;
}
diff --git a/src/sksl/SkSLUtil.h b/src/sksl/SkSLUtil.h
index eb4fa51..efff74c 100644
--- a/src/sksl/SkSLUtil.h
+++ b/src/sksl/SkSLUtil.h
@@ -341,13 +341,9 @@
} // namespace
#ifdef SKSL_STANDALONE
-#define ASSERT(x) (void)((x) || (ABORT("failed assert(%s): %s:%d\n", #x, __FILE__, __LINE__), 0))
-#define ASSERT_RESULT(x) ASSERT(x)
-#define SKSL_DEBUGCODE(x) x
-#else
-#define ASSERT SkASSERT
-#define ASSERT_RESULT(x) SkAssertResult(x)
-#define SKSL_DEBUGCODE(x) SkDEBUGCODE(x)
+#define SkASSERT(x)
+#define SkAssertResult(x) x
+#define SkDEBUGCODE(x)
#endif
#define SKSL_WARN_UNUSED_RESULT __attribute__((warn_unused_result))
diff --git a/src/sksl/ast/SkSLASTEnum.h b/src/sksl/ast/SkSLASTEnum.h
index 6fdd091..38023f5 100644
--- a/src/sksl/ast/SkSLASTEnum.h
+++ b/src/sksl/ast/SkSLASTEnum.h
@@ -18,7 +18,7 @@
, fTypeName(typeName)
, fNames(std::move(names))
, fValues(std::move(values)) {
- ASSERT(fNames.size() == fValues.size());
+ SkASSERT(fNames.size() == fValues.size());
}
String description() const override {
diff --git a/src/sksl/ast/SkSLASTPrecision.h b/src/sksl/ast/SkSLASTPrecision.h
index 0b81ca3..db2baee 100644
--- a/src/sksl/ast/SkSLASTPrecision.h
+++ b/src/sksl/ast/SkSLASTPrecision.h
@@ -28,10 +28,10 @@
case Modifiers::kMediump_Flag: return String("precision mediump float;");
case Modifiers::kHighp_Flag: return String("precision highp float;");
default:
- ASSERT(false);
+ SkASSERT(false);
return String("<error>");
}
- ASSERT(false);
+ SkASSERT(false);
return String("<error>");
}
diff --git a/src/sksl/ir/SkSLConstructor.h b/src/sksl/ir/SkSLConstructor.h
index b8824ba..5e7c3d0 100644
--- a/src/sksl/ir/SkSLConstructor.h
+++ b/src/sksl/ir/SkSLConstructor.h
@@ -83,7 +83,7 @@
}
bool compareConstant(const Context& context, const Expression& other) const override {
- ASSERT(other.fKind == Expression::kConstructor_Kind && other.fType == fType);
+ SkASSERT(other.fKind == Expression::kConstructor_Kind && other.fType == fType);
Constructor& c = (Constructor&) other;
if (c.fType.kind() == Type::kVector_Kind) {
for (int i = 0; i < fType.columns(); i++) {
@@ -96,14 +96,14 @@
// shouldn't be possible to have a constant constructor that isn't a vector or matrix;
// a constant scalar constructor should have been collapsed down to the appropriate
// literal
- ASSERT(fType.kind() == Type::kMatrix_Kind);
+ SkASSERT(fType.kind() == Type::kMatrix_Kind);
const FloatLiteral fzero(context, -1, 0);
const IntLiteral izero(context, -1, 0);
const Expression* zero;
if (fType.componentType() == *context.fFloat_Type) {
zero = &fzero;
} else {
- ASSERT(fType.componentType() == *context.fInt_Type);
+ SkASSERT(fType.componentType() == *context.fInt_Type);
zero = &izero;
}
for (int col = 0; col < fType.columns(); col++) {
@@ -121,21 +121,21 @@
}
const Expression& getVecComponent(int index) const {
- ASSERT(fType.kind() == Type::kVector_Kind);
+ SkASSERT(fType.kind() == Type::kVector_Kind);
if (fArguments.size() == 1 && fArguments[0]->fType.kind() == Type::kScalar_Kind) {
return *fArguments[0];
}
int current = 0;
for (const auto& arg : fArguments) {
- ASSERT(current <= index);
+ SkASSERT(current <= index);
if (arg->fType.kind() == Type::kScalar_Kind) {
if (index == current) {
return *arg;
}
current++;
} else {
- ASSERT(arg->fType.kind() == Type::kVector_Kind);
- ASSERT(arg->fKind == Expression::kConstructor_Kind);
+ SkASSERT(arg->fType.kind() == Type::kVector_Kind);
+ SkASSERT(arg->fKind == Expression::kConstructor_Kind);
if (current + arg->fType.columns() > index) {
return ((const Constructor&) *arg).getVecComponent(index - current);
}
@@ -155,9 +155,9 @@
// null return should be interpreted as zero
const Expression* getMatComponent(int col, int row) const {
- ASSERT(this->isConstant());
- ASSERT(fType.kind() == Type::kMatrix_Kind);
- ASSERT(col < fType.columns() && row < fType.rows());
+ SkASSERT(this->isConstant());
+ SkASSERT(fType.kind() == Type::kMatrix_Kind);
+ SkASSERT(col < fType.columns() && row < fType.rows());
if (fArguments.size() == 1) {
if (fArguments[0]->fType.kind() == Type::kScalar_Kind) {
// single scalar argument, so matrix is of the form:
@@ -168,7 +168,7 @@
return col == row ? fArguments[0].get() : nullptr;
}
if (fArguments[0]->fType.kind() == Type::kMatrix_Kind) {
- ASSERT(fArguments[0]->fKind == Expression::kConstructor_Kind);
+ SkASSERT(fArguments[0]->fKind == Expression::kConstructor_Kind);
// single matrix argument. make sure we're within the argument's bounds.
const Type& argType = ((Constructor&) *fArguments[0]).fType;
if (col < argType.columns() && row < argType.rows()) {
@@ -182,14 +182,14 @@
int currentIndex = 0;
int targetIndex = col * fType.rows() + row;
for (const auto& arg : fArguments) {
- ASSERT(targetIndex >= currentIndex);
- ASSERT(arg->fType.rows() == 1);
+ SkASSERT(targetIndex >= currentIndex);
+ SkASSERT(arg->fType.rows() == 1);
if (currentIndex + arg->fType.columns() > targetIndex) {
if (arg->fType.columns() == 1) {
return arg.get();
} else {
- ASSERT(arg->fType.kind() == Type::kVector_Kind);
- ASSERT(arg->fKind == Expression::kConstructor_Kind);
+ SkASSERT(arg->fType.kind() == Type::kVector_Kind);
+ SkASSERT(arg->fKind == Expression::kConstructor_Kind);
return &((Constructor&) *arg).getVecComponent(targetIndex - currentIndex);
}
}
diff --git a/src/sksl/ir/SkSLFunctionDeclaration.h b/src/sksl/ir/SkSLFunctionDeclaration.h
index d0f9d24..e07ed68 100644
--- a/src/sksl/ir/SkSLFunctionDeclaration.h
+++ b/src/sksl/ir/SkSLFunctionDeclaration.h
@@ -71,7 +71,7 @@
bool determineFinalTypes(const std::vector<std::unique_ptr<Expression>>& arguments,
std::vector<const Type*>* outParameterTypes,
const Type** outReturnType) const {
- ASSERT(arguments.size() == fParameters.size());
+ SkASSERT(arguments.size() == fParameters.size());
int genericIndex = -1;
for (size_t i = 0; i < arguments.size(); i++) {
if (fParameters[i]->fType.kind() == Type::kGeneric_Kind) {
@@ -93,7 +93,7 @@
}
}
if (fReturnType.kind() == Type::kGeneric_Kind) {
- ASSERT(genericIndex != -1);
+ SkASSERT(genericIndex != -1);
*outReturnType = fReturnType.coercibleTypes()[genericIndex];
} else {
*outReturnType = &fReturnType;
diff --git a/src/sksl/ir/SkSLIndexExpression.h b/src/sksl/ir/SkSLIndexExpression.h
index 803d5ff..de44b1a 100644
--- a/src/sksl/ir/SkSLIndexExpression.h
+++ b/src/sksl/ir/SkSLIndexExpression.h
@@ -24,22 +24,22 @@
case 2: return *context.fFloat2_Type;
case 3: return *context.fFloat3_Type;
case 4: return *context.fFloat4_Type;
- default: ASSERT(false);
+ default: SkASSERT(false);
}
} else if (type.componentType() == *context.fHalf_Type) {
switch (type.rows()) {
case 2: return *context.fHalf2_Type;
case 3: return *context.fHalf3_Type;
case 4: return *context.fHalf4_Type;
- default: ASSERT(false);
+ default: SkASSERT(false);
}
} else {
- ASSERT(type.componentType() == *context.fDouble_Type);
+ SkASSERT(type.componentType() == *context.fDouble_Type);
switch (type.rows()) {
case 2: return *context.fDouble2_Type;
case 3: return *context.fDouble3_Type;
case 4: return *context.fDouble4_Type;
- default: ASSERT(false);
+ default: SkASSERT(false);
}
}
}
@@ -55,7 +55,7 @@
: INHERITED(base->fOffset, kIndex_Kind, index_type(context, base->fType))
, fBase(std::move(base))
, fIndex(std::move(index)) {
- ASSERT(fIndex->fType == *context.fInt_Type || fIndex->fType == *context.fUInt_Type);
+ SkASSERT(fIndex->fType == *context.fInt_Type || fIndex->fType == *context.fUInt_Type);
}
bool hasSideEffects() const override {
diff --git a/src/sksl/ir/SkSLProgram.h b/src/sksl/ir/SkSLProgram.h
index 1ad9fff..9f14087 100644
--- a/src/sksl/ir/SkSLProgram.h
+++ b/src/sksl/ir/SkSLProgram.h
@@ -50,7 +50,7 @@
offset,
fValue));
default:
- ASSERT(false);
+ SkASSERT(false);
return nullptr;
}
}
diff --git a/src/sksl/ir/SkSLSetting.h b/src/sksl/ir/SkSLSetting.h
index f479ad1..1396099 100644
--- a/src/sksl/ir/SkSLSetting.h
+++ b/src/sksl/ir/SkSLSetting.h
@@ -22,7 +22,7 @@
: INHERITED(offset, kSetting_Kind, value->fType)
, fName(std::move(name))
, fValue(std::move(value)) {
- ASSERT(fValue->isConstant());
+ SkASSERT(fValue->isConstant());
}
std::unique_ptr<Expression> constantPropagate(const IRGenerator& irGenerator,
diff --git a/src/sksl/ir/SkSLSwizzle.h b/src/sksl/ir/SkSLSwizzle.h
index d07f16e..b90b78d 100644
--- a/src/sksl/ir/SkSLSwizzle.h
+++ b/src/sksl/ir/SkSLSwizzle.h
@@ -86,22 +86,22 @@
: INHERITED(base->fOffset, kSwizzle_Kind, get_type(context, *base, components.size()))
, fBase(std::move(base))
, fComponents(std::move(components)) {
- ASSERT(fComponents.size() >= 1 && fComponents.size() <= 4);
+ SkASSERT(fComponents.size() >= 1 && fComponents.size() <= 4);
}
std::unique_ptr<Expression> constantPropagate(const IRGenerator& irGenerator,
const DefinitionMap& definitions) override {
if (fBase->fKind == Expression::kConstructor_Kind && fBase->isConstant()) {
// we're swizzling a constant vector, e.g. float4(1).x. Simplify it.
- ASSERT(fBase->fKind == Expression::kConstructor_Kind);
+ SkASSERT(fBase->fKind == Expression::kConstructor_Kind);
if (fType == *irGenerator.fContext.fInt_Type) {
- ASSERT(fComponents.size() == 1);
+ SkASSERT(fComponents.size() == 1);
int64_t value = ((Constructor&) *fBase).getIVecComponent(fComponents[0]);
return std::unique_ptr<Expression>(new IntLiteral(irGenerator.fContext,
-1,
value));
} else if (fType == *irGenerator.fContext.fFloat_Type) {
- ASSERT(fComponents.size() == 1);
+ SkASSERT(fComponents.size() == 1);
double value = ((Constructor&) *fBase).getFVecComponent(fComponents[0]);
return std::unique_ptr<Expression>(new FloatLiteral(irGenerator.fContext,
-1,
diff --git a/src/sksl/ir/SkSLSymbolTable.cpp b/src/sksl/ir/SkSLSymbolTable.cpp
index 90a1189..418a3d5 100644
--- a/src/sksl/ir/SkSLSymbolTable.cpp
+++ b/src/sksl/ir/SkSLSymbolTable.cpp
@@ -50,7 +50,7 @@
}
}
if (modified) {
- ASSERT(functions.size() > 1);
+ SkASSERT(functions.size() > 1);
return this->takeOwnership(new UnresolvedFunction(functions));
}
}
diff --git a/src/sksl/ir/SkSLTernaryExpression.h b/src/sksl/ir/SkSLTernaryExpression.h
index 282a322..b77e0e0 100644
--- a/src/sksl/ir/SkSLTernaryExpression.h
+++ b/src/sksl/ir/SkSLTernaryExpression.h
@@ -23,7 +23,7 @@
, fTest(std::move(test))
, fIfTrue(std::move(ifTrue))
, fIfFalse(std::move(ifFalse)) {
- ASSERT(fIfTrue->fType == fIfFalse->fType);
+ SkASSERT(fIfTrue->fType == fIfFalse->fType);
}
bool hasSideEffects() const override {
diff --git a/src/sksl/ir/SkSLType.cpp b/src/sksl/ir/SkSLType.cpp
index 4310229d..d569818 100644
--- a/src/sksl/ir/SkSLType.cpp
+++ b/src/sksl/ir/SkSLType.cpp
@@ -47,7 +47,7 @@
}
const Type& Type::toCompound(const Context& context, int columns, int rows) const {
- ASSERT(this->kind() == Type::kScalar_Kind);
+ SkASSERT(this->kind() == Type::kScalar_Kind);
if (columns == 1 && rows == 1) {
return *this;
}
diff --git a/src/sksl/ir/SkSLType.h b/src/sksl/ir/SkSLType.h
index c33b94b..ed4b8d5 100644
--- a/src/sksl/ir/SkSLType.h
+++ b/src/sksl/ir/SkSLType.h
@@ -261,35 +261,35 @@
/**
* For matrices and vectors, returns the type of individual cells (e.g. mat2 has a component
- * type of kFloat_Type). For all other types, causes an assertion failure.
+ * type of kFloat_Type). For all other types, causes an SkASSERTion failure.
*/
const Type& componentType() const {
- ASSERT(fComponentType);
+ SkASSERT(fComponentType);
return *fComponentType;
}
/**
* For matrices and vectors, returns the number of columns (e.g. both mat3 and float3return 3).
* For scalars, returns 1. For arrays, returns either the size of the array (if known) or -1.
- * For all other types, causes an assertion failure.
+ * For all other types, causes an SkASSERTion failure.
*/
int columns() const {
- ASSERT(fTypeKind == kScalar_Kind || fTypeKind == kVector_Kind ||
+ SkASSERT(fTypeKind == kScalar_Kind || fTypeKind == kVector_Kind ||
fTypeKind == kMatrix_Kind || fTypeKind == kArray_Kind);
return fColumns;
}
/**
* For matrices, returns the number of rows (e.g. mat2x4 returns 4). For vectors and scalars,
- * returns 1. For all other types, causes an assertion failure.
+ * returns 1. For all other types, causes an SkASSERTion failure.
*/
int rows() const {
- ASSERT(fRows > 0);
+ SkASSERT(fRows > 0);
return fRows;
}
const std::vector<Field>& fields() const {
- ASSERT(fTypeKind == kStruct_Kind);
+ SkASSERT(fTypeKind == kStruct_Kind);
return fFields;
}
@@ -298,32 +298,32 @@
* types, returns a list of other types that this type can be coerced into.
*/
const std::vector<const Type*>& coercibleTypes() const {
- ASSERT(fCoercibleTypes.size() > 0);
+ SkASSERT(fCoercibleTypes.size() > 0);
return fCoercibleTypes;
}
SpvDim_ dimensions() const {
- ASSERT(kSampler_Kind == fTypeKind);
+ SkASSERT(kSampler_Kind == fTypeKind);
return fDimensions;
}
bool isDepth() const {
- ASSERT(kSampler_Kind == fTypeKind);
+ SkASSERT(kSampler_Kind == fTypeKind);
return fIsDepth;
}
bool isArrayed() const {
- ASSERT(kSampler_Kind == fTypeKind);
+ SkASSERT(kSampler_Kind == fTypeKind);
return fIsArrayed;
}
bool isMultisampled() const {
- ASSERT(kSampler_Kind == fTypeKind);
+ SkASSERT(kSampler_Kind == fTypeKind);
return fIsMultisampled;
}
bool isSampled() const {
- ASSERT(kSampler_Kind == fTypeKind);
+ SkASSERT(kSampler_Kind == fTypeKind);
return fIsSampled;
}
diff --git a/src/sksl/ir/SkSLUnresolvedFunction.h b/src/sksl/ir/SkSLUnresolvedFunction.h
index 62035da..09b405f 100644
--- a/src/sksl/ir/SkSLUnresolvedFunction.h
+++ b/src/sksl/ir/SkSLUnresolvedFunction.h
@@ -21,7 +21,7 @@
, fFunctions(std::move(funcs)) {
#ifdef DEBUG
for (auto func : funcs) {
- ASSERT(func->fName == fName);
+ SkASSERT(func->fName == fName);
}
#endif
}
diff --git a/src/sksl/ir/SkSLVariable.h b/src/sksl/ir/SkSLVariable.h
index b7cef10..e4028b4 100644
--- a/src/sksl/ir/SkSLVariable.h
+++ b/src/sksl/ir/SkSLVariable.h
@@ -44,7 +44,7 @@
if (fInitialValue) {
--fWriteCount;
}
- ASSERT(!fReadCount && !fWriteCount);
+ SkASSERT(!fReadCount && !fWriteCount);
}
virtual String description() const override {
diff --git a/src/sksl/ir/SkSLVariableReference.cpp b/src/sksl/ir/SkSLVariableReference.cpp
index 37e0ca2..fa23e47 100644
--- a/src/sksl/ir/SkSLVariableReference.cpp
+++ b/src/sksl/ir/SkSLVariableReference.cpp
@@ -53,7 +53,7 @@
std::unique_ptr<Expression> VariableReference::copy_constant(const IRGenerator& irGenerator,
const Expression* expr) {
- ASSERT(expr->isConstant());
+ SkASSERT(expr->isConstant());
switch (expr->fKind) {
case Expression::kIntLiteral_Kind:
return std::unique_ptr<Expression>(new IntLiteral(irGenerator.fContext,
diff --git a/src/sksl/lex/LexUtil.h b/src/sksl/lex/LexUtil.h
index 86a6c10..338b864 100644
--- a/src/sksl/lex/LexUtil.h
+++ b/src/sksl/lex/LexUtil.h
@@ -13,6 +13,6 @@
#define INVALID -1
#define ABORT(...) (fprintf(stderr, __VA_ARGS__), abort())
-#define ASSERT(x) (void)((x) || (ABORT("failed assert(%s): %s:%d\n", #x, __FILE__, __LINE__), 0))
+#define SkASSERT(x) (void)((x) || (ABORT("failed SkASSERT(%s): %s:%d\n", #x, __FILE__, __LINE__), 0))
#endif
diff --git a/src/sksl/lex/Main.cpp b/src/sksl/lex/Main.cpp
index fe06a87..68c97f0 100644
--- a/src/sksl/lex/Main.cpp
+++ b/src/sksl/lex/Main.cpp
@@ -33,7 +33,7 @@
void writeH(const DFA& dfa, const char* lexer, const char* token,
const std::vector<std::string>& tokens, const char* hPath) {
std::ofstream out(hPath);
- ASSERT(out.good());
+ SkASSERT(out.good());
out << HEADER;
out << "#ifndef SKSL_" << lexer << "\n";
out << "#define SKSL_" << lexer << "\n";
@@ -87,7 +87,7 @@
void writeCPP(const DFA& dfa, const char* lexer, const char* token, const char* include,
const char* cppPath) {
std::ofstream out(cppPath);
- ASSERT(out.good());
+ SkASSERT(out.good());
out << HEADER;
out << "#include \"" << include << "\"\n";
out << "\n";
@@ -172,13 +172,13 @@
std::istringstream split(line);
std::string name, delimiter, pattern;
if (split >> name >> delimiter >> pattern) {
- ASSERT(split.eof());
- ASSERT(name != "");
- ASSERT(delimiter == "=");
- ASSERT(pattern != "");
+ SkASSERT(split.eof());
+ SkASSERT(name != "");
+ SkASSERT(delimiter == "=");
+ SkASSERT(pattern != "");
tokens.push_back(name);
if (pattern[0] == '"') {
- ASSERT(pattern.size() > 2 && pattern[pattern.size() - 1] == '"');
+ SkASSERT(pattern.size() > 2 && pattern[pattern.size() - 1] == '"');
RegexNode node = RegexNode(RegexNode::kChar_Kind, pattern[1]);
for (size_t i = 2; i < pattern.size() - 1; ++i) {
node = RegexNode(RegexNode::kConcat_Kind, node,
diff --git a/src/sksl/lex/RegexNode.cpp b/src/sksl/lex/RegexNode.cpp
index 8915c60..d2668dd 100644
--- a/src/sksl/lex/RegexNode.cpp
+++ b/src/sksl/lex/RegexNode.cpp
@@ -24,7 +24,7 @@
}
chars[child.fPayload.fChar] = true;
} else {
- ASSERT(child.fKind == kRange_Kind);
+ SkASSERT(child.fKind == kRange_Kind);
while (chars.size() <= (size_t) child.fChildren[1].fPayload.fChar) {
chars.push_back(false);
}
diff --git a/src/sksl/lex/RegexParser.cpp b/src/sksl/lex/RegexParser.cpp
index 154df15..f4fec3f 100644
--- a/src/sksl/lex/RegexParser.cpp
+++ b/src/sksl/lex/RegexParser.cpp
@@ -12,10 +12,10 @@
RegexNode RegexParser::parse(std::string source) {
fSource = source;
fIndex = 0;
- ASSERT(fStack.size() == 0);
+ SkASSERT(fStack.size() == 0);
this->regex();
- ASSERT(fStack.size() == 1);
- ASSERT(fIndex == source.size());
+ SkASSERT(fStack.size() == 1);
+ SkASSERT(fIndex == source.size());
return this->pop();
}
@@ -119,9 +119,9 @@
else {
literal();
RegexNode end = this->pop();
- ASSERT(end.fKind == RegexNode::kChar_Kind);
+ SkASSERT(end.fKind == RegexNode::kChar_Kind);
RegexNode start = this->pop();
- ASSERT(start.fKind == RegexNode::kChar_Kind);
+ SkASSERT(start.fKind == RegexNode::kChar_Kind);
fStack.push(RegexNode(RegexNode::kRange_Kind, std::move(start), std::move(end)));
}
}
@@ -171,6 +171,6 @@
case ')':
return;
default:
- ASSERT(false);
+ SkASSERT(false);
}
}