context.h

// Copyright (c) 2020-now by the Zeek Project. See LICENSE for details.
 
#pragma once
 
#include <map>
#include <memory>
#include <string>
#include <tuple>
#include <unordered_map>
#include <utility>
#include <vector>
 
#include <hilti/rt/any.h>
#include <hilti/rt/filesystem.h>
 
#include <hilti/ast/id.h>
#include <hilti/autogen/config.h>
#include <hilti/base/logger.h>
#include <hilti/base/result.h>
#include <hilti/base/util.h>
 
namespace hilti {
 
class PluginRegistry;
class Unit;
 
struct Options {
    bool debug = false; 
    bool debug_trace =
        false; 
    bool debug_flow = false; 
    bool track_location = true;   
    bool skip_validation = false; 
    bool enable_profiling = false; 
    std::vector<hilti::rt::filesystem::path> library_paths; 
    std::string cxx_namespace_extern =
        "hlt"; 
    // NOTE: This should be consistent with identifiers generated with `HILTI_INTERNAL_GLOBAL_ID`.
    std::string cxx_namespace_intern = HILTI_INTERNAL_NS_ID; 
    std::vector<hilti::rt::filesystem::path>
        cxx_include_paths;             
    bool keep_tmps = false;            
    std::vector<std::string> cxx_link; 
    bool cxx_enable_dynamic_globals =
        false; 
    bool global_optimizations = true;    
    bool import_standard_modules = true; 
    enum class PublicAPIMode {
        Strict, 
        NonStrict, 
        Default,   
    };
 
    PublicAPIMode public_api_mode = PublicAPIMode::Default;
 
    template<typename T>
    T getAuxOption(const std::string& key, T default_) const {
        auto i = _aux_options.find(key);
        if ( i != _aux_options.end() )
            return hilti::rt::any_cast<T>(i->second);
        else
            return default_;
    }
 
    template<typename T>
    void setAuxOption(const std::string& key, T value) {
        _aux_options[key] = value;
    }
 
    Result<Nothing> parseDebugAddl(const std::string& flags);
 
    void print(std::ostream& out) const;
 
private:
    std::map<std::string, hilti::rt::any> _aux_options;
};
 
namespace context {} // namespace context
 
class Context {
public:
    explicit Context(Options options);
 
    ~Context();
 
    const Options& options() const { return _options; }
 
    auto* astContext() const { return _ast_context.get(); }
 
private:
    Options _options;
    std::unique_ptr<ASTContext> _ast_context;
};
 
} // namespace hilti