From 7d975fc200bbbea991ec4c04c08f3a5ea7b847af Mon Sep 17 00:00:00 2001 From: Ethan Nicholas Date: Thu, 23 Feb 2017 16:18:54 +0000 Subject: Revert "skslc switch support" This reverts commit 2b1e468dabd2ac7bea7ec17740275f4f4aad30c3. Reason for revert: bot breakage Original change's description: > skslc switch support > > BUG=skia: > > Change-Id: Ida7f9e80139aa1e4f43804cafbcac640e47fab25 > Reviewed-on: https://skia-review.googlesource.com/8771 > Commit-Queue: Ethan Nicholas > Reviewed-by: Ben Wagner > TBR=benjaminwagner@google.com,ethannicholas@google.com,reviews@skia.org NOPRESUBMIT=true NOTREECHECKS=true NOTRY=true BUG=skia: Change-Id: Iaaa35d10a15704279c6883d4d68f6d4ad5078320 Reviewed-on: https://skia-review.googlesource.com/8792 Reviewed-by: Ethan Nicholas Commit-Queue: Ethan Nicholas --- src/sksl/SkSLCFGGenerator.cpp | 39 +-- src/sksl/SkSLCompiler.cpp | 6 +- src/sksl/SkSLGLSLCodeGenerator.cpp | 27 -- src/sksl/SkSLGLSLCodeGenerator.h | 3 - src/sksl/SkSLIRGenerator.cpp | 78 +---- src/sksl/SkSLIRGenerator.h | 4 - src/sksl/SkSLParser.cpp | 83 ----- src/sksl/SkSLParser.h | 6 - src/sksl/SkSLToken.h | 3 - src/sksl/ast/SkSLASTStatement.h | 1 - src/sksl/ast/SkSLASTSwitchCase.h | 48 --- src/sksl/ast/SkSLASTSwitchStatement.h | 43 --- src/sksl/ir/SkSLStatement.h | 1 - src/sksl/ir/SkSLSwitchCase.h | 47 --- src/sksl/ir/SkSLSwitchStatement.h | 43 --- src/sksl/lex.sksl.c | 634 +++++++++++++++++----------------- src/sksl/sksl.flex | 6 - 17 files changed, 324 insertions(+), 748 deletions(-) delete mode 100644 src/sksl/ast/SkSLASTSwitchCase.h delete mode 100644 src/sksl/ast/SkSLASTSwitchStatement.h delete mode 100644 src/sksl/ir/SkSLSwitchCase.h delete mode 100644 src/sksl/ir/SkSLSwitchStatement.h (limited to 'src/sksl') diff --git a/src/sksl/SkSLCFGGenerator.cpp b/src/sksl/SkSLCFGGenerator.cpp index 28533df557..31bace9fb7 100644 --- a/src/sksl/SkSLCFGGenerator.cpp +++ b/src/sksl/SkSLCFGGenerator.cpp @@ -20,7 +20,6 @@ #include "ir/SkSLPrefixExpression.h" #include "ir/SkSLReturnStatement.h" #include "ir/SkSLSwizzle.h" -#include "ir/SkSLSwitchStatement.h" #include "ir/SkSLTernaryExpression.h" #include "ir/SkSLVarDeclarationsStatement.h" #include "ir/SkSLWhileStatement.h" @@ -153,17 +152,13 @@ void CFGGenerator::addExpression(CFG& cfg, std::unique_ptr* e, bool cfg.fBlocks[cfg.fCurrent].fNodes.push_back({ BasicBlock::Node::kExpression_Kind, constantPropagate, e, nullptr }); break; - case Expression::kPrefix_Kind: { - PrefixExpression* p = (PrefixExpression*) e->get(); - this->addExpression(cfg, &p->fOperand, constantPropagate && - p->fOperator != Token::PLUSPLUS && - p->fOperator != Token::MINUSMINUS); + case Expression::kPrefix_Kind: + this->addExpression(cfg, &((PrefixExpression*) e->get())->fOperand, constantPropagate); cfg.fBlocks[cfg.fCurrent].fNodes.push_back({ BasicBlock::Node::kExpression_Kind, constantPropagate, e, nullptr }); break; - } case Expression::kPostfix_Kind: - this->addExpression(cfg, &((PostfixExpression*) e->get())->fOperand, false); + this->addExpression(cfg, &((PostfixExpression*) e->get())->fOperand, constantPropagate); cfg.fBlocks[cfg.fCurrent].fNodes.push_back({ BasicBlock::Node::kExpression_Kind, constantPropagate, e, nullptr }); break; @@ -350,34 +345,6 @@ void CFGGenerator::addStatement(CFG& cfg, const Statement* s) { cfg.fCurrent = loopExit; break; } - case Statement::kSwitch_Kind: { - SwitchStatement* ss = (SwitchStatement*) s; - this->addExpression(cfg, &ss->fValue, true); - BlockId start = cfg.fCurrent; - BlockId switchExit = cfg.newIsolatedBlock(); - fLoopExits.push(switchExit); - for (const auto& c : ss->fCases) { - cfg.newBlock(); - cfg.addExit(start, cfg.fCurrent); - if (c->fValue) { - // technically this should go in the start block, but it doesn't actually matter - // because it must be constant. Not worth running two loops for. - this->addExpression(cfg, &c->fValue, true); - } - for (const auto& caseStatement : c->fStatements) { - this->addStatement(cfg, caseStatement.get()); - } - } - cfg.addExit(cfg.fCurrent, switchExit); - // note that unlike GLSL, our grammar requires the default case to be last - if (0 == ss->fCases.size() || ss->fCases[ss->fCases.size() - 1]->fValue) { - // switch does not have a default clause, mark that it can skip straight to the end - cfg.addExit(start, switchExit); - } - fLoopExits.pop(); - cfg.fCurrent = switchExit; - break; - } default: printf("statement: %s\n", s->description().c_str()); ABORT("unsupported statement kind"); diff --git a/src/sksl/SkSLCompiler.cpp b/src/sksl/SkSLCompiler.cpp index d5742390a9..004eab7053 100644 --- a/src/sksl/SkSLCompiler.cpp +++ b/src/sksl/SkSLCompiler.cpp @@ -286,12 +286,8 @@ void Compiler::scanCFG(CFG* cfg, BlockId blockId, std::set* workList) { if (e1 != e2) { // definition has changed, merge and add exit block to worklist workList->insert(exitId); - if (e1 && e2) { - exit.fBefore[pair.first] = + exit.fBefore[pair.first] = (std::unique_ptr*) &fContext.fDefined_Expression; - } else { - exit.fBefore[pair.first] = nullptr; - } } } } diff --git a/src/sksl/SkSLGLSLCodeGenerator.cpp b/src/sksl/SkSLGLSLCodeGenerator.cpp index 35a2f62b08..3f5f9d1b39 100644 --- a/src/sksl/SkSLGLSLCodeGenerator.cpp +++ b/src/sksl/SkSLGLSLCodeGenerator.cpp @@ -681,9 +681,6 @@ void GLSLCodeGenerator::writeStatement(const Statement& s) { case Statement::kDo_Kind: this->writeDoStatement((DoStatement&) s); break; - case Statement::kSwitch_Kind: - this->writeSwitchStatement((SwitchStatement&) s); - break; case Statement::kBreak_Kind: this->write("break;"); break; @@ -753,30 +750,6 @@ void GLSLCodeGenerator::writeDoStatement(const DoStatement& d) { this->write(");"); } -void GLSLCodeGenerator::writeSwitchStatement(const SwitchStatement& s) { - this->write("switch ("); - this->writeExpression(*s.fValue, kTopLevel_Precedence); - this->writeLine(") {"); - fIndentation++; - for (const auto& c : s.fCases) { - if (c->fValue) { - this->write("case "); - this->writeExpression(*c->fValue, kTopLevel_Precedence); - this->writeLine(":"); - } else { - this->writeLine("default:"); - } - fIndentation++; - for (const auto& stmt : c->fStatements) { - this->writeStatement(*stmt); - this->writeLine(); - } - fIndentation--; - } - fIndentation--; - this->write("}"); -} - void GLSLCodeGenerator::writeReturnStatement(const ReturnStatement& r) { this->write("return"); if (r.fExpression) { diff --git a/src/sksl/SkSLGLSLCodeGenerator.h b/src/sksl/SkSLGLSLCodeGenerator.h index 907c3053c6..0ae2c5c585 100644 --- a/src/sksl/SkSLGLSLCodeGenerator.h +++ b/src/sksl/SkSLGLSLCodeGenerator.h @@ -34,7 +34,6 @@ #include "ir/SkSLProgramElement.h" #include "ir/SkSLReturnStatement.h" #include "ir/SkSLStatement.h" -#include "ir/SkSLSwitchStatement.h" #include "ir/SkSLSwizzle.h" #include "ir/SkSLTernaryExpression.h" #include "ir/SkSLVarDeclarations.h" @@ -156,8 +155,6 @@ private: void writeDoStatement(const DoStatement& d); - void writeSwitchStatement(const SwitchStatement& s); - void writeReturnStatement(const ReturnStatement& r); const Context& fContext; diff --git a/src/sksl/SkSLIRGenerator.cpp b/src/sksl/SkSLIRGenerator.cpp index ae2a90f899..247766f51e 100644 --- a/src/sksl/SkSLIRGenerator.cpp +++ b/src/sksl/SkSLIRGenerator.cpp @@ -8,7 +8,6 @@ #include "SkSLIRGenerator.h" #include "limits.h" -#include #include "SkSLCompiler.h" #include "ast/SkSLASTBoolLiteral.h" @@ -40,8 +39,6 @@ #include "ir/SkSLPostfixExpression.h" #include "ir/SkSLPrefixExpression.h" #include "ir/SkSLReturnStatement.h" -#include "ir/SkSLSwitchCase.h" -#include "ir/SkSLSwitchStatement.h" #include "ir/SkSLSwizzle.h" #include "ir/SkSLTernaryExpression.h" #include "ir/SkSLUnresolvedFunction.h" @@ -84,27 +81,12 @@ public: IRGenerator* fIR; }; -class AutoSwitchLevel { -public: - AutoSwitchLevel(IRGenerator* ir) - : fIR(ir) { - fIR->fSwitchLevel++; - } - - ~AutoSwitchLevel() { - fIR->fSwitchLevel--; - } - - IRGenerator* fIR; -}; - IRGenerator::IRGenerator(const Context* context, std::shared_ptr symbolTable, ErrorReporter& errorReporter) : fContext(*context) , fCurrentFunction(nullptr) , fSymbolTable(std::move(symbolTable)) , fLoopLevel(0) -, fSwitchLevel(0) , fErrors(errorReporter) {} void IRGenerator::pushSymbolTable() { @@ -171,8 +153,6 @@ std::unique_ptr IRGenerator::convertStatement(const ASTStatement& sta return this->convertWhile((ASTWhileStatement&) statement); case ASTStatement::kDo_Kind: return this->convertDo((ASTDoStatement&) statement); - case ASTStatement::kSwitch_Kind: - return this->convertSwitch((ASTSwitchStatement&) statement); case ASTStatement::kReturn_Kind: return this->convertReturn((ASTReturnStatement&) statement); case ASTStatement::kBreak_Kind: @@ -377,60 +357,6 @@ std::unique_ptr IRGenerator::convertDo(const ASTDoStatement& d) { std::move(test))); } -std::unique_ptr IRGenerator::convertSwitch(const ASTSwitchStatement& s) { - AutoSwitchLevel level(this); - std::unique_ptr value = this->convertExpression(*s.fValue); - if (!value) { - return nullptr; - } - if (value->fType != *fContext.fUInt_Type) { - value = this->coerce(std::move(value), *fContext.fInt_Type); - if (!value) { - return nullptr; - } - } - AutoSymbolTable table(this); - std::unordered_set caseValues; - std::vector> cases; - for (const auto& c : s.fCases) { - std::unique_ptr caseValue; - if (c->fValue) { - caseValue = this->convertExpression(*c->fValue); - if (!caseValue) { - return nullptr; - } - if (caseValue->fType != *fContext.fUInt_Type) { - caseValue = this->coerce(std::move(caseValue), *fContext.fInt_Type); - if (!caseValue) { - return nullptr; - } - } - if (!caseValue->isConstant()) { - fErrors.error(caseValue->fPosition, "case value must be a constant"); - return nullptr; - } - ASSERT(caseValue->fKind == Expression::kIntLiteral_Kind); - int64_t v = ((IntLiteral&) *caseValue).fValue; - if (caseValues.find(v) != caseValues.end()) { - fErrors.error(caseValue->fPosition, "duplicate case value"); - } - caseValues.insert(v); - } - std::vector> statements; - for (const auto& s : c->fStatements) { - std::unique_ptr converted = this->convertStatement(*s); - if (!converted) { - return nullptr; - } - statements.push_back(std::move(converted)); - } - cases.emplace_back(new SwitchCase(c->fPosition, std::move(caseValue), - std::move(statements))); - } - return std::unique_ptr(new SwitchStatement(s.fPosition, std::move(value), - std::move(cases))); -} - std::unique_ptr IRGenerator::convertExpressionStatement( const ASTExpressionStatement& s) { std::unique_ptr e = this->convertExpression(*s.fExpression); @@ -467,10 +393,10 @@ std::unique_ptr IRGenerator::convertReturn(const ASTReturnStatement& } std::unique_ptr IRGenerator::convertBreak(const ASTBreakStatement& b) { - if (fLoopLevel > 0 || fSwitchLevel > 0) { + if (fLoopLevel > 0) { return std::unique_ptr(new BreakStatement(b.fPosition)); } else { - fErrors.error(b.fPosition, "break statement must be inside a loop or switch"); + fErrors.error(b.fPosition, "break statement must be inside a loop"); return nullptr; } } diff --git a/src/sksl/SkSLIRGenerator.h b/src/sksl/SkSLIRGenerator.h index fb79cda9b5..1336b68c88 100644 --- a/src/sksl/SkSLIRGenerator.h +++ b/src/sksl/SkSLIRGenerator.h @@ -29,7 +29,6 @@ #include "ast/SkSLASTReturnStatement.h" #include "ast/SkSLASTStatement.h" #include "ast/SkSLASTSuffixExpression.h" -#include "ast/SkSLASTSwitchStatement.h" #include "ast/SkSLASTTernaryExpression.h" #include "ast/SkSLASTVarDeclaration.h" #include "ast/SkSLASTVarDeclarationStatement.h" @@ -141,7 +140,6 @@ private: std::unique_ptr convertContinue(const ASTContinueStatement& c); std::unique_ptr convertDiscard(const ASTDiscardStatement& d); std::unique_ptr convertDo(const ASTDoStatement& d); - std::unique_ptr convertSwitch(const ASTSwitchStatement& s); std::unique_ptr convertBinaryExpression(const ASTBinaryExpression& expression); std::unique_ptr convertExtension(const ASTExtension& e); std::unique_ptr convertExpressionStatement(const ASTExpressionStatement& s); @@ -172,12 +170,10 @@ private: std::unordered_map fCapsMap; std::shared_ptr fSymbolTable; int fLoopLevel; - int fSwitchLevel; ErrorReporter& fErrors; friend class AutoSymbolTable; friend class AutoLoopLevel; - friend class AutoSwitchLevel; friend class Compiler; }; diff --git a/src/sksl/SkSLParser.cpp b/src/sksl/SkSLParser.cpp index a5a7e0c4b6..cc47577e93 100644 --- a/src/sksl/SkSLParser.cpp +++ b/src/sksl/SkSLParser.cpp @@ -63,8 +63,6 @@ #include "ast/SkSLASTReturnStatement.h" #include "ast/SkSLASTStatement.h" #include "ast/SkSLASTSuffixExpression.h" -#include "ast/SkSLASTSwitchCase.h" -#include "ast/SkSLASTSwitchStatement.h" #include "ast/SkSLASTTernaryExpression.h" #include "ast/SkSLASTType.h" #include "ast/SkSLASTVarDeclaration.h" @@ -772,8 +770,6 @@ std::unique_ptr Parser::statement() { return this->doStatement(); case Token::WHILE: return this->whileStatement(); - case Token::SWITCH: - return this->switchStatement(); case Token::RETURN: return this->returnStatement(); case Token::BREAK: @@ -979,85 +975,6 @@ std::unique_ptr Parser::whileStatement() { std::move(statement))); } -/* CASE expression COLON statement* */ -std::unique_ptr Parser::switchCase() { - if (!this->expect(Token::CASE, "'case'")) { - return nullptr; - } - std::unique_ptr value = this->expression(); - if (!value) { - return nullptr; - } - if (!this->expect(Token::COLON, "':'")) { - return nullptr; - } - std::vector> statements; - while (this->peek().fKind != Token::RBRACE && this->peek().fKind != Token::CASE && - this->peek().fKind != Token::DEFAULT) { - std::unique_ptr s = this->statement(); - if (!s) { - return nullptr; - } - statements.push_back(std::move(s)); - } - return std::unique_ptr(new ASTSwitchCase(value->fPosition, std::move(value), - std::move(statements))); -} - -/* SWITCH LPAREN expression RPAREN LBRACE switchCase* (DEFAULT COLON statement*)? RBRACE */ -std::unique_ptr Parser::switchStatement() { - Token start; - if (!this->expect(Token::SWITCH, "'switch'", &start)) { - return nullptr; - } - if (!this->expect(Token::LPAREN, "'('")) { - return nullptr; - } - std::unique_ptr value(this->expression()); - if (!value) { - return nullptr; - } - if (!this->expect(Token::RPAREN, "')'")) { - return nullptr; - } - if (!this->expect(Token::LBRACE, "'{'")) { - return nullptr; - } - std::vector> cases; - while (this->peek().fKind == Token::CASE) { - std::unique_ptr c = this->switchCase(); - if (!c) { - return nullptr; - } - cases.push_back(std::move(c)); - } - // Requiring default: to be last (in defiance of C and GLSL) was a deliberate decision. Other - // parts of the compiler may rely upon this assumption. - if (this->peek().fKind == Token::DEFAULT) { - Token defaultStart; - SkAssertResult(this->expect(Token::DEFAULT, "'default'", &defaultStart)); - if (!this->expect(Token::COLON, "':'")) { - return nullptr; - } - std::vector> statements; - while (this->peek().fKind != Token::RBRACE) { - std::unique_ptr s = this->statement(); - if (!s) { - return nullptr; - } - statements.push_back(std::move(s)); - } - cases.emplace_back(new ASTSwitchCase(defaultStart.fPosition, nullptr, - std::move(statements))); - } - if (!this->expect(Token::RBRACE, "'}'")) { - return nullptr; - } - return std::unique_ptr(new ASTSwitchStatement(start.fPosition, - std::move(value), - std::move(cases))); -} - /* FOR LPAREN (declaration | expression)? SEMICOLON expression? SEMICOLON expression? RPAREN STATEMENT */ std::unique_ptr Parser::forStatement() { diff --git a/src/sksl/SkSLParser.h b/src/sksl/SkSLParser.h index 63894e0227..78d9933871 100644 --- a/src/sksl/SkSLParser.h +++ b/src/sksl/SkSLParser.h @@ -37,8 +37,6 @@ struct ASTPrecision; struct ASTReturnStatement; struct ASTStatement; struct ASTSuffix; -struct ASTSwitchCase; -struct ASTSwitchStatement; struct ASTType; struct ASTWhileStatement; struct ASTVarDeclarations; @@ -145,10 +143,6 @@ private: std::unique_ptr forStatement(); - std::unique_ptr switchCase(); - - std::unique_ptr switchStatement(); - std::unique_ptr returnStatement(); std::unique_ptr breakStatement(); diff --git a/src/sksl/SkSLToken.h b/src/sksl/SkSLToken.h index 70b4ed298e..197781f2a0 100644 --- a/src/sksl/SkSLToken.h +++ b/src/sksl/SkSLToken.h @@ -82,9 +82,6 @@ struct Token { FOR, WHILE, DO, - SWITCH, - CASE, - DEFAULT, RETURN, BREAK, CONTINUE, diff --git a/src/sksl/ast/SkSLASTStatement.h b/src/sksl/ast/SkSLASTStatement.h index 6ce320e343..9ddde063ea 100644 --- a/src/sksl/ast/SkSLASTStatement.h +++ b/src/sksl/ast/SkSLASTStatement.h @@ -26,7 +26,6 @@ struct ASTStatement : public ASTPositionNode { kFor_Kind, kWhile_Kind, kDo_Kind, - kSwitch_Kind, kReturn_Kind, kBreak_Kind, kContinue_Kind, diff --git a/src/sksl/ast/SkSLASTSwitchCase.h b/src/sksl/ast/SkSLASTSwitchCase.h deleted file mode 100644 index 2c0a01c7fa..0000000000 --- a/src/sksl/ast/SkSLASTSwitchCase.h +++ /dev/null @@ -1,48 +0,0 @@ -/* - * Copyright 2017 Google Inc. - * - * Use of this source code is governed by a BSD-style license that can be - * found in the LICENSE file. - */ - -#ifndef SKSL_ASTSWITCHCASE -#define SKSL_ASTSWITCHCASE - -#include "SkSLASTStatement.h" - -namespace SkSL { - -/** - * A single case of a 'switch' statement. - */ -struct ASTSwitchCase : public ASTStatement { - // a null value means "default:" - ASTSwitchCase(Position position, std::unique_ptr value, - std::vector> statements) - : INHERITED(position, kSwitch_Kind) - , fValue(std::move(value)) - , fStatements(std::move(statements)) {} - - SkString description() const override { - SkString result; - if (fValue) { - result.appendf("case %s:\n", fValue->description().c_str()); - } else { - result += "default:\n"; - } - for (const auto& s : fStatements) { - result += s->description() + "\n"; - } - return result; - } - - // null value implies "default" case - const std::unique_ptr fValue; - const std::vector> fStatements; - - typedef ASTStatement INHERITED; -}; - -} // namespace - -#endif diff --git a/src/sksl/ast/SkSLASTSwitchStatement.h b/src/sksl/ast/SkSLASTSwitchStatement.h deleted file mode 100644 index 3031a7d2b1..0000000000 --- a/src/sksl/ast/SkSLASTSwitchStatement.h +++ /dev/null @@ -1,43 +0,0 @@ -/* - * Copyright 2017 Google Inc. - * - * Use of this source code is governed by a BSD-style license that can be - * found in the LICENSE file. - */ - -#ifndef SKSL_ASTSWITCHSTATEMENT -#define SKSL_ASTSWITCHSTATEMENT - -#include "SkSLASTStatement.h" -#include "SkSLASTSwitchCase.h" - -namespace SkSL { - -/** - * A 'switch' statement. - */ -struct ASTSwitchStatement : public ASTStatement { - ASTSwitchStatement(Position position, std::unique_ptr value, - std::vector> cases) - : INHERITED(position, kSwitch_Kind) - , fValue(std::move(value)) - , fCases(std::move(cases)) {} - - SkString description() const override { - SkString result = SkStringPrintf("switch (%s) {\n", + fValue->description().c_str()); - for (const auto& c : fCases) { - result += c->description(); - } - result += "}"; - return result; - } - - const std::unique_ptr fValue; - const std::vector> fCases; - - typedef ASTStatement INHERITED; -}; - -} // namespace - -#endif diff --git a/src/sksl/ir/SkSLStatement.h b/src/sksl/ir/SkSLStatement.h index c3a6f9539e..012311fdd3 100644 --- a/src/sksl/ir/SkSLStatement.h +++ b/src/sksl/ir/SkSLStatement.h @@ -27,7 +27,6 @@ struct Statement : public IRNode { kFor_Kind, kIf_Kind, kReturn_Kind, - kSwitch_Kind, kVarDeclarations_Kind, kWhile_Kind }; diff --git a/src/sksl/ir/SkSLSwitchCase.h b/src/sksl/ir/SkSLSwitchCase.h deleted file mode 100644 index 3f1c3acbd3..0000000000 --- a/src/sksl/ir/SkSLSwitchCase.h +++ /dev/null @@ -1,47 +0,0 @@ -/* - * Copyright 2017 Google Inc. - * - * Use of this source code is governed by a BSD-style license that can be - * found in the LICENSE file. - */ - -#ifndef SKSL_SWITCHCASE -#define SKSL_SWITCHCASE - -#include "SkSLStatement.h" - -namespace SkSL { - -/** - * A single case of a 'switch' statement. - */ -struct SwitchCase : public Statement { - SwitchCase(Position position, std::unique_ptr value, - std::vector> statements) - : INHERITED(position, kSwitch_Kind) - , fValue(std::move(value)) - , fStatements(std::move(statements)) {} - - SkString description() const override { - SkString result; - if (fValue) { - result.appendf("case %s:\n", fValue->description().c_str()); - } else { - result += "default:\n"; - } - for (const auto& s : fStatements) { - result += s->description() + "\n"; - } - return result; - } - - // null value implies "default" case - std::unique_ptr fValue; - std::vector> fStatements; - - typedef Statement INHERITED; -}; - -} // namespace - -#endif diff --git a/src/sksl/ir/SkSLSwitchStatement.h b/src/sksl/ir/SkSLSwitchStatement.h deleted file mode 100644 index 31765c4e04..0000000000 --- a/src/sksl/ir/SkSLSwitchStatement.h +++ /dev/null @@ -1,43 +0,0 @@ -/* - * Copyright 2017 Google Inc. - * - * Use of this source code is governed by a BSD-style license that can be - * found in the LICENSE file. - */ - -#ifndef SKSL_SWITCHSTATEMENT -#define SKSL_SWITCHSTATEMENT - -#include "SkSLStatement.h" -#include "SkSLSwitchCase.h" - -namespace SkSL { - -/** - * A 'switch' statement. - */ -struct SwitchStatement : public Statement { - SwitchStatement(Position position, std::unique_ptr value, - std::vector> cases) - : INHERITED(position, kSwitch_Kind) - , fValue(std::move(value)) - , fCases(std::move(cases)) {} - - SkString description() const override { - SkString result = SkStringPrintf("switch (%s) {\n", + fValue->description().c_str()); - for (const auto& c : fCases) { - result += c->description(); - } - result += "}"; - return result; - } - - std::unique_ptr fValue; - std::vector> fCases; - - typedef Statement INHERITED; -}; - -} // namespace - -#endif diff --git a/src/sksl/lex.sksl.c b/src/sksl/lex.sksl.c index 2c5eb73402..4cff376fa5 100644 --- a/src/sksl/lex.sksl.c +++ b/src/sksl/lex.sksl.c @@ -1,5 +1,5 @@ /* - * Copyright 2017 Google Inc. + * Copyright 2016 Google Inc. * * Use of this source code is governed by a BSD-style license that can be * found in the LICENSE file. @@ -13,8 +13,8 @@ #define FLEX_SCANNER #define YY_FLEX_MAJOR_VERSION 2 -#define YY_FLEX_MINOR_VERSION 5 -#define YY_FLEX_SUBMINOR_VERSION 39 +#define YY_FLEX_MINOR_VERSION 6 +#define YY_FLEX_SUBMINOR_VERSION 0 #if YY_FLEX_SUBMINOR_VERSION > 0 #define FLEX_BETA #endif @@ -248,7 +248,7 @@ struct yy_buffer_state /* Number of characters read into yy_ch_buf, not including EOB * characters. */ - yy_size_t yy_n_chars; + int yy_n_chars; /* Whether we "own" the buffer - i.e., we know we created it, * and can realloc() it to grow it, and should free() it to @@ -368,6 +368,9 @@ typedef int yy_state_type; static yy_state_type yy_get_previous_state (yyscan_t yyscanner ); static yy_state_type yy_try_NUL_trans (yy_state_type current_state ,yyscan_t yyscanner); static int yy_get_next_buffer (yyscan_t yyscanner ); +#if defined(__GNUC__) && __GNUC__ >= 3 +__attribute__((__noreturn__)) +#endif static void yy_fatal_error (yyconst char msg[] ,yyscan_t yyscanner ); /* Done after the current pattern has been matched and before the @@ -380,8 +383,8 @@ static void yy_fatal_error (yyconst char msg[] ,yyscan_t yyscanner ); *yy_cp = '\0'; \ yyg->yy_c_buf_p = yy_cp; -#define YY_NUM_RULES 92 -#define YY_END_OF_BUFFER 93 +#define YY_NUM_RULES 89 +#define YY_END_OF_BUFFER 90 /* This struct is not used in this scanner, but its presence is necessary. */ struct yy_trans_info @@ -389,39 +392,37 @@ struct yy_trans_info flex_int32_t yy_verify; flex_int32_t yy_nxt; }; -static yyconst flex_int16_t yy_accept[253] = +static yyconst flex_int16_t yy_accept[239] = { 0, - 0, 0, 93, 91, 90, 90, 64, 91, 38, 54, - 59, 40, 41, 52, 50, 47, 51, 46, 53, 4, - 4, 66, 87, 71, 67, 70, 65, 44, 45, 58, - 38, 38, 38, 38, 38, 38, 38, 38, 38, 38, - 38, 38, 38, 38, 38, 38, 38, 38, 42, 57, - 43, 60, 90, 69, 39, 38, 78, 63, 83, 76, - 48, 74, 49, 75, 1, 0, 88, 77, 2, 4, - 0, 0, 55, 73, 68, 72, 56, 82, 62, 38, - 38, 38, 38, 38, 12, 38, 38, 38, 38, 38, - 8, 20, 38, 38, 38, 38, 38, 38, 38, 38, - - 38, 38, 38, 38, 38, 38, 81, 61, 39, 86, - 0, 0, 0, 88, 1, 0, 0, 3, 5, 79, - 80, 85, 38, 38, 38, 38, 38, 38, 38, 38, - 38, 10, 38, 38, 38, 38, 38, 38, 21, 38, - 38, 38, 38, 38, 38, 38, 38, 38, 38, 38, - 84, 0, 1, 89, 0, 0, 2, 38, 14, 38, - 38, 38, 38, 38, 9, 38, 28, 38, 38, 38, - 25, 38, 38, 38, 38, 38, 38, 38, 38, 6, - 38, 38, 38, 38, 0, 1, 16, 38, 24, 38, - 38, 38, 7, 27, 22, 38, 38, 38, 38, 38, - - 38, 38, 38, 38, 38, 38, 11, 38, 38, 38, - 38, 38, 36, 38, 38, 38, 38, 38, 19, 35, - 13, 38, 38, 38, 38, 38, 15, 18, 26, 38, - 38, 38, 38, 23, 38, 38, 32, 17, 38, 38, - 30, 34, 33, 38, 38, 37, 31, 38, 38, 38, - 29, 0 + 0, 0, 90, 88, 87, 87, 61, 88, 35, 51, + 56, 37, 38, 49, 47, 44, 48, 43, 50, 4, + 4, 63, 84, 68, 64, 67, 62, 41, 42, 55, + 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, + 35, 35, 35, 35, 35, 35, 35, 35, 39, 54, + 40, 57, 87, 66, 36, 35, 75, 60, 80, 73, + 45, 71, 46, 72, 1, 0, 85, 74, 2, 4, + 0, 0, 52, 70, 65, 69, 53, 79, 59, 35, + 35, 35, 12, 35, 35, 35, 35, 35, 8, 17, + 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, + + 35, 35, 35, 78, 58, 36, 83, 0, 0, 0, + 85, 1, 0, 0, 3, 5, 76, 77, 82, 35, + 35, 35, 35, 35, 35, 35, 10, 35, 35, 35, + 35, 35, 35, 18, 35, 35, 35, 35, 35, 35, + 35, 35, 35, 35, 81, 0, 1, 86, 0, 0, + 2, 35, 35, 35, 35, 35, 9, 35, 25, 35, + 35, 35, 22, 35, 35, 35, 35, 35, 35, 35, + 6, 35, 35, 35, 35, 0, 1, 13, 35, 21, + 35, 35, 7, 24, 19, 35, 35, 35, 35, 35, + 35, 35, 35, 35, 35, 11, 35, 35, 35, 35, + + 33, 35, 35, 35, 35, 35, 16, 32, 35, 35, + 35, 35, 35, 15, 23, 35, 35, 35, 35, 20, + 35, 35, 29, 14, 35, 35, 27, 31, 30, 35, + 35, 34, 28, 35, 35, 35, 26, 0 } ; -static yyconst flex_int32_t yy_ec[256] = +static yyconst YY_CHAR yy_ec[256] = { 0, 1, 1, 1, 1, 1, 1, 1, 1, 2, 3, 1, 1, 2, 1, 1, 1, 1, 1, 1, 1, @@ -453,7 +454,7 @@ static yyconst flex_int32_t yy_ec[256] = 1, 1, 1, 1, 1 } ; -static yyconst flex_int32_t yy_meta[57] = +static yyconst YY_CHAR yy_meta[57] = { 0, 1, 1, 2, 1, 1, 3, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 4, 4, 1, 1, @@ -463,71 +464,69 @@ static yyconst flex_int32_t yy_meta[57] = 3, 3, 1, 1, 1, 1 } ; -static yyconst flex_int16_t yy_base[259] = +static yyconst flex_uint16_t yy_base[245] = { 0, - 0, 0, 320, 321, 55, 57, 297, 0, 0, 296, - 53, 321, 321, 295, 50, 321, 49, 47, 57, 52, - 59, 321, 321, 59, 294, 60, 321, 321, 321, 62, - 270, 57, 54, 274, 59, 275, 59, 65, 278, 268, - 262, 264, 274, 57, 262, 264, 262, 53, 321, 74, - 321, 321, 103, 321, 0, 0, 321, 282, 321, 321, - 321, 321, 321, 321, 92, 292, 0, 321, 95, 99, - 118, 0, 280, 321, 321, 321, 279, 321, 278, 265, - 252, 78, 262, 250, 0, 249, 254, 263, 247, 255, - 0, 247, 237, 238, 254, 242, 238, 250, 92, 238, - - 244, 233, 242, 239, 240, 239, 321, 254, 0, 321, - 128, 264, 258, 0, 126, 136, 106, 138, 0, 321, - 321, 321, 243, 238, 237, 111, 240, 237, 234, 221, - 219, 0, 228, 216, 220, 218, 223, 226, 0, 227, - 225, 210, 208, 207, 207, 219, 217, 221, 210, 202, - 321, 144, 146, 321, 153, 151, 155, 209, 0, 202, - 199, 207, 196, 213, 0, 208, 0, 197, 193, 191, - 0, 190, 192, 198, 192, 189, 188, 200, 199, 0, - 187, 182, 194, 193, 157, 159, 0, 192, 0, 183, - 184, 178, 0, 0, 0, 175, 180, 174, 173, 176, - - 179, 174, 168, 177, 168, 174, 0, 168, 168, 161, - 161, 174, 0, 162, 161, 166, 163, 170, 0, 0, - 0, 160, 160, 157, 146, 145, 0, 0, 0, 132, - 116, 99, 102, 0, 113, 101, 0, 0, 105, 92, - 0, 0, 0, 79, 80, 0, 0, 81, 62, 32, - 0, 321, 175, 178, 181, 186, 191, 193 + 0, 0, 306, 307, 55, 57, 283, 0, 0, 282, + 53, 307, 307, 281, 50, 307, 49, 47, 57, 52, + 59, 307, 307, 59, 280, 60, 307, 307, 307, 62, + 256, 257, 49, 259, 58, 260, 54, 64, 263, 253, + 247, 249, 259, 245, 246, 248, 246, 60, 307, 68, + 307, 307, 97, 307, 0, 0, 307, 266, 307, 307, + 307, 307, 307, 307, 91, 276, 0, 307, 93, 97, + 112, 0, 264, 307, 307, 307, 263, 307, 262, 249, + 76, 236, 0, 235, 240, 249, 233, 241, 0, 233, + 223, 224, 240, 228, 224, 236, 74, 224, 220, 229, + + 226, 227, 226, 307, 241, 0, 307, 120, 251, 245, + 0, 118, 128, 130, 132, 0, 307, 307, 307, 230, + 225, 107, 226, 223, 210, 208, 0, 217, 205, 209, + 207, 212, 215, 0, 216, 214, 199, 197, 196, 209, + 207, 211, 200, 192, 307, 138, 140, 307, 147, 145, + 149, 199, 192, 189, 197, 204, 0, 199, 0, 188, + 184, 182, 0, 181, 183, 189, 183, 180, 179, 191, + 0, 179, 174, 186, 185, 151, 153, 0, 184, 0, + 175, 171, 0, 0, 0, 168, 173, 167, 166, 169, + 172, 167, 161, 162, 168, 0, 162, 162, 155, 169, + + 0, 157, 156, 161, 158, 165, 0, 0, 155, 155, + 152, 146, 153, 0, 0, 139, 117, 99, 96, 0, + 107, 99, 0, 0, 101, 86, 0, 0, 0, 64, + 59, 0, 0, 64, 46, 32, 0, 307, 169, 172, + 175, 180, 185, 187 } ; -static yyconst flex_int16_t yy_def[259] = +static yyconst flex_int16_t yy_def[245] = { 0, - 252, 1, 252, 252, 252, 252, 252, 253, 254, 252, - 252, 252, 252, 252, 252, 252, 252, 252, 252, 252, - 252, 252, 252, 252, 252, 252, 252, 252, 252, 252, - 254, 254, 254, 254, 254, 254, 254, 254, 254, 254, - 254, 254, 254, 254, 254, 254, 254, 254, 252, 252, - 252, 252, 252, 252, 255, 254, 252, 252, 252, 252, - 252, 252, 252, 252, 252, 256, 257, 252, 252, 252, - 252, 258, 252, 252, 252, 252, 252, 252, 252, 254, - 254, 254, 254, 254, 254, 254, 254, 254, 254, 254, - 254, 254, 254, 254, 254, 254, 254, 254, 254, 254, - - 254, 254, 254, 254, 254, 254, 252, 252, 255, 252, - 252, 256, 256, 257, 252, 252, 252, 252, 258, 252, - 252, 252, 254, 254, 254, 254, 254, 254, 254, 254, - 254, 254, 254, 254, 254, 254, 254, 254, 254, 254, - 254, 254, 254, 254, 254, 254, 254, 254, 254, 254, - 252, 252, 252, 252, 252, 252, 252, 254, 254, 254, - 254, 254, 254, 254, 254, 254, 254, 254, 254, 254, - 254, 254, 254, 254, 254, 254, 254, 254, 254, 254, - 254, 254, 254, 254, 252, 252, 254, 254, 254, 254, - 254, 254, 254, 254, 254, 254, 254, 254, 254, 254, - - 254, 254, 254, 254, 254, 254, 254, 254, 254, 254, - 254, 254, 254, 254, 254, 254, 254, 254, 254, 254, - 254, 254, 254, 254, 254, 254, 254, 254, 254, 254, - 254, 254, 254, 254, 254, 254, 254, 254, 254, 254, - 254, 254, 254, 254, 254, 254, 254, 254, 254, 254, - 254, 0, 252, 252, 252, 252, 252, 252 + 238, 1, 238, 238, 238, 238, 238, 239, 240, 238, + 238, 238, 238, 238, 238, 238, 238, 238, 238, 238, + 238, 238, 238, 238, 238, 238, 238, 238, 238, 238, + 240, 240, 240, 240, 240, 240, 240, 240, 240, 240, + 240, 240, 240, 240, 240, 240, 240, 240, 238, 238, + 238, 238, 238, 238, 241, 240, 238, 238, 238, 238, + 238, 238, 238, 238, 238, 242, 243, 238, 238, 238, + 238, 244, 238, 238, 238, 238, 238, 238, 238, 240, + 240, 240, 240, 240, 240, 240, 240, 240, 240, 240, + 240, 240, 240, 240, 240, 240, 240, 240, 240, 240, + + 240, 240, 240, 238, 238, 241, 238, 238, 242, 242, + 243, 238, 238, 238, 238, 244, 238, 238, 238, 240, + 240, 240, 240, 240, 240, 240, 240, 240, 240, 240, + 240, 240, 240, 240, 240, 240, 240, 240, 240, 240, + 240, 240, 240, 240, 238, 238, 238, 238, 238, 238, + 238, 240, 240, 240, 240, 240, 240, 240, 240, 240, + 240, 240, 240, 240, 240, 240, 240, 240, 240, 240, + 240, 240, 240, 240, 240, 238, 238, 240, 240, 240, + 240, 240, 240, 240, 240, 240, 240, 240, 240, 240, + 240, 240, 240, 240, 240, 240, 240, 240, 240, 240, + + 240, 240, 240, 240, 240, 240, 240, 240, 240, 240, + 240, 240, 240, 240, 240, 240, 240, 240, 240, 240, + 240, 240, 240, 240, 240, 240, 240, 240, 240, 240, + 240, 240, 240, 240, 240, 240, 240, 0, 238, 238, + 238, 238, 238, 238 } ; -static yyconst flex_int16_t yy_nxt[378] = +static yyconst flex_uint16_t yy_nxt[364] = { 0, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, @@ -535,44 +534,43 @@ static yyconst flex_int16_t yy_nxt[378] = 31, 32, 33, 34, 35, 9, 36, 37, 9, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 9, 9, 49, 50, 51, 52, 53, 53, 53, 53, - 58, 61, 63, 65, 65, 251, 69, 66, 70, 70, + 58, 61, 63, 65, 65, 237, 69, 66, 70, 70, 64, 62, 67, 69, 59, 70, 70, 71, 68, 73, - 74, 76, 77, 78, 71, 71, 81, 83, 87, 105, - 79, 84, 71, 91, 93, 107, 85, 106, 88, 82, - - 92, 89, 72, 100, 53, 53, 101, 94, 65, 65, - 250, 115, 115, 69, 125, 70, 70, 111, 249, 126, - 116, 141, 118, 118, 71, 111, 248, 108, 116, 117, - 247, 117, 71, 246, 118, 118, 245, 142, 143, 152, - 244, 152, 115, 115, 153, 153, 243, 156, 242, 156, - 241, 155, 157, 157, 118, 118, 161, 162, 240, 155, - 153, 153, 153, 153, 185, 239, 185, 157, 157, 186, - 186, 157, 157, 186, 186, 186, 186, 55, 238, 55, - 56, 56, 56, 109, 109, 109, 112, 112, 112, 112, - 112, 114, 237, 114, 114, 114, 119, 119, 236, 235, - - 234, 233, 232, 231, 230, 229, 228, 227, 226, 225, - 224, 223, 222, 221, 220, 219, 218, 217, 216, 215, - 214, 213, 212, 211, 210, 209, 208, 207, 206, 205, - 204, 203, 202, 201, 200, 199, 198, 197, 196, 195, - 194, 193, 192, 191, 190, 189, 188, 187, 184, 183, - 182, 181, 180, 179, 178, 177, 176, 175, 174, 173, - 172, 171, 170, 169, 168, 167, 166, 165, 164, 163, - 160, 159, 158, 154, 113, 151, 150, 149, 148, 147, - 146, 145, 144, 140, 139, 138, 137, 136, 135, 134, - 133, 132, 131, 130, 129, 128, 127, 124, 123, 122, - - 121, 120, 113, 110, 104, 103, 102, 99, 98, 97, - 96, 95, 90, 86, 80, 75, 60, 57, 54, 252, - 3, 252, 252, 252, 252, 252, 252, 252, 252, 252, - 252, 252, 252, 252, 252, 252, 252, 252, 252, 252, - 252, 252, 252, 252, 252, 252, 252, 252, 252, 252, - 252, 252, 252, 252, 252, 252, 252, 252, 252, 252, - 252, 252, 252, 252, 252, 252, 252, 252, 252, 252, - 252, 252, 252, 252, 252, 252, 252 + 74, 76, 77, 78, 71, 71, 82, 85, 89, 104, + 79, 83, 71, 91, 236, 90, 102, 86, 53, 53, + + 87, 235, 72, 136, 103, 234, 92, 65, 65, 112, + 112, 69, 121, 70, 70, 233, 108, 122, 113, 137, + 138, 105, 71, 114, 108, 114, 113, 232, 115, 115, + 71, 146, 231, 146, 112, 112, 147, 147, 230, 150, + 229, 150, 228, 149, 151, 151, 115, 115, 115, 115, + 227, 149, 154, 155, 147, 147, 147, 147, 176, 226, + 176, 151, 151, 177, 177, 151, 151, 177, 177, 177, + 177, 55, 225, 55, 56, 56, 56, 106, 106, 106, + 109, 109, 109, 109, 109, 111, 224, 111, 111, 111, + 116, 116, 223, 222, 221, 220, 219, 218, 217, 216, + + 215, 214, 213, 212, 211, 210, 209, 208, 207, 206, + 205, 204, 203, 202, 201, 200, 199, 198, 197, 196, + 195, 194, 193, 192, 191, 190, 189, 188, 187, 186, + 185, 184, 183, 182, 181, 180, 179, 178, 175, 174, + 173, 172, 171, 170, 169, 168, 167, 166, 165, 164, + 163, 162, 161, 160, 159, 158, 157, 156, 153, 152, + 148, 110, 145, 144, 143, 142, 141, 140, 139, 135, + 134, 133, 132, 131, 130, 129, 128, 127, 126, 125, + 124, 123, 120, 119, 118, 117, 110, 107, 101, 100, + 99, 98, 97, 96, 95, 94, 93, 88, 84, 81, + + 80, 75, 60, 57, 54, 238, 3, 238, 238, 238, + 238, 238, 238, 238, 238, 238, 238, 238, 238, 238, + 238, 238, 238, 238, 238, 238, 238, 238, 238, 238, + 238, 238, 238, 238, 238, 238, 238, 238, 238, 238, + 238, 238, 238, 238, 238, 238, 238, 238, 238, 238, + 238, 238, 238, 238, 238, 238, 238, 238, 238, 238, + 238, 238, 238 } ; -static yyconst flex_int16_t yy_chk[378] = +static yyconst flex_int16_t yy_chk[364] = { 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, @@ -580,51 +578,50 @@ static yyconst flex_int16_t yy_chk[378] = 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 5, 5, 6, 6, - 11, 15, 17, 18, 18, 250, 20, 19, 20, 20, + 11, 15, 17, 18, 18, 236, 20, 19, 20, 20, 17, 15, 19, 21, 11, 21, 21, 20, 19, 24, - 24, 26, 26, 30, 21, 20, 32, 33, 35, 48, - 30, 33, 21, 37, 38, 50, 33, 48, 35, 32, - - 37, 35, 20, 44, 53, 53, 44, 38, 65, 65, - 249, 69, 69, 70, 82, 70, 70, 65, 248, 82, - 69, 99, 117, 117, 70, 65, 245, 50, 69, 71, - 244, 71, 70, 240, 71, 71, 239, 99, 99, 111, - 236, 111, 115, 115, 111, 111, 235, 116, 233, 116, - 232, 115, 116, 116, 118, 118, 126, 126, 231, 115, - 152, 152, 153, 153, 155, 230, 155, 156, 156, 155, - 155, 157, 157, 185, 185, 186, 186, 253, 226, 253, - 254, 254, 254, 255, 255, 255, 256, 256, 256, 256, - 256, 257, 225, 257, 257, 257, 258, 258, 224, 223, - - 222, 218, 217, 216, 215, 214, 212, 211, 210, 209, - 208, 206, 205, 204, 203, 202, 201, 200, 199, 198, - 197, 196, 192, 191, 190, 188, 184, 183, 182, 181, - 179, 178, 177, 176, 175, 174, 173, 172, 170, 169, - 168, 166, 164, 163, 162, 161, 160, 158, 150, 149, - 148, 147, 146, 145, 144, 143, 142, 141, 140, 138, - 137, 136, 135, 134, 133, 131, 130, 129, 128, 127, - 125, 124, 123, 113, 112, 108, 106, 105, 104, 103, - 102, 101, 100, 98, 97, 96, 95, 94, 93, 92, - 90, 89, 88, 87, 86, 84, 83, 81, 80, 79, - - 77, 73, 66, 58, 47, 46, 45, 43, 42, 41, - 40, 39, 36, 34, 31, 25, 14, 10, 7, 3, - 252, 252, 252, 252, 252, 252, 252, 252, 252, 252, - 252, 252, 252, 252, 252, 252, 252, 252, 252, 252, - 252, 252, 252, 252, 252, 252, 252, 252, 252, 252, - 252, 252, 252, 252, 252, 252, 252, 252, 252, 252, - 252, 252, 252, 252, 252, 252, 252, 252, 252, 252, - 252, 252, 252, 252, 252, 252, 252 + 24, 26, 26, 30, 21, 20, 33, 35, 37, 50, + 30, 33, 21, 38, 235, 37, 48, 35, 53, 53, + + 35, 234, 20, 97, 48, 231, 38, 65, 65, 69, + 69, 70, 81, 70, 70, 230, 65, 81, 69, 97, + 97, 50, 70, 71, 65, 71, 69, 226, 71, 71, + 70, 108, 225, 108, 112, 112, 108, 108, 222, 113, + 221, 113, 219, 112, 113, 113, 114, 114, 115, 115, + 218, 112, 122, 122, 146, 146, 147, 147, 149, 217, + 149, 150, 150, 149, 149, 151, 151, 176, 176, 177, + 177, 239, 216, 239, 240, 240, 240, 241, 241, 241, + 242, 242, 242, 242, 242, 243, 213, 243, 243, 243, + 244, 244, 212, 211, 210, 209, 206, 205, 204, 203, + + 202, 200, 199, 198, 197, 195, 194, 193, 192, 191, + 190, 189, 188, 187, 186, 182, 181, 179, 175, 174, + 173, 172, 170, 169, 168, 167, 166, 165, 164, 162, + 161, 160, 158, 156, 155, 154, 153, 152, 144, 143, + 142, 141, 140, 139, 138, 137, 136, 135, 133, 132, + 131, 130, 129, 128, 126, 125, 124, 123, 121, 120, + 110, 109, 105, 103, 102, 101, 100, 99, 98, 96, + 95, 94, 93, 92, 91, 90, 88, 87, 86, 85, + 84, 82, 80, 79, 77, 73, 66, 58, 47, 46, + 45, 44, 43, 42, 41, 40, 39, 36, 34, 32, + + 31, 25, 14, 10, 7, 3, 238, 238, 238, 238, + 238, 238, 238, 238, 238, 238, 238, 238, 238, 238, + 238, 238, 238, 238, 238, 238, 238, 238, 238, 238, + 238, 238, 238, 238, 238, 238, 238, 238, 238, 238, + 238, 238, 238, 238, 238, 238, 238, 238, 238, 238, + 238, 238, 238, 238, 238, 238, 238, 238, 238, 238, + 238, 238, 238 } ; /* Table of booleans, true if rule could match eol. */ -static yyconst flex_int32_t yy_rule_can_match_eol[93] = +static yyconst flex_int32_t yy_rule_can_match_eol[90] = { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 0, 0, }; + 0, 0, 0, 0, 0, 0, 1, 1, 0, 0, }; /* The intent behind this definition is that it'll catch * any uses of REJECT which flex missed. @@ -647,7 +644,7 @@ static yyconst flex_int32_t yy_rule_can_match_eol[93] = */ #define YY_NO_UNISTD_H 1 -#line 645 "lex.sksl.c" +#line 642 "lex.sksl.c" #define INITIAL 0 @@ -676,7 +673,7 @@ struct yyguts_t size_t yy_buffer_stack_max; /**< capacity of stack. */ YY_BUFFER_STATE * yy_buffer_stack; /**< Stack as an array. */ char yy_hold_char; - yy_size_t yy_n_chars; + int yy_n_chars; yy_size_t yyleng_r; char *yy_c_buf_p; int yy_init; @@ -718,11 +715,11 @@ void skslset_extra (YY_EXTRA_TYPE user_defined ,yyscan_t yyscanner ); FILE *skslget_in (yyscan_t yyscanner ); -void skslset_in (FILE * in_str ,yyscan_t yyscanner ); +void skslset_in (FILE * _in_str ,yyscan_t yyscanner ); FILE *skslget_out (yyscan_t yyscanner ); -void skslset_out (FILE * out_str ,yyscan_t yyscanner ); +void skslset_out (FILE * _out_str ,yyscan_t yyscanner ); yy_size_t skslget_leng (yyscan_t yyscanner ); @@ -730,11 +727,11 @@ char *skslget_text (yyscan_t yyscanner ); int skslget_lineno (yyscan_t yyscanner ); -void skslset_lineno (int line_number ,yyscan_t yyscanner ); +void skslset_lineno (int _line_number ,yyscan_t yyscanner ); int skslget_column (yyscan_t yyscanner ); -void skslset_column (int column_no ,yyscan_t yyscanner ); +void skslset_column (int _column_no ,yyscan_t yyscanner ); /* Macros after this point can all be overridden by user definitions in * section 1. @@ -748,8 +745,12 @@ extern int skslwrap (yyscan_t yyscanner ); #endif #endif +#ifndef YY_NO_UNPUT + static void yyunput (int c,char *buf_ptr ,yyscan_t yyscanner); +#endif + #ifndef yytext_ptr static void yy_flex_strncpy (char *,yyconst char *,int ,yyscan_t yyscanner); #endif @@ -862,7 +863,7 @@ extern int sksllex (yyscan_t yyscanner); /* Code executed at the end of each rule. */ #ifndef YY_BREAK -#define YY_BREAK break; +#define YY_BREAK /*LINTED*/break; #endif #define YY_RULE_SETUP \ @@ -872,9 +873,9 @@ extern int sksllex (yyscan_t yyscanner); */ YY_DECL { - register yy_state_type yy_current_state; - register char *yy_cp, *yy_bp; - register int yy_act; + yy_state_type yy_current_state; + char *yy_cp, *yy_bp; + int yy_act; struct yyguts_t * yyg = (struct yyguts_t*)yyscanner; if ( !yyg->yy_init ) @@ -907,9 +908,9 @@ YY_DECL #line 23 "sksl.flex" -#line 905 "lex.sksl.c" +#line 906 "lex.sksl.c" - while ( 1 ) /* loops until end-of-file is reached */ + while ( /*CONSTCOND*/1 ) /* loops until end-of-file is reached */ { yy_cp = yyg->yy_c_buf_p; @@ -925,7 +926,7 @@ YY_DECL yy_match: do { - register YY_CHAR yy_c = yy_ec[YY_SC_TO_UI(*yy_cp)] ; + YY_CHAR yy_c = yy_ec[YY_SC_TO_UI(*yy_cp)] ; if ( yy_accept[yy_current_state] ) { yyg->yy_last_accepting_state = yy_current_state; @@ -934,13 +935,13 @@ yy_match: while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state ) { yy_current_state = (int) yy_def[yy_current_state]; - if ( yy_current_state >= 253 ) + if ( yy_current_state >= 239 ) yy_c = yy_meta[(unsigned int) yy_c]; } yy_current_state = yy_nxt[yy_base[yy_current_state] + (unsigned int) yy_c]; ++yy_cp; } - while ( yy_current_state != 252 ); + while ( yy_current_state != 238 ); yy_cp = yyg->yy_last_accepting_cpos; yy_current_state = yyg->yy_last_accepting_state; @@ -1035,406 +1036,391 @@ YY_RULE_SETUP case 13: YY_RULE_SETUP #line 49 "sksl.flex" -{ return SkSL::Token::SWITCH; } +{ return SkSL::Token::BREAK; } YY_BREAK case 14: YY_RULE_SETUP #line 51 "sksl.flex" -{ return SkSL::Token::CASE; } +{ return SkSL::Token::CONTINUE; } YY_BREAK case 15: YY_RULE_SETUP #line 53 "sksl.flex" -{ return SkSL::Token::DEFAULT; } +{ return SkSL::Token::DISCARD; } YY_BREAK case 16: YY_RULE_SETUP #line 55 "sksl.flex" -{ return SkSL::Token::BREAK; } +{ return SkSL::Token::RETURN; } YY_BREAK case 17: YY_RULE_SETUP #line 57 "sksl.flex" -{ return SkSL::Token::CONTINUE; } +{ return SkSL::Token::IN; } YY_BREAK case 18: YY_RULE_SETUP #line 59 "sksl.flex" -{ return SkSL::Token::DISCARD; } +{ return SkSL::Token::OUT; } YY_BREAK case 19: YY_RULE_SETUP #line 61 "sksl.flex" -{ return SkSL::Token::RETURN; } +{ return SkSL::Token::INOUT; } YY_BREAK case 20: YY_RULE_SETUP #line 63 "sksl.flex" -{ return SkSL::Token::IN; } +{ return SkSL::Token::UNIFORM; } YY_BREAK case 21: YY_RULE_SETUP #line 65 "sksl.flex" -{ return SkSL::Token::OUT; } +{ return SkSL::Token::CONST; } YY_BREAK case 22: YY_RULE_SETUP #line 67 "sksl.flex" -{ return SkSL::Token::INOUT; } +{ return SkSL::Token::LOWP; } YY_BREAK case 23: YY_RULE_SETUP #line 69 "sksl.flex" -{ return SkSL::Token::UNIFORM; } +{ return SkSL::Token::MEDIUMP; } YY_BREAK case 24: YY_RULE_SETUP #line 71 "sksl.flex" -{ return SkSL::Token::CONST; } +{ return SkSL::Token::HIGHP; } YY_BREAK case 25: YY_RULE_SETUP #line 73 "sksl.flex" -{ return SkSL::Token::LOWP; } +{ return SkSL::Token::FLAT; } YY_BREAK case 26: YY_RULE_SETUP #line 75 "sksl.flex" -{ return SkSL::Token::MEDIUMP; } +{ return SkSL::Token::NOPERSPECTIVE; } YY_BREAK case 27: YY_RULE_SETUP #line 77 "sksl.flex" -{ return SkSL::Token::HIGHP; } +{ return SkSL::Token::READONLY; } YY_BREAK case 28: YY_RULE_SETUP #line 79 "sksl.flex" -{ return SkSL::Token::FLAT; } +{ return SkSL::Token::WRITEONLY; } YY_BREAK case 29: YY_RULE_SETUP #line 81 "sksl.flex" -{ return SkSL::Token::NOPERSPECTIVE; } +{ return SkSL::Token::COHERENT; } YY_BREAK case 30: YY_RULE_SETUP #line 83 "sksl.flex" -{ return SkSL::Token::READONLY; } +{ return SkSL::Token::VOLATILE; } YY_BREAK case 31: YY_RULE_SETUP #line 85 "sksl.flex" -{ return SkSL::Token::WRITEONLY; } +{ return SkSL::Token::RESTRICT; } YY_BREAK case 32: YY_RULE_SETUP #line 87 "sksl.flex" -{ return SkSL::Token::COHERENT; } +{ return SkSL::Token::STRUCT; } YY_BREAK case 33: YY_RULE_SETUP #line 89 "sksl.flex" -{ return SkSL::Token::VOLATILE; } +{ return SkSL::Token::LAYOUT; } YY_BREAK case 34: YY_RULE_SETUP #line 91 "sksl.flex" -{ return SkSL::Token::RESTRICT; } +{ return SkSL::Token::PRECISION; } YY_BREAK case 35: YY_RULE_SETUP #line 93 "sksl.flex" -{ return SkSL::Token::STRUCT; } +{ return SkSL::Token::IDENTIFIER; } YY_BREAK case 36: YY_RULE_SETUP #line 95 "sksl.flex" -{ return SkSL::Token::LAYOUT; } +{ return SkSL::Token::DIRECTIVE; } YY_BREAK case 37: YY_RULE_SETUP #line 97 "sksl.flex" -{ return SkSL::Token::PRECISION; } +{ return SkSL::Token::LPAREN; } YY_BREAK case 38: YY_RULE_SETUP #line 99 "sksl.flex" -{ return SkSL::Token::IDENTIFIER; } +{ return SkSL::Token::RPAREN; } YY_BREAK case 39: YY_RULE_SETUP #line 101 "sksl.flex" -{ return SkSL::Token::DIRECTIVE; } +{ return SkSL::Token::LBRACE; } YY_BREAK case 40: YY_RULE_SETUP #line 103 "sksl.flex" -{ return SkSL::Token::LPAREN; } +{ return SkSL::Token::RBRACE; } YY_BREAK case 41: YY_RULE_SETUP #line 105 "sksl.flex" -{ return SkSL::Token::RPAREN; } +{ return SkSL::Token::LBRACKET; } YY_BREAK case 42: YY_RULE_SETUP #line 107 "sksl.flex" -{ return SkSL::Token::LBRACE; } +{ return SkSL::Token::RBRACKET; } YY_BREAK case 43: YY_RULE_SETUP #line 109 "sksl.flex" -{ return SkSL::Token::RBRACE; } +{ return SkSL::Token::DOT; } YY_BREAK case 44: YY_RULE_SETUP #line 111 "sksl.flex" -{ return SkSL::Token::LBRACKET; } +{ return SkSL::Token::COMMA; } YY_BREAK case 45: YY_RULE_SETUP #line 113 "sksl.flex" -{ return SkSL::Token::RBRACKET; } +{ return SkSL::Token::PLUSPLUS; } YY_BREAK case 46: YY_RULE_SETUP #line 115 "sksl.flex" -{ return SkSL::Token::DOT; } +{ return SkSL::Token::MINUSMINUS; } YY_BREAK case 47: YY_RULE_SETUP #line 117 "sksl.flex" -{ return SkSL::Token::COMMA; } +{ return SkSL::Token::PLUS; } YY_BREAK case 48: YY_RULE_SETUP #line 119 "sksl.flex" -{ return SkSL::Token::PLUSPLUS; } +{ return SkSL::Token::MINUS; } YY_BREAK case 49: YY_RULE_SETUP #line 121 "sksl.flex" -{ return SkSL::Token::MINUSMINUS; } +{ return SkSL::Token::STAR; } YY_BREAK case 50: YY_RULE_SETUP #line 123 "sksl.flex" -{ return SkSL::Token::PLUS; } +{ return SkSL::Token::SLASH; } YY_BREAK case 51: YY_RULE_SETUP #line 125 "sksl.flex" -{ return SkSL::Token::MINUS; } +{ return SkSL::Token::PERCENT; } YY_BREAK case 52: YY_RULE_SETUP #line 127 "sksl.flex" -{ return SkSL::Token::STAR; } +{ return SkSL::Token::SHL; } YY_BREAK case 53: YY_RULE_SETUP #line 129 "sksl.flex" -{ return SkSL::Token::SLASH; } +{ return SkSL::Token::SHR; } YY_BREAK case 54: YY_RULE_SETUP #line 131 "sksl.flex" -{ return SkSL::Token::PERCENT; } +{ return SkSL::Token::BITWISEOR; } YY_BREAK case 55: YY_RULE_SETUP #line 133 "sksl.flex" -{ return SkSL::Token::SHL; } +{ return SkSL::Token::BITWISEXOR; } YY_BREAK case 56: YY_RULE_SETUP #line 135 "sksl.flex" -{ return SkSL::Token::SHR; } +{ return SkSL::Token::BITWISEAND; } YY_BREAK case 57: YY_RULE_SETUP #line 137 "sksl.flex" -{ return SkSL::Token::BITWISEOR; } +{ return SkSL::Token::BITWISENOT; } YY_BREAK case 58: YY_RULE_SETUP #line 139 "sksl.flex" -{ return SkSL::Token::BITWISEXOR; } +{ return SkSL::Token::LOGICALOR; } YY_BREAK case 59: YY_RULE_SETUP #line 141 "sksl.flex" -{ return SkSL::Token::BITWISEAND; } +{ return SkSL::Token::LOGICALXOR; } YY_BREAK case 60: YY_RULE_SETUP #line 143 "sksl.flex" -{ return SkSL::Token::BITWISENOT; } +{ return SkSL::Token::LOGICALAND; } YY_BREAK case 61: YY_RULE_SETUP #line 145 "sksl.flex" -{ return SkSL::Token::LOGICALOR; } +{ return SkSL::Token::LOGICALNOT; } YY_BREAK case 62: YY_RULE_SETUP #line 147 "sksl.flex" -{ return SkSL::Token::LOGICALXOR; } +{ return SkSL::Token::QUESTION; } YY_BREAK case 63: YY_RULE_SETUP #line 149 "sksl.flex" -{ return SkSL::Token::LOGICALAND; } +{ return SkSL::Token::COLON; } YY_BREAK case 64: YY_RULE_SETUP #line 151 "sksl.flex" -{ return SkSL::Token::LOGICALNOT; } +{ return SkSL::Token::EQ; } YY_BREAK case 65: YY_RULE_SETUP #line 153 "sksl.flex" -{ return SkSL::Token::QUESTION; } +{ return SkSL::Token::EQEQ; } YY_BREAK case 66: YY_RULE_SETUP #line 155 "sksl.flex" -{ return SkSL::Token::COLON; } +{ return SkSL::Token::NEQ; } YY_BREAK case 67: YY_RULE_SETUP #line 157 "sksl.flex" -{ return SkSL::Token::EQ; } +{ return SkSL::Token::GT; } YY_BREAK case 68: YY_RULE_SETUP #line 159 "sksl.flex" -{ return SkSL::Token::EQEQ; } +{ return SkSL::Token::LT; } YY_BREAK case 69: YY_RULE_SETUP #line 161 "sksl.flex" -{ return SkSL::Token::NEQ; } +{ return SkSL::Token::GTEQ; } YY_BREAK case 70: YY_RULE_SETUP #line 163 "sksl.flex" -{ return SkSL::Token::GT; } +{ return SkSL::Token::LTEQ; } YY_BREAK case 71: YY_RULE_SETUP #line 165 "sksl.flex" -{ return SkSL::Token::LT; } +{ return SkSL::Token::PLUSEQ; } YY_BREAK case 72: YY_RULE_SETUP #line 167 "sksl.flex" -{ return SkSL::Token::GTEQ; } +{ return SkSL::Token::MINUSEQ; } YY_BREAK case 73: YY_RULE_SETUP #line 169 "sksl.flex" -{ return SkSL::Token::LTEQ; } +{ return SkSL::Token::STAREQ; } YY_BREAK case 74: YY_RULE_SETUP #line 171 "sksl.flex" -{ return SkSL::Token::PLUSEQ; } +{ return SkSL::Token::SLASHEQ; } YY_BREAK case 75: YY_RULE_SETUP #line 173 "sksl.flex" -{ return SkSL::Token::MINUSEQ; } +{ return SkSL::Token::PERCENTEQ; } YY_BREAK case 76: YY_RULE_SETUP #line 175 "sksl.flex" -{ return SkSL::Token::STAREQ; } +{ return SkSL::Token::SHLEQ; } YY_BREAK case 77: YY_RULE_SETUP #line 177 "sksl.flex" -{ return SkSL::Token::SLASHEQ; } +{ return SkSL::Token::SHREQ; } YY_BREAK case 78: YY_RULE_SETUP #line 179 "sksl.flex" -{ return SkSL::Token::PERCENTEQ; } +{ return SkSL::Token::BITWISEOREQ; } YY_BREAK case 79: YY_RULE_SETUP #line 181 "sksl.flex" -{ return SkSL::Token::SHLEQ; } +{ return SkSL::Token::BITWISEXOREQ; } YY_BREAK case 80: YY_RULE_SETUP #line 183 "sksl.flex" -{ return SkSL::Token::SHREQ; } +{ return SkSL::Token::BITWISEANDEQ; } YY_BREAK case 81: YY_RULE_SETUP #line 185 "sksl.flex" -{ return SkSL::Token::BITWISEOREQ; } +{ return SkSL::Token::LOGICALOREQ; } YY_BREAK case 82: YY_RULE_SETUP #line 187 "sksl.flex" -{ return SkSL::Token::BITWISEXOREQ; } +{ return SkSL::Token::LOGICALXOREQ; } YY_BREAK case 83: YY_RULE_SETUP #line 189 "sksl.flex" -{ return SkSL::Token::BITWISEANDEQ; } +{ return SkSL::Token::LOGICALANDEQ; } YY_BREAK case 84: YY_RULE_SETUP #line 191 "sksl.flex" -{ return SkSL::Token::LOGICALOREQ; } +{ return SkSL::Token::SEMICOLON; } YY_BREAK case 85: YY_RULE_SETUP #line 193 "sksl.flex" -{ return SkSL::Token::LOGICALXOREQ; } +/* line comment */ YY_BREAK case 86: +/* rule 86 can match eol */ YY_RULE_SETUP #line 195 "sksl.flex" -{ return SkSL::Token::LOGICALANDEQ; } +/* block comment */ YY_BREAK case 87: +/* rule 87 can match eol */ YY_RULE_SETUP #line 197 "sksl.flex" -{ return SkSL::Token::SEMICOLON; } +/* whitespace */ YY_BREAK case 88: YY_RULE_SETUP #line 199 "sksl.flex" -/* line comment */ +{ return SkSL::Token::INVALID_TOKEN; } YY_BREAK case 89: -/* rule 89 can match eol */ YY_RULE_SETUP #line 201 "sksl.flex" -/* block comment */ - YY_BREAK -case 90: -/* rule 90 can match eol */ -YY_RULE_SETUP -#line 203 "sksl.flex" -/* whitespace */ - YY_BREAK -case 91: -YY_RULE_SETUP -#line 205 "sksl.flex" -{ return SkSL::Token::INVALID_TOKEN; } - YY_BREAK -case 92: -YY_RULE_SETUP -#line 207 "sksl.flex" ECHO; YY_BREAK -#line 1432 "lex.sksl.c" +#line 1418 "lex.sksl.c" case YY_STATE_EOF(INITIAL): yyterminate(); @@ -1579,9 +1565,9 @@ case YY_STATE_EOF(INITIAL): static int yy_get_next_buffer (yyscan_t yyscanner) { struct yyguts_t * yyg = (struct yyguts_t*)yyscanner; - register char *dest = YY_CURRENT_BUFFER_LVALUE->yy_ch_buf; - register char *source = yyg->yytext_ptr; - register int number_to_move, i; + char *dest = YY_CURRENT_BUFFER_LVALUE->yy_ch_buf; + char *source = yyg->yytext_ptr; + yy_size_t number_to_move, i; int ret_val; if ( yyg->yy_c_buf_p > &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[yyg->yy_n_chars + 1] ) @@ -1610,7 +1596,7 @@ static int yy_get_next_buffer (yyscan_t yyscanner) /* Try to read more data. */ /* First move last chars to start of buffer. */ - number_to_move = (int) (yyg->yy_c_buf_p - yyg->yytext_ptr) - 1; + number_to_move = (yy_size_t) (yyg->yy_c_buf_p - yyg->yytext_ptr) - 1; for ( i = 0; i < number_to_move; ++i ) *(dest++) = *(source++); @@ -1692,9 +1678,9 @@ static int yy_get_next_buffer (yyscan_t yyscanner) else ret_val = EOB_ACT_CONTINUE_SCAN; - if ((yy_size_t) (yyg->yy_n_chars + number_to_move) > YY_CURRENT_BUFFER_LVALUE->yy_buf_size) { + if ((int) (yyg->yy_n_chars + number_to_move) > YY_CURRENT_BUFFER_LVALUE->yy_buf_size) { /* Extend the array by 50%, plus the number we really need. */ - yy_size_t new_size = yyg->yy_n_chars + number_to_move + (yyg->yy_n_chars >> 1); + int new_size = yyg->yy_n_chars + number_to_move + (yyg->yy_n_chars >> 1); YY_CURRENT_BUFFER_LVALUE->yy_ch_buf = (char *) skslrealloc((void *) YY_CURRENT_BUFFER_LVALUE->yy_ch_buf,new_size ,yyscanner ); if ( ! YY_CURRENT_BUFFER_LVALUE->yy_ch_buf ) YY_FATAL_ERROR( "out of dynamic memory in yy_get_next_buffer()" ); @@ -1713,15 +1699,15 @@ static int yy_get_next_buffer (yyscan_t yyscanner) static yy_state_type yy_get_previous_state (yyscan_t yyscanner) { - register yy_state_type yy_current_state; - register char *yy_cp; + yy_state_type yy_current_state; + char *yy_cp; struct yyguts_t * yyg = (struct yyguts_t*)yyscanner; yy_current_state = yyg->yy_start; for ( yy_cp = yyg->yytext_ptr + YY_MORE_ADJ; yy_cp < yyg->yy_c_buf_p; ++yy_cp ) { - register YY_CHAR yy_c = (*yy_cp ? yy_ec[YY_SC_TO_UI(*yy_cp)] : 1); + YY_CHAR yy_c = (*yy_cp ? yy_ec[YY_SC_TO_UI(*yy_cp)] : 1); if ( yy_accept[yy_current_state] ) { yyg->yy_last_accepting_state = yy_current_state; @@ -1730,7 +1716,7 @@ static int yy_get_next_buffer (yyscan_t yyscanner) while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state ) { yy_current_state = (int) yy_def[yy_current_state]; - if ( yy_current_state >= 253 ) + if ( yy_current_state >= 239 ) yy_c = yy_meta[(unsigned int) yy_c]; } yy_current_state = yy_nxt[yy_base[yy_current_state] + (unsigned int) yy_c]; @@ -1746,11 +1732,11 @@ static int yy_get_next_buffer (yyscan_t yyscanner) */ static yy_state_type yy_try_NUL_trans (yy_state_type yy_current_state , yyscan_t yyscanner) { - register int yy_is_jam; + int yy_is_jam; struct yyguts_t * yyg = (struct yyguts_t*)yyscanner; /* This var may be unused depending upon options. */ - register char *yy_cp = yyg->yy_c_buf_p; + char *yy_cp = yyg->yy_c_buf_p; - register YY_CHAR yy_c = 1; + YY_CHAR yy_c = 1; if ( yy_accept[yy_current_state] ) { yyg->yy_last_accepting_state = yy_current_state; @@ -1759,19 +1745,21 @@ static int yy_get_next_buffer (yyscan_t yyscanner) while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state ) { yy_current_state = (int) yy_def[yy_current_state]; - if ( yy_current_state >= 253 ) + if ( yy_current_state >= 239 ) yy_c = yy_meta[(unsigned int) yy_c]; } yy_current_state = yy_nxt[yy_base[yy_current_state] + (unsigned int) yy_c]; - yy_is_jam = (yy_current_state == 252); + yy_is_jam = (yy_current_state == 238); (void)yyg; return yy_is_jam ? 0 : yy_current_state; } - static void yyunput (int c, register char * yy_bp , yyscan_t yyscanner) +#ifndef YY_NO_UNPUT + + static void yyunput (int c, char * yy_bp , yyscan_t yyscanner) { - register char *yy_cp; + char *yy_cp; struct yyguts_t * yyg = (struct yyguts_t*)yyscanner; yy_cp = yyg->yy_c_buf_p; @@ -1782,10 +1770,10 @@ static int yy_get_next_buffer (yyscan_t yyscanner) if ( yy_cp < YY_CURRENT_BUFFER_LVALUE->yy_ch_buf + 2 ) { /* need to shift things up to make room */ /* +2 for EOB chars. */ - register yy_size_t number_to_move = yyg->yy_n_chars + 2; - register char *dest = &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[ + yy_size_t number_to_move = yyg->yy_n_chars + 2; + char *dest = &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[ YY_CURRENT_BUFFER_LVALUE->yy_buf_size + 2]; - register char *source = + char *source = &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[number_to_move]; while ( source > YY_CURRENT_BUFFER_LVALUE->yy_ch_buf ) @@ -1811,6 +1799,8 @@ static int yy_get_next_buffer (yyscan_t yyscanner) yyg->yy_c_buf_p = yy_cp; } +#endif + #ifndef YY_NO_INPUT #ifdef __cplusplus static int yyinput (yyscan_t yyscanner) @@ -1971,7 +1961,7 @@ static void sksl_load_buffer_state (yyscan_t yyscanner) if ( ! b ) YY_FATAL_ERROR( "out of dynamic memory in sksl_create_buffer()" ); - b->yy_buf_size = size; + b->yy_buf_size = (yy_size_t)size; /* yy_ch_buf has to be 2 characters longer than the size given because * we need to put in 2 end-of-buffer characters. @@ -2132,7 +2122,7 @@ static void skslensure_buffer_stack (yyscan_t yyscanner) * scanner will even need a stack. We use 2 instead of 1 to avoid an * immediate realloc on the next call. */ - num_to_alloc = 1; + num_to_alloc = 1; /* After all that talk, this was set to 1 anyways... */ yyg->yy_buffer_stack = (struct yy_buffer_state**)skslalloc (num_to_alloc * sizeof(struct yy_buffer_state*) , yyscanner); @@ -2149,7 +2139,7 @@ static void skslensure_buffer_stack (yyscan_t yyscanner) if (yyg->yy_buffer_stack_top >= (yyg->yy_buffer_stack_max) - 1){ /* Increase the buffer to prepare for a possible push. */ - int grow_size = 8 /* arbitrary grow size */; + yy_size_t grow_size = 8 /* arbitrary grow size */; num_to_alloc = yyg->yy_buffer_stack_max + grow_size; yyg->yy_buffer_stack = (struct yy_buffer_state**)skslrealloc @@ -2257,7 +2247,9 @@ YY_BUFFER_STATE sksl_scan_bytes (yyconst char * yybytes, yy_size_t _yybytes_le static void yy_fatal_error (yyconst char* msg , yyscan_t yyscanner) { - (void) fprintf( stderr, "%s\n", msg ); + struct yyguts_t * yyg = (struct yyguts_t*)yyscanner; + (void)yyg; + (void) fprintf( stderr, "%s\n", msg ); exit( YY_EXIT_FAILURE ); } @@ -2363,10 +2355,10 @@ void skslset_extra (YY_EXTRA_TYPE user_defined , yyscan_t yyscanner) } /** Set the current line number. - * @param line_number + * @param _line_number line number * @param yyscanner The scanner object. */ -void skslset_lineno (int line_number , yyscan_t yyscanner) +void skslset_lineno (int _line_number , yyscan_t yyscanner) { struct yyguts_t * yyg = (struct yyguts_t*)yyscanner; @@ -2374,14 +2366,14 @@ void skslset_lineno (int line_number , yyscan_t yyscanner) if (! YY_CURRENT_BUFFER ) YY_FATAL_ERROR( "skslset_lineno called with no buffer" ); - yylineno = line_number; + yylineno = _line_number; } /** Set the current column. - * @param line_number + * @param _column_no column number * @param yyscanner The scanner object. */ -void skslset_column (int column_no , yyscan_t yyscanner) +void skslset_column (int _column_no , yyscan_t yyscanner) { struct yyguts_t * yyg = (struct yyguts_t*)yyscanner; @@ -2389,25 +2381,25 @@ void skslset_column (int column_no , yyscan_t yyscanner) if (! YY_CURRENT_BUFFER ) YY_FATAL_ERROR( "skslset_column called with no buffer" ); - yycolumn = column_no; + yycolumn = _column_no; } /** Set the input stream. This does not discard the current * input buffer. - * @param in_str A readable stream. + * @param _in_str A readable stream. * @param yyscanner The scanner object. * @see sksl_switch_to_buffer */ -void skslset_in (FILE * in_str , yyscan_t yyscanner) +void skslset_in (FILE * _in_str , yyscan_t yyscanner) { struct yyguts_t * yyg = (struct yyguts_t*)yyscanner; - yyin = in_str ; + yyin = _in_str ; } -void skslset_out (FILE * out_str , yyscan_t yyscanner) +void skslset_out (FILE * _out_str , yyscan_t yyscanner) { struct yyguts_t * yyg = (struct yyguts_t*)yyscanner; - yyout = out_str ; + yyout = _out_str ; } int skslget_debug (yyscan_t yyscanner) @@ -2416,10 +2408,10 @@ int skslget_debug (yyscan_t yyscanner) return yy_flex_debug; } -void skslset_debug (int bdebug , yyscan_t yyscanner) +void skslset_debug (int _bdebug , yyscan_t yyscanner) { struct yyguts_t * yyg = (struct yyguts_t*)yyscanner; - yy_flex_debug = bdebug ; + yy_flex_debug = _bdebug ; } /* Accessor methods for yylval and yylloc */ @@ -2558,7 +2550,10 @@ int sksllex_destroy (yyscan_t yyscanner) #ifndef yytext_ptr static void yy_flex_strncpy (char* s1, yyconst char * s2, int n , yyscan_t yyscanner) { - register int i; + struct yyguts_t * yyg = (struct yyguts_t*)yyscanner; + (void)yyg; + + int i; for ( i = 0; i < n; ++i ) s1[i] = s2[i]; } @@ -2567,7 +2562,7 @@ static void yy_flex_strncpy (char* s1, yyconst char * s2, int n , yyscan_t yysca #ifdef YY_NEED_STRLEN static int yy_flex_strlen (yyconst char * s , yyscan_t yyscanner) { - register int n; + int n; for ( n = 0; s[n]; ++n ) ; @@ -2577,11 +2572,16 @@ static int yy_flex_strlen (yyconst char * s , yyscan_t yyscanner) void *skslalloc (yy_size_t size , yyscan_t yyscanner) { + struct yyguts_t * yyg = (struct yyguts_t*)yyscanner; + (void)yyg; return (void *) malloc( size ); } void *skslrealloc (void * ptr, yy_size_t size , yyscan_t yyscanner) { + struct yyguts_t * yyg = (struct yyguts_t*)yyscanner; + (void)yyg; + /* The cast to (char *) in the following accommodates both * implementations that use char* generic pointers, and those * that use void* generic pointers. It works with the latter @@ -2594,12 +2594,14 @@ void *skslrealloc (void * ptr, yy_size_t size , yyscan_t yyscanner) void skslfree (void * ptr , yyscan_t yyscanner) { + struct yyguts_t * yyg = (struct yyguts_t*)yyscanner; + (void)yyg; free( (char *) ptr ); /* see skslrealloc() for (char *) cast */ } #define YYTABLES_NAME "yytables" -#line 206 "sksl.flex" +#line 201 "sksl.flex" diff --git a/src/sksl/sksl.flex b/src/sksl/sksl.flex index adecbcf62f..25216bd607 100644 --- a/src/sksl/sksl.flex +++ b/src/sksl/sksl.flex @@ -46,12 +46,6 @@ while { return SkSL::Token::WHILE; } do { return SkSL::Token::DO; } -switch { return SkSL::Token::SWITCH; } - -case { return SkSL::Token::CASE; } - -default { return SkSL::Token::DEFAULT; } - break { return SkSL::Token::BREAK; } continue { return SkSL::Token::CONTINUE; } -- cgit v1.2.3