VisitorTracker.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 "Visitor.hpp"
 
#include "CeresEngine/Foundation/Container/Stack.hpp"
#include "CeresEngine/Foundation/Container/Vector.hpp"
 
namespace CeresEngine::ShaderCompiler {
 
    // Extended visitor class with AST tracking functions.
    class VisitorTracker : public Visitor {
    protected: // Global scope tracker
        [[nodiscard]] bool isInsideGlobalScope() const;
 
    protected: // Function declaration tracker
        void pushFunctionDeclaration(FunctionDeclaration* funcDeclaration);
        void popFunctionDeclaration();
 
        // Returns true if the visitor is currently inside a function declaration.
        [[nodiscard]] bool isInsideFunctionDeclaration() const;
 
        // Returns true if the visitor is currently inside the main entry point.
        [[nodiscard]] bool isInsideEntryPoint() const;
 
        // Returns true if the visitor is currently inside the secondary entry point.
        [[nodiscard]] bool isInsideSecondaryEntryPoint() const;
 
        // Returns the active (inner most) function declaration or null if the analyzer is currently not inside a function declaration.
        [[nodiscard]] FunctionDeclaration* getActiveFunctionDeclaration() const;
 
        // Returns the structure the active (inner most) member function declaration belongs to or null if no such structure exists.
        [[nodiscard]] StructDeclaration* getActiveFunctionStructDeclaration() const;
 
    protected: // Call expression tracker
        void pushCallExpression(CallExpression* callExpression);
        void popCallExpression();
 
        // Returns the active (inner most) call expression or null if the visitor is currently not inside a function call.
        [[nodiscard]] CallExpression* getActiveCallExpression() const;
 
    protected: // L-value expression tracker
        void pushLValueExpression(Expression* expression);
        void popLValueExpression();
 
        // Returns the active (inner most) l-value expression or null (can be AssignExpression, UnaryExpression, or PostUnaryExpression).
        [[nodiscard]] Expression* getActiveLValueExpression() const;
 
    protected: // Structure declaration tracker
        void pushStructDeclaration(StructDeclaration* structDeclaration);
        void popStructDeclaration();
 
        // Returns true if the analyzer is currently inside a structure declaration.
        [[nodiscard]] bool isInsideStructDeclaration() const;
 
        // Returns the active (inner most) structure declaration or null if the visitor is currently not inside a structure declaration.
        [[nodiscard]] StructDeclaration* getActiveStructDeclaration() const;
 
        // Returns the stack (or rather the list) of all current, nested structure declarations.
        [[nodiscard]] inline const Vector<StructDeclaration*>& getStructDeclarationStack() const { return mStructDeclarationStack; }
 
    protected: // Uniform buffer declaration tracker
        void pushUniformBufferDeclaration(UniformBufferDeclaration* uniformBufferDeclaration);
        void popUniformBufferDeclaration();
 
        // Returns true if the analyzer is currently inside a uniform buffer declaration.
        [[nodiscard]] bool isInsideUniformBufferDeclaration() const;
 
        // Returns the stack (or rather the list) of all current, nested structure declarations.
        [[nodiscard]] inline const Vector<UniformBufferDeclaration*>& getUniformBufferDeclarationStack() const { return mUniformBufferDeclarationStack; }
 
    protected: // Variable declaration statement tracker
        void pushVarDeclarationStatement(VarDeclarationStatement* varDeclarationStatement);
        void popVarDeclarationStatement();
 
        // Returns true if the visitor is currently inside a variable declaration statement.
        [[nodiscard]] bool isInsideVarDeclarationStatement() const;
 
        // Returns the active (inner most) variable declaration statement.
        [[nodiscard]] VarDeclarationStatement* getActiveVarDeclarationStatement() const;
 
    private:
        // Function declaration stack.
        Stack<FunctionDeclaration*> mFuncDeclarationStack;
 
        // Call expression stack to join arguments with its function call.
        Stack<CallExpression*> mCallExpressionStack;
 
        // L-value expression stack
        Stack<Expression*> mLvalueExpressionStack;
 
        // Structure stack to collect all members with system value semantic (SV_...), and detect all nested structures.
        Vector<StructDeclaration*> mStructDeclarationStack;
 
        // Uniform buffer declaration stack.
        Vector<UniformBufferDeclaration*> mUniformBufferDeclarationStack;
 
        // Variable declaration stack.
        Stack<VarDeclarationStatement*> mVarDeclarationStatementStack;
 
        // Function declaration level of the main entry point.
        std::size_t mStackLevelOfEntryPoint = std::size_t(~0);
 
        // Function declaration level of the secondary entry point.
        std::size_t mStackLevelOf2ndEntryPoint = std::size_t(~0);
    };
 
#undef VISITOR_VISIT_PROC
 
} // namespace CeresEngine::ShaderCompiler