Analyzer.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 "CeresEngine/DataTypes.hpp"
 
#include "CeresEngine/Foundation/String.hpp"
#include "CeresEngine/Foundation/Container/Stack.hpp"
 
#include "CeresEngine/Material/ShaderCompiler/ShaderCompiler.hpp"
#include "CeresEngine/Material/ShaderCompiler/SymbolTable.hpp"
#include "CeresEngine/Material/ShaderCompiler/Variant.hpp"
 
#include "CeresEngine/Material/ShaderCompiler/AST/AST.hpp"
#include "CeresEngine/Material/ShaderCompiler/AST/Token.hpp"
#include "CeresEngine/Material/ShaderCompiler/Report/ReportHandler.hpp"
 
#include "CeresEngine/Material/ShaderCompiler/AST/Visitor/VisitorTracker.hpp"
 
namespace CeresEngine::ShaderCompiler {
 
    struct StructTypeDenoter;
 
    // Context analyzer base class.
    class Analyzer : protected VisitorTracker {
    private:
        ReportHandler mReportHandler;
        SourceCode* mSourceCode = nullptr;
 
        ASTSymbolOverloadTable mSymTable;
 
        RawFlags mWarnings;
 
    public:
        Analyzer(Log* log = nullptr);
 
        bool decorateAST(Program& program, const ShaderInput& inputDesc, const ShaderOutput& outputDesc);
 
    protected:
        using OnOverrideProc = ASTSymbolTable::OnOverrideProc;
 
        virtual void decorateASTPrimary(Program& program, const ShaderInput& inputDesc, const ShaderOutput& outputDesc) = 0;
 
    protected: // Report and error handling
        void submitReport(bool isError, const String& msg, const AST* ast = nullptr, const Vector<const AST*>& astAppendices = {});
 
        void error(const String& msg, const AST* ast = nullptr, const Vector<const AST*>& astAppendices = {});
        void errorUndeclaredIdent(const String& ident, const AST* ast = nullptr);
        void errorUndeclaredIdent(const String& ident, const String& contextName, const AST* ast = nullptr);
        void errorUndeclaredIdent(const String& ident, const String& contextName, const String& similarIdent, const AST* ast = nullptr);
        void errorInternal(const String& msg, const AST* ast = nullptr);
 
        void warning(const String& msg, const AST* ast = nullptr);
        void warningOnNullStatement(const StatementPtr& ast, const String& statementTypeName);
 
        // Returns the report handler.
        inline ReportHandler& getReportHandler() { return mReportHandler; }
 
        // Returns true if the specified warnings flags are enabled.
        [[nodiscard]] bool isWarningEnabled(UInt32 flags) const;
 
    protected: // Symbol table functions
        // Opens a new scope in the smybol table.
        void openScope();
 
        // Closes the current scope in the symbol table.
        void closeScope();
 
        // Registers the AST node in the current scope with the specified identifier.
        void register_(const String& ident, AST* ast);
 
        // Tries to fetch an AST node with the specified identifier from the symbol table and reports an error on failure.
        AST* fetch(const String& ident, const AST* ast = nullptr);
 
        // Tries to fetch an AST node with the specified identifier from the current scope of the symbol table and returns null on failure.
        [[nodiscard]] AST* fetchFromCurrentScopeOrNull(const String& ident) const;
 
        // Tries to fetch a declaration node with the specified identifier from the symbol table and reports an error on failure.
        Declaration* fetchDeclaration(const String& ident, const AST* ast = nullptr);
 
        // Tries to fetch a 'StructDecl' or 'AliasDecl' with the specified identifier from the symbol table and reports an error on failure.
        Declaration* fetchType(const String& ident, const AST* ast = nullptr);
 
        // Tries to fetch a 'VarDecl' with the specified identifier from the symbol table and reports an error on failure.
        VarDeclaration* fetchVarDeclaration(const String& ident, const AST* ast = nullptr);
 
        // Tries to fetch a 'FunctionDecl' with the specified identifier and arguments from the symbol table and reports an error on failure.
        FunctionDeclaration* fetchFunctionDeclaration(const String& ident, const Vector<ExpressionPtr>& args, const AST* ast = nullptr);
 
        // Tries to fetch a 'FunctionDecl' with the specified identifier from the symbol table and reports an error on failure (used for patch-constant-function).
        FunctionDeclaration* fetchFunctionDeclaration(const String& ident, const AST* ast = nullptr);
 
        // Tries to fetch a 'VarDecl' with the specified identifier from the structure type denoter and reports an error on failure.
        VarDeclaration* fetchVarDeclarationFromStruct(const StructTypeDenoter& structTypeDenoter, const String& ident, const AST* ast = nullptr);
 
        FunctionDeclaration* fetchFunctionDeclarationFromStruct(const StructTypeDenoter& structTypeDenoter, const String& ident, const Vector<ExpressionPtr>& args,
            const AST* ast = nullptr);
 
        StructDeclaration* fetchStructDeclarationFromIdent(const String& ident, const AST* ast = nullptr);
        StructDeclaration* fetchStructDeclarationFromTypeDenoter(const TypeDenoter& typeDenoter);
 
        // Tries to find a type compatible structure declaration within the current scope.
        StructDeclaration* findCompatibleStructDeclaration(const StructDeclaration& rhs);
 
        //TODO: maybe replace this by "VisitorTracker::insideGlobalScope"
        // Returns true if the visitor is currently inside the global scope (i.e. out of any function declaration).
        [[nodiscard]] bool isInsideGlobalScope() const;
 
    protected: // Analyzer functions
        void analyzeTypeDenoter(TypeDenoterPtr& typeDenoter, const AST* ast);
        void analyzeBufferTypeDenoter(BufferTypeDenoter& bufferTypeDen, const AST* ast);
        void analyzeStructTypeDenoter(StructTypeDenoter& structTypeDen, const AST* ast);
        void analyzeAliasTypeDenoter(TypeDenoterPtr& typeDenoter, const AST* ast);
 
        void analyzeTypeSpecifier(TypeSpecifier* typeSpecifier);
        void analyzeTypeSpecifierForParameter(const TypeSpecifier* typeSpecifier);
 
        void analyzeFunctionEndOfScopes(const FunctionDeclaration& funcDeclaration);
        void analyzeFunctionControlPath(FunctionDeclaration& funcDeclaration);
 
        TypeDenoterPtr getTypeDenoterFrom(TypedAST* ast, const TypeDenoter* expectedTypeDenoter = nullptr);
 
        // Validates the implicit type cast from the source type denoter to the destination type denoter.
        void validateTypeCast(const TypeDenoter& sourceTypeDen, const TypeDenoter& destTypeDen, const String& contextDesc, const AST* ast = nullptr);
        void validateTypeCastFrom(TypedAST* sourceAST, TypedAST* destAST, const String& contextDesc);
 
        void analyzeConditionalExpression(Expression* expression);
 
    protected: // Const-expression evaluation
        // Evaluates the specified constant expression.
        Variant evaluateConstExpression(Expression& expression);
 
        // Evaluates the specified constant object expression or throws the expression if it's not constant.
        Variant evaluateConstExpressionObject(const ObjectExpression& expression);
 
        // Tries to evaluate the specified constant expression, or returns the default value on failure.
        Variant evaluateOrDefault(Expression& expression, const Variant& defaultValue = {});
 
        // Evaluates the specified constant integer expression.
        Int32 evaluateConstExpressionInt(Expression& expression);
 
        // Evaluates the specified constant floating-point expression.
        float evaluateConstExpressionFloat(Expression& expression);
 
    private:
        bool collectArgumentTypeDenoters(const Vector<ExpressionPtr>& args, Vector<TypeDenoterPtr>& argTypeDens);
 
        // Tries to find a similar identifier in the following order: symbol table, structure (if enabled).
        String fetchSimilarIdent(const String& ident, StructDeclaration* structDeclaration = nullptr) const;
 
        // Callback for the symbol table when a symbol is realsed from its scope.
        void onReleaseSymbol(const ASTSymbolOverloadPtr& symbol);
    };
 
} // namespace CeresEngine::ShaderCompiler