GLSLParser.hpp

Go to the documentation of this file.

//
//  CeresEngine - A game development framework
//
//  Created by Rogiel Sulzbach.
//  Copyright (c) 2018-2022 Rogiel Sulzbach. All rights reserved.
//
 
#pragma once
 
#include "GLSLScanner.hpp"
 
#include "CeresEngine/DataTypes.hpp"
 
#include "CeresEngine/Foundation/Container/Map.hpp"
 
#include "CeresEngine/Material/ShaderCompiler/SymbolTable.hpp"
 
#include "CeresEngine/Material/ShaderCompiler/Frontend/SLParser.hpp"
 
namespace CeresEngine::ShaderCompiler {
 
    // Syntax parser class for the shading language GLSL.
    class GLSLParser : public SLParser {
    private:
        using TypeNameSymbolTable = SymbolTable<bool>;
 
        // Symbol table for type name (i.e. structure and typedef identifiers) to detect cast expression, which are not context free.
        TypeNameSymbolTable mTypeNameSymbolTable;
 
        Int32 mVersion = 0;
        bool mIsESSL = false;
        bool mIsCoreProfile = false;
 
    public:
        GLSLParser(Log* log = nullptr);
 
        ProgramPtr parseSource(const SourceCodePtr& source, const NameMangling& nameMangling, const InputShaderVersion versionIn, bool enableWarnings = false);
 
    private:
        ScannerPtr makeScanner() override;
 
        // Returns true if the current token is a data type.
        [[nodiscard]] bool isDataType() const;
 
        // Returns true if the current token is a base data type (i.e. scalar, vector, matrix, or string type denoter).
        [[nodiscard]] bool isBaseDataType() const;
 
        // Returns true if the current token is a literal.
        [[nodiscard]] bool isLiteral() const;
 
        // Returns true if the current token is part of an arithmetic unary expression, i.e. either '-' or '+'.
        [[nodiscard]] bool isArithmeticUnaryExpression() const;
 
        // Returns true if the current token is a modifier of a type specifier.
        [[nodiscard]] bool isModifier() const;
 
        // Overrides the token accept function to process all directives before the actual parsing.
        TokenPtr acceptIt() override;
 
        // Processes the specified directive (only '#line'-directive are allowed after pre-processing).
        void processDirective(const String& ident);
        void processDirectiveLine();
        void processDirectiveVersion();
        void processDirectiveExtension();
 
    private: // Symbol table
        // Opens a new scope of the type name symbol table.
        void openScope();
 
        // Closes the current scope of the type name symbol table.
        void closeScope();
 
        // Registers the specified identifier as type name, to detect cast expressions.
        void registerTypeName(const String& ident);
 
        // Returns true if the specified identifier is a valid type name within the current scope.
        [[nodiscard]] bool isRegisteredTypeName(const String& ident) const;
 
    private: // Parsing
        ProgramPtr parseProgram(const SourceCodePtr& source);
 
        CodeBlockPtr parseCodeBlock() override;
        VarDeclarationStatementPtr parseParameter() override;
        StatementPtr parseLocalStatement() override;
        StatementPtr parseForLoopInitializer() override;
        SwitchCasePtr parseSwitchCase() override;
        VarDeclarationPtr parseVarDeclaration(VarDeclarationStatement* declarationStatementRef, const TokenPtr& identifierToken = nullptr) override;
 
        AttributePtr parseAttribute();
        TypeSpecifierPtr parseTypeSpecifier(bool parseVoidType = false, const TokenPtr& inputtoken = nullptr);
 
#if 0
        BufferDeclarationPtr parseBufferDeclaration(BufferDeclarationStatement* declarationStatementRef, const TokenPtr& identifierToken = nullptr);
        SamplerDeclarationPtr parseSamplerDeclaration(SamplerDeclarationStatement* declarationStatementRef, const TokenPtr& identifierToken = nullptr);
#endif
        StructDeclarationPtr parseStructDeclaration(bool parseStructtoken = true, const TokenPtr& identifierToken = nullptr);
        FunctionDeclarationPtr parseFunctionDeclaration(BasicDeclarationStatement* declarationStatementRef, const TypeSpecifierPtr& returnType = nullptr,
            const TokenPtr& identifierToken = nullptr);
        UniformBufferDeclarationPtr parseUniformBufferDeclaration(const TokenPtr& identifierToken = nullptr);
 
        StatementPtr parseGlobalStatement();
        StatementPtr parseGlobalStatementPrimary(bool hasAttribs = false);
        StatementPtr parseGlobalStatementWithTypeSpecifier(const TokenPtr& inputtoken = nullptr);
        StatementPtr parseGlobalStatementWithLayoutQualifier();
#if 0
        StatementPtr                        ParseGlobalStatementWithSamplerTypeDenoter();
        StatementPtr                        ParseGlobalStatementWithBufferTypeDenoter();
#endif
        BasicDeclarationStatementPtr parseFunctionDeclarationStatement(const TypeSpecifierPtr& returnType = nullptr, const TokenPtr& identifierToken = nullptr);
        StatementPtr parseUniformDeclarationStatement();
        BasicDeclarationStatementPtr parseUniformBufferDeclarationStatement(const TokenPtr& identifierToken = nullptr);
#if 0
        BufferDeclarationStatementPtr              ParseBufferDeclarationStatement(const BufferTypeDenoterPtr& typeDenoter = nullptr, const TokenPtr& identifierToken = nullptr);
        SamplerDeclarationStatementPtr             ParseSamplerDeclarationStatement(const SamplerTypeDenoterPtr& typeDenoter = nullptr, const TokenPtr& identifierToken = nullptr);
#endif
        VarDeclarationStatementPtr parseVarDeclarationStatement(bool isUniform = false, const TokenPtr& identifierToken = nullptr);
 
        StatementPtr parseStatement();
        StatementPtr parseStatementWithStructDeclaration();
#if 0
        StatementPtr                        ParseStatementWithIdent();
#endif
 
        ExpressionPtr parsePrimaryExpression() override;
        ExpressionPtr parsePrimaryExpressionPrefix();
        ExpressionPtr parseExpressionWithSuffixOpt(ExpressionPtr expression);
        LiteralExpressionPtr parseLiteralExpression();
        ExpressionPtr parseTypeSpecifierOrCallExpression();
        TypeSpecifierExpressionPtr parseTypeSpecifierExpression();
        UnaryExpressionPtr parseUnaryExpression();
        PostUnaryExpressionPtr parsePostUnaryExpression(const ExpressionPtr& expression);
        BracketExpressionPtr parseBracketExpression();
        ObjectExpressionPtr parseObjectExpression(const ExpressionPtr& expression = nullptr);
        AssignExpressionPtr parseAssignExpression(const ExpressionPtr& expression);
        ExpressionPtr parseObjectOrCallExpression(const ExpressionPtr& expression = nullptr);
        CallExpressionPtr parseCallExpression(const ObjectExpressionPtr& objectExpression = nullptr, const TypeDenoterPtr& typeDenoter = nullptr);
        CallExpressionPtr parseCallExpressionWithPrefixOpt(const ExpressionPtr& prefixExpression = nullptr, bool isStatic = false, const TokenPtr& identifierToken = nullptr);
        CallExpressionPtr parseCallExpressionAsTypeCtor(const TypeDenoterPtr& typeDenoter);
 
        Vector<StatementPtr> parseGlobalStatementList();
        Vector<AttributePtr> parseAttributeList();
#if 0
        Vector<BufferDeclarationPtr>      ParseBufferDeclarationList(BufferDeclarationStatement* declarationStatementRef, const TokenPtr& identifierToken = nullptr);
        Vector<SamplerDeclarationPtr>     ParseSamplerDeclarationList(SamplerDeclarationStatement* declarationStatementRef, const TokenPtr& identifierToken = nullptr);
#endif
 
        TypeDenoterPtr parseTypeDenoter(bool allowVoidType = true, StructDeclarationPtr* structDeclaration = nullptr);
        TypeDenoterPtr parseTypeDenoterPrimary(StructDeclarationPtr* structDeclaration = nullptr);
        TypeDenoterPtr parseTypeDenoterWithStructDeclarationOpt(StructDeclarationPtr& structDeclaration, bool allowVoidType = true);
        VoidTypeDenoterPtr parseVoidTypeDenoter();
        BaseTypeDenoterPtr parseBaseTypeDenoter();
        BufferTypeDenoterPtr parseBufferTypeDenoter();
        SamplerTypeDenoterPtr parseSamplerTypeDenoter();
        StructTypeDenoterPtr parseStructTypeDenoter();
        StructTypeDenoterPtr parseStructTypeDenoterWithStructDeclarationOpt(StructDeclarationPtr& structDeclaration);
 
        DataType parseDataType(const String& keyword);
        PrimitiveType parsePrimitiveType();
        InterpModifier parseInterpModifier();
        TypeModifier parseTypeModifier();
        StorageClass parseStorageClass();
        SamplerType parseSamplerType();
 
        bool parseModifiers(TypeSpecifier* typeSpecifier, bool allowPrimitiveType = false, const TokenPtr& inputtoken = nullptr);
    };
 
} // namespace CeresEngine::ShaderCompiler