Parser.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 "Scanner.hpp"
 
#include "CeresEngine/DataTypes.hpp"
 
#include "CeresEngine/Foundation/Function.hpp"
#include "CeresEngine/Foundation/SmartPtr.hpp"
#include "CeresEngine/Foundation/String.hpp"
#include "CeresEngine/Foundation/Utility.hpp"
#include "CeresEngine/Foundation/Container/Map.hpp"
#include "CeresEngine/Foundation/Container/Stack.hpp"
#include "CeresEngine/Foundation/Container/Vector.hpp"
 
#include "CeresEngine/Material/ShaderCompiler/Log.hpp"
 
#include "CeresEngine/Material/ShaderCompiler/AST/AST.hpp"
#include "CeresEngine/Material/ShaderCompiler/AST/ASTEnums.hpp"
#include "CeresEngine/Material/ShaderCompiler/AST/Token.hpp"
#include "CeresEngine/Material/ShaderCompiler/Report/ReportHandler.hpp"
 
#include "CeresEngine/Material/ShaderCompiler/AST/Visitor/Visitor.hpp"
 
namespace CeresEngine::ShaderCompiler {
 
    // Syntax parser base class.
    class Parser {
    protected:
        struct ParsingState {
            bool activeTemplate; // If true, '<' and '>' will not be parsed as a binary operator.
        };
 
    private:
        struct ScannerStackEntry {
            ScannerPtr scanner;
            String filename;
            TokenPtr nextToken;
        };
 
        ReportHandler mReportHandler;
        NameMangling mNameMangling;
 
        Log* mLog = nullptr;
        TokenPtr mToken;
 
        Stack<ScannerStackEntry> mScannerStack;
        Stack<ParsingState> mParsingStateStack;
        Stack<ASTPtr> mPreParsedASTStack;
 
        UInt32 mUnexpectedTokenCounter = 0;
        const UInt32 unexpectedTokenLimit = 3; //< this should never be less than 1
 
        bool mEnableWarnings = false;
 
    public:
        virtual ~Parser() = default;
 
    protected:
        using Tokens = Token::Types;
        using BinaryOpList = InitializerList<BinaryOp>;
 
        Parser(Log* log);
 
    protected: // Report Handling
        void error(const String& msg, const SourceArea& area, bool breakWithException = true);
        void error(const String& msg, const Token* token, bool breakWithException = true);
        void error(const String& msg, bool prevToken = true, bool breakWithException = true);
 
        void errorUnexpected(const String& hint = "", const Token* token = nullptr, bool breakWithException = false);
        void errorUnexpected(const Tokens type, const Token* token = nullptr, bool breakWithException = false);
 
        void errorInternal(const String& msg, const String& procName);
 
        void warning(const String& msg, const SourceArea& area);
        void warning(const String& msg, const Token* token);
        void warning(const String& msg, bool prevToken = true);
 
        void enableWarnings(bool enable);
 
    protected: // Scanner
        virtual ScannerPtr makeScanner() = 0;
 
        virtual void pushScannerSource(const SourceCodePtr& source, const String& filename = "");
        virtual bool popScannerSource();
 
        [[nodiscard]] ParsingState getActiveParsingState() const;
 
        // Returns the current token scanner.
        Scanner& getScanner();
 
        // Returns the filename for the current scanner source.
        [[nodiscard]] String getCurrentFilename() const;
 
        TokenPtr accept(const Tokens type);
        TokenPtr accept(const Tokens type, const String& spell);
        virtual TokenPtr acceptIt();
 
        // Pushes the specified token string onto the stack where further tokens will be parsed from the top of the stack.
        void pushTokenString(const TokenPtrString& tokenString);
        void popTokenString();
 
        // Ignores the next tokens if they are white spaces and optionally new lines.
        void ignoreWhiteSpaces(bool includeNewLines = false, bool includeComments = false);
        void ignoreNewLines();
 
    protected: // Source area
        // Sets the source area of the specified AST to area of the 'areaOriginAST' (if not null), and updates the area with the previous scanner token.
        template<typename T> const T& updateSourceArea(const T& ast, const AST* areaOriginAST = nullptr) {
            if(areaOriginAST) {
                ast->area = areaOriginAST->area;
            }
            ast->area.update(getScanner().getPreviousToken()->getSourceArea());
            return ast;
        }
 
        // Sets the source area of the specified AST to area of the first origin and updates the area with last origin.
        template<typename T> const T& updateSourceArea(const T& ast, const ASTPtr& firstAreaOriginAST, const ASTPtr& lastAreaOriginAST) {
            ast->area = firstAreaOriginAST->area;
            ast->area.update(*lastAreaOriginAST);
            return ast;
        }
 
        // Sets the source area offset of the specified AST to the source position of the previous scanner token.
        template<typename T> const T& updateSourceAreaOffset(const T& ast) {
            ast->area.offset(getScanner().getPreviousToken()->getPosition());
            return ast;
        }
 
    protected: // Parsing
        void pushParsingState(const ParsingState& state);
        void popParsingState();
 
        void pushPreParsedAST(const ASTPtr& ast);
        [[nodiscard]] ASTPtr popPreParsedAST();
 
        [[nodiscard]] ExpressionPtr parseGenericExpression();
        [[nodiscard]] TernaryExpressionPtr parseTernaryExpression(const ExpressionPtr& condExpression);
 
        [[nodiscard]] ExpressionPtr parseLogicOrExpression();
        [[nodiscard]] ExpressionPtr parseLogicAndExpression();
        [[nodiscard]] ExpressionPtr parseBitwiseOrExpression();
        [[nodiscard]] ExpressionPtr parseBitwiseXOrExpression();
        [[nodiscard]] ExpressionPtr parseBitwiseAndExpression();
        [[nodiscard]] ExpressionPtr parseEqualityExpression();
        [[nodiscard]] ExpressionPtr parseRelationExpression();
        [[nodiscard]] ExpressionPtr parseShiftExpression();
        [[nodiscard]] ExpressionPtr parseAddExpression();
        [[nodiscard]] ExpressionPtr parseSubExpression();
        [[nodiscard]] ExpressionPtr parseMulExpression();
        [[nodiscard]] ExpressionPtr parseDivExpression();
        [[nodiscard]] ExpressionPtr parseValueExpression();
 
        [[nodiscard]] virtual ExpressionPtr parsePrimaryExpression() = 0;
 
        [[nodiscard]] Int32 parseIntLiteral(TokenPtr token = nullptr);
        [[nodiscard]] Int32 parseIntLiteral(const String& valueStr, const Token* token = nullptr);
 
    protected: // Common
        // Returns the log pointer or null if no log was defined.
        [[nodiscard]] inline Log* getLog() const { return mLog; }
 
        // Returns a reference to the report handler.
        inline ReportHandler& getReportHandler() { return mReportHandler; }
 
        // Returns a reference to the name mangling options.
        inline NameMangling& getNameMangling() { return mNameMangling; }
 
        // Returns a pointer to the name mangling prefix the specified identifier conflicts with, or null if no conflict exists.
        [[nodiscard]] const String* findNameManglingPrefix(const String& ident) const;
 
        // Makes a new shared pointer of the specified AST node class.
        template<typename T, typename... Args> SPtr<T> make(Args&&... args) {
            return ce_shared_new<T>(getScanner().getPosition(), std::forward<Args>(args)...);
        }
 
        // Returns the current token.
        [[nodiscard]] inline const TokenPtr& getToken() const { return mToken; }
 
        // Returns the type of the next token.
        [[nodiscard]] inline Tokens getTokenType() const { return getToken()->getType(); }
 
        // Returns true if the next token is from the specified type.
        [[nodiscard]] inline bool is(const Tokens type) const { return (getTokenType() == type); }
 
        // Returns true if the next token is from the specified type and has the specified spelling.
        [[nodiscard]] inline bool is(const Tokens type, const String& spell) const { return (getTokenType() == type && getToken()->getSpelling() == spell); }
 
    private:
        // Parse left-to-right associative binary expression.
        ExpressionPtr parseLtrBinaryExpression(const UniqueFunction<ExpressionPtr() const>& parseSubExpressionFunc, const BinaryOpList& binaryOps);
 
        void incUnexpectedTokenCounter();
 
        void assertTokenType(const Tokens type);
        void assertTokenSpell(const String& spell);
    };
 
} // namespace CeresEngine::ShaderCompiler