PreProcessor.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 "Parser.hpp"
#include "PreProcessorScanner.hpp"
 
#include "CeresEngine/DataTypes.hpp"
 
#include "CeresEngine/Foundation/SmartPtr.hpp"
#include "CeresEngine/Foundation/Container/InitializerList.hpp"
#include "CeresEngine/Foundation/Container/Map.hpp"
#include "CeresEngine/Foundation/Container/Set.hpp"
#include "CeresEngine/Foundation/Container/Stack.hpp"
 
#include "CeresEngine/Material/ShaderCompiler/Log.hpp"
#include "CeresEngine/Material/ShaderCompiler/ShaderCompiler.hpp"
#include "CeresEngine/Material/ShaderCompiler/SourceCode.hpp"
 
#include "CeresEngine/Material/ShaderCompiler/AST/ASTEnums.hpp"
#include "CeresEngine/Material/ShaderCompiler/AST/TokenString.hpp"
 
#include <functional>
#include <iostream>
 
namespace CeresEngine::ShaderCompiler {
 
    class PreProcessor : public Parser {
    protected:
        // Macro object structure.
        struct Macro {
            Macro() = default;
            Macro(const Macro&) = default;
            Macro& operator=(const Macro&) = default;
 
            Macro(const TokenPtr& identifierToken);
            Macro(const TokenPtr& identifierToken, const TokenPtrString& value);
 
            Macro(const TokenPtr& identifierToken, const TokenPtrString& value, const Vector<String>& parameters, bool varArgs = false, bool stdMacro = false,
                bool emptyParamList = false);
 
            [[nodiscard]] bool hasParameterList() const;
 
            TokenPtr identifierToken; // Macro identifier token
            TokenPtrString tokenString; // Macro definition value as token string
            Vector<String> parameters; // Parameter identifiers
            bool varArgs = false; // Specifies whether the macro supports variadic arguments
            bool stdMacro = false; // Specifies whether the macro is a standard macro (i.e. part of the language) or not
            bool emptyParamList = false; // Macro has an empty parameter list
        };
 
        struct IfBlock {
            void setActive(bool activate);
 
            TokenPtr directiveToken;
            SourceCodePtr directiveSource;
            bool parentActive = true; // Is the parent if-block active?
            bool active = true; // Is this if-block active?
            bool wasActive = false; // Was this if-block active?
            bool elseAllowed = true; // Is an else-block allowed?
        };
 
        using MacroPtr = SPtr<Macro>;
 
    private:
        IncludeHandler& mIncludeHandler;
 
        UPtr<StringStream> mOutput;
 
        Map<String, MacroPtr> mMacros;
        Set<String> mOnceIncluded;
        Map<String, std::size_t> mIncludeCounter; // Counter for each included file
 
        Stack<IfBlock> mIfBlockStack;
 
        bool mWriteLineMarks = true;
        bool mWriteLineMarkFilenames = true;
 
    public:
        PreProcessor(IncludeHandler& includeHandler, Log* log = nullptr);
 
        UPtr<std::iostream> process(const SourceCodePtr& input, const String& filename = "", bool writeLineMarks = true, bool writeLineMarkFilenames = true,
            bool enableWarnings = false);
 
        // Returns a list of all defined macro identifiers after pre-processing.
        [[nodiscard]] Vector<String> listDefinedMacroIdents() const;
 
    protected:
        // Parses the specified directive, that is not part of the standard pre-processor directive (e.g. "version" or "extension" for GLSL).
        virtual void parseDirective(const String& directive, bool ignoreUnknown);
 
        // Callback function when an auto-generated '#line'-directive is to be written.
        virtual void writeLineDirective(UInt32 lineNo, const String& filename);
 
        // Ignores the remaining tokens of the current directive.
        void ignoreDirective();
 
        // Defines a macro with the specified identifier, value token string, and parameters.
        void defineMacro(const Macro& macro);
 
        // Defines a standard macro (i.e. not part of the source code) with value set to integer literal '1'.
        void defineStandardMacro(const String& ident, Int32 intValue = 1);
 
        // Removes the macro definition with the specified identifier.
        void undefineMacro(const String& ident, const Token* token = nullptr);
 
        // Returns true if the specified macro identifier is defined.
        [[nodiscard]] bool isDefined(const String& ident) const;
 
        // Callback function when a macro is about to be defined
        virtual bool onDefineMacro(const Macro& macro);
 
        // Callback function when a macro is about to be redefined, returns true if the redefinition is allowed.
        virtual bool onRedefineMacro(const Macro& macro, const Macro& previousMacro);
 
        // Callback function when a macro is about to be undefined, return true if the undefinition is allowed.
        virtual bool onUndefineMacro(const Macro& macro);
 
        // Callback function when the standard macro must be substituted (e.g. __FILE__ to string literal).
        virtual bool onSubstituteStdMacro(const Token& identifierToken, TokenPtrString& tokenString);
 
        // Evaluate the expression of the specified token string.
        Variant evaluateExpression(const TokenPtrString& tokenString, const Token* token = nullptr);
 
        // Parse a token string and evaluate it as expression.
        Variant parseAndEvaluateExpression(const Token* token = nullptr);
 
        // Parse a token string as argument and evaluate it as expression.
        Variant parseAndEvaluateArgumentExpression(const Token* token = nullptr);
 
        // Returns the output stream as reference.
        inline StringStream& getOutputStream() { return *mOutput; }
 
    private:
        ScannerPtr makeScanner() override;
 
        void pushScannerSource(const SourceCodePtr& source, const String& filename = "") override;
        bool popScannerSource() override;
 
        void pushIfBlock(const TokenPtr& directiveToken, bool active = false, bool elseAllowed = true);
        void setIfBlock(const TokenPtr& directiveToken, bool active = false, bool elseAllowed = true);
        void popIfBlock();
 
        // Returns the if-block state from the top of the stack. If the stack is empty, the default state is returned.
        [[nodiscard]] IfBlock getTopIfBlock() const;
 
        TokenPtrString expandMacro(const Macro& macro, const Vector<TokenPtrString>& arguments);
 
        // Writes a '#line'-directive to the output with the current source position and filename.
        void writePosToLineDirective();
 
    private: // Parsing
        void parseProgram();
 
        void paresComment();
        void parseIdent();
        TokenPtrString parseIdentAsTokenString();
        TokenPtrString parseIdentArgumentsForMacro(const TokenPtr& identifierToken, const Macro& macro);
        void parseMisc();
 
        void parseDirective();
        void parseAnyIfDirectiveAndSkipValidation();
        void parseDirectiveDefine();
        void parseDirectiveUndef();
        void parseDirectiveInclude();
        void parseDirectiveIf(bool skipEvaluation = false);
        void parseDirectiveIfdef(bool skipEvaluation = false);
        void parseDirectiveIfndef(bool skipEvaluation = false);
        void parseDirectiveElif(bool skipEvaluation = false);
        void parseDirectiveIfOrElifCondition(bool isElseBranch, bool skipEvaluation = false);
        void parseDirectiveElse();
        void parseDirectiveEndif();
        void parseDirectivePragma();
        void parseDirectiveLine();
        void parseDirectiveError();
        void parseDirectiveSpecialization();
 
        ExpressionPtr parseExpression();
        ExpressionPtr parsePrimaryExpression() override;
 
        TokenPtrString parseDirectiveTokenString(bool expandDefinedDirective = false, bool ignoreComments = false);
        TokenPtrString parseArgumentTokenString();
 
        String parseDefinedMacro();
        String parseDefinedSpecialization();
    };
 
} // namespace CeresEngine::ShaderCompiler