Scanner.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/Function.hpp"
#include "CeresEngine/Foundation/SmartPtr.hpp"
#include "CeresEngine/Foundation/String.hpp"
 
#include "CeresEngine/Material/ShaderCompiler/Log.hpp"
#include "CeresEngine/Material/ShaderCompiler/ShaderCompiler.hpp"
#include "CeresEngine/Material/ShaderCompiler/SourceCode.hpp"
 
#include "CeresEngine/Material/ShaderCompiler/AST/SourceArea.hpp"
#include "CeresEngine/Material/ShaderCompiler/AST/Token.hpp"
#include "CeresEngine/Material/ShaderCompiler/AST/TokenString.hpp"
 
#include <functional>
 
namespace CeresEngine::ShaderCompiler {
 
    // Scanner base class.
    class Scanner {
    private:
        SourceCodePtr mSource;
        char mChr = 0;
 
        Log* mLog = nullptr;
 
        SourcePosition mNextStartPos;
        TokenPtr mActiveToken;
        TokenPtr mPrevToken;
 
        Vector<TokenPtrString::ConstIterator> mTokenStringItStack;
 
        // Active commentary string (in front of the next token).
        String mComment;
        UInt32 mCommentStartPos = 0;
        bool mCommentFirstLine = false;
 
    public:
        Scanner(Log* log = nullptr);
        virtual ~Scanner() = default;
 
        // Starts scanning the specified source code.
        bool scanSource(const SourceCodePtr& source);
 
        // 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();
 
        // Returns the iterator of the top most token string on the stack.
        [[nodiscard]] TokenPtrString::ConstIterator getTopTokenStringIterator() const;
 
        // Scanes the source code for the next token
        virtual TokenPtr next() = 0;
 
        // Returns the token previously returned by the "Next" function.
        [[nodiscard]] TokenPtr getActiveToken() const;
 
        // Returns the token previously returned by the "Next" function.
        [[nodiscard]] TokenPtr getPreviousToken() const;
 
        // Returns the start position of the token previously returned by the "Next" function.
        [[nodiscard]] inline const SourcePosition& getPosition() const { return mNextStartPos; }
 
        // Returns the source code which is currently being scanned.
        [[nodiscard]] inline SourceCode* getSource() const { return mSource.get(); }
 
        // Returns the source code which is currently being scanned.
        [[nodiscard]] inline const SourceCodePtr& getSharedSource() const { return mSource; }
 
        // Returns the active commentary string, which is in front of the next token.
        [[nodiscard]] inline const String& getComment() const { return mComment; }
 
    protected:
        using Tokens = Token::Types;
 
        TokenPtr nextToken(bool scanComments, bool scanWhiteSpaces);
 
        void storeStartPos();
 
        virtual TokenPtr scanToken() = 0;
 
        char take(char chr);
        char takeIt();
 
        TokenPtr make(const Token::Types& type, bool takeChr = false);
        TokenPtr make(const Token::Types& type, String& spell, bool takeChr = false);
        TokenPtr make(const Token::Types& type, String& spell, const SourcePosition& pos, bool takeChr = false);
 
    protected: // Report Handling
        // Throws an instance of the exception Report class.
        [[noreturn]] void error(const String& msg);
 
        // Throws an 'unexpected character' error.
        [[noreturn]] void errorUnexpected();
 
        // Throws an 'unexpected character' error with suggestion which character was expected.
        [[noreturn]] void errorUnexpected(char expectedChar);
 
        // Throws an 'unexpected end-of-stream' error.
        [[noreturn]] void errorUnexpectedEos();
 
    protected: // Scanning
        // Ignores all characters which comply the specified predicate.
        void ignore(const UniqueFunction<bool(char) const>& pred);
        void ignoreWhiteSpaces(bool includeNewLines = true);
 
        TokenPtr scanWhiteSpaces(bool includeNewLines = true);
        TokenPtr scanCommentLine(bool scanComments);
        TokenPtr scanCommentBlock(bool scanComments);
        TokenPtr scanStringLiteral();
        TokenPtr scanCharLiteral();
        TokenPtr scanNumber(bool startWithPeriod = false);
        TokenPtr scanNumberOrDot();
        TokenPtr scanVarArg(String& spell);
 
        bool scanDigitSequence(String& spell);
 
    protected: // Helper functions
        // Returns true if the next character is a new-line character (i.e. '\n' or '\r').
        [[nodiscard]] inline bool isNewLine() const { return (mChr == '\n' || mChr == '\r'); }
 
        // Returns true if the next character is equal to the specified character.
        [[nodiscard]] inline bool is(const char chr) const { return (mChr == chr); }
 
        // Returns the next character.
        [[nodiscard]] inline char chr() const { return mChr; }
 
        // Returns the next character as 'unsigned char'.
        [[nodiscard]] inline unsigned char uChr() const { return static_cast<unsigned char>(mChr); }
 
    private:
        TokenPtr nextTokenScan(bool scanComments, bool scanWhiteSpaces);
 
        void appendComment(const String& s);
        void appendMultiLineComment(const String& s);
    };
 
    using ScannerPtr = SPtr<Scanner>;
 
} // namespace CeresEngine::ShaderCompiler