blob: beae5ad4532f9312e7705e60789f430843197f34 [file] [log] [blame]
/*
* Copyright 2021 Google LLC.
*
* Use of this source code is governed by a BSD-style license that can be
* found in the LICENSE file.
*/
#include "src/sksl/SkSLParser.h"
#include "include/core/SkSpan.h"
#include "include/private/SkSLModifiers.h"
#include "include/private/SkSLProgramElement.h"
#include "include/private/SkSLString.h"
#include "include/private/SkTHash.h"
#include "include/sksl/DSLBlock.h"
#include "include/sksl/DSLCase.h"
#include "include/sksl/DSLFunction.h"
#include "include/sksl/DSLSymbols.h"
#include "include/sksl/DSLVar.h"
#include "include/sksl/SkSLOperator.h"
#include "include/sksl/SkSLVersion.h"
#include "src/sksl/SkSLCompiler.h"
#include "src/sksl/SkSLConstantFolder.h"
#include "src/sksl/SkSLParsedModule.h"
#include "src/sksl/SkSLThreadContext.h"
#include "src/sksl/dsl/priv/DSLWriter.h"
#include "src/sksl/dsl/priv/DSL_priv.h"
#include "src/sksl/ir/SkSLExpression.h"
#include "src/sksl/ir/SkSLProgram.h"
#include <algorithm>
#include <climits>
#include <initializer_list>
#include <memory>
#include <type_traits>
#include <utility>
#include <vector>
using namespace SkSL::dsl;
namespace SkSL {
static constexpr int kMaxParseDepth = 50;
static int parse_modifier_token(Token::Kind token) {
switch (token) {
case Token::Kind::TK_UNIFORM: return Modifiers::kUniform_Flag;
case Token::Kind::TK_CONST: return Modifiers::kConst_Flag;
case Token::Kind::TK_IN: return Modifiers::kIn_Flag;
case Token::Kind::TK_OUT: return Modifiers::kOut_Flag;
case Token::Kind::TK_INOUT: return Modifiers::kIn_Flag | Modifiers::kOut_Flag;
case Token::Kind::TK_FLAT: return Modifiers::kFlat_Flag;
case Token::Kind::TK_NOPERSPECTIVE: return Modifiers::kNoPerspective_Flag;
case Token::Kind::TK_PURE: return Modifiers::kPure_Flag;
case Token::Kind::TK_INLINE: return Modifiers::kInline_Flag;
case Token::Kind::TK_NOINLINE: return Modifiers::kNoInline_Flag;
case Token::Kind::TK_HIGHP: return Modifiers::kHighp_Flag;
case Token::Kind::TK_MEDIUMP: return Modifiers::kMediump_Flag;
case Token::Kind::TK_LOWP: return Modifiers::kLowp_Flag;
case Token::Kind::TK_ES3: return Modifiers::kES3_Flag;
case Token::Kind::TK_THREADGROUP: return Modifiers::kThreadgroup_Flag;
case Token::Kind::TK_READONLY: return Modifiers::kReadOnly_Flag;
case Token::Kind::TK_WRITEONLY: return Modifiers::kWriteOnly_Flag;
case Token::Kind::TK_BUFFER: return Modifiers::kBuffer_Flag;
default: return 0;
}
}
class AutoDepth {
public:
AutoDepth(Parser* p)
: fParser(p)
, fDepth(0) {}
~AutoDepth() {
fParser->fDepth -= fDepth;
}
bool increase() {
++fDepth;
++fParser->fDepth;
if (fParser->fDepth > kMaxParseDepth) {
fParser->error(fParser->peek(), "exceeded max parse depth");
fParser->fEncounteredFatalError = true;
return false;
}
return true;
}
private:
Parser* fParser;
int fDepth;
};
class AutoSymbolTable {
public:
AutoSymbolTable() {
dsl::PushSymbolTable();
}
~AutoSymbolTable() {
dsl::PopSymbolTable();
}
};
Parser::Parser(Compiler* compiler,
const ProgramSettings& settings,
ProgramKind kind,
std::string text)
: fCompiler(*compiler)
, fSettings(settings)
, fKind(kind)
, fText(std::make_unique<std::string>(std::move(text)))
, fPushback(Token::Kind::TK_NONE, /*offset=*/-1, /*length=*/-1) {
fLexer.start(*fText);
}
Token Parser::nextRawToken() {
Token token;
if (fPushback.fKind != Token::Kind::TK_NONE) {
// Retrieve the token from the pushback buffer.
token = fPushback;
fPushback.fKind = Token::Kind::TK_NONE;
} else {
// Fetch a token from the lexer.
token = fLexer.next();
// Some tokens are always invalid, so we detect and report them here.
switch (token.fKind) {
case Token::Kind::TK_RESERVED:
this->error(token, "'" + std::string(this->text(token)) + "' is a reserved word");
token.fKind = Token::Kind::TK_IDENTIFIER; // reduces additional follow-up errors
break;
case Token::Kind::TK_BAD_OCTAL:
this->error(token, "'" + std::string(this->text(token)) +
"' is not a valid octal number");
break;
default:
break;
}
}
return token;
}
static bool is_whitespace(Token::Kind kind) {
switch (kind) {
case Token::Kind::TK_WHITESPACE:
case Token::Kind::TK_LINE_COMMENT:
case Token::Kind::TK_BLOCK_COMMENT:
return true;
default:
return false;
}
}
bool Parser::expectNewline() {
Token token = this->nextRawToken();
if (token.fKind == Token::Kind::TK_WHITESPACE) {
// The lexer doesn't distinguish newlines from other forms of whitespace, so we check
// for newlines by searching through the token text.
std::string_view tokenText = this->text(token);
if (tokenText.find_first_of('\r') != std::string_view::npos ||
tokenText.find_first_of('\n') != std::string_view::npos) {
return true;
}
}
// We didn't find a newline.
this->pushback(token);
return false;
}
Token Parser::nextToken() {
for (;;) {
Token token = this->nextRawToken();
if (!is_whitespace(token.fKind)) {
return token;
}
}
}
void Parser::pushback(Token t) {
SkASSERT(fPushback.fKind == Token::Kind::TK_NONE);
fPushback = std::move(t);
}
Token Parser::peek() {
if (fPushback.fKind == Token::Kind::TK_NONE) {
fPushback = this->nextToken();
}
return fPushback;
}
bool Parser::checkNext(Token::Kind kind, Token* result) {
if (fPushback.fKind != Token::Kind::TK_NONE && fPushback.fKind != kind) {
return false;
}
Token next = this->nextToken();
if (next.fKind == kind) {
if (result) {
*result = next;
}
return true;
}
this->pushback(std::move(next));
return false;
}
bool Parser::expect(Token::Kind kind, const char* expected, Token* result) {
Token next = this->nextToken();
if (next.fKind == kind) {
if (result) {
*result = std::move(next);
}
return true;
} else {
this->error(next, "expected " + std::string(expected) + ", but found '" +
std::string(this->text(next)) + "'");
this->fEncounteredFatalError = true;
return false;
}
}
bool Parser::expectIdentifier(Token* result) {
if (!this->expect(Token::Kind::TK_IDENTIFIER, "an identifier", result)) {
return false;
}
if (CurrentSymbolTable()->isBuiltinType(this->text(*result))) {
this->error(*result, "expected an identifier, but found type '" +
std::string(this->text(*result)) + "'");
this->fEncounteredFatalError = true;
return false;
}
return true;
}
bool Parser::checkIdentifier(Token* result) {
if (!this->checkNext(Token::Kind::TK_IDENTIFIER, result)) {
return false;
}
if (CurrentSymbolTable()->isBuiltinType(this->text(*result))) {
this->pushback(std::move(*result));
return false;
}
return true;
}
std::string_view Parser::text(Token token) {
return std::string_view(fText->data() + token.fOffset, token.fLength);
}
Position Parser::position(Token t) {
if (t.fOffset >= 0) {
return Position::Range(t.fOffset, t.fOffset + t.fLength);
} else {
return Position();
}
}
void Parser::error(Token token, std::string_view msg) {
this->error(this->position(token), msg);
}
void Parser::error(Position position, std::string_view msg) {
GetErrorReporter().error(position, msg);
}
Position Parser::rangeFrom(Position start) {
int offset = fPushback.fKind != Token::Kind::TK_NONE ? fPushback.fOffset
: fLexer.getCheckpoint().fOffset;
return Position::Range(start.startOffset(), offset);
}
Position Parser::rangeFrom(Token start) {
return this->rangeFrom(this->position(start));
}
/* declaration* END_OF_FILE */
std::unique_ptr<Program> Parser::program() {
ErrorReporter* errorReporter = &fCompiler.errorReporter();
Start(&fCompiler, fKind, fSettings);
SetErrorReporter(errorReporter);
errorReporter->setSource(*fText);
this->declarations();
std::unique_ptr<Program> result;
if (!GetErrorReporter().errorCount()) {
result = dsl::ReleaseProgram(std::move(fText));
}
errorReporter->setSource(std::string_view());
End();
return result;
}
SkSL::LoadedModule Parser::moduleInheritingFrom(SkSL::ParsedModule baseModule) {
ErrorReporter* errorReporter = &fCompiler.errorReporter();
StartModule(&fCompiler, fKind, fSettings, std::move(baseModule));
SetErrorReporter(errorReporter);
errorReporter->setSource(*fText);
this->declarations();
CurrentSymbolTable()->takeOwnershipOfString(std::move(*fText));
SkSL::LoadedModule result{ fKind, CurrentSymbolTable(),
std::move(ThreadContext::ProgramElements()) };
errorReporter->setSource(std::string_view());
End();
return result;
}
void Parser::declarations() {
fEncounteredFatalError = false;
// Any #version directive must appear as the first thing in a file
if (this->peek().fKind == Token::Kind::TK_DIRECTIVE) {
this->directive(/*allowVersion=*/true);
}
bool done = false;
while (!done) {
switch (this->peek().fKind) {
case Token::Kind::TK_END_OF_FILE:
done = true;
break;
case Token::Kind::TK_DIRECTIVE:
this->directive(/*allowVersion=*/false);
break;
case Token::Kind::TK_INVALID:
this->error(this->peek(), "invalid token");
this->nextToken();
done = true;
break;
default:
this->declaration();
done = fEncounteredFatalError;
break;
}
}
}
/* DIRECTIVE(#extension) IDENTIFIER COLON IDENTIFIER NEWLINE |
DIRECTIVE(#version) INTLITERAL NEWLINE */
void Parser::directive(bool allowVersion) {
Token start;
if (!this->expect(Token::Kind::TK_DIRECTIVE, "a directive", &start)) {
return;
}
std::string_view text = this->text(start);
const bool allowExtensions = !ProgramConfig::IsRuntimeEffect(fKind);
if (text == "#extension" && allowExtensions) {
Token name;
if (!this->expectIdentifier(&name)) {
return;
}
if (!this->expect(Token::Kind::TK_COLON, "':'")) {
return;
}
Token behavior;
if (!this->expect(Token::Kind::TK_IDENTIFIER, "an identifier", &behavior)) {
return;
}
std::string_view behaviorText = this->text(behavior);
if (behaviorText != "disable") {
if (behaviorText == "require" || behaviorText == "enable" || behaviorText == "warn") {
// We don't currently do anything different between require, enable, and warn
dsl::AddExtension(this->text(name));
} else {
this->error(behavior, "expected 'require', 'enable', 'warn', or 'disable'");
}
}
// We expect a newline after an #extension directive.
if (!this->expectNewline()) {
this->error(start, "invalid #extension directive");
}
} else if (text == "#version") {
if (!allowVersion) {
this->error(start, "#version directive must appear before anything else");
return;
}
SKSL_INT version;
if (!this->intLiteral(&version)) {
return;
}
switch (version) {
case 100:
ThreadContext::GetProgramConfig()->fRequiredSkSLVersion = Version::k100;
break;
case 300:
ThreadContext::GetProgramConfig()->fRequiredSkSLVersion = Version::k300;
break;
default:
this->error(start, "unsupported version number");
return;
}
// We expect a newline after a #version directive.
if (!this->expectNewline()) {
this->error(start, "invalid #version directive");
}
} else {
this->error(start, "unsupported directive '" + std::string(this->text(start)) + "'");
}
}
/* modifiers (structVarDeclaration | type IDENTIFIER ((LPAREN parameter (COMMA parameter)* RPAREN
(block | SEMICOLON)) | SEMICOLON) | interfaceBlock) */
bool Parser::declaration() {
Token start = this->peek();
if (start.fKind == Token::Kind::TK_SEMICOLON) {
this->nextToken();
this->error(start, "expected a declaration, but found ';'");
return false;
}
DSLModifiers modifiers = this->modifiers();
Token lookahead = this->peek();
if (lookahead.fKind == Token::Kind::TK_IDENTIFIER &&
!CurrentSymbolTable()->isType(this->text(lookahead))) {
// we have an identifier that's not a type, could be the start of an interface block
return this->interfaceBlock(modifiers);
}
if (lookahead.fKind == Token::Kind::TK_SEMICOLON) {
this->nextToken();
Declare(modifiers, this->position(start));
return true;
}
if (lookahead.fKind == Token::Kind::TK_STRUCT) {
this->structVarDeclaration(this->position(start), modifiers);
return true;
}
DSLType type = this->type(&modifiers);
if (!type.hasValue()) {
return false;
}
Token name;
if (!this->expectIdentifier(&name)) {
return false;
}
if (this->checkNext(Token::Kind::TK_LPAREN)) {
return this->functionDeclarationEnd(this->position(start), modifiers, type, name);
} else {
this->globalVarDeclarationEnd(this->position(start), modifiers, type, name);
return true;
}
}
/* (RPAREN | VOID RPAREN | parameter (COMMA parameter)* RPAREN) (block | SEMICOLON) */
bool Parser::functionDeclarationEnd(Position start,
DSLModifiers& modifiers,
DSLType type,
const Token& name) {
SkSTArray<8, DSLParameter> parameters;
Token lookahead = this->peek();
if (lookahead.fKind == Token::Kind::TK_RPAREN) {
// `()` means no parameters at all.
} else if (lookahead.fKind == Token::Kind::TK_IDENTIFIER && this->text(lookahead) == "void") {
// `(void)` also means no parameters at all.
this->nextToken();
} else {
for (;;) {
size_t paramIndex = parameters.size();
std::optional<DSLParameter> parameter = this->parameter(paramIndex);
if (!parameter) {
return false;
}
parameters.push_back(std::move(*parameter));
if (!this->checkNext(Token::Kind::TK_COMMA)) {
break;
}
}
}
if (!this->expect(Token::Kind::TK_RPAREN, "')'")) {
return false;
}
SkSTArray<8, DSLParameter*> parameterPointers;
parameterPointers.reserve_back(parameters.size());
for (DSLParameter& param : parameters) {
parameterPointers.push_back(&param);
}
DSLFunction result(this->text(name), modifiers, type, parameterPointers,
this->rangeFrom(start));
const bool hasFunctionBody = !this->checkNext(Token::Kind::TK_SEMICOLON);
if (hasFunctionBody) {
AutoSymbolTable symbols;
for (DSLParameter* var : parameterPointers) {
AddToSymbolTable(*var);
}
Token bodyStart = this->peek();
std::optional<DSLBlock> body = this->block();
if (!body) {
return false;
}
result.define(std::move(*body), this->rangeFrom(bodyStart));
} else {
result.prototype();
}
return true;
}
bool Parser::arraySize(SKSL_INT* outResult) {
// Start out with a safe value that won't generate any errors downstream
*outResult = 1;
Token next = this->peek();
if (next.fKind == Token::Kind::TK_RBRACKET) {
this->error(this->position(next), "unsized arrays are not permitted here");
return true;
}
DSLExpression sizeExpr = this->expression();
if (!sizeExpr.hasValue()) {
return false;
}
if (sizeExpr.isValid()) {
std::unique_ptr<SkSL::Expression> sizeLiteral = sizeExpr.release();
SKSL_INT size;
if (!ConstantFolder::GetConstantInt(*sizeLiteral, &size)) {
this->error(sizeLiteral->fPosition, "array size must be an integer");
return true;
}
if (size > INT32_MAX) {
this->error(sizeLiteral->fPosition, "array size out of bounds");
return true;
}
if (size <= 0) {
this->error(sizeLiteral->fPosition, "array size must be positive");
return true;
}
// Now that we've validated it, output the real value
*outResult = size;
}
return true;
}
bool Parser::parseArrayDimensions(Position pos, DSLType* type) {
Token next;
while (this->checkNext(Token::Kind::TK_LBRACKET, &next)) {
if (this->checkNext(Token::Kind::TK_RBRACKET)) {
if (this->allowUnsizedArrays()) {
*type = UnsizedArray(*type, this->rangeFrom(pos));
} else {
this->error(this->rangeFrom(pos), "unsized arrays are not permitted here");
}
} else {
SKSL_INT size;
if (!this->arraySize(&size)) {
return false;
}
if (!this->expect(Token::Kind::TK_RBRACKET, "']'")) {
return false;
}
*type = Array(*type, size, this->rangeFrom(pos));
}
}
return true;
}
bool Parser::parseInitializer(Position pos, DSLExpression* initializer) {
if (this->checkNext(Token::Kind::TK_EQ)) {
DSLExpression value = this->assignmentExpression();
if (!value.hasValue()) {
return false;
}
initializer->swap(value);
}
return true;
}
/* (LBRACKET expression? RBRACKET)* (EQ assignmentExpression)? (COMMA IDENTIFER
(LBRACKET expression? RBRACKET)* (EQ assignmentExpression)?)* SEMICOLON */
void Parser::globalVarDeclarationEnd(Position pos,
const dsl::DSLModifiers& mods,
dsl::DSLType baseType,
Token name) {
using namespace dsl;
DSLType type = baseType;
DSLExpression initializer;
if (!this->parseArrayDimensions(pos, &type)) {
return;
}
if (!this->parseInitializer(pos, &initializer)) {
return;
}
DSLGlobalVar first(mods, type, this->text(name), std::move(initializer), this->rangeFrom(pos),
this->position(name));
Declare(first);
AddToSymbolTable(first);
while (this->checkNext(Token::Kind::TK_COMMA)) {
type = baseType;
Token identifierName;
if (!this->expectIdentifier(&identifierName)) {
return;
}
if (!this->parseArrayDimensions(pos, &type)) {
return;
}
DSLExpression anotherInitializer;
if (!this->parseInitializer(pos, &anotherInitializer)) {
return;
}
DSLGlobalVar next(mods, type, this->text(identifierName), std::move(anotherInitializer),
this->rangeFrom(identifierName));
Declare(next);
AddToSymbolTable(next, this->position(identifierName));
}
this->expect(Token::Kind::TK_SEMICOLON, "';'");
}
/* (LBRACKET expression? RBRACKET)* (EQ assignmentExpression)? (COMMA IDENTIFER
(LBRACKET expression? RBRACKET)* (EQ assignmentExpression)?)* SEMICOLON */
DSLStatement Parser::localVarDeclarationEnd(Position pos,
const dsl::DSLModifiers& mods,
dsl::DSLType baseType,
Token name) {
using namespace dsl;
DSLType type = baseType;
DSLExpression initializer;
if (!this->parseArrayDimensions(pos, &type)) {
return {};
}
if (!this->parseInitializer(pos, &initializer)) {
return {};
}
DSLVar first(mods, type, this->text(name), std::move(initializer), this->rangeFrom(pos),
this->position(name));
DSLStatement result = Declare(first);
AddToSymbolTable(first);
while (this->checkNext(Token::Kind::TK_COMMA)) {
type = baseType;
Token identifierName;
if (!this->expectIdentifier(&identifierName)) {
return result;
}
if (!this->parseArrayDimensions(pos, &type)) {
return result;
}
DSLExpression anotherInitializer;
if (!this->parseInitializer(pos, &anotherInitializer)) {
return result;
}
DSLVar next(mods, type, this->text(identifierName), std::move(anotherInitializer),
this->rangeFrom(identifierName), this->position(identifierName));
DSLWriter::AddVarDeclaration(result, next);
AddToSymbolTable(next, this->position(identifierName));
}
this->expect(Token::Kind::TK_SEMICOLON, "';'");
result.setPosition(this->rangeFrom(pos));
return result;
}
/* (varDeclarations | expressionStatement) */
DSLStatement Parser::varDeclarationsOrExpressionStatement() {
Token nextToken = this->peek();
if (nextToken.fKind == Token::Kind::TK_CONST) {
// Statements that begin with `const` might be variable declarations, but can't be legal
// SkSL expression-statements. (SkSL constructors don't take a `const` modifier.)
return this->varDeclarations();
}
if (nextToken.fKind == Token::Kind::TK_HIGHP ||
nextToken.fKind == Token::Kind::TK_MEDIUMP ||
nextToken.fKind == Token::Kind::TK_LOWP ||
CurrentSymbolTable()->isType(this->text(nextToken))) {
// Statements that begin with a typename are most often variable declarations, but
// occasionally the type is part of a constructor, and these are actually expression-
// statements in disguise. First, attempt the common case: parse it as a vardecl.
Checkpoint checkpoint(this);
VarDeclarationsPrefix prefix;
if (this->varDeclarationsPrefix(&prefix)) {
checkpoint.accept();
return this->localVarDeclarationEnd(prefix.fPosition, prefix.fModifiers, prefix.fType,
prefix.fName);
}
// If this statement wasn't actually a vardecl after all, rewind and try parsing it as an
// expression-statement instead.
checkpoint.rewind();
}
return this->expressionStatement();
}
// Helper function for varDeclarations(). If this function succeeds, we assume that the rest of the
// statement is a variable-declaration statement, not an expression-statement.
bool Parser::varDeclarationsPrefix(VarDeclarationsPrefix* prefixData) {
prefixData->fPosition = this->position(this->peek());
prefixData->fModifiers = this->modifiers();
prefixData->fType = this->type(&prefixData->fModifiers);
if (!prefixData->fType.hasValue()) {
return false;
}
return this->expectIdentifier(&prefixData->fName);
}
/* modifiers type IDENTIFIER varDeclarationEnd */
DSLStatement Parser::varDeclarations() {
VarDeclarationsPrefix prefix;
if (!this->varDeclarationsPrefix(&prefix)) {
return {};
}
return this->localVarDeclarationEnd(prefix.fPosition, prefix.fModifiers, prefix.fType,
prefix.fName);
}
/* STRUCT IDENTIFIER LBRACE varDeclaration* RBRACE */
DSLType Parser::structDeclaration() {
Position start = this->position(this->peek());
if (!this->expect(Token::Kind::TK_STRUCT, "'struct'")) {
return DSLType(nullptr);
}
Token name;
if (!this->expectIdentifier(&name)) {
return DSLType(nullptr);
}
if (!this->expect(Token::Kind::TK_LBRACE, "'{'")) {
return DSLType(nullptr);
}
AutoDepth depth(this);
if (!depth.increase()) {
return DSLType(nullptr);
}
SkTArray<DSLField> fields;
SkTHashSet<std::string_view> fieldNames;
while (!this->checkNext(Token::Kind::TK_RBRACE)) {
Token fieldStart = this->peek();
DSLModifiers modifiers = this->modifiers();
DSLType type = this->type(&modifiers);
if (!type.hasValue()) {
return DSLType(nullptr);
}
do {
DSLType actualType = type;
Token memberName;
if (!this->expectIdentifier(&memberName)) {
return DSLType(nullptr);
}
while (this->checkNext(Token::Kind::TK_LBRACKET)) {
SKSL_INT size;
if (!this->arraySize(&size)) {
return DSLType(nullptr);
}
if (!this->expect(Token::Kind::TK_RBRACKET, "']'")) {
return DSLType(nullptr);
}
actualType = dsl::Array(actualType, size,
this->rangeFrom(this->position(fieldStart)));
}
std::string_view nameText = this->text(memberName);
if (!fieldNames.contains(nameText)) {
fields.push_back(DSLField(modifiers,
std::move(actualType),
nameText,
this->rangeFrom(fieldStart)));
fieldNames.add(nameText);
} else {
this->error(memberName, "field '" + std::string(nameText) +
"' was already defined in the same struct ('" +
std::string(this->text(name)) + "')");
}
} while (this->checkNext(Token::Kind::TK_COMMA));
if (!this->expect(Token::Kind::TK_SEMICOLON, "';'")) {
return DSLType(nullptr);
}
}
if (fields.empty()) {
this->error(this->rangeFrom(start), "struct '" + std::string(this->text(name)) +
"' must contain at least one field");
}
return dsl::Struct(this->text(name), SkSpan(fields), this->rangeFrom(start));
}
/* structDeclaration ((IDENTIFIER varDeclarationEnd) | SEMICOLON) */
SkTArray<dsl::DSLGlobalVar> Parser::structVarDeclaration(Position start,
const DSLModifiers& modifiers) {
DSLType type = this->structDeclaration();
if (!type.hasValue()) {
return {};
}
Token name;
if (this->checkIdentifier(&name)) {
this->globalVarDeclarationEnd(this->rangeFrom(name), modifiers, type, name);
} else {
this->expect(Token::Kind::TK_SEMICOLON, "';'");
}
return {};
}
/* modifiers type IDENTIFIER (LBRACKET INT_LITERAL RBRACKET)? */
std::optional<DSLParameter> Parser::parameter(size_t paramIndex) {
Position pos = this->position(this->peek());
DSLModifiers modifiers = this->modifiers();
DSLType type = this->type(&modifiers);
if (!type.hasValue()) {
return std::nullopt;
}
Token name;
std::string_view paramText;
Position paramPos;
if (this->checkIdentifier(&name)) {
paramText = this->text(name);
paramPos = this->position(name);
} else {
std::string anonymousName = String::printf("_skAnonymousParam%zu", paramIndex);
paramText = *CurrentSymbolTable()->takeOwnershipOfString(std::move(anonymousName));
paramPos = this->rangeFrom(pos);
}
if (!this->parseArrayDimensions(pos, &type)) {
return std::nullopt;
}
return DSLParameter(modifiers, type, paramText, this->rangeFrom(pos), paramPos);
}
/** EQ INT_LITERAL */
int Parser::layoutInt() {
if (!this->expect(Token::Kind::TK_EQ, "'='")) {
return -1;
}
Token resultToken;
if (!this->expect(Token::Kind::TK_INT_LITERAL, "a non-negative integer", &resultToken)) {
return -1;
}
std::string_view resultFrag = this->text(resultToken);
SKSL_INT resultValue;
if (!SkSL::stoi(resultFrag, &resultValue)) {
this->error(resultToken, "value in layout is too large: " + std::string(resultFrag));
return -1;
}
return resultValue;
}
/** EQ IDENTIFIER */
std::string_view Parser::layoutIdentifier() {
if (!this->expect(Token::Kind::TK_EQ, "'='")) {
return {};
}
Token resultToken;
if (!this->expectIdentifier(&resultToken)) {
return {};
}
return this->text(resultToken);
}
/* LAYOUT LPAREN IDENTIFIER (EQ INT_LITERAL)? (COMMA IDENTIFIER (EQ INT_LITERAL)?)* RPAREN */
DSLLayout Parser::layout() {
enum class LayoutToken {
LOCATION,
OFFSET,
BINDING,
INDEX,
SET,
BUILTIN,
INPUT_ATTACHMENT_INDEX,
ORIGIN_UPPER_LEFT,
BLEND_SUPPORT_ALL_EQUATIONS,
PUSH_CONSTANT,
COLOR,
};
using LayoutMap = SkTHashMap<std::string_view, LayoutToken>;
static LayoutMap* sLayoutTokens = new LayoutMap{
{"location", LayoutToken::LOCATION},
{"offset", LayoutToken::OFFSET},
{"binding", LayoutToken::BINDING},
{"index", LayoutToken::INDEX},
{"set", LayoutToken::SET},
{"builtin", LayoutToken::BUILTIN},
{"input_attachment_index", LayoutToken::INPUT_ATTACHMENT_INDEX},
{"origin_upper_left", LayoutToken::ORIGIN_UPPER_LEFT},
{"blend_support_all_equations", LayoutToken::BLEND_SUPPORT_ALL_EQUATIONS},
{"push_constant", LayoutToken::PUSH_CONSTANT},
{"color", LayoutToken::COLOR},
};
DSLLayout result;
if (this->checkNext(Token::Kind::TK_LAYOUT)) {
if (!this->expect(Token::Kind::TK_LPAREN, "'('")) {
return result;
}
for (;;) {
Token t = this->nextToken();
std::string text(this->text(t));
LayoutToken* found = sLayoutTokens->find(text);
if (found != nullptr) {
switch (*found) {
case LayoutToken::ORIGIN_UPPER_LEFT:
result.originUpperLeft(this->position(t));
break;
case LayoutToken::PUSH_CONSTANT:
result.pushConstant(this->position(t));
break;
case LayoutToken::BLEND_SUPPORT_ALL_EQUATIONS:
result.blendSupportAllEquations(this->position(t));
break;
case LayoutToken::COLOR:
result.color(this->position(t));
break;
case LayoutToken::LOCATION:
result.location(this->layoutInt(), this->position(t));
break;
case LayoutToken::OFFSET:
result.offset(this->layoutInt(), this->position(t));
break;
case LayoutToken::BINDING:
result.binding(this->layoutInt(), this->position(t));
break;
case LayoutToken::INDEX:
result.index(this->layoutInt(), this->position(t));
break;
case LayoutToken::SET:
result.set(this->layoutInt(), this->position(t));
break;
case LayoutToken::BUILTIN:
result.builtin(this->layoutInt(), this->position(t));
break;
case LayoutToken::INPUT_ATTACHMENT_INDEX:
result.inputAttachmentIndex(this->layoutInt(), this->position(t));
break;
default:
this->error(t, "'" + text + "' is not a valid layout qualifier");
break;
}
} else {
this->error(t, "'" + text + "' is not a valid layout qualifier");
}
if (this->checkNext(Token::Kind::TK_RPAREN)) {
break;
}
if (!this->expect(Token::Kind::TK_COMMA, "','")) {
break;
}
}
}
return result;
}
/* layout? (UNIFORM | CONST | IN | OUT | INOUT | LOWP | MEDIUMP | HIGHP | FLAT | NOPERSPECTIVE |
VARYING | INLINE | THREADGROUP | READONLY | WRITEONLY | BUFFER)* */
DSLModifiers Parser::modifiers() {
int start = this->peek().fOffset;
DSLLayout layout = this->layout();
Token raw = this->nextRawToken();
int end = raw.fOffset;
if (!is_whitespace(raw.fKind)) {
this->pushback(raw);
}
int flags = 0;
for (;;) {
int tokenFlag = parse_modifier_token(peek().fKind);
if (!tokenFlag) {
break;
}
Token modifier = this->nextToken();
if (int duplicateFlags = (tokenFlag & flags)) {
this->error(modifier, "'" + Modifiers::DescribeFlags(duplicateFlags) +
"' appears more than once");
}
flags |= tokenFlag;
end = this->position(modifier).endOffset();
}
return DSLModifiers(std::move(layout), flags, Position::Range(start, end));
}
/* ifStatement | forStatement | doStatement | whileStatement | block | expression */
DSLStatement Parser::statement() {
Token start = this->nextToken();
AutoDepth depth(this);
if (!depth.increase()) {
return {};
}
this->pushback(start);
switch (start.fKind) {
case Token::Kind::TK_IF: // fall through
case Token::Kind::TK_STATIC_IF:
return this->ifStatement();
case Token::Kind::TK_FOR:
return this->forStatement();
case Token::Kind::TK_DO:
return this->doStatement();
case Token::Kind::TK_WHILE:
return this->whileStatement();
case Token::Kind::TK_SWITCH: // fall through
case Token::Kind::TK_STATIC_SWITCH:
return this->switchStatement();
case Token::Kind::TK_RETURN:
return this->returnStatement();
case Token::Kind::TK_BREAK:
return this->breakStatement();
case Token::Kind::TK_CONTINUE:
return this->continueStatement();
case Token::Kind::TK_DISCARD:
return this->discardStatement();
case Token::Kind::TK_LBRACE: {
std::optional<DSLBlock> result = this->block();
return result ? DSLStatement(std::move(*result)) : DSLStatement();
}
case Token::Kind::TK_SEMICOLON:
this->nextToken();
return DSLBlock();
case Token::Kind::TK_HIGHP:
case Token::Kind::TK_MEDIUMP:
case Token::Kind::TK_LOWP:
case Token::Kind::TK_CONST:
case Token::Kind::TK_IDENTIFIER:
return this->varDeclarationsOrExpressionStatement();
default:
return this->expressionStatement();
}
}
/* IDENTIFIER(type) (LBRACKET intLiteral? RBRACKET)* QUESTION? */
DSLType Parser::type(DSLModifiers* modifiers) {
Token type;
if (!this->expect(Token::Kind::TK_IDENTIFIER, "a type", &type)) {
return DSLType(nullptr);
}
if (!CurrentSymbolTable()->isType(this->text(type))) {
this->error(type, "no type named '" + std::string(this->text(type)) + "'");
return DSLType(nullptr);
}
DSLType result(this->text(type), modifiers, this->position(type));
Token bracket;
while (this->checkNext(Token::Kind::TK_LBRACKET, &bracket)) {
if (this->checkNext(Token::Kind::TK_RBRACKET)) {
if (this->allowUnsizedArrays()) {
result = UnsizedArray(result, this->rangeFrom(type));
} else {
this->error(this->rangeFrom(bracket), "unsized arrays are not permitted here");
}
} else {
SKSL_INT size;
if (!this->arraySize(&size)) {
return DSLType(nullptr);
}
this->expect(Token::Kind::TK_RBRACKET, "']'");
result = Array(result, size, this->rangeFrom(type));
}
}
return result;
}
/* IDENTIFIER LBRACE
varDeclaration+
RBRACE (IDENTIFIER (LBRACKET expression RBRACKET)*)? SEMICOLON */
bool Parser::interfaceBlock(const dsl::DSLModifiers& modifiers) {
Token typeName;
if (!this->expectIdentifier(&typeName)) {
return false;
}
if (this->peek().fKind != Token::Kind::TK_LBRACE) {
// we only get into interfaceBlock if we found a top-level identifier which was not a type.
// 99% of the time, the user was not actually intending to create an interface block, so
// it's better to report it as an unknown type
this->error(typeName, "no type named '" + std::string(this->text(typeName)) + "'");
return false;
}
this->nextToken();
SkTArray<DSLField> fields;
SkTHashSet<std::string_view> fieldNames;
while (!this->checkNext(Token::Kind::TK_RBRACE)) {
Position fieldPos = this->position(this->peek());
DSLModifiers fieldModifiers = this->modifiers();
DSLType type = this->type(&fieldModifiers);
if (!type.hasValue()) {
return false;
}
do {
Token fieldName;
if (!this->expectIdentifier(&fieldName)) {
return false;
}
DSLType actualType = type;
if (this->checkNext(Token::Kind::TK_LBRACKET)) {
Token sizeToken = this->peek();
if (sizeToken.fKind != Token::Kind::TK_RBRACKET) {
SKSL_INT size;
if (!this->arraySize(&size)) {
return false;
}
actualType = Array(std::move(actualType), size, this->position(typeName));
} else if (this->allowUnsizedArrays()) {
actualType = UnsizedArray(std::move(actualType), this->position(typeName));
} else {
this->error(sizeToken, "unsized arrays are not permitted here");
}
this->expect(Token::Kind::TK_RBRACKET, "']'");
}
if (!this->expect(Token::Kind::TK_SEMICOLON, "';'")) {
return false;
}
std::string_view nameText = this->text(fieldName);
if (!fieldNames.contains(nameText)) {
fields.push_back(DSLField(fieldModifiers,
std::move(actualType),
nameText,
this->rangeFrom(fieldPos)));
fieldNames.add(nameText);
} else {
this->error(fieldName, "field '" + std::string(nameText) +
"' was already defined in the same interface block ('" +
std::string(this->text(typeName)) + "')");
}
} while (this->checkNext(Token::Kind::TK_COMMA));
}
if (fields.empty()) {
this->error(this->rangeFrom(typeName), "interface block '" +
std::string(this->text(typeName)) + "' must contain at least one member");
}
std::string_view instanceName;
Token instanceNameToken;
SKSL_INT size = 0;
if (this->checkIdentifier(&instanceNameToken)) {
instanceName = this->text(instanceNameToken);
if (this->checkNext(Token::Kind::TK_LBRACKET)) {
if (!this->arraySize(&size)) {
return false;
}
this->expect(Token::Kind::TK_RBRACKET, "']'");
}
}
if (!fields.empty()) {
dsl::InterfaceBlock(modifiers, this->text(typeName), std::move(fields), instanceName,
size, this->position(typeName));
}
this->expect(Token::Kind::TK_SEMICOLON, "';'");
return true;
}
/* IF LPAREN expression RPAREN statement (ELSE statement)? */
DSLStatement Parser::ifStatement() {
Token start;
bool isStatic = this->checkNext(Token::Kind::TK_STATIC_IF, &start);
if (!isStatic && !this->expect(Token::Kind::TK_IF, "'if'", &start)) {
return {};
}
if (!this->expect(Token::Kind::TK_LPAREN, "'('")) {
return {};
}
DSLExpression test = this->expression();
if (!test.hasValue()) {
return {};
}
if (!this->expect(Token::Kind::TK_RPAREN, "')'")) {
return {};
}
DSLStatement ifTrue = this->statement();
if (!ifTrue.hasValue()) {
return {};
}
DSLStatement ifFalse;
if (this->checkNext(Token::Kind::TK_ELSE)) {
ifFalse = this->statement();
if (!ifFalse.hasValue()) {
return {};
}
}
Position pos = this->rangeFrom(start);
if (isStatic) {
return StaticIf(std::move(test), std::move(ifTrue),
ifFalse.hasValue() ? std::move(ifFalse) : DSLStatement(), pos);
} else {
return If(std::move(test), std::move(ifTrue),
ifFalse.hasValue() ? std::move(ifFalse) : DSLStatement(), pos);
}
}
/* DO statement WHILE LPAREN expression RPAREN SEMICOLON */
DSLStatement Parser::doStatement() {
Token start;
if (!this->expect(Token::Kind::TK_DO, "'do'", &start)) {
return {};
}
DSLStatement statement = this->statement();
if (!statement.hasValue()) {
return {};
}
if (!this->expect(Token::Kind::TK_WHILE, "'while'")) {
return {};
}
if (!this->expect(Token::Kind::TK_LPAREN, "'('")) {
return {};
}
DSLExpression test = this->expression();
if (!test.hasValue()) {
return {};
}
if (!this->expect(Token::Kind::TK_RPAREN, "')'")) {
return {};
}
if (!this->expect(Token::Kind::TK_SEMICOLON, "';'")) {
return {};
}
return Do(std::move(statement), std::move(test), this->rangeFrom(start));
}
/* WHILE LPAREN expression RPAREN STATEMENT */
DSLStatement Parser::whileStatement() {
Token start;
if (!this->expect(Token::Kind::TK_WHILE, "'while'", &start)) {
return {};
}
if (!this->expect(Token::Kind::TK_LPAREN, "'('")) {
return {};
}
DSLExpression test = this->expression();
if (!test.hasValue()) {
return {};
}
if (!this->expect(Token::Kind::TK_RPAREN, "')'")) {
return {};
}
DSLStatement statement = this->statement();
if (!statement.hasValue()) {
return {};
}
return While(std::move(test), std::move(statement), this->rangeFrom(start));
}
/* CASE expression COLON statement* */
std::optional<DSLCase> Parser::switchCase() {
Token start;
if (!this->expect(Token::Kind::TK_CASE, "'case'", &start)) {
return {};
}
DSLExpression value = this->expression();
if (!value.hasValue()) {
return {};
}
if (!this->expect(Token::Kind::TK_COLON, "':'")) {
return {};
}
SkTArray<DSLStatement> statements;
while (this->peek().fKind != Token::Kind::TK_RBRACE &&
this->peek().fKind != Token::Kind::TK_CASE &&
this->peek().fKind != Token::Kind::TK_DEFAULT) {
DSLStatement s = this->statement();
if (!s.hasValue()) {
return {};
}
statements.push_back(std::move(s));
}
return DSLCase(std::move(value), std::move(statements));
}
/* SWITCH LPAREN expression RPAREN LBRACE switchCase* (DEFAULT COLON statement*)? RBRACE */
DSLStatement Parser::switchStatement() {
Token start;
bool isStatic = this->checkNext(Token::Kind::TK_STATIC_SWITCH, &start);
if (!isStatic && !this->expect(Token::Kind::TK_SWITCH, "'switch'", &start)) {
return {};
}
if (!this->expect(Token::Kind::TK_LPAREN, "'('")) {
return {};
}
DSLExpression value = this->expression();
if (!value.hasValue()) {
return {};
}
if (!this->expect(Token::Kind::TK_RPAREN, "')'")) {
return {};
}
if (!this->expect(Token::Kind::TK_LBRACE, "'{'")) {
return {};
}
SkTArray<DSLCase> cases;
while (this->peek().fKind == Token::Kind::TK_CASE) {
std::optional<DSLCase> c = this->switchCase();
if (!c) {
return {};
}
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::Kind::TK_DEFAULT) {
SkTArray<DSLStatement> statements;
Token defaultStart;
SkAssertResult(this->expect(Token::Kind::TK_DEFAULT, "'default'", &defaultStart));
if (!this->expect(Token::Kind::TK_COLON, "':'")) {
return {};
}
while (this->peek().fKind != Token::Kind::TK_RBRACE) {
DSLStatement s = this->statement();
if (!s.hasValue()) {
return {};
}
statements.push_back(std::move(s));
}
cases.push_back(DSLCase(DSLExpression(), std::move(statements), this->position(start)));
}
if (!this->expect(Token::Kind::TK_RBRACE, "'}'")) {
return {};
}
Position pos = this->rangeFrom(start);
if (isStatic) {
return StaticSwitch(std::move(value), std::move(cases), pos);
} else {
return Switch(std::move(value), std::move(cases), pos);
}
}
static Position range_of_at_least_one_char(int start, int end) {
return Position::Range(start, std::max(end, start + 1));
}
/* FOR LPAREN (declaration | expression)? SEMICOLON expression? SEMICOLON expression? RPAREN
STATEMENT */
dsl::DSLStatement Parser::forStatement() {
Token start;
if (!this->expect(Token::Kind::TK_FOR, "'for'", &start)) {
return {};
}
Token lparen;
if (!this->expect(Token::Kind::TK_LPAREN, "'('", &lparen)) {
return {};
}
AutoSymbolTable symbols;
dsl::DSLStatement initializer;
Token nextToken = this->peek();
int firstSemicolonOffset;
if (nextToken.fKind == Token::Kind::TK_SEMICOLON) {
// An empty init-statement.
firstSemicolonOffset = this->nextToken().fOffset;
} else {
// The init-statement must be an expression or variable declaration.
initializer = this->varDeclarationsOrExpressionStatement();
if (!initializer.hasValue()) {
return {};
}
firstSemicolonOffset = fLexer.getCheckpoint().fOffset - 1;
}
dsl::DSLExpression test;
if (this->peek().fKind != Token::Kind::TK_SEMICOLON) {
dsl::DSLExpression testValue = this->expression();
if (!testValue.hasValue()) {
return {};
}
test.swap(testValue);
}
Token secondSemicolon;
if (!this->expect(Token::Kind::TK_SEMICOLON, "';'", &secondSemicolon)) {
return {};
}
dsl::DSLExpression next;
if (this->peek().fKind != Token::Kind::TK_RPAREN) {
dsl::DSLExpression nextValue = this->expression();
if (!nextValue.hasValue()) {
return {};
}
next.swap(nextValue);
}
Token rparen;
if (!this->expect(Token::Kind::TK_RPAREN, "')'", &rparen)) {
return {};
}
dsl::DSLStatement statement = this->statement();
if (!statement.hasValue()) {
return {};
}
return For(initializer.hasValue() ? std::move(initializer) : DSLStatement(),
test.hasValue() ? std::move(test) : DSLExpression(),
next.hasValue() ? std::move(next) : DSLExpression(),
std::move(statement),
this->rangeFrom(start),
ForLoopPositions{
range_of_at_least_one_char(lparen.fOffset + 1, firstSemicolonOffset),
range_of_at_least_one_char(firstSemicolonOffset + 1, secondSemicolon.fOffset),
range_of_at_least_one_char(secondSemicolon.fOffset + 1, rparen.fOffset)
});
}
/* RETURN expression? SEMICOLON */
DSLStatement Parser::returnStatement() {
Token start;
if (!this->expect(Token::Kind::TK_RETURN, "'return'", &start)) {
return {};
}
DSLExpression expression;
if (this->peek().fKind != Token::Kind::TK_SEMICOLON) {
DSLExpression next = this->expression();
if (!next.hasValue()) {
return {};
}
expression.swap(next);
}
if (!this->expect(Token::Kind::TK_SEMICOLON, "';'")) {
return {};
}
return Return(expression.hasValue() ? std::move(expression) : DSLExpression(),
this->rangeFrom(start));
}
/* BREAK SEMICOLON */
DSLStatement Parser::breakStatement() {
Token start;
if (!this->expect(Token::Kind::TK_BREAK, "'break'", &start)) {
return {};
}
if (!this->expect(Token::Kind::TK_SEMICOLON, "';'")) {
return {};
}
return Break(this->position(start));
}
/* CONTINUE SEMICOLON */
DSLStatement Parser::continueStatement() {
Token start;
if (!this->expect(Token::Kind::TK_CONTINUE, "'continue'", &start)) {
return {};
}
if (!this->expect(Token::Kind::TK_SEMICOLON, "';'")) {
return {};
}
return Continue(this->position(start));
}
/* DISCARD SEMICOLON */
DSLStatement Parser::discardStatement() {
Token start;
if (!this->expect(Token::Kind::TK_DISCARD, "'continue'", &start)) {
return {};
}
if (!this->expect(Token::Kind::TK_SEMICOLON, "';'")) {
return {};
}
return Discard(this->position(start));
}
/* LBRACE statement* RBRACE */
std::optional<DSLBlock> Parser::block() {
Token start;
if (!this->expect(Token::Kind::TK_LBRACE, "'{'", &start)) {
return std::nullopt;
}
AutoDepth depth(this);
if (!depth.increase()) {
return std::nullopt;
}
AutoSymbolTable symbols;
StatementArray statements;
for (;;) {
switch (this->peek().fKind) {
case Token::Kind::TK_RBRACE:
this->nextToken();
return DSLBlock(std::move(statements), CurrentSymbolTable(),
this->rangeFrom(start));
case Token::Kind::TK_END_OF_FILE:
this->error(this->peek(), "expected '}', but found end of file");
return std::nullopt;
default: {
DSLStatement statement = this->statement();
if (fEncounteredFatalError) {
return std::nullopt;
}
if (statement.hasValue()) {
statements.push_back(statement.release());
}
break;
}
}
}
}
/* expression SEMICOLON */
DSLStatement Parser::expressionStatement() {
DSLExpression expr = this->expression();
if (expr.hasValue()) {
if (!this->expect(Token::Kind::TK_SEMICOLON, "';'")) {
return {};
}
return DSLStatement(std::move(expr));
}
return {};
}
bool Parser::operatorRight(AutoDepth& depth,
Operator::Kind op,
BinaryParseFn rightFn,
DSLExpression& result) {
this->nextToken();
if (!depth.increase()) {
return false;
}
DSLExpression right = (this->*rightFn)();
if (!right.hasValue()) {
return false;
}
Position pos = result.position().rangeThrough(right.position());
DSLExpression next = result.binary(op, std::move(right), pos);
result.swap(next);
return true;
}
/* assignmentExpression (COMMA assignmentExpression)* */
DSLExpression Parser::expression() {
[[maybe_unused]] Token start = this->peek();
DSLExpression result = this->assignmentExpression();
if (!result.hasValue()) {
return {};
}
Token t;
AutoDepth depth(this);
while (this->peek().fKind == Token::Kind::TK_COMMA) {
if (!operatorRight(depth, Operator::Kind::COMMA, &Parser::assignmentExpression,
result)) {
return {};
}
}
SkASSERTF(result.position().valid(), "Expression %s has invalid position",
result.description().c_str());
SkASSERTF(result.position().startOffset() == this->position(start).startOffset(),
"Expected %s to start at %d (first token: '%.*s'), but it has range %d-%d\n",
result.description().c_str(), this->position(start).startOffset(),
(int)this->text(start).length(), this->text(start).data(),
result.position().startOffset(), result.position().endOffset());
return result;
}
/* ternaryExpression ((EQEQ | STAREQ | SLASHEQ | PERCENTEQ | PLUSEQ | MINUSEQ | SHLEQ | SHREQ |
BITWISEANDEQ | BITWISEXOREQ | BITWISEOREQ | LOGICALANDEQ | LOGICALXOREQ | LOGICALOREQ)
assignmentExpression)*
*/
DSLExpression Parser::assignmentExpression() {
AutoDepth depth(this);
DSLExpression result = this->ternaryExpression();
if (!result.hasValue()) {
return {};
}
for (;;) {
switch (this->peek().fKind) {
case Token::Kind::TK_EQ:
if (!operatorRight(depth, Operator::Kind::EQ, &Parser::assignmentExpression,
result)) {
return {};
}
break;
case Token::Kind::TK_STAREQ:
if (!operatorRight(depth, Operator::Kind::STAREQ, &Parser::assignmentExpression,
result)) {
return {};
}
break;
case Token::Kind::TK_SLASHEQ:
if (!operatorRight(depth, Operator::Kind::SLASHEQ, &Parser::assignmentExpression,
result)) {
return {};
}
break;
case Token::Kind::TK_PERCENTEQ:
if (!operatorRight(depth, Operator::Kind::PERCENTEQ,
&Parser::assignmentExpression, result)) {
return {};
}
break;
case Token::Kind::TK_PLUSEQ:
if (!operatorRight(depth, Operator::Kind::PLUSEQ, &Parser::assignmentExpression,
result)) {
return {};
}
break;
case Token::Kind::TK_MINUSEQ:
if (!operatorRight(depth, Operator::Kind::MINUSEQ, &Parser::assignmentExpression,
result)) {
return {};
}
break;
case Token::Kind::TK_SHLEQ:
if (!operatorRight(depth, Operator::Kind::SHLEQ, &Parser::assignmentExpression,
result)) {
return {};
}
break;
case Token::Kind::TK_SHREQ:
if (!operatorRight(depth, Operator::Kind::SHREQ, &Parser::assignmentExpression,
result)) {
return {};
}
break;
case Token::Kind::TK_BITWISEANDEQ:
if (!operatorRight(depth, Operator::Kind::BITWISEANDEQ,
&Parser::assignmentExpression, result)) {
return {};
}
break;
case Token::Kind::TK_BITWISEXOREQ:
if (!operatorRight(depth, Operator::Kind::BITWISEXOREQ,
&Parser::assignmentExpression, result)) {
return {};
}
break;
case Token::Kind::TK_BITWISEOREQ:
if (!operatorRight(depth, Operator::Kind::BITWISEOREQ,
&Parser::assignmentExpression, result)) {
return {};
}
break;
default:
return result;
}
}
}
/* logicalOrExpression ('?' expression ':' assignmentExpression)? */
DSLExpression Parser::ternaryExpression() {
DSLExpression base = this->logicalOrExpression();
if (!base.hasValue()) {
return {};
}
if (!this->checkNext(Token::Kind::TK_QUESTION)) {
return base;
}
AutoDepth depth(this);
if (!depth.increase()) {
return {};
}
DSLExpression trueExpr = this->expression();
if (!trueExpr.hasValue()) {
return {};
}
if (!this->expect(Token::Kind::TK_COLON, "':'")) {
return {};
}
DSLExpression falseExpr = this->assignmentExpression();
if (!falseExpr.hasValue()) {
return {};
}
Position pos = base.position().rangeThrough(falseExpr.position());
return Select(std::move(base), std::move(trueExpr), std::move(falseExpr), pos);
}
/* logicalXorExpression (LOGICALOR logicalXorExpression)* */
DSLExpression Parser::logicalOrExpression() {
AutoDepth depth(this);
DSLExpression result = this->logicalXorExpression();
if (!result.hasValue()) {
return {};
}
while (this->peek().fKind == Token::Kind::TK_LOGICALOR) {
if (!operatorRight(depth, Operator::Kind::LOGICALOR, &Parser::logicalXorExpression,
result)) {
return {};
}
}
return result;
}
/* logicalAndExpression (LOGICALXOR logicalAndExpression)* */
DSLExpression Parser::logicalXorExpression() {
AutoDepth depth(this);
DSLExpression result = this->logicalAndExpression();
if (!result.hasValue()) {
return {};
}
while (this->peek().fKind == Token::Kind::TK_LOGICALXOR) {
if (!operatorRight(depth, Operator::Kind::LOGICALXOR, &Parser::logicalAndExpression,
result)) {
return {};
}
}
return result;
}
/* bitwiseOrExpression (LOGICALAND bitwiseOrExpression)* */
DSLExpression Parser::logicalAndExpression() {
AutoDepth depth(this);
DSLExpression result = this->bitwiseOrExpression();
if (!result.hasValue()) {
return {};
}
while (this->peek().fKind == Token::Kind::TK_LOGICALAND) {
if (!operatorRight(depth, Operator::Kind::LOGICALAND, &Parser::bitwiseOrExpression,
result)) {
return {};
}
}
return result;
}
/* bitwiseXorExpression (BITWISEOR bitwiseXorExpression)* */
DSLExpression Parser::bitwiseOrExpression() {
AutoDepth depth(this);
DSLExpression result = this->bitwiseXorExpression();
if (!result.hasValue()) {
return {};
}
while (this->peek().fKind == Token::Kind::TK_BITWISEOR) {
if (!operatorRight(depth, Operator::Kind::BITWISEOR, &Parser::bitwiseXorExpression,
result)) {
return {};
}
}
return result;
}
/* bitwiseAndExpression (BITWISEXOR bitwiseAndExpression)* */
DSLExpression Parser::bitwiseXorExpression() {
AutoDepth depth(this);
DSLExpression result = this->bitwiseAndExpression();
if (!result.hasValue()) {
return {};
}
while (this->peek().fKind == Token::Kind::TK_BITWISEXOR) {
if (!operatorRight(depth, Operator::Kind::BITWISEXOR, &Parser::bitwiseAndExpression,
result)) {
return {};
}
}
return result;
}
/* equalityExpression (BITWISEAND equalityExpression)* */
DSLExpression Parser::bitwiseAndExpression() {
AutoDepth depth(this);
DSLExpression result = this->equalityExpression();
if (!result.hasValue()) {
return {};
}
while (this->peek().fKind == Token::Kind::TK_BITWISEAND) {
if (!operatorRight(depth, Operator::Kind::BITWISEAND, &Parser::equalityExpression,
result)) {
return {};
}
}
return result;
}
/* relationalExpression ((EQEQ | NEQ) relationalExpression)* */
DSLExpression Parser::equalityExpression() {
AutoDepth depth(this);
DSLExpression result = this->relationalExpression();
if (!result.hasValue()) {
return {};
}
for (;;) {
switch (this->peek().fKind) {
case Token::Kind::TK_EQEQ:
if (!operatorRight(depth, Operator::Kind::EQEQ, &Parser::relationalExpression,
result)) {
return {};
}
break;
case Token::Kind::TK_NEQ:
if (!operatorRight(depth, Operator::Kind::NEQ, &Parser::relationalExpression,
result)) {
return {};
}
break;
default: return result;
}
}
}
/* shiftExpression ((LT | GT | LTEQ | GTEQ) shiftExpression)* */
DSLExpression Parser::relationalExpression() {
AutoDepth depth(this);
DSLExpression result = this->shiftExpression();
if (!result.hasValue()) {
return {};
}
for (;;) {
switch (this->peek().fKind) {
case Token::Kind::TK_LT:
if (!operatorRight(depth, Operator::Kind::LT, &Parser::shiftExpression,
result)) {
return {};
}
break;
case Token::Kind::TK_GT:
if (!operatorRight(depth, Operator::Kind::GT, &Parser::shiftExpression,
result)) {
return {};
}
break;
case Token::Kind::TK_LTEQ:
if (!operatorRight(depth, Operator::Kind::LTEQ, &Parser::shiftExpression,
result)) {
return {};
}
break;
case Token::Kind::TK_GTEQ:
if (!operatorRight(depth, Operator::Kind::GTEQ, &Parser::shiftExpression,
result)) {
return {};
}
break;
default:
return result;
}
}
}
/* additiveExpression ((SHL | SHR) additiveExpression)* */
DSLExpression Parser::shiftExpression() {
AutoDepth depth(this);
DSLExpression result = this->additiveExpression();
if (!result.hasValue()) {
return {};
}
for (;;) {
switch (this->peek().fKind) {
case Token::Kind::TK_SHL:
if (!operatorRight(depth, Operator::Kind::SHL, &Parser::additiveExpression,
result)) {
return {};
}
break;
case Token::Kind::TK_SHR:
if (!operatorRight(depth, Operator::Kind::SHR, &Parser::additiveExpression,
result)) {
return {};
}
break;
default:
return result;
}
}
}
/* multiplicativeExpression ((PLUS | MINUS) multiplicativeExpression)* */
DSLExpression Parser::additiveExpression() {
AutoDepth depth(this);
DSLExpression result = this->multiplicativeExpression();
if (!result.hasValue()) {
return {};
}
for (;;) {
switch (this->peek().fKind) {
case Token::Kind::TK_PLUS:
if (!operatorRight(depth, Operator::Kind::PLUS,
&Parser::multiplicativeExpression, result)) {
return {};
}
break;
case Token::Kind::TK_MINUS:
if (!operatorRight(depth, Operator::Kind::MINUS,
&Parser::multiplicativeExpression, result)) {
return {};
}
break;
default:
return result;
}
}
}
/* unaryExpression ((STAR | SLASH | PERCENT) unaryExpression)* */
DSLExpression Parser::multiplicativeExpression() {
AutoDepth depth(this);
DSLExpression result = this->unaryExpression();
if (!result.hasValue()) {
return {};
}
for (;;) {
switch (this->peek().fKind) {
case Token::Kind::TK_STAR:
if (!operatorRight(depth, Operator::Kind::STAR, &Parser::unaryExpression,
result)) {
return {};
}
break;
case Token::Kind::TK_SLASH:
if (!operatorRight(depth, Operator::Kind::SLASH, &Parser::unaryExpression,
result)) {
return {};
}
break;
case Token::Kind::TK_PERCENT:
if (!operatorRight(depth, Operator::Kind::PERCENT, &Parser::unaryExpression,
result)) {
return {};
}
break;
default: return result;
}
}
}
/* postfixExpression | (PLUS | MINUS | NOT | PLUSPLUS | MINUSMINUS) unaryExpression */
DSLExpression Parser::unaryExpression() {
AutoDepth depth(this);
Token start = this->peek();
switch (start.fKind) {
case Token::Kind::TK_PLUS:
case Token::Kind::TK_MINUS:
case Token::Kind::TK_LOGICALNOT:
case Token::Kind::TK_BITWISENOT:
case Token::Kind::TK_PLUSPLUS:
case Token::Kind::TK_MINUSMINUS: {
this->nextToken();
if (!depth.increase()) {
return {};
}
DSLExpression expr = this->unaryExpression();
if (!expr.hasValue()) {
return {};
}
Position p = Position::Range(start.fOffset, expr.position().endOffset());
switch (start.fKind) {
case Token::Kind::TK_PLUS: return expr.prefix(Operator::Kind::PLUS, p);
case Token::Kind::TK_MINUS: return expr.prefix(Operator::Kind::MINUS, p);
case Token::Kind::TK_LOGICALNOT: return expr.prefix(Operator::Kind::LOGICALNOT, p);
case Token::Kind::TK_BITWISENOT: return expr.prefix(Operator::Kind::BITWISENOT, p);
case Token::Kind::TK_PLUSPLUS: return expr.prefix(Operator::Kind::PLUSPLUS, p);
case Token::Kind::TK_MINUSMINUS: return expr.prefix(Operator::Kind::MINUSMINUS, p);
default: SkUNREACHABLE;
}
}
default:
return this->postfixExpression();
}
}
/* term suffix* */
DSLExpression Parser::postfixExpression() {
AutoDepth depth(this);
DSLExpression result = this->term();
if (!result.hasValue()) {
return {};
}
for (;;) {
Token t = this->peek();
switch (t.fKind) {
case Token::Kind::TK_FLOAT_LITERAL:
if (this->text(t)[0] != '.') {
return result;
}
[[fallthrough]];
case Token::Kind::TK_LBRACKET:
case Token::Kind::TK_DOT:
case Token::Kind::TK_LPAREN:
case Token::Kind::TK_PLUSPLUS:
case Token::Kind::TK_MINUSMINUS: {
if (!depth.increase()) {
return {};
}
DSLExpression next = this->suffix(std::move(result));
if (!next.hasValue()) {
return {};
}
result.swap(next);
break;
}
default:
return result;
}
}
}
DSLExpression Parser::swizzle(Position pos,
DSLExpression base,
std::string_view swizzleMask,
Position maskPos) {
SkASSERT(swizzleMask.length() > 0);
if (!base.type().isVector() && !base.type().isScalar()) {
return base.field(swizzleMask, pos);
}
int length = swizzleMask.length();
SkSL::SwizzleComponent::Type components[4];
for (int i = 0; i < length; ++i) {
if (i >= 4) {
Position errorPos = maskPos.valid() ? Position::Range(maskPos.startOffset() + 4,
maskPos.endOffset())
: pos;
this->error(errorPos, "too many components in swizzle mask");
return DSLExpression::Poison(pos);
}
switch (swizzleMask[i]) {
case '0': components[i] = SwizzleComponent::ZERO; break;
case '1': components[i] = SwizzleComponent::ONE; break;
case 'r': components[i] = SwizzleComponent::R; break;
case 'x': components[i] = SwizzleComponent::X; break;
case 's': components[i] = SwizzleComponent::S; break;
case 'L': components[i] = SwizzleComponent::UL; break;
case 'g': components[i] = SwizzleComponent::G; break;
case 'y': components[i] = SwizzleComponent::Y; break;
case 't': components[i] = SwizzleComponent::T; break;
case 'T': components[i] = SwizzleComponent::UT; break;
case 'b': components[i] = SwizzleComponent::B; break;
case 'z': components[i] = SwizzleComponent::Z; break;
case 'p': components[i] = SwizzleComponent::P; break;
case 'R': components[i] = SwizzleComponent::UR; break;
case 'a': components[i] = SwizzleComponent::A; break;
case 'w': components[i] = SwizzleComponent::W; break;
case 'q': components[i] = SwizzleComponent::Q; break;
case 'B': components[i] = SwizzleComponent::UB; break;
default: {
Position componentPos = Position::Range(maskPos.startOffset() + i,
maskPos.startOffset() + i + 1);
this->error(componentPos, String::printf("invalid swizzle component '%c'",
swizzleMask[i]).c_str());
return DSLExpression::Poison(pos);
}
}
}
switch (length) {
case 1: return dsl::Swizzle(std::move(base), components[0], pos, maskPos);
case 2: return dsl::Swizzle(std::move(base), components[0], components[1], pos, maskPos);
case 3: return dsl::Swizzle(std::move(base), components[0], components[1], components[2],
pos, maskPos);
case 4: return dsl::Swizzle(std::move(base), components[0], components[1], components[2],
components[3], pos, maskPos);
default: SkUNREACHABLE;
}
}
dsl::DSLExpression Parser::call(Position pos, dsl::DSLExpression base, ExpressionArray args) {
return base(std::move(args), pos);
}
/* LBRACKET expression? RBRACKET | DOT IDENTIFIER | LPAREN arguments RPAREN |
PLUSPLUS | MINUSMINUS | COLONCOLON IDENTIFIER | FLOAT_LITERAL [IDENTIFIER] */
DSLExpression Parser::suffix(DSLExpression base) {
Token next = this->nextToken();
AutoDepth depth(this);
if (!depth.increase()) {
return {};
}
switch (next.fKind) {
case Token::Kind::TK_LBRACKET: {
if (this->checkNext(Token::Kind::TK_RBRACKET)) {
this->error(this->rangeFrom(next), "missing index in '[]'");
return DSLExpression::Poison(this->rangeFrom(base.position()));
}
DSLExpression index = this->expression();
if (!index.hasValue()) {
return {};
}
this->expect(Token::Kind::TK_RBRACKET, "']' to complete array access expression");
return base.index(std::move(index), this->rangeFrom(base.position()));
}
case Token::Kind::TK_DOT: {
std::string_view text;
if (this->identifier(&text)) {
Position pos = this->rangeFrom(base.position());
return this->swizzle(pos, std::move(base), text,
this->rangeFrom(this->position(next).after()));
}
[[fallthrough]];
}
case Token::Kind::TK_FLOAT_LITERAL: {
// Swizzles that start with a constant number, e.g. '.000r', will be tokenized as
// floating point literals, possibly followed by an identifier. Handle that here.
std::string_view field = this->text(next);
SkASSERT(field[0] == '.');
field.remove_prefix(1);
// use the next *raw* token so we don't ignore whitespace - we only care about
// identifiers that directly follow the float
Position pos = this->rangeFrom(base.position());
Position start = this->position(next);
// skip past the "."
start = Position::Range(start.startOffset() + 1, start.endOffset());
Position maskPos = this->rangeFrom(start);
Token id = this->nextRawToken();
if (id.fKind == Token::Kind::TK_IDENTIFIER) {
pos = this->rangeFrom(base.position());
maskPos = this->rangeFrom(start);
return this->swizzle(pos, std::move(base), std::string(field) +
std::string(this->text(id)), maskPos);
} else if (field.empty()) {
this->error(pos, "expected field name or swizzle mask after '.'");
return {{DSLExpression::Poison(pos)}};
}
this->pushback(id);
return this->swizzle(pos, std::move(base), field, maskPos);
}
case Token::Kind::TK_LPAREN: {
ExpressionArray args;
if (this->peek().fKind != Token::Kind::TK_RPAREN) {
for (;;) {
DSLExpression expr = this->assignmentExpression();
if (!expr.hasValue()) {
return {};
}
args.push_back(expr.release());
if (!this->checkNext(Token::Kind::TK_COMMA)) {
break;
}
}
}
this->expect(Token::Kind::TK_RPAREN, "')' to complete function arguments");
Position pos = this->rangeFrom(base.position());
return this->call(pos, std::move(base), std::move(args));
}
case Token::Kind::TK_PLUSPLUS:
return base.postfix(Operator::Kind::PLUSPLUS, this->rangeFrom(base.position()));
case Token::Kind::TK_MINUSMINUS:
return base.postfix(Operator::Kind::MINUSMINUS, this->rangeFrom(base.position()));
default: {
this->error(next, "expected expression suffix, but found '" +
std::string(this->text(next)) + "'");
return {};
}
}
}
/* IDENTIFIER | intLiteral | floatLiteral | boolLiteral | '(' expression ')' */
DSLExpression Parser::term() {
Token t = this->peek();
switch (t.fKind) {
case Token::Kind::TK_IDENTIFIER: {
std::string_view text;
if (this->identifier(&text)) {
return dsl::Symbol(text, this->position(t));
}
break;
}
case Token::Kind::TK_INT_LITERAL: {
SKSL_INT i;
if (!this->intLiteral(&i)) {
i = 0;
}
return DSLExpression(i, this->position(t));
}
case Token::Kind::TK_FLOAT_LITERAL: {
SKSL_FLOAT f;
if (!this->floatLiteral(&f)) {
f = 0.0f;
}
return DSLExpression(f, this->position(t));
}
case Token::Kind::TK_TRUE_LITERAL: // fall through
case Token::Kind::TK_FALSE_LITERAL: {
bool b;
SkAssertResult(this->boolLiteral(&b));
return DSLExpression(b, this->position(t));
}
case Token::Kind::TK_LPAREN: {
this->nextToken();
AutoDepth depth(this);
if (!depth.increase()) {
return {};
}
DSLExpression result = this->expression();
if (result.hasValue()) {
this->expect(Token::Kind::TK_RPAREN, "')' to complete expression");
result.setPosition(this->rangeFrom(this->position(t)));
return result;
}
break;
}
default:
this->nextToken();
this->error(t, "expected expression, but found '" + std::string(this->text(t)) + "'");
fEncounteredFatalError = true;
break;
}
return {};
}
/* INT_LITERAL */
bool Parser::intLiteral(SKSL_INT* dest) {
Token t;
if (!this->expect(Token::Kind::TK_INT_LITERAL, "integer literal", &t)) {
return false;
}
std::string_view s = this->text(t);
if (!SkSL::stoi(s, dest)) {
this->error(t, "integer is too large: " + std::string(s));
return false;
}
return true;
}
/* FLOAT_LITERAL */
bool Parser::floatLiteral(SKSL_FLOAT* dest) {
Token t;
if (!this->expect(Token::Kind::TK_FLOAT_LITERAL, "float literal", &t)) {
return false;
}
std::string_view s = this->text(t);
if (!SkSL::stod(s, dest)) {
this->error(t, "floating-point value is too large: " + std::string(s));
return false;
}
return true;
}
/* TRUE_LITERAL | FALSE_LITERAL */
bool Parser::boolLiteral(bool* dest) {
Token t = this->nextToken();
switch (t.fKind) {
case Token::Kind::TK_TRUE_LITERAL:
*dest = true;
return true;
case Token::Kind::TK_FALSE_LITERAL:
*dest = false;
return true;
default:
this->error(t, "expected 'true' or 'false', but found '" +
std::string(this->text(t)) + "'");
return false;
}
}
/* IDENTIFIER */
bool Parser::identifier(std::string_view* dest) {
Token t;
if (this->expect(Token::Kind::TK_IDENTIFIER, "identifier", &t)) {
*dest = this->text(t);
return true;
}
return false;
}
} // namespace SkSL