unit.h

// Copyright (c) 2020-now by the Zeek Project. See LICENSE for details.
 
#pragma once
 
#include <unistd.h>
 
#include <memory>
#include <set>
#include <string>
#include <utility>
#include <vector>
 
#include <hilti/rt/filesystem.h>
 
#include <hilti/ast/declarations/module.h>
#include <hilti/ast/id.h>
#include <hilti/base/logger.h>
#include <hilti/base/result.h>
#include <hilti/base/util.h>
#include <hilti/compiler/context.h>
#include <hilti/compiler/detail/cxx/unit.h>
#include <hilti/compiler/jit.h>
 
namespace hilti {
 
struct Plugin;
 
namespace linker {
using MetaData = detail::cxx::linker::MetaData;
} // namespace linker
 
class Unit {
public:
    ~Unit();
 
    declaration::Module* module() const;
 
    const auto& uid() const { return _uid; }
 
    void setUID(const declaration::module::UID& uid) { _uid = uid; }
 
    Result<Nothing> codegen();
 
    Result<Nothing> print(std::ostream& out) const;
 
    Result<Nothing> createPrototypes(std::ostream& out);
 
    Result<CxxCode> cxxCode() const;
 
    Result<linker::MetaData> linkerMetaData() const {
        if ( _cxx_unit )
            return _cxx_unit->linkerMetaData();
 
        return result::Error("no C++ code compiled");
    }
 
    bool isCompiledHILTI() const;
 
    bool requiresCompilation();
 
    void setRequiresCompilation() { _requires_compilation = true; }
 
    std::shared_ptr<Context> context() const { return _context.lock(); }
 
    const Options& options() const { return context()->options(); }
 
    static Result<std::shared_ptr<Unit>> fromSource(const std::shared_ptr<Context>& context, Builder* builder,
                                                    const hilti::rt::filesystem::path& path);
 
    static Result<std::shared_ptr<Unit>> fromCXX(const std::shared_ptr<Context>& context,
                                                 std::shared_ptr<detail::cxx::Unit> cxx,
                                                 const hilti::rt::filesystem::path& path = "");
 
    // Must already be part of AST.
    static std::shared_ptr<Unit> fromExistingUID(const std::shared_ptr<Context>& context, declaration::module::UID uid);
 
 
    static Result<std::shared_ptr<Unit>> link(const std::shared_ptr<Context>& context,
                                              const std::vector<linker::MetaData>& mds);
 
private:
    // Private constructor initializing the unit's meta data. Use the public
    // `from*()` factory functions instead to instantiate a unit.
    Unit(const std::shared_ptr<Context>& context, declaration::module::UID uid)
        : _context(context), _uid(std::move(uid)) {}
    Unit(const std::shared_ptr<Context>& context, declaration::module::UID uid,
         std::shared_ptr<detail::cxx::Unit> cxx_unit)
        : _context(context), _uid(std::move(uid)), _cxx_unit(std::move(cxx_unit)) {}
 
    Result<std::shared_ptr<detail::cxx::Unit>> _codegenModule(const declaration::module::UID& uid);
 
    std::weak_ptr<Context> _context;              // global context
    declaration::module::UID _uid;                // module's globally unique ID
    std::shared_ptr<detail::cxx::Unit> _cxx_unit; // compiled C++ code for this unit, once available
    bool _requires_compilation = false;           // mark explicitly as requiring compilation to C++
};
 
} // namespace hilti