HLSLParser.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 "HLSLScanner.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 HLSL.
    class HLSLParser : public SLParser {
    public:
        HLSLParser(Log* log = nullptr);
 
        ProgramPtr parseSource(const SourceCodePtr& source, const NameMangling& nameMangling, const InputShaderVersion versionIn,
            bool rowMajorAlignment = false, 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;
 
        // Converts the specified expression to a type name expression if it is a left-hand-side of a cast expression.
        TypeSpecifierPtr makeTypeSpecifierIfLhsOfCastExpression(const ExpressionPtr& expression);
 
        // 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 processDirectivePragma();
 
    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;
 
        // Makes a new alias declaration statement and registers it's identifier in the symbol table.
        AliasDeclarationStatementPtr makeAndRegisterBuildinAlias(const DataType dataType, const String& ident);
 
        // Generates all pre defined type aliases (e.g. 'typedef Int32 DWORD').
        void generatePreDefinedTypeAliases(Program& ast);
 
        // Creates a new var-decl statement with the current matrix pack alignment type modifier.
        TypeSpecifierPtr makeTypeSpecifierWithPackAlignment();
 
    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;
 
        SamplerValuePtr parseSamplerValue();
        AttributePtr parseAttribute();
        RegisterPtr parseRegister(bool parseColon = true);
        PackOffsetPtr parsePackOffset(bool parseColon = true);
        TypeSpecifierPtr parseTypeSpecifier(bool parseVoidType = false);
 
        BufferDeclarationPtr parseBufferDeclaration(BufferDeclarationStatement* declarationStatementRef, const TokenPtr& identifierToken = nullptr);
        SamplerDeclarationPtr parseSamplerDeclaration(SamplerDeclarationStatement* declarationStatementRef, const TokenPtr& identifierToken = nullptr);
        StructDeclarationPtr parseStructDeclaration(bool parseStructtoken = true, const TokenPtr& identifierToken = nullptr);
        AliasDeclarationPtr parseAliasDeclaration(TypeDenoterPtr typeDenoter);
        FunctionDeclarationPtr parseFunctionDeclaration(BasicDeclarationStatement* declarationStatementRef, const TypeSpecifierPtr& returnType = nullptr,
            const TokenPtr& identifierToken = nullptr);
        UniformBufferDeclarationPtr parseUniformBufferDeclaration();
 
        StatementPtr parseGlobalStatement();
        StatementPtr parseGlobalStatementPrimary();
        StatementPtr parseGlobalStatementWithTypeSpecifier();
        StatementPtr parseGlobalStatementWithSamplerTypeDenoter();
        StatementPtr parseGlobalStatementWithBufferTypeDenoter();
        BasicDeclarationStatementPtr parseFunctionDeclarationStatement(const TypeSpecifierPtr& returnType = nullptr, const TokenPtr& identifierToken = nullptr);
        BasicDeclarationStatementPtr parseUniformBufferDeclarationStatement();
        BufferDeclarationStatementPtr parseBufferDeclarationStatement(const BufferTypeDenoterPtr& typeDenoter = nullptr, const TokenPtr& identifierToken = nullptr);
        SamplerDeclarationStatementPtr parseSamplerDeclarationStatement(const SamplerTypeDenoterPtr& typeDenoter = nullptr, const TokenPtr& identifierToken = nullptr);
        VarDeclarationStatementPtr parseVarDeclarationStatement();
        AliasDeclarationStatementPtr parseAliasDeclarationStatement();
 
        StatementPtr parseStatement(bool allowAttributes = true);
        StatementPtr parseStatementPrimary();
        StatementPtr parseStatementWithStructDeclaration();
        StatementPtr parseStatementWithIdent();
 
        ExpressionPtr parsePrimaryExpression() override;
        ExpressionPtr parsePrimaryExpressionPrefix();
        ExpressionPtr parseExpressionWithSuffixOpt(ExpressionPtr expression);
        LiteralExpressionPtr parseLiteralExpression();
        ExpressionPtr parseTypeSpecifierOrCallExpression();
        TypeSpecifierExpressionPtr parseTypeSpecifierExpression();
        UnaryExpressionPtr parseUnaryExpression();
        PostUnaryExpressionPtr parsePostUnaryExpression(const ExpressionPtr& expression);
        ExpressionPtr parseExpressionWithBracketPrefix();
        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<VarDeclarationStatementPtr> parseAnnotationList();
        Vector<RegisterPtr> parseRegisterList(bool parseFirstColon = true);
        Vector<AttributePtr> parseAttributeList();
        Vector<BufferDeclarationPtr> parseBufferDeclarationList(BufferDeclarationStatement* declarationStatementRef, const TokenPtr& identifierToken = nullptr);
        Vector<SamplerDeclarationPtr> parseSamplerDeclarationList(SamplerDeclarationStatement* declarationStatementRef, const TokenPtr& identifierToken = nullptr);
        Vector<SamplerValuePtr> parseSamplerValueList();
        Vector<AliasDeclarationPtr> parseAliasDeclarationList(TypeDenoterPtr typeDenoter);
 
        String parseIdentWithNamespaceOpt(ObjectExpressionPtr& namespaceExpression, TokenPtr identifierToken = nullptr, SourceArea* area = nullptr);
 
        TypeDenoterPtr parseTypeDenoter(bool allowVoidType = true, StructDeclarationPtr* structDeclaration = nullptr);
        TypeDenoterPtr parseTypeDenoterPrimary(StructDeclarationPtr* structDeclaration = nullptr);
        TypeDenoterPtr parseTypeDenoterWithStructDeclarationOpt(StructDeclarationPtr& structDeclaration, bool allowVoidType = true);
        VoidTypeDenoterPtr ParseVoidTypeDenoter();
        BaseTypeDenoterPtr parseBaseTypeDenoter();
        BaseTypeDenoterPtr parseBaseVectorTypeDenoter();
        BaseTypeDenoterPtr parseBaseMatrixTypeDenoter();
        BufferTypeDenoterPtr parseBufferTypeDenoter();
        SamplerTypeDenoterPtr parseSamplerTypeDenoter();
        StructTypeDenoterPtr parseStructTypeDenoter();
        StructTypeDenoterPtr parseStructTypeDenoterWithStructDeclarationOpt(StructDeclarationPtr& structDeclaration);
        AliasTypeDenoterPtr parseAliasTypeDenoter(String ident = "");
 
        void parseAndIgnoreTechniquesAndNullStatements();
        void parseAndIgnoreTechnique();
 
        void parseVarDeclarationSemantic(VarDeclaration& varDeclaration, bool allowPackOffset = true);
        void parseFunctionDeclarationSemantic(FunctionDeclaration& funcDeclaration);
 
        DataType parseDataType(const String& keyword);
        PrimitiveType parsePrimitiveType();
        InterpModifier parseInterpModifier();
        TypeModifier parseTypeModifier();
        StorageClass parseStorageClass();
        UniformBufferType parseUniformBufferType();
        BufferType parseBufferType();
        SamplerType parseSamplerType();
        IndexedSemantic parseSemantic(bool parseColon = true);
 
        String parseSamplerStateTextureIdent();
 
        bool parseModifiers(TypeSpecifier* typeSpecifier, bool allowPrimitiveType = false);
 
    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;
 
        // True, if semantics are parsed for D3D10+ shader.
        bool mUseD3D10Semantics = true;
 
        // True, if Cg keyword extensions are enabled.
        bool mEnableCgKeywords = false;
 
        // True, if matrix packing is globally set to row major.
        bool mRowMajorAlignment = false;
    };
 
} // namespace CeresEngine::ShaderCompiler