Module.Windows.cpp

#include "Module.h"
 
#include "Unicode.h"
#include "../Logging/Logger.h"
#include <array>
#include <span>
 
namespace
{
  const Cogs::Logging::Log logger = Cogs::Logging::getLogger("Module");
 
 
  std::span<const char*> dllVersions() {
#if defined( DEBUG )
    static std::array paths = { ".Debug.dll" };
    return std::span<const char*>(paths);
#elif defined( OSOMP_EnableProfiler )
    static std::array paths = { ".ReleaseMemProfile.dll", ".Release.dll" };
    return std::span<const char*>(paths);
#elif defined( ASAN )
    static std::array paths = { ".ReleaseASan.dll", ".Release.dll" };
    return std::span<const char*>(paths);
#else
    static std::array paths = { ".Release.dll" };
    return std::span<const char*>(paths);
#endif
  }
}
 
void Cogs::Module::load(const std::string& path, LoadStatus& status, void*& handle) {
  std::string fullPath = path;
 
  if (fullPath.find(".dll") == std::string::npos) {
#if defined( _WIN64 )
    fullPath += ".x64";
#else
    fullPath += ".x32";
#endif
 
    std::span<const char*> versions = dllVersions();
    std::string libraryPath;
    libraryPath.reserve(fullPath.size() + 40);
    for (const char* version : versions) {
      libraryPath.clear();
      libraryPath += fullPath;
      libraryPath += version;
      handle = LoadLibraryW(Cogs::widen(libraryPath).c_str());
      if (handle) break;
    }
    if (!handle) {
      fullPath = libraryPath;
    }
  }
  else {
    handle = LoadLibraryW(Cogs::widen(path).c_str());
  }
 
  if (!handle) {
    DWORD  error = GetLastError();
    LPWSTR messageBuffer = nullptr;
    FormatMessageW(FORMAT_MESSAGE_ALLOCATE_BUFFER | FORMAT_MESSAGE_FROM_SYSTEM | FORMAT_MESSAGE_IGNORE_INSERTS,
                   nullptr,
                   error,
                   MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT),
                   reinterpret_cast<LPWSTR>(&messageBuffer),
                   0,
                   nullptr);
    std::string message = narrow(messageBuffer);
    LocalFree(messageBuffer);
    while (!message.empty() && (message.back() == '\r' || message.back() == '\n')) { message.pop_back(); }
    LOG_ERROR(logger, "Failed to load %s: Error %#x: %s", fullPath.c_str(), GetLastError(), message.c_str());
  }
 
  status = handle ? LoadStatus::Loaded : LoadStatus::Failed;
}
 
void Cogs::Module::unload(void* handle) {
  if (handle) {
    FreeLibrary(static_cast<HMODULE>(handle));
  }
}
 
void* Cogs::Module::getProcAddress(void* handle, const char* procName) {
  return GetProcAddress(static_cast<HMODULE>(handle), procName);
}