initialize()

bool Lila::ClangInterpreter::initialize

(

)

Initializes the Clang interpreter and prepares for code evaluation.

Returns

True if initialization succeeded, false otherwise

Definition at line 42 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");
    llvm::sys::DynamicLibrary::LoadLibraryPermanently("MayaFluxLib.dll");
#endif
 
    llvm::InitializeNativeTarget();
    llvm::InitializeNativeTargetAsmPrinter();
    llvm::InitializeNativeTargetAsmParser();
 
    m_impl->compile_flags.clear();
    m_impl->compile_flags.emplace_back("-std=c++23");
    m_impl->compile_flags.emplace_back("-DMAYASIMPLE");
 
    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);
 
    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/20");
        LILA_WARN(Emitter::INTERPRETER,
            "Using default clang resource dir: /usr/lib/clang/20");
    }
 
    auto system_includes = MayaFlux::Platform::SystemConfig::get_system_includes();
    for (const auto& include : system_includes) {
        m_impl->compile_flags.push_back("-isystem" + include);
    }
 
#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");
    }
#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");
#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");
 
    auto result = m_impl->interpreter->ParseAndExecute(
        "#include \"pch.h\"\n"
        "#include \"Lila/LiveAid.hpp\"\n");
 
    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 LILA_DEBUG, LILA_ERROR, LILA_INFO, and LILA_WARN.