SkSLParser.h

Go to the documentation of this file.

/*
 * Copyright 2021 Google LLC.
 *
 * Use of this source code is governed by a BSD-style license that can be
 * found in the LICENSE file.
 */
 
#ifndef SKSL_PARSER
#define SKSL_PARSER
 
#include "include/core/SkTypes.h"
#include "src/sksl/SkSLDefines.h"
#include "src/sksl/SkSLLexer.h"
#include "src/sksl/SkSLOperator.h"
#include "src/sksl/SkSLPosition.h"
#include "src/sksl/SkSLProgramSettings.h"
#include "src/sksl/ir/SkSLLayout.h"
#include "src/sksl/ir/SkSLModifiers.h"
 
#include <cstdint>
#include <memory>
#include <string>
#include <string_view>
#include <vector>
 
namespace SkSL {
 
class Compiler;
class ErrorReporter;
class Expression;
class FunctionDeclaration;
struct Module;
struct Program;
class ProgramElement;
enum class ProgramKind : int8_t;
class Statement;
class SymbolTable;
class Type;
class VarDeclaration;
class Variable;
 
/**
 * Consumes .sksl text and converts it into an IR tree, encapsulated in a Program.
 */
class Parser {
public:
    Parser(Compiler* compiler,
           const ProgramSettings& settings,
           ProgramKind kind,
           std::unique_ptr<std::string> text);
    ~Parser();
 
    std::unique_ptr<Program> programInheritingFrom(const Module* module);
 
    std::unique_ptr<Module> moduleInheritingFrom(const Module* parentModule);
 
    std::string_view text(Token token);
 
    Position position(Token token);
 
private:
    class AutoDepth;
    class AutoSymbolTable;
    class Checkpoint;
 
    /**
     * Return the next token, including whitespace tokens, from the parse stream.
     */
    Token nextRawToken();
 
    /**
     * Return the next non-whitespace token from the parse stream.
     */
    Token nextToken();
 
    /**
     * Push a token back onto the parse stream, so that it is the next one read. Only a single level
     * of pushback is supported (that is, it is an error to call pushback() twice in a row without
     * an intervening nextToken()).
     */
    void pushback(Token t);
 
    /**
     * Returns the next non-whitespace token without consuming it from the stream.
     */
    Token peek();
 
    /**
     * Checks to see if the next token is of the specified type. If so, stores it in result (if
     * result is non-null) and returns true. Otherwise, pushes it back and returns false.
     */
    bool checkNext(Token::Kind kind, Token* result = nullptr);
 
    /**
     * Behaves like checkNext(TK_IDENTIFIER), but also verifies that identifier is not a builtin
     * type. If the token was actually a builtin type, false is returned (the next token is not
     * considered to be an identifier).
     */
    bool checkIdentifier(Token* result = nullptr);
 
    /**
     * Reads the next non-whitespace token and generates an error if it is not the expected type.
     * The 'expected' string is part of the error message, which reads:
     *
     * "expected <expected>, but found '<actual text>'"
     *
     * If 'result' is non-null, it is set to point to the token that was read.
     * Returns true if the read token was as expected, false otherwise.
     */
    bool expect(Token::Kind kind, const char* expected, Token* result = nullptr);
    bool expect(Token::Kind kind, std::string expected, Token* result = nullptr);
 
    /**
     * Behaves like expect(TK_IDENTIFIER), but also verifies that identifier is not a type.
     * If the token was actually a type, generates an error message of the form:
     *
     * "expected an identifier, but found type 'float2'"
     */
    bool expectIdentifier(Token* result);
 
    /** If the next token is a newline, consumes it and returns true. If not, returns false. */
    bool expectNewline();
 
    void error(Token token, std::string_view msg);
    void error(Position position, std::string_view msg);
 
    // Returns the range from `start` to the current parse position.
    Position rangeFrom(Position start);
    Position rangeFrom(Token start);
 
    // these functions parse individual grammar rules from the current parse position; you probably
    // don't need to call any of these outside of the parser. The function declarations in the .cpp
    // file have comments describing the grammar rules.
 
    void declarations();
 
    /**
     * Parses an expression representing an array size. Reports errors if the array size is not
     * valid (out of bounds, not a literal integer). Returns true if an expression was
     * successfully parsed, even if that array size is not actually valid. In the event of a true
     * return, outResult always contains a valid array size (even if the parsed array size was not
     * actually valid; invalid array sizes result in a 1 to avoid additional errors downstream).
     */
    bool arraySize(SKSL_INT* outResult);
 
    void directive(bool allowVersion);
 
    void extensionDirective(Position start);
 
    void versionDirective(Position start, bool allowVersion);
 
    bool declaration();
 
    bool functionDeclarationEnd(Position start,
                                Modifiers& modifiers,
                                const Type* returnType,
                                const Token& name);
 
    bool prototypeFunction(SkSL::FunctionDeclaration* decl);
 
    bool defineFunction(SkSL::FunctionDeclaration* decl);
 
    struct VarDeclarationsPrefix {
        Position fPosition;
        Modifiers fModifiers;
        const Type* fType;
        Token fName;
    };
 
    bool varDeclarationsPrefix(VarDeclarationsPrefix* prefixData);
 
    std::unique_ptr<Statement> varDeclarationsOrExpressionStatement();
 
    std::unique_ptr<Statement> varDeclarations();
 
    const Type* structDeclaration();
 
    void structVarDeclaration(Position start, const Modifiers& modifiers);
 
    bool allowUnsizedArrays() {
        return ProgramConfig::IsCompute(fKind) || ProgramConfig::IsFragment(fKind) ||
               ProgramConfig::IsVertex(fKind);
    }
 
    const Type* arrayType(const Type* base, int count, Position pos);
 
    const Type* unsizedArrayType(const Type* base, Position pos);
 
    bool parseArrayDimensions(Position pos, const Type** type);
 
    bool parseInitializer(Position pos, std::unique_ptr<Expression>* initializer);
 
    void addGlobalVarDeclaration(std::unique_ptr<SkSL::VarDeclaration> decl);
 
    void globalVarDeclarationEnd(Position position, const Modifiers& mods,
                                 const Type* baseType, Token name);
 
    std::unique_ptr<Statement> localVarDeclarationEnd(Position position,
                                                      const Modifiers& mods,
                                                      const Type* baseType,
                                                      Token name);
 
    bool modifiersDeclarationEnd(const Modifiers& mods);
 
    bool parameter(std::unique_ptr<SkSL::Variable>* outParam);
 
    int layoutInt();
 
    std::string_view layoutIdentifier();
 
    SkSL::Layout layout();
 
    Modifiers modifiers();
 
    std::unique_ptr<Statement> statementOrNop(Position pos, std::unique_ptr<Statement> stmt);
 
    std::unique_ptr<Statement> statement(bool bracesIntroduceNewScope = true);
 
    const Type* findType(Position pos, Modifiers* modifiers, std::string_view name);
 
    const Type* type(Modifiers* modifiers);
 
    bool interfaceBlock(const Modifiers& mods);
 
    std::unique_ptr<Statement> ifStatement();
 
    std::unique_ptr<Statement> doStatement();
 
    std::unique_ptr<Statement> whileStatement();
 
    std::unique_ptr<Statement> forStatement();
 
    bool switchCaseBody(ExpressionArray* values,
                        StatementArray* caseBlocks,
                        std::unique_ptr<Expression> value);
 
    bool switchCase(ExpressionArray* values, StatementArray* caseBlocks);
 
    std::unique_ptr<Statement> switchStatement();
 
    std::unique_ptr<Statement> returnStatement();
 
    std::unique_ptr<Statement> breakStatement();
 
    std::unique_ptr<Statement> continueStatement();
 
    std::unique_ptr<Statement> discardStatement();
 
    std::unique_ptr<Statement> block(bool introduceNewScope,
                                     std::unique_ptr<SymbolTable>* adoptExistingSymbolTable);
 
    std::unique_ptr<Statement> expressionStatement();
 
    using BinaryParseFn = std::unique_ptr<Expression> (Parser::*)();
    [[nodiscard]] bool operatorRight(AutoDepth& depth,
                                     Operator::Kind op,
                                     BinaryParseFn rightFn,
                                     std::unique_ptr<Expression>& expr);
 
    std::unique_ptr<Expression> poison(Position pos);
 
    std::unique_ptr<Expression> expressionOrPoison(Position pos, std::unique_ptr<Expression> expr);
 
    std::unique_ptr<Expression> expression();
 
    std::unique_ptr<Expression> assignmentExpression();
 
    std::unique_ptr<Expression> ternaryExpression();
 
    std::unique_ptr<Expression> logicalOrExpression();
 
    std::unique_ptr<Expression> logicalXorExpression();
 
    std::unique_ptr<Expression> logicalAndExpression();
 
    std::unique_ptr<Expression> bitwiseOrExpression();
 
    std::unique_ptr<Expression> bitwiseXorExpression();
 
    std::unique_ptr<Expression> bitwiseAndExpression();
 
    std::unique_ptr<Expression> equalityExpression();
 
    std::unique_ptr<Expression> relationalExpression();
 
    std::unique_ptr<Expression> shiftExpression();
 
    std::unique_ptr<Expression> additiveExpression();
 
    std::unique_ptr<Expression> multiplicativeExpression();
 
    std::unique_ptr<Expression> unaryExpression();
 
    std::unique_ptr<Expression> postfixExpression();
 
    std::unique_ptr<Expression> swizzle(Position pos,
                                        std::unique_ptr<Expression> base,
                                        std::string_view swizzleMask,
                                        Position maskPos);
 
    std::unique_ptr<Expression> call(Position pos,
                                     std::unique_ptr<Expression> base,
                                     ExpressionArray args);
 
    std::unique_ptr<Expression> suffix(std::unique_ptr<Expression> base);
 
    std::unique_ptr<Expression> term();
 
    bool intLiteral(SKSL_INT* dest);
 
    bool floatLiteral(SKSL_FLOAT* dest);
 
    bool boolLiteral(bool* dest);
 
    bool identifier(std::string_view* dest);
 
    SymbolTable* symbolTable();
 
    Compiler& fCompiler;
    ProgramSettings fSettings;
    ErrorReporter* fErrorReporter;
    bool fEncounteredFatalError;
    ProgramKind fKind;
    std::unique_ptr<std::string> fText;
    std::vector<std::unique_ptr<SkSL::ProgramElement>> fProgramElements;
    Lexer fLexer;
    // current parse depth, used to enforce a recursion limit to try to keep us from overflowing the
    // stack on pathological inputs
    int fDepth = 0;
    Token fPushback;
};
 
}  // namespace SkSL
 
#endif