Context.hpp

Go to the documentation of this file.

#ifndef CHI_CONTEXT_HPP
#define CHI_CONTEXT_HPP

#pragma once

#include <memory>
#include <unordered_map>

#include "chi/Fwd.hpp"
#include "chi/ModuleCache.hpp"
#include "chi/Support/Flags.hpp"
#include "chi/Support/json.hpp"

#include <llvm/IR/LLVMContext.h>
#include <llvm/Support/CodeGen.h>  // for CodeGenOpt

#include <boost/filesystem/path.hpp>
#include <boost/utility/string_view.hpp>

namespace chi {

enum class CompileSettings {

    UseCache = 1u,

    LinkDependencies = 1u << 1,

    Default = UseCache | LinkDependencies
};

struct Context {
    Context(const boost::filesystem::path& workPath = {});

    ~Context();

    // no move or copy, doesn't make sense
    Context(const Context& context) = delete;
    Context(Context&&)              = delete;

    ChiModule* moduleByFullName(const boost::filesystem::path& fullModuleName) const noexcept;

    GraphModule* newGraphModule(const boost::filesystem::path& fullName);

    // init it (pretty sure it inits windows networking stuff)
    std::vector<std::string> listModulesInWorkspace() const noexcept;

    Result loadModule(const boost::filesystem::path& name, ChiModule** toFill = nullptr);

    Result addModuleFromJson(const boost::filesystem::path& fullName, const nlohmann::json& json,
                             GraphModule** toFill = nullptr);

    bool addModule(std::unique_ptr<ChiModule> modToAdd) noexcept;

    bool unloadModule(const boost::filesystem::path& fullName);

    Result typeFromModule(const boost::filesystem::path& module, boost::string_view name,
                          DataType* toFill) noexcept;

    Result nodeTypeFromModule(const boost::filesystem::path& moduleName,
                              boost::string_view typeName, const nlohmann::json& data,
                              std::unique_ptr<NodeType>* toFill) noexcept;
                              
    std::unique_ptr<NodeType> createConverterNodeType(const DataType& fromType, const DataType& toType);

    boost::filesystem::path workspacePath() const { return mWorkspacePath; }
    bool hasWorkspace() const noexcept { return !workspacePath().empty(); }

    Result compileModule(const boost::filesystem::path& fullName, Flags<CompileSettings> settings,
                         std::unique_ptr<llvm::Module>* toFill);

    Result compileModule(ChiModule& mod, Flags<CompileSettings> settings,
                         std::unique_ptr<llvm::Module>* toFill);

    std::vector<NodeInstance*> findInstancesOfType(const boost::filesystem::path& moduleName,
                                                   boost::string_view             typeName) const;

    llvm::LLVMContext& llvmContext() { return mLLVMContext; }

    LangModule* langModule() const { return mLangModule; }

    std::vector<ChiModule*> modules() const {
        std::vector<ChiModule*> ret;

        for (const auto& mod : mModules) { ret.push_back(mod.get()); }

        return ret;
    }

    const ModuleCache& moduleCache() const { return *mModuleCache; }

    ModuleCache& moduleCache() { return *mModuleCache; }

    void setModuleCache(std::unique_ptr<ModuleCache> newCache);

private:
    boost::filesystem::path mWorkspacePath;

    llvm::LLVMContext mLLVMContext;

    std::vector<std::unique_ptr<ChiModule>> mModules;

    // This cache is only for use during compilation to not duplicate modules
    std::unordered_map<std::string /*full name*/, llvm::Module* /*the compiled module*/>
        mCompileCache;

    LangModule* mLangModule = nullptr;

    std::unique_ptr<ModuleCache> mModuleCache;
    
    std::unordered_map<std::string /*from Type*/, std::unordered_map<std::string /*to type*/, std::unique_ptr<NodeType>>> mTypeConverters;
};

boost::filesystem::path workspaceFromChildPath(const boost::filesystem::path& path);

std::string stringifyLLVMType(llvm::Type* ty);

Result interpretLLVMIR(std::unique_ptr<llvm::Module>          mod,
                       llvm::CodeGenOpt::Level                optLevel = llvm::CodeGenOpt::Default,
                       const std::vector<llvm::GenericValue>& args     = {},
                       llvm::Function* funcToRun = nullptr, llvm::GenericValue* ret = nullptr);

Result interpretLLVMIRAsMain(std::unique_ptr<llvm::Module>   mod,
                             llvm::CodeGenOpt::Level         optLevel = llvm::CodeGenOpt::Default,
                             const std::vector<std::string>& args     = {},
                             llvm::Function* funcToRun = nullptr, int* ret = nullptr);
}  // namespace chi

#endif  // CHI_CONTEXT_HPP