gdl.h

Go to the documentation of this file.

#pragma once
 
// geomc
#include <gemc/glogging/glogger.h>
#include <gemc/guts/gutilities.h>
 
// POSIX dynamic loading
// documentation: http://www.faqs.org/docs/Linux-mini/C++-dlopen.html
#include <dlfcn.h>
 
// c++
#include <cstdlib>
#include <filesystem>
#include <sstream>
#include <sys/stat.h> // to check if file exists
#include <string>

typedef void* dlhandle;
 
static dlhandle load_lib(const std::string& path);
static void     close_lib(dlhandle handle);
 
// exit codes: 1000s
namespace gfactory {
inline constexpr int ERR_DLNOTFOUND = 1001;
inline constexpr int ERR_FACTORYNOTFOUND = 1002;
inline constexpr int ERR_DLHANDLENOTFOUND = 1003;
} // namespace gfactory
 

struct DynamicLib
{
private:
    std::string dlFileName;

    bool doesFileExists(const std::string& name) {
        struct stat buffer{};
        return (stat(name.c_str(), &buffer) == 0);
    }

    std::shared_ptr<GLogger> log;
 
public:
    DynamicLib() = default;

    DynamicLib(std::shared_ptr<GLogger> logger, std::string path) : dlFileName(path), log(logger), handle(nullptr) {
        log->debug(CONSTRUCTOR, "Instantiating ", path);
        log->debug(NORMAL, "Trying ", dlFileName);
 
        // Try GEMC_PLUGIN_PATH directories before falling back to gemc installation paths.
        if (!doesFileExists(dlFileName)) {
            log->debug(NORMAL, dlFileName, " not found...");
 
            if (const char* envPath = std::getenv("GEMC_PLUGIN_PATH")) {
                std::istringstream ss(envPath);
                std::string        dir;
                while (std::getline(ss, dir, ':')) {
                    const std::string candidate = dir + "/" + path;
                    if (doesFileExists(candidate)) {
                        dlFileName = candidate;
                        break;
                    }
                }
            }
            log->debug(NORMAL, "Trying ", dlFileName);
        }
 
        // Try installation path + "/lib" if not found at the provided location.
        if (!doesFileExists(dlFileName)) {
            log->debug(NORMAL, dlFileName, " not found...");
 
            std::filesystem::path gemcRoot = gutilities::gemc_root();
            dlFileName                     = gemcRoot.string() + "/lib/" + path;
 
            log->debug(NORMAL, "Trying ", dlFileName);
        }
 
        // Try installation path + "/build" if not found - allows Meson tests to run from the build dir.
        if (!doesFileExists(dlFileName)) {
            log->debug(NORMAL, dlFileName, " not found...");
 
            std::filesystem::path gemcRoot = gutilities::gemc_root();
            dlFileName                     = gemcRoot.string() + "/build/" + path;
 
            log->debug(NORMAL, "Trying ", dlFileName);
        }
 
        if (doesFileExists(dlFileName)) {
            dlFileName = std::filesystem::absolute(dlFileName).string();
            handle = load_lib(dlFileName);
            if (handle == nullptr) {
                char const* const dlopen_error = dlerror();
                log->error(gfactory::ERR_DLHANDLENOTFOUND, "File ", dlFileName,
                           " found, but handle is null. dlopen_error >> ",
                           dlopen_error != nullptr ? dlopen_error : "unknown dlopen error");
            }
            else { log->info(1, "Loaded ", dlFileName); }
        }
        else {
                const char* envPath = std::getenv("GEMC_PLUGIN_PATH");
                log->error(gfactory::ERR_DLNOTFOUND,
                           "could not find ", dlFileName, "\n",
                           "  GEMC_PLUGIN_PATH = ", (envPath ? envPath : "(not set)"), "\n",
                           "  Hint: set GEMC_PLUGIN_PATH or use -plugin_path=<dir> to the directory ",
                           "containing *.gplugin files.");
            }
    }

    dlhandle handle = nullptr;

    ~DynamicLib() {
        if (handle != nullptr) {
            close_lib(handle);
            log->debug(DESTRUCTOR, "Destroying ", dlFileName);
        }
    }
};
 

dlhandle load_lib(const std::string& lib) // never throws
{
    dlhandle h = nullptr;
 
#if defined(__linux__) && defined(RTLD_NODELETE)
    constexpr int dlopen_flags = RTLD_NOW | RTLD_NODELETE;
#else
    constexpr int dlopen_flags = RTLD_NOW;
#endif
 
    // If the caller already supplied a path (has a slash) just try it.
    if (lib.find('/') != std::string::npos) { h = dlopen(lib.c_str(), dlopen_flags); }
    else {
        // 1. Try the file in the current working directory.
        std::string cwdPath = "./" + lib;
        h                   = dlopen(cwdPath.c_str(), dlopen_flags);
 
        // 2. Fallback to the normal search path so LD_LIBRARY_PATH,
        //    RPATH/RUNPATH, system dirs, etc. are still honoured.
        if (!h) { h = dlopen(lib.c_str(), dlopen_flags); }
    }
    return h; // may be nullptr – caller should check and use dlerror()
}

static void close_lib(dlhandle handle) { dlclose(handle); }