SymbolTable.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/Foundation/Container/Map.hpp"
#include "CeresEngine/Foundation/Container/Stack.hpp"
#include "CeresEngine/Foundation/Container/Vector.hpp"
 
#include "CeresEngine/Material/ShaderCompiler/AST/AST.hpp"
 
#include <functional>
 
namespace CeresEngine::ShaderCompiler {
 
    // Returns the ranked distance between the two strings.
    UInt32 stringDistance(const String& a, const String& b);
 
    [[noreturn]] void runtimeErrNoActiveScope();
 
    [[noreturn]] void runtimeErrIdentAlreadyDeclared(const String& ident, const AST* prevDeclarationAST = nullptr);
 
    template<typename SymbolType> AST* fetchASTFromSymbol(const SymbolType& symbol);
 
    template<typename T> struct GenericDefaultValue {
        static T get() { return nullptr; }
    };
 
    template<> struct GenericDefaultValue<bool> {
        static bool get() { return false; }
    };
 
    // Common symbol table class with a single scope.
    template<typename SymbolType> class SymbolTable {
    public:
        // Callback function when a symbol is about to be overriden. Must return true to allow a symbol override.
        using OnOverrideProc = UniqueFunction<bool(SymbolType& prevSymbol) const>;
 
        // Callback function when a symbol is about to be released from its scope.
        using OnReleaseProc = UniqueFunction<void(const SymbolType& symbol) const>;
 
        // Search predicate function signature.
        using SearchPredicateProc = UniqueFunction<bool(const SymbolType& symbol) const>;
 
        SymbolTable() { openScope(); }
 
        // Opens a new scope.
        void openScope() {
            mScopeStack.push({});
            mSymTableAnonymous.push_back({});
        }
 
        // Closes the active scope.
        void closeScope(const OnReleaseProc& releaseProc = nullptr) {
            if(!mScopeStack.empty()) {
                for(const auto& ident : mScopeStack.top()) {
                    auto it = mSymTable.find(ident);
                    if(it != mSymTable.end()) {
                        if(releaseProc) {
                            releaseProc(it->second.top().symbol);
                        }
 
                        it->second.pop();
                        if(it->second.empty()) {
                            mSymTable.erase(it);
                        }
                    }
                }
 
                if(releaseProc) {
                    for(const auto& sym : mSymTableAnonymous.back()) {
                        releaseProc(sym.symbol);
                    }
                }
 
                mScopeStack.pop();
                mSymTableAnonymous.pop_back();
            }
        }
 
        bool register_(const String& ident, SymbolType symbol, const OnOverrideProc& overrideProc = nullptr, const bool throwOnFailure = true) {
            if(mScopeStack.empty()) {
                runtimeErrNoActiveScope();
            }
 
            if(ident.empty()) {
                mSymTableAnonymous.back().push_back({symbol, getScopeLevel()});
            } else {
                auto it = mSymTable.find(ident);
                if(it != mSymTable.end() && !it->second.empty()) {
                    auto& entry = it->second.top();
                    if(entry.symbol && entry.scopeLevel == getScopeLevel()) {
                        if(overrideProc && overrideProc(entry.symbol)) {
                            return true;
                        }
                        if(throwOnFailure) {
                            runtimeErrIdentAlreadyDeclared(ident, fetchASTFromSymbol(entry.symbol));
                        } else {
                            return false;
                        }
                    }
                }
 
                mSymTable[ident].push({symbol, getScopeLevel()});
                mScopeStack.top().push_back(ident);
            }
 
            return true;
        }
 
        // Returns the symbol with the specified identifer which is in the deepest scope, or null if there is no such symbol.
        [[nodiscard]] SymbolType fetch(const String& ident) const {
            auto it = mSymTable.find(ident);
            if(it != mSymTable.end() && !it->second.empty()) {
                return it->second.top().symbol;
            }
            return GenericDefaultValue<SymbolType>::get();
        }
 
        // Returns the symbol with the specified identifer which is in the current scope, or null if there is no such symbol.
        [[nodiscard]] SymbolType fetchFromCurrentScope(const String& ident) const {
            auto it = mSymTable.find(ident);
            if(it != mSymTable.end() && !it->second.empty()) {
                const auto& sym = it->second.top();
                if(sym.scopeLevel == getScopeLevel()) {
                    return sym.symbol;
                }
            }
            return GenericDefaultValue<SymbolType>::get();
        }
 
        // Returns the first symbol in the scope hierarchy for which the search predicate returns true.
        [[nodiscard]] SymbolType find(const SearchPredicateProc& searchPredicate) const {
            if(searchPredicate) {
                for(const auto& sym : mSymTable) {
                    if(!sym.second.empty()) {
                        const auto& symRef = sym.second.top().symbol;
                        if(searchPredicate(symRef)) {
                            return symRef;
                        }
                    }
                }
 
                if(!mSymTableAnonymous.empty()) {
                    for(auto scope = mSymTableAnonymous.rbegin(); scope != mSymTableAnonymous.rend(); ++scope) {
                        for(const auto& sym : *scope) {
                            if(searchPredicate(sym.symbol)) {
                                return sym.symbol;
                            }
                        }
                    }
                }
            }
            return GenericDefaultValue<SymbolType>::get();
        }
 
        // Returns an identifier that is similar to the specified identifier (for suggestions of typos)
        [[nodiscard]] String fetchSimilar(const String& ident) const {
            const String* similar = nullptr;
            UInt32 dist = static_cast<UInt32>(~0);
 
            for(const auto& symbol : mSymTable) {
                auto d = stringDistance(ident, symbol.first);
                if(d < dist) {
                    similar = (&symbol.first);
                    dist = d;
                }
            }
 
            if(similar != nullptr && dist < ident.size()) {
                return *similar;
            }
 
            return "";
        }
 
        // Returns current scope level.
        [[nodiscard]] std::size_t getScopeLevel() const { return mScopeStack.size(); }
 
        // Returns true if the symbol table is currently inside the global scope (i.e. scope level = 1).
        [[nodiscard]] bool isInsideGlobalScope() const { return (getScopeLevel() == 1); }
 
    private:
        struct Symbol {
            SymbolType symbol;
            std::size_t scopeLevel;
        };
 
        // Stores the scope stack for all identifiable symbols.
        Map<String, Stack<Symbol>> mSymTable;
 
        // Stores the scope stack for all anonymous symbols.
        Vector<Vector<Symbol>> mSymTableAnonymous;
 
        Stack<Vector<String>> mScopeStack;
    };
 
    // AST symbol table type.
    using ASTSymbolTable = SymbolTable<AST*>;
 
    // AST symbol class for the AST, that allows overloaded symbol (for functions).
    class ASTSymbolOverload {
    public:
        ASTSymbolOverload(const String& ident, AST* ast);
 
        // Adds the specified AST reference to this overloaded symbol, and return true if the overload is valid.
        bool addSymbolRef(AST* ast);
 
        // Fetches any AST. If there is more than one reference, an std::runtime_error is thrown.
        [[nodiscard]] AST* fetch(bool throwOnFailure = true) const;
 
        // Returns the VarDecl AST node.
        [[nodiscard]] VarDeclaration* fetchVarDeclaration(bool throwOnFailure = true) const;
 
        [[nodiscard]] Declaration* fetchType(bool throwOnFailure = true) const;
 
        // Returns the FunctionDecl AST node (if the function is not overloaded).
        [[nodiscard]] FunctionDeclaration* fetchFunctionDeclaration(bool throwOnFailure = true) const;
 
        // Returns the FunctionDecl AST node for the specified argument type denoter list (used to derive the overloaded function).
        [[nodiscard]] FunctionDeclaration* fetchFunctionDeclaration(const Vector<TypeDenoterPtr>& argTypeDenoters) const;
 
    private:
        String mIdent;
        Vector<AST*> mRefs;
    };
 
    using ASTSymbolOverloadPtr = SPtr<ASTSymbolOverload>;
 
    // AST symbol table type for ovloading.
    using ASTSymbolOverloadTable = SymbolTable<ASTSymbolOverloadPtr>;
 
    // Template to fetch AST node from a generic symbol type.
    template<typename SymbolType> AST* fetchASTFromSymbol(const SymbolType& symbol) { return nullptr; }
 
    template<> inline AST* fetchASTFromSymbol<ASTSymbolOverloadPtr>(const ASTSymbolOverloadPtr& symbol) { return symbol->fetch(false); }
 
} // namespace CeresEngine::ShaderCompiler