initialize()

bool Lila::ClangInterpreter::initialize

(

bool

skip_host_library_load = false

)

Initialize the Clang interpreter.

Parameters

skip_host_library_load

If true, do not call LoadDynamicLibrary on MayaFluxLib. Pass true when the host process has already loaded MayaFluxLib (attach scenario). Pass false for standalone use (lila_server).

Returns

true on success.

Definition at line 62 of file ClangInterpreter.cpp.

{
    LILA_INFO(Emitter::INTERPRETER, "Initializing Clang interpreter");
 
#ifdef MAYAFLUX_PLATFORM_WINDOWS
    llvm::sys::DynamicLibrary::LoadLibraryPermanently("msvcp140.dll");
    llvm::sys::DynamicLibrary::LoadLibraryPermanently("vcruntime140.dll");
    llvm::sys::DynamicLibrary::LoadLibraryPermanently("ucrtbase.dll");
#endif
 
    llvm::InitializeNativeTarget();
    llvm::InitializeNativeTargetAsmPrinter();
    llvm::InitializeNativeTargetAsmParser();
 
    m_impl->compile_flags.clear();
    m_impl->compile_flags.emplace_back("-std=c++23");
 
#ifdef MAYAFLUX_PLATFORM_LINUX
    m_impl->compile_flags.emplace_back("-mcmodel=large");
    m_impl->compile_flags.emplace_back("-fPIC");
    m_impl->compile_flags.emplace_back("-fPIE");
#endif
 
    std::string pch_dir;
    if (std::filesystem::exists(MayaFlux::Config::PCH_RUNTIME_PATH)) {
        pch_dir = MayaFlux::Config::RUNTIME_DATA_DIR;
        LILA_DEBUG(Emitter::INTERPRETER,
            std::string("Using installed PCH from: ") + std::string(MayaFlux::Config::PCH_RUNTIME_PATH));
 
    } else if (std::filesystem::exists(MayaFlux::Config::PCH_SOURCE_PATH)) {
        pch_dir = std::string(MayaFlux::Config::SOURCE_DIR) + "/cmake";
        LILA_DEBUG(Emitter::INTERPRETER,
            std::string("Using source PCH from: ") + std::string(MayaFlux::Config::PCH_SOURCE_PATH));
 
    } else {
        m_last_error = "Cannot find pch.h in runtime or source locations";
        LILA_ERROR(Emitter::INTERPRETER, m_last_error);
        return false;
    }
 
    m_impl->compile_flags.push_back("-I" + pch_dir);
 
    const std::string& resource_dir = MayaFlux::Platform::SystemConfig::get_clang_resource_dir();
    if (!resource_dir.empty()) {
        m_impl->compile_flags.push_back("-resource-dir=" + resource_dir);
        LILA_DEBUG(Emitter::INTERPRETER,
            std::string("Using clang resource dir: ") + resource_dir);
    } else {
        m_impl->compile_flags.emplace_back("-resource-dir=/usr/lib/clang/21");
        LILA_WARN(Emitter::INTERPRETER,
            "Using default clang resource dir: /usr/lib/clang/21");
    }
 
    const auto& system_includes = MayaFlux::Platform::SystemConfig::get_system_includes();
    for (const auto& include : system_includes) {
        m_impl->compile_flags.push_back("-isystem" + include);
    }
 
#ifndef MAYAFLUX_PLATFORM_WINDOWS
    const auto& eigen_include = MayaFlux::Platform::SystemConfig::get_dep_includes("eigen");
    if (!eigen_include.empty()) {
        m_impl->compile_flags.push_back("-isystem" + eigen_include);
        LILA_DEBUG(Emitter::INTERPRETER,
            std::string("Added Eigen include path: ") + eigen_include);
    } else {
        LILA_WARN(Emitter::INTERPRETER,
            "Could not find Eigen include path - some features may not work");
    }
 
    const auto& freetype_include = MayaFlux::Platform::SystemConfig::get_dep_includes("freetype2");
    if (!freetype_include.empty()) {
        m_impl->compile_flags.push_back("-isystem" + freetype_include);
        LILA_DEBUG(Emitter::INTERPRETER,
            std::string("Added FreeType include path: ") + freetype_include);
    } else {
        LILA_WARN(Emitter::INTERPRETER,
            "Could not find FreeType include path - some features may not work");
    }
#endif
 
    const std::string magic_enum_include = std::string(MayaFlux::Config::MAGIC_ENUM_INCLUDE);
    if (!magic_enum_include.empty()) {
        m_impl->compile_flags.push_back("-I" + magic_enum_include);
        LILA_DEBUG(Emitter::INTERPRETER,
            std::string("Added magic_enum include path: ") + magic_enum_include);
    } else {
        LILA_WARN(Emitter::INTERPRETER,
            "Could not find magic_enum include path - some features may not work");
    }
 
#ifdef MAYAFLUX_PLATFORM_MACOS
    // CRITICAL: JIT uses Homebrew LLVM but needs macOS SDK for system headers
    // Homebrew LLVM's libc++ requires pthread.h, sched.h, time.h, etc. from SDK
    std::string sdk_path = MayaFlux::Platform::SystemConfig::get_macos_sdk_path();
    if (!sdk_path.empty()) {
        m_impl->compile_flags.push_back("-isysroot" + sdk_path);
        LILA_DEBUG(Emitter::INTERPRETER, "Using macOS SDK: " + sdk_path);
    } else {
        LILA_WARN(Emitter::INTERPRETER,
            "Could not find macOS SDK - JIT may fail to find system headers");
    }
    m_impl->compile_flags.emplace_back("-fexperimental-library");
#endif
 
    for (const auto& path : m_impl->include_paths) {
        m_impl->compile_flags.push_back("-I" + path);
    }
 
#ifdef MAYAFLUX_PLATFORM_WINDOWS
    m_impl->compile_flags.emplace_back("-fno-function-sections");
    m_impl->compile_flags.emplace_back("-fno-data-sections");
    m_impl->compile_flags.emplace_back("-fno-unique-section-names");
    m_impl->compile_flags.emplace_back("-D_CRT_SECURE_NO_WARNINGS");
#endif
 
    std::vector<const char*> args;
    for (const auto& flag : m_impl->compile_flags) {
        args.push_back(flag.c_str());
    }
 
    clang::IncrementalCompilerBuilder ICB;
    ICB.SetCompilerArgs(args);
 
    auto CI = ICB.CreateCpp();
    if (!CI) {
        m_last_error = "Failed to create CompilerInstance: " + llvm::toString(CI.takeError());
        LILA_ERROR(Emitter::INTERPRETER, m_last_error);
        return false;
    }
 
    auto interp = clang::Interpreter::create(std::move(*CI));
    if (!interp) {
        m_last_error = "Failed to create interpreter: " + llvm::toString(interp.takeError());
        LILA_ERROR(Emitter::INTERPRETER, m_last_error);
        return false;
    }
 
    m_impl->interpreter = std::move(*interp);
 
    LILA_INFO(Emitter::INTERPRETER, "Clang interpreter created successfully");
 
    if (skip_host_library_load) {
        LILA_DEBUG(Emitter::INTERPRETER,
            "Skipping MayaFluxLib load: host process already resident");
    } else {
        const auto& lib_to_load = MayaFlux::Platform::SystemConfig::find_dep_library(
            "MayaFluxLib", std::string(MayaFlux::Config::INSTALL_PREFIX));
 
        LILA_DEBUG(Emitter::INTERPRETER, "Loading MayaFlux library: " + lib_to_load);
 
        if (auto err = m_impl->interpreter->LoadDynamicLibrary(lib_to_load.c_str())) {
            m_last_error = "Failed to load " + lib_to_load + ": "
                + llvm::toString(std::move(err));
            LILA_ERROR(Emitter::INTERPRETER, m_last_error);
            return false;
        }
 
        LILA_DEBUG(Emitter::INTERPRETER, "Loaded " + lib_to_load);
    }
 
    const char* header_include = "#include \"pch.h\"\n"
                                 "#include \"MayaFlux/MayaFlux.hpp\"\n";
 
    auto result = m_impl->interpreter->ParseAndExecute(header_include);
 
    if (result) {
        std::string warning = "Failed to load MayaFlux headers: " + llvm::toString(std::move(result));
        LILA_WARN(Emitter::INTERPRETER, warning);
    } else {
        LILA_INFO(Emitter::INTERPRETER, "MayaFlux headers loaded successfully");
    }
 
    result = m_impl->interpreter->ParseAndExecute("std::cout << \"Ready for Live\" << std::flush;");
 
    return true;
}

References MayaFlux::Platform::SystemConfig::find_dep_library(), MayaFlux::Platform::SystemConfig::get_clang_resource_dir(), MayaFlux::Platform::SystemConfig::get_dep_includes(), MayaFlux::Platform::SystemConfig::get_system_includes(), LILA_DEBUG, LILA_ERROR, LILA_INFO, and LILA_WARN.

Here is the call graph for this function: