summaryrefslogtreecommitdiffstats
path: root/src/common
diff options
context:
space:
mode:
Diffstat (limited to '')
-rw-r--r--src/common/CMakeLists.txt2
-rw-r--r--src/common/dynamic_library.cpp106
-rw-r--r--src/common/dynamic_library.h75
-rw-r--r--src/common/file_util.cpp22
-rw-r--r--src/common/thread.cpp9
5 files changed, 199 insertions, 15 deletions
diff --git a/src/common/CMakeLists.txt b/src/common/CMakeLists.txt
index fbebed715..eeceaa655 100644
--- a/src/common/CMakeLists.txt
+++ b/src/common/CMakeLists.txt
@@ -106,6 +106,8 @@ add_library(common STATIC
common_funcs.h
common_paths.h
common_types.h
+ dynamic_library.cpp
+ dynamic_library.h
file_util.cpp
file_util.h
hash.h
diff --git a/src/common/dynamic_library.cpp b/src/common/dynamic_library.cpp
new file mode 100644
index 000000000..7ab54e9e4
--- /dev/null
+++ b/src/common/dynamic_library.cpp
@@ -0,0 +1,106 @@
+// Copyright 2019 Dolphin Emulator Project
+// Licensed under GPLv2+
+// Refer to the license.txt file included.
+
+#include <cstring>
+#include <string>
+#include <utility>
+
+#include <fmt/format.h>
+
+#include "common/dynamic_library.h"
+
+#ifdef _WIN32
+#include <windows.h>
+#else
+#include <dlfcn.h>
+#endif
+
+namespace Common {
+
+DynamicLibrary::DynamicLibrary() = default;
+
+DynamicLibrary::DynamicLibrary(const char* filename) {
+ Open(filename);
+}
+
+DynamicLibrary::DynamicLibrary(DynamicLibrary&& rhs) noexcept
+ : handle{std::exchange(rhs.handle, nullptr)} {}
+
+DynamicLibrary& DynamicLibrary::operator=(DynamicLibrary&& rhs) noexcept {
+ Close();
+ handle = std::exchange(rhs.handle, nullptr);
+ return *this;
+}
+
+DynamicLibrary::~DynamicLibrary() {
+ Close();
+}
+
+std::string DynamicLibrary::GetUnprefixedFilename(const char* filename) {
+#if defined(_WIN32)
+ return std::string(filename) + ".dll";
+#elif defined(__APPLE__)
+ return std::string(filename) + ".dylib";
+#else
+ return std::string(filename) + ".so";
+#endif
+}
+
+std::string DynamicLibrary::GetVersionedFilename(const char* libname, int major, int minor) {
+#if defined(_WIN32)
+ if (major >= 0 && minor >= 0)
+ return fmt::format("{}-{}-{}.dll", libname, major, minor);
+ else if (major >= 0)
+ return fmt::format("{}-{}.dll", libname, major);
+ else
+ return fmt::format("{}.dll", libname);
+#elif defined(__APPLE__)
+ const char* prefix = std::strncmp(libname, "lib", 3) ? "lib" : "";
+ if (major >= 0 && minor >= 0)
+ return fmt::format("{}{}.{}.{}.dylib", prefix, libname, major, minor);
+ else if (major >= 0)
+ return fmt::format("{}{}.{}.dylib", prefix, libname, major);
+ else
+ return fmt::format("{}{}.dylib", prefix, libname);
+#else
+ const char* prefix = std::strncmp(libname, "lib", 3) ? "lib" : "";
+ if (major >= 0 && minor >= 0)
+ return fmt::format("{}{}.so.{}.{}", prefix, libname, major, minor);
+ else if (major >= 0)
+ return fmt::format("{}{}.so.{}", prefix, libname, major);
+ else
+ return fmt::format("{}{}.so", prefix, libname);
+#endif
+}
+
+bool DynamicLibrary::Open(const char* filename) {
+#ifdef _WIN32
+ handle = reinterpret_cast<void*>(LoadLibraryA(filename));
+#else
+ handle = dlopen(filename, RTLD_NOW);
+#endif
+ return handle != nullptr;
+}
+
+void DynamicLibrary::Close() {
+ if (!IsOpen())
+ return;
+
+#ifdef _WIN32
+ FreeLibrary(reinterpret_cast<HMODULE>(handle));
+#else
+ dlclose(handle);
+#endif
+ handle = nullptr;
+}
+
+void* DynamicLibrary::GetSymbolAddress(const char* name) const {
+#ifdef _WIN32
+ return reinterpret_cast<void*>(GetProcAddress(reinterpret_cast<HMODULE>(handle), name));
+#else
+ return reinterpret_cast<void*>(dlsym(handle, name));
+#endif
+}
+
+} // namespace Common
diff --git a/src/common/dynamic_library.h b/src/common/dynamic_library.h
new file mode 100644
index 000000000..2a06372fd
--- /dev/null
+++ b/src/common/dynamic_library.h
@@ -0,0 +1,75 @@
+// Copyright 2019 Dolphin Emulator Project
+// Licensed under GPLv2+
+// Refer to the license.txt file included.
+
+#pragma once
+
+#include <string>
+
+namespace Common {
+
+/**
+ * Provides a platform-independent interface for loading a dynamic library and retrieving symbols.
+ * The interface maintains an internal reference count to allow one handle to be shared between
+ * multiple users.
+ */
+class DynamicLibrary final {
+public:
+ /// Default constructor, does not load a library.
+ explicit DynamicLibrary();
+
+ /// Automatically loads the specified library. Call IsOpen() to check validity before use.
+ explicit DynamicLibrary(const char* filename);
+
+ /// Moves the library.
+ DynamicLibrary(DynamicLibrary&&) noexcept;
+ DynamicLibrary& operator=(DynamicLibrary&&) noexcept;
+
+ /// Delete copies, we can't copy a dynamic library.
+ DynamicLibrary(const DynamicLibrary&) = delete;
+ DynamicLibrary& operator=(const DynamicLibrary&) = delete;
+
+ /// Closes the library.
+ ~DynamicLibrary();
+
+ /// Returns the specified library name with the platform-specific suffix added.
+ static std::string GetUnprefixedFilename(const char* filename);
+
+ /// Returns the specified library name in platform-specific format.
+ /// Major/minor versions will not be included if set to -1.
+ /// If libname already contains the "lib" prefix, it will not be added again.
+ /// Windows: LIBNAME-MAJOR-MINOR.dll
+ /// Linux: libLIBNAME.so.MAJOR.MINOR
+ /// Mac: libLIBNAME.MAJOR.MINOR.dylib
+ static std::string GetVersionedFilename(const char* libname, int major = -1, int minor = -1);
+
+ /// Returns true if a module is loaded, otherwise false.
+ bool IsOpen() const {
+ return handle != nullptr;
+ }
+
+ /// Loads (or replaces) the handle with the specified library file name.
+ /// Returns true if the library was loaded and can be used.
+ bool Open(const char* filename);
+
+ /// Unloads the library, any function pointers from this library are no longer valid.
+ void Close();
+
+ /// Returns the address of the specified symbol (function or variable) as an untyped pointer.
+ /// If the specified symbol does not exist in this library, nullptr is returned.
+ void* GetSymbolAddress(const char* name) const;
+
+ /// Obtains the address of the specified symbol, automatically casting to the correct type.
+ /// Returns true if the symbol was found and assigned, otherwise false.
+ template <typename T>
+ bool GetSymbol(const char* name, T* ptr) const {
+ *ptr = reinterpret_cast<T>(GetSymbolAddress(name));
+ return *ptr != nullptr;
+ }
+
+private:
+ /// Platform-dependent data type representing a dynamic library handle.
+ void* handle = nullptr;
+};
+
+} // namespace Common
diff --git a/src/common/file_util.cpp b/src/common/file_util.cpp
index 41167f57a..35eee0096 100644
--- a/src/common/file_util.cpp
+++ b/src/common/file_util.cpp
@@ -3,6 +3,7 @@
// Refer to the license.txt file included.
#include <array>
+#include <limits>
#include <memory>
#include <sstream>
#include <unordered_map>
@@ -530,11 +531,11 @@ void CopyDir(const std::string& source_path, const std::string& dest_path) {
std::optional<std::string> GetCurrentDir() {
// Get the current working directory (getcwd uses malloc)
#ifdef _WIN32
- wchar_t* dir;
- if (!(dir = _wgetcwd(nullptr, 0))) {
+ wchar_t* dir = _wgetcwd(nullptr, 0);
+ if (!dir) {
#else
- char* dir;
- if (!(dir = getcwd(nullptr, 0))) {
+ char* dir = getcwd(nullptr, 0);
+ if (!dir) {
#endif
LOG_ERROR(Common_Filesystem, "GetCurrentDirectory failed: {}", GetLastErrorMsg());
return {};
@@ -918,19 +919,22 @@ void IOFile::Swap(IOFile& other) noexcept {
bool IOFile::Open(const std::string& filename, const char openmode[], int flags) {
Close();
+ bool m_good;
#ifdef _WIN32
if (flags != 0) {
m_file = _wfsopen(Common::UTF8ToUTF16W(filename).c_str(),
Common::UTF8ToUTF16W(openmode).c_str(), flags);
+ m_good = m_file != nullptr;
} else {
- _wfopen_s(&m_file, Common::UTF8ToUTF16W(filename).c_str(),
- Common::UTF8ToUTF16W(openmode).c_str());
+ m_good = _wfopen_s(&m_file, Common::UTF8ToUTF16W(filename).c_str(),
+ Common::UTF8ToUTF16W(openmode).c_str()) == 0;
}
#else
- m_file = fopen(filename.c_str(), openmode);
+ m_file = std::fopen(filename.c_str(), openmode);
+ m_good = m_file != nullptr;
#endif
- return IsOpen();
+ return m_good;
}
bool IOFile::Close() {
@@ -956,7 +960,7 @@ u64 IOFile::Tell() const {
if (IsOpen())
return ftello(m_file);
- return -1;
+ return std::numeric_limits<u64>::max();
}
bool IOFile::Flush() {
diff --git a/src/common/thread.cpp b/src/common/thread.cpp
index fe7a420cc..0cd2d10bf 100644
--- a/src/common/thread.cpp
+++ b/src/common/thread.cpp
@@ -28,11 +28,8 @@ namespace Common {
#ifdef _MSC_VER
// Sets the debugger-visible name of the current thread.
-// Uses undocumented (actually, it is now documented) trick.
-// http://msdn.microsoft.com/library/default.asp?url=/library/en-us/vsdebug/html/vxtsksettingthreadname.asp
-
-// This is implemented much nicer in upcoming msvc++, see:
-// http://msdn.microsoft.com/en-us/library/xcb2z8hs(VS.100).aspx
+// Uses trick documented in:
+// https://docs.microsoft.com/en-us/visualstudio/debugger/how-to-set-a-thread-name-in-native-code
void SetCurrentThreadName(const char* name) {
static const DWORD MS_VC_EXCEPTION = 0x406D1388;
@@ -47,7 +44,7 @@ void SetCurrentThreadName(const char* name) {
info.dwType = 0x1000;
info.szName = name;
- info.dwThreadID = -1; // dwThreadID;
+ info.dwThreadID = std::numeric_limits<DWORD>::max();
info.dwFlags = 0;
__try {
generated by cgit v1.2.3 (git 2.25.1) at 2024-09-14 02:27:50 +0200