feat(debugger): Add specs for dbg/LibDebugger, overall code

improvements.
vendor(debugger): Add pfd for LibDebugger, to retrieve file to parse or
notify events.

Signed-off-by: Amlal El Mahrouss <amlal.elmahrouss@icloud.com>

4 files changed, 2058 insertions, 31 deletions

diff --git a/dev/LibDebugger/.private b/dev/LibDebugger/.private
deleted file mode 100644
index e69de29..0000000
--- a/dev/LibDebugger/.private
+++ /dev/null
diff --git a/dev/LibDebugger/POSIX.h b/dev/LibDebugger/POSIX.h
index d859868..0ebe929 100644
--- a/dev/LibDebugger/POSIX.h
+++ b/dev/LibDebugger/POSIX.h
@@ -43,50 +43,48 @@ namespace LibDebugger::POSIX
 		Debugger(const Debugger&)			 = default;
 
 	public:
-		void Attach(pid_t pid)
+		bool Attach(pid_t pid)
 		{
 			if (ptrace(PTRACE_ATTACH, pid, nullptr, 0) == -1)
 			{
-				perror("dbg: Attach");
-				return;
+				return false;
 			}
 
 			this->m_pid = pid;
 
 			waitpid(m_pid, nullptr, 0);
 
-			std::cout << "[+] Attached to process: " << m_pid << std::endl;
+			return true;
 		}
 
-		void Break(CAddr addr)
+		bool Break(CAddr addr)
 		{
 			uintptr_t original_data = ptrace(PTRACE_PEEKTEXT, m_pid, addr, 0);
 
 			if (original_data == -1)
 			{
-				perror("dbg: Peek");
-				return;
+				return false;
 			}
 
-			uintptr_t data_with_int3 = (original_data & ~0xFF) | 0xCC; // Insert INT3 (0xCC)
+			constexpr uint8_t kInt3x86 = 0xCC;
+
+			uintptr_t data_with_int3 = (original_data & ~0xFF) | kInt3x86; // Insert INT3 (0xCC)
 
 			if (ptrace(PTRACE_POKETEXT, m_pid, addr, data_with_int3) == -1)
 			{
-				perror("dbg: Poke");
-				return;
+				return false;
 			}
 
-			std::cout << "[+] Breakpoint set at: " << addr << std::endl;
-
 			m_breakpoints[reinterpret_cast<uintptr_t>(addr)] = original_data; // Store original data
+
+			return true;
 		}
 
-		void Continue()
+		bool Continue()
 		{
 			if (ptrace(PTRACE_CONT, m_pid, nullptr, 0) == -1)
 			{
-				perror("dbg: Cont");
-				return;
+				return false;
 			}
 
 			int status;
@@ -94,22 +92,23 @@ namespace LibDebugger::POSIX
 
 			if (WIFSTOPPED(status) && WSTOPSIG(status) == SIGTRAP)
 			{
-				std::cout << "[!] Breakpoint hit." << std::endl;
+				std::cout << "[!] Breakpoint has been hit!" << std::endl;
 			}
+
+			return true;
 		}
 
-		void Detach()
+		bool Detach()
 		{
 			if (ptrace(PTRACE_DETACH, m_pid, nullptr, 0) == -1)
 			{
-				perror("dbg: Detach");
-				return;
+				return false;
 			}
 
-			std::cout << "[-] Detached from process: " << m_pid << std::endl;
+			return true;
 		}
 
-		std::unordered_map<uintptr_t, uintptr_t>& Breakpoints()
+		std::unordered_map<uintptr_t, uintptr_t>& Get()
 		{
 			return m_breakpoints;
 		}
diff --git a/dev/LibDebugger/src/POSIX.cc b/dev/LibDebugger/src/POSIX.cc
index 21e122c..89ee572 100644
--- a/dev/LibDebugger/src/POSIX.cc
+++ b/dev/LibDebugger/src/POSIX.cc
@@ -3,10 +3,35 @@
  */
 
 #include <LibCompiler/Defines.h>
+#include <LibDebugger/vendor/Dialogs.h>
 #include <LibDebugger/POSIX.h>
+#include <cstdint>
+#include <string>
 
 #ifndef _WIN32
 
+static bool					 kKeepRunning = false;
+LibDebugger::POSIX::Debugger kDebugger;
+
+static void DebuggerCtrlCHandler(std::int32_t _)
+{
+	auto list = kDebugger.Get();
+
+	LibDebugger::POSIX::CAddr addr = (LibDebugger::POSIX::CAddr)list[list.size() - 1];
+
+	if (!addr)
+	{
+		pfd::notify("Debugger Event", "Invalid breakpoint at: " + std::to_string(list[list.size() - 1]));
+		return;
+	}
+
+	kDebugger.Break(addr);
+
+	pfd::notify("Debugger Event", "Breakpoint at: " + std::to_string(list[list.size() - 1]));
+
+	kKeepRunning = false;
+}
+
 LIBCOMPILER_MODULE(DebuggerPOSIX)
 {
 	if (argc < 1)
@@ -14,28 +39,37 @@ LIBCOMPILER_MODULE(DebuggerPOSIX)
 		return EXIT_FAILURE;
 	}
 
-	LibDebugger::POSIX::Debugger debugger;
-	pid_t						 pid = 0L;
+	pid_t pid = 0L;
 
 	if (argc >= 3 && std::string(argv[1]) == "-p" &&
 		argv[2] != nullptr)
 	{
 		pid = std::stoi(argv[2]);
-		debugger.Attach(pid);
+		kDebugger.Attach(pid);
 	}
 
+	::signal(SIGINT, DebuggerCtrlCHandler);
+
 	while (YES)
 	{
+		if (kKeepRunning)
+		{
+			continue;
+		}
+
 		std::string cmd;
 		std::getline(std::cin, cmd);
 
 		if (cmd == "c" ||
 			cmd == "cont")
-			debugger.Continue();
+		{
+			kDebugger.Continue();
+			kKeepRunning = true;
+		}
 
 		if (cmd == "d" ||
 			cmd == "detach")
-			debugger.Detach();
+			kDebugger.Detach();
 
 		if (cmd == "attach")
 		{
@@ -44,13 +78,15 @@ LIBCOMPILER_MODULE(DebuggerPOSIX)
 			std::getline(std::cin, cmd);
 			pid = std::stoi(cmd.c_str());
 
-			debugger.Attach(pid);
+			pfd::notify("Debugger Event", "Attach process: " + std::to_string(pid));
+
+			kDebugger.Attach(pid);
 		}
 
 		if (cmd == "exit")
 		{
 			if (pid > 0)
-				debugger.Detach();
+				kDebugger.Detach();
 
 			break;
 		}
@@ -58,14 +94,25 @@ LIBCOMPILER_MODULE(DebuggerPOSIX)
 		if (cmd == "break" ||
 			cmd == "b")
 		{
-			std::cout << "[?] Enter an address to add a breakpoint on: ";
+			std::cout << "[?] Enter an address/symbol to add a break on: ";
 
 			std::getline(std::cin, cmd);
 
-			LibDebugger::POSIX::CAddr breakpoint_addr = reinterpret_cast<LibDebugger::POSIX::CAddr>(std::stoul(cmd.c_str(), nullptr, 16));
+			auto addr = std::stoul(cmd.c_str(), nullptr, 16);
+
+			try
+			{
+				pfd::notify("Debugger Event", "Add Breakpoint at: " + std::to_string(addr));
+			}
+			catch (...)
+			{
+				pfd::notify("Debugger Event", "Add Breakpoint at: " + cmd);
+			}
+
+			LibDebugger::POSIX::CAddr breakpoint_addr = reinterpret_cast<LibDebugger::POSIX::CAddr>(addr);
 
 			if (breakpoint_addr)
-				debugger.Break(breakpoint_addr);
+				kDebugger.Break(breakpoint_addr);
 		}
 	}
 
diff --git a/dev/LibDebugger/vendor/Dialogs.h b/dev/LibDebugger/vendor/Dialogs.h
new file mode 100644
index 0000000..fd64026
--- /dev/null
+++ b/dev/LibDebugger/vendor/Dialogs.h
@@ -0,0 +1,1981 @@
+//
+//  Portable File Dialogs
+//
+//  Copyright © 2018–2022 Sam Hocevar <sam@hocevar.net>
+//
+//  This library is free software. It comes without any warranty, to
+//  the extent permitted by applicable law. You can redistribute it
+//  and/or modify it under the terms of the Do What the Fuck You Want
+//  to Public License, Version 2, as published by the WTFPL Task Force.
+//  See http://www.wtfpl.net/ for more details.
+//
+
+#pragma once
+
+#if _WIN32
+#ifndef WIN32_LEAN_AND_MEAN
+#define WIN32_LEAN_AND_MEAN 1
+#endif
+#include <windows.h>
+#include <commdlg.h>
+#include <shlobj.h>
+#include <shobjidl.h> // IFileDialog
+#include <shellapi.h>
+#include <strsafe.h>
+#include <future>	 // std::async
+#include <userenv.h> // GetUserProfileDirectory()
+
+#elif __EMSCRIPTEN__
+#include <emscripten.h>
+
+#else
+#ifndef _POSIX_C_SOURCE
+#define _POSIX_C_SOURCE 2 // for popen()
+#endif
+#ifdef __APPLE__
+#ifndef _DARWIN_C_SOURCE
+#define _DARWIN_C_SOURCE
+#endif
+#endif
+#include <cstdio>	  // popen()
+#include <cstdlib>	  // std::getenv()
+#include <fcntl.h>	  // fcntl()
+#include <unistd.h>	  // read(), pipe(), dup2(), getuid()
+#include <csignal>	  // ::kill, std::signal
+#include <sys/stat.h> // stat()
+#include <sys/wait.h> // waitpid()
+#include <pwd.h>	  // getpwnam()
+#endif
+
+#include <string>	// std::string
+#include <memory>	// std::shared_ptr
+#include <iostream> // std::ostream
+#include <map>		// std::map
+#include <set>		// std::set
+#include <regex>	// std::regex
+#include <thread>	// std::mutex, std::this_thread
+#include <chrono>	// std::chrono
+
+// Versions of mingw64 g++ up to 9.3.0 do not have a complete IFileDialog
+#ifndef PFD_HAS_IFILEDIALOG
+#define PFD_HAS_IFILEDIALOG 1
+#if (defined __MINGW64__ || defined __MINGW32__) && defined __GXX_ABI_VERSION
+#if __GXX_ABI_VERSION <= 1013
+#undef PFD_HAS_IFILEDIALOG
+#define PFD_HAS_IFILEDIALOG 0
+#endif
+#endif
+#endif
+
+namespace pfd
+{
+
+	enum class button
+	{
+		cancel = -1,
+		ok,
+		yes,
+		no,
+		abort,
+		retry,
+		ignore,
+	};
+
+	enum class choice
+	{
+		ok = 0,
+		ok_cancel,
+		yes_no,
+		yes_no_cancel,
+		retry_cancel,
+		abort_retry_ignore,
+	};
+
+	enum class icon
+	{
+		info = 0,
+		warning,
+		error,
+		question,
+	};
+
+	// Additional option flags for various dialog constructors
+	enum class opt : uint8_t
+	{
+		none = 0,
+		// For file open, allow multiselect.
+		multiselect = 0x1,
+		// For file save, force overwrite and disable the confirmation dialog.
+		force_overwrite = 0x2,
+		// For folder select, force path to be the provided argument instead
+		// of the last opened directory, which is the Microsoft-recommended,
+		// user-friendly behaviour.
+		force_path = 0x4,
+	};
+
+	inline opt operator|(opt a, opt b)
+	{
+		return opt(uint8_t(a) | uint8_t(b));
+	}
+	inline bool operator&(opt a, opt b)
+	{
+		return bool(uint8_t(a) & uint8_t(b));
+	}
+
+	// The settings class, only exposing to the user a way to set verbose mode
+	// and to force a rescan of installed desktop helpers (zenity, kdialog…).
+	class settings
+	{
+	public:
+		static bool available();
+
+		static void verbose(bool value);
+		static void rescan();
+
+	protected:
+		explicit settings(bool resync = false);
+
+		bool check_program(std::string const& program);
+
+		inline bool is_osascript() const;
+		inline bool is_zenity() const;
+		inline bool is_kdialog() const;
+
+		enum class flag
+		{
+			is_scanned = 0,
+			is_verbose,
+
+			has_zenity,
+			has_matedialog,
+			has_qarma,
+			has_kdialog,
+			is_vista,
+
+			max_flag,
+		};
+
+		// Static array of flags for internal state
+		bool const& flags(flag in_flag) const;
+
+		// Non-const getter for the static array of flags
+		bool& flags(flag in_flag);
+	};
+
+	// Internal classes, not to be used by client applications
+	namespace internal
+	{
+
+		// Process wait timeout, in milliseconds
+		static int const default_wait_timeout = 20;
+
+		class executor
+		{
+			friend class dialog;
+
+		public:
+			// High level function to get the result of a command
+			std::string result(int* exit_code = nullptr);
+
+			// High level function to abort
+			bool kill();
+
+#if _WIN32
+			void				 start_func(std::function<std::string(int*)> const& fun);
+			static BOOL CALLBACK enum_windows_callback(HWND hwnd, LPARAM lParam);
+#elif __EMSCRIPTEN__
+			void start(int exit_code);
+#else
+			void  start_process(std::vector<std::string> const& command);
+#endif
+
+			~executor();
+
+		protected:
+			bool ready(int timeout = default_wait_timeout);
+			void stop();
+
+		private:
+			bool		m_running = false;
+			std::string m_stdout;
+			int			m_exit_code = -1;
+#if _WIN32
+			std::future<std::string> m_future;
+			std::set<HWND>			 m_windows;
+			std::condition_variable	 m_cond;
+			std::mutex				 m_mutex;
+			DWORD					 m_tid;
+#elif __EMSCRIPTEN__ || __NX__
+			// FIXME: do something
+#else
+			pid_t m_pid = 0;
+			int	  m_fd	= -1;
+#endif
+		};
+
+		class platform
+		{
+		protected:
+#if _WIN32
+			// Helper class around LoadLibraryA() and GetProcAddress() with some safety
+			class dll
+			{
+			public:
+				dll(std::string const& name);
+				~dll();
+
+				template <typename T>
+				class proc
+				{
+				public:
+					proc(dll const& lib, std::string const& sym)
+						: m_proc(reinterpret_cast<T*>((void*)::GetProcAddress(lib.handle, sym.c_str())))
+					{
+					}
+
+					operator bool() const
+					{
+						return m_proc != nullptr;
+					}
+					operator T*() const
+					{
+						return m_proc;
+					}
+
+				private:
+					T* m_proc;
+				};
+
+			private:
+				HMODULE handle;
+			};
+
+			// Helper class around CoInitialize() and CoUnInitialize()
+			class ole32_dll : public dll
+			{
+			public:
+				ole32_dll();
+				~ole32_dll();
+				bool is_initialized();
+
+			private:
+				HRESULT m_state;
+			};
+
+			// Helper class around CreateActCtx() and ActivateActCtx()
+			class new_style_context
+			{
+			public:
+				new_style_context();
+				~new_style_context();
+
+			private:
+				HANDLE	  create();
+				ULONG_PTR m_cookie = 0;
+			};
+#endif
+		};
+
+		class dialog : protected settings, protected platform
+		{
+		public:
+			bool ready(int timeout = default_wait_timeout) const;
+			bool kill() const;
+
+		protected:
+			explicit dialog();
+
+			std::vector<std::string> desktop_helper() const;
+			static std::string		 buttons_to_name(choice _choice);
+			static std::string		 get_icon_name(icon _icon);
+
+			std::string powershell_quote(std::string const& str) const;
+			std::string osascript_quote(std::string const& str) const;
+			std::string shell_quote(std::string const& str) const;
+
+			// Keep handle to executing command
+			std::shared_ptr<executor> m_async;
+		};
+
+		class file_dialog : public dialog
+		{
+		protected:
+			enum type
+			{
+				open,
+				save,
+				folder,
+			};
+
+			file_dialog(type							in_type,
+						std::string const&				title,
+						std::string const&				default_path = "",
+						std::vector<std::string> const& filters		 = {},
+						opt								options		 = opt::none);
+
+		protected:
+			std::string				 string_result();
+			std::vector<std::string> vector_result();
+
+#if _WIN32
+			static int CALLBACK bffcallback(HWND hwnd, UINT uMsg, LPARAM, LPARAM pData);
+#if PFD_HAS_IFILEDIALOG
+			std::string select_folder_vista(IFileDialog* ifd, bool force_path);
+#endif
+
+			std::wstring m_wtitle;
+			std::wstring m_wdefault_path;
+
+			std::vector<std::string> m_vector_result;
+#endif
+		};
+
+	} // namespace internal
+
+	//
+	// The path class provides some platform-specific path constants
+	//
+
+	class path : protected internal::platform
+	{
+	public:
+		static std::string home();
+		static std::string separator();
+	};
+
+	//
+	// The notify widget
+	//
+
+	class notify : public internal::dialog
+	{
+	public:
+		notify(std::string const& title,
+			   std::string const& message,
+			   icon				  _icon = icon::info);
+	};
+
+	//
+	// The message widget
+	//
+
+	class message : public internal::dialog
+	{
+	public:
+		message(std::string const& title,
+				std::string const& text,
+				choice			   _choice = choice::ok_cancel,
+				icon			   _icon   = icon::info);
+
+		button result();
+
+	private:
+		// Some extra logic to map the exit code to button number
+		std::map<int, button> m_mappings;
+	};
+
+	//
+	// The open_file, save_file, and open_folder widgets
+	//
+
+	class open_file : public internal::file_dialog
+	{
+	public:
+		open_file(std::string const&			  title,
+				  std::string const&			  default_path = "",
+				  std::vector<std::string> const& filters	   = {"All Files", "*"},
+				  opt							  options	   = opt::none);
+
+#if defined(__has_cpp_attribute)
+#if __has_cpp_attribute(deprecated)
+		// Backwards compatibility
+		[[deprecated("Use pfd::opt::multiselect instead of allow_multiselect")]]
+#endif
+#endif
+		open_file(std::string const&			  title,
+				  std::string const&			  default_path,
+				  std::vector<std::string> const& filters,
+				  bool							  allow_multiselect);
+
+		std::vector<std::string> result();
+	};
+
+	class save_file : public internal::file_dialog
+	{
+	public:
+		save_file(std::string const&			  title,
+				  std::string const&			  default_path = "",
+				  std::vector<std::string> const& filters	   = {"All Files", "*"},
+				  opt							  options	   = opt::none);
+
+#if defined(__has_cpp_attribute)
+#if __has_cpp_attribute(deprecated)
+		// Backwards compatibility
+		[[deprecated("Use pfd::opt::force_overwrite instead of confirm_overwrite")]]
+#endif
+#endif
+		save_file(std::string const&			  title,
+				  std::string const&			  default_path,
+				  std::vector<std::string> const& filters,
+				  bool							  confirm_overwrite);
+
+		std::string result();
+	};
+
+	class select_folder : public internal::file_dialog
+	{
+	public:
+		select_folder(std::string const& title,
+					  std::string const& default_path = "",
+					  opt				 options	  = opt::none);
+
+		std::string result();
+	};
+
+	//
+	// Below this are all the method implementations. You may choose to define the
+	// macro PFD_SKIP_IMPLEMENTATION everywhere before including this header except
+	// in one place. This may reduce compilation times.
+	//
+
+#if !defined PFD_SKIP_IMPLEMENTATION
+
+	// internal free functions implementations
+
+	namespace internal
+	{
+
+#if _WIN32
+		static inline std::wstring str2wstr(std::string const& str)
+		{
+			int			 len = MultiByteToWideChar(CP_UTF8, 0, str.c_str(), (int)str.size(), nullptr, 0);
+			std::wstring ret(len, '\0');
+			MultiByteToWideChar(CP_UTF8, 0, str.c_str(), (int)str.size(), (LPWSTR)ret.data(), (int)ret.size());
+			return ret;
+		}
+
+		static inline std::string wstr2str(std::wstring const& str)
+		{
+			int			len = WideCharToMultiByte(CP_UTF8, 0, str.c_str(), (int)str.size(), nullptr, 0, nullptr, nullptr);
+			std::string ret(len, '\0');
+			WideCharToMultiByte(CP_UTF8, 0, str.c_str(), (int)str.size(), (LPSTR)ret.data(), (int)ret.size(), nullptr, nullptr);
+			return ret;
+		}
+
+		static inline bool is_vista()
+		{
+			OSVERSIONINFOEXW osvi;
+			memset(&osvi, 0, sizeof(osvi));
+			DWORDLONG const mask = VerSetConditionMask(
+				VerSetConditionMask(
+					VerSetConditionMask(
+						0, VER_MAJORVERSION, VER_GREATER_EQUAL),
+					VER_MINORVERSION, VER_GREATER_EQUAL),
+				VER_SERVICEPACKMAJOR, VER_GREATER_EQUAL);
+			osvi.dwOSVersionInfoSize = sizeof(osvi);
+			osvi.dwMajorVersion		 = HIBYTE(_WIN32_WINNT_VISTA);
+			osvi.dwMinorVersion		 = LOBYTE(_WIN32_WINNT_VISTA);
+			osvi.wServicePackMajor	 = 0;
+
+			return VerifyVersionInfoW(&osvi, VER_MAJORVERSION | VER_MINORVERSION | VER_SERVICEPACKMAJOR, mask) != FALSE;
+		}
+#endif
+
+		// This is necessary until C++20 which will have std::string::ends_with() etc.
+
+		static inline bool ends_with(std::string const& str, std::string const& suffix)
+		{
+			return suffix.size() <= str.size() &&
+				   str.compare(str.size() - suffix.size(), suffix.size(), suffix) == 0;
+		}
+
+		static inline bool starts_with(std::string const& str, std::string const& prefix)
+		{
+			return prefix.size() <= str.size() &&
+				   str.compare(0, prefix.size(), prefix) == 0;
+		}
+
+		// This is necessary until C++17 which will have std::filesystem::is_directory
+
+		static inline bool is_directory(std::string const& path)
+		{
+#if _WIN32
+			auto attr = GetFileAttributesA(path.c_str());
+			return attr != INVALID_FILE_ATTRIBUTES && (attr & FILE_ATTRIBUTE_DIRECTORY);
+#elif __EMSCRIPTEN__
+			// TODO
+			return false;
+#else
+			struct stat s;
+			return stat(path.c_str(), &s) == 0 && S_ISDIR(s.st_mode);
+#endif
+		}
+
+		// This is necessary because getenv is not thread-safe
+
+		static inline std::string getenv(std::string const& str)
+		{
+#if _MSC_VER
+			char*  buf	= nullptr;
+			size_t size = 0;
+			if (_dupenv_s(&buf, &size, str.c_str()) == 0 && buf)
+			{
+				std::string ret(buf);
+				free(buf);
+				return ret;
+			}
+			return "";
+#else
+			auto buf = std::getenv(str.c_str());
+			return buf ? buf : "";
+#endif
+		}
+
+	} // namespace internal
+
+	// settings implementation
+
+	inline settings::settings(bool resync)
+	{
+		flags(flag::is_scanned) &= !resync;
+
+		if (flags(flag::is_scanned))
+			return;
+
+		auto pfd_verbose = internal::getenv("PFD_VERBOSE");
+		auto match_no	 = std::regex("(|0|no|false)", std::regex_constants::icase);
+		if (!std::regex_match(pfd_verbose, match_no))
+			flags(flag::is_verbose) = true;
+
+#if _WIN32
+		flags(flag::is_vista) = internal::is_vista();
+#elif !__APPLE__
+		flags(flag::has_zenity) = check_program("zenity");
+		flags(flag::has_matedialog) = check_program("matedialog");
+		flags(flag::has_qarma) = check_program("qarma");
+		flags(flag::has_kdialog) = check_program("kdialog");
+
+		// If multiple helpers are available, try to default to the best one
+		if (flags(flag::has_zenity) && flags(flag::has_kdialog))
+		{
+			auto desktop_name = internal::getenv("XDG_SESSION_DESKTOP");
+			if (desktop_name == std::string("gnome"))
+				flags(flag::has_kdialog) = false;
+			else if (desktop_name == std::string("KDE"))
+				flags(flag::has_zenity) = false;
+		}
+#endif
+
+		flags(flag::is_scanned) = true;
+	}
+
+	inline bool settings::available()
+	{
+#if _WIN32
+		return true;
+#elif __APPLE__
+		return true;
+#elif __EMSCRIPTEN__
+		// FIXME: Return true after implementation is complete.
+		return false;
+#else
+		settings tmp;
+		return tmp.flags(flag::has_zenity) ||
+			   tmp.flags(flag::has_matedialog) ||
+			   tmp.flags(flag::has_qarma) ||
+			   tmp.flags(flag::has_kdialog);
+#endif
+	}
+
+	inline void settings::verbose(bool value)
+	{
+		settings().flags(flag::is_verbose) = value;
+	}
+
+	inline void settings::rescan()
+	{
+		settings(/* resync = */ true);
+	}
+
+	// Check whether a program is present using “which”.
+	inline bool settings::check_program(std::string const& program)
+	{
+#if _WIN32
+		(void)program;
+		return false;
+#elif __EMSCRIPTEN__
+		(void)program;
+		return false;
+#else
+		int exit_code = -1;
+		internal::executor async;
+		async.start_process({"/bin/sh", "-c", "which " + program});
+		async.result(&exit_code);
+		return exit_code == 0;
+#endif
+	}
+
+	inline bool settings::is_osascript() const
+	{
+#if __APPLE__
+		return true;
+#else
+		return false;
+#endif
+	}
+
+	inline bool settings::is_zenity() const
+	{
+		return flags(flag::has_zenity) ||
+			   flags(flag::has_matedialog) ||
+			   flags(flag::has_qarma);
+	}
+
+	inline bool settings::is_kdialog() const
+	{
+		return flags(flag::has_kdialog);
+	}
+
+	inline bool const& settings::flags(flag in_flag) const
+	{
+		static bool flags[size_t(flag::max_flag)];
+		return flags[size_t(in_flag)];
+	}
+
+	inline bool& settings::flags(flag in_flag)
+	{
+		return const_cast<bool&>(static_cast<settings const*>(this)->flags(in_flag));
+	}
+
+	// path implementation
+	inline std::string path::home()
+	{
+#if _WIN32
+		// First try the USERPROFILE environment variable
+		auto user_profile = internal::getenv("USERPROFILE");
+		if (user_profile.size() > 0)
+			return user_profile;
+		// Otherwise, try GetUserProfileDirectory()
+		HANDLE token		 = nullptr;
+		DWORD  len			 = MAX_PATH;
+		char   buf[MAX_PATH] = {'\0'};
+		if (OpenProcessToken(GetCurrentProcess(), TOKEN_QUERY, &token))
+		{
+			dll											   userenv("userenv.dll");
+			dll::proc<BOOL WINAPI(HANDLE, LPSTR, LPDWORD)> get_user_profile_directory(userenv, "GetUserProfileDirectoryA");
+			get_user_profile_directory(token, buf, &len);
+			CloseHandle(token);
+			if (*buf)
+				return buf;
+		}
+#elif __EMSCRIPTEN__
+		return "/";
+#else
+		// First try the HOME environment variable
+		auto home = internal::getenv("HOME");
+		if (home.size() > 0)
+			return home;
+		// Otherwise, try getpwuid_r()
+		size_t len = 4096;
+#if defined(_SC_GETPW_R_SIZE_MAX)
+		auto size_max = sysconf(_SC_GETPW_R_SIZE_MAX);
+		if (size_max != -1)
+			len = size_t(size_max);
+#endif
+		std::vector<char> buf(len);
+		struct passwd pwd, *result;
+		if (getpwuid_r(getuid(), &pwd, buf.data(), buf.size(), &result) == 0)
+			return result->pw_dir;
+#endif
+		return "/";
+	}
+
+	inline std::string path::separator()
+	{
+#if _WIN32
+		return "\\";
+#else
+		return "/";
+#endif
+	}
+
+	// executor implementation
+
+	inline std::string internal::executor::result(int* exit_code /* = nullptr */)
+	{
+		stop();
+		if (exit_code)
+			*exit_code = m_exit_code;
+		return m_stdout;
+	}
+
+	inline bool internal::executor::kill()
+	{
+#if _WIN32
+		if (m_future.valid())
+		{
+			// Close all windows that weren’t open when we started the future
+			auto previous_windows = m_windows;
+			EnumWindows(&enum_windows_callback, (LPARAM)this);
+			for (auto hwnd : m_windows)
+				if (previous_windows.find(hwnd) == previous_windows.end())
+				{
+					SendMessage(hwnd, WM_CLOSE, 0, 0);
+					// Also send IDNO in case of a Yes/No or Abort/Retry/Ignore messagebox
+					SendMessage(hwnd, WM_COMMAND, IDNO, 0);
+				}
+		}
+#elif __EMSCRIPTEN__ || __NX__
+		// FIXME: do something
+		return false; // cannot kill
+#else
+		::kill(m_pid, SIGKILL);
+#endif
+		stop();
+		return true;
+	}
+
+#if _WIN32
+	inline BOOL CALLBACK internal::executor::enum_windows_callback(HWND hwnd, LPARAM lParam)
+	{
+		auto that = (executor*)lParam;
+
+		DWORD pid;
+		auto  tid = GetWindowThreadProcessId(hwnd, &pid);
+		if (tid == that->m_tid)
+			that->m_windows.insert(hwnd);
+		return TRUE;
+	}
+#endif
+
+#if _WIN32
+	inline void internal::executor::start_func(std::function<std::string(int*)> const& fun)
+	{
+		stop();
+
+		auto trampoline = [fun, this]() {
+			// Save our thread id so that the caller can cancel us
+			m_tid = GetCurrentThreadId();
+			EnumWindows(&enum_windows_callback, (LPARAM)this);
+			m_cond.notify_all();
+			return fun(&m_exit_code);
+		};
+
+		std::unique_lock<std::mutex> lock(m_mutex);
+		m_future = std::async(std::launch::async, trampoline);
+		m_cond.wait(lock);
+		m_running = true;
+	}
+
+#elif __EMSCRIPTEN__
+	inline void internal::executor::start(int exit_code)
+	{
+		m_exit_code = exit_code;
+	}
+
+#else
+	inline void internal::executor::start_process(std::vector<std::string> const& command)
+	{
+		stop();
+		m_stdout.clear();
+		m_exit_code = -1;
+
+		int in[2], out[2];
+		if (pipe(in) != 0 || pipe(out) != 0)
+			return;
+
+		m_pid = fork();
+		if (m_pid < 0)
+			return;
+
+		close(in[m_pid ? 0 : 1]);
+		close(out[m_pid ? 1 : 0]);
+
+		if (m_pid == 0)
+		{
+			dup2(in[0], STDIN_FILENO);
+			dup2(out[1], STDOUT_FILENO);
+
+			// Ignore stderr so that it doesn’t pollute the console (e.g. GTK+ errors from zenity)
+			int fd = open("/dev/null", O_WRONLY);
+			dup2(fd, STDERR_FILENO);
+			close(fd);
+
+			std::vector<char*> args;
+			std::transform(command.cbegin(), command.cend(), std::back_inserter(args),
+						   [](std::string const& s) { return const_cast<char*>(s.c_str()); });
+			args.push_back(nullptr); // null-terminate argv[]
+
+			execvp(args[0], args.data());
+			exit(1);
+		}
+
+		close(in[1]);
+		m_fd = out[0];
+		auto flags = fcntl(m_fd, F_GETFL);
+		fcntl(m_fd, F_SETFL, flags | O_NONBLOCK);
+
+		m_running = true;
+	}
+#endif
+
+	inline internal::executor::~executor()
+	{
+		stop();
+	}
+
+	inline bool internal::executor::ready(int timeout /* = default_wait_timeout */)
+	{
+		if (!m_running)
+			return true;
+
+#if _WIN32
+		if (m_future.valid())
+		{
+			auto status = m_future.wait_for(std::chrono::milliseconds(timeout));
+			if (status != std::future_status::ready)
+			{
+				// On Windows, we need to run the message pump. If the async
+				// thread uses a Windows API dialog, it may be attached to the
+				// main thread and waiting for messages that only we can dispatch.
+				MSG msg;
+				while (PeekMessage(&msg, nullptr, 0, 0, PM_REMOVE))
+				{
+					TranslateMessage(&msg);
+					DispatchMessage(&msg);
+				}
+				return false;
+			}
+
+			m_stdout = m_future.get();
+		}
+#elif __EMSCRIPTEN__ || __NX__
+		// FIXME: do something
+		(void)timeout;
+#else
+		char buf[BUFSIZ];
+		ssize_t received = read(m_fd, buf, BUFSIZ); // Flawfinder: ignore
+		if (received > 0)
+		{
+			m_stdout += std::string(buf, received);
+			return false;
+		}
+
+		// Reap child process if it is dead. It is possible that the system has already reaped it
+		// (this happens when the calling application handles or ignores SIG_CHLD) and results in
+		// waitpid() failing with ECHILD. Otherwise we assume the child is running and we sleep for
+		// a little while.
+		int status;
+		pid_t child = waitpid(m_pid, &status, WNOHANG);
+		if (child != m_pid && (child >= 0 || errno != ECHILD))
+		{
+			// FIXME: this happens almost always at first iteration
+			std::this_thread::sleep_for(std::chrono::milliseconds(timeout));
+			return false;
+		}
+
+		close(m_fd);
+		m_exit_code = WEXITSTATUS(status);
+#endif
+
+		m_running = false;
+		return true;
+	}
+
+	inline void internal::executor::stop()
+	{
+		// Loop until the user closes the dialog
+		while (!ready())
+			;
+	}
+
+	// dll implementation
+
+#if _WIN32
+	inline internal::platform::dll::dll(std::string const& name)
+		: handle(::LoadLibraryA(name.c_str()))
+	{
+	}
+
+	inline internal::platform::dll::~dll()
+	{
+		if (handle)
+			::FreeLibrary(handle);
+	}
+#endif // _WIN32
+
+	// ole32_dll implementation
+
+#if _WIN32
+	inline internal::platform::ole32_dll::ole32_dll()
+		: dll("ole32.dll")
+	{
+		// Use COINIT_MULTITHREADED because COINIT_APARTMENTTHREADED causes crashes.
+		// See https://github.com/samhocevar/portable-file-dialogs/issues/51
+		auto coinit = proc<HRESULT WINAPI(LPVOID, DWORD)>(*this, "CoInitializeEx");
+		m_state		= coinit(nullptr, COINIT_MULTITHREADED);
+	}
+
+	inline internal::platform::ole32_dll::~ole32_dll()
+	{
+		if (is_initialized())
+			proc<void WINAPI()>(*this, "CoUninitialize")();
+	}
+
+	inline bool internal::platform::ole32_dll::is_initialized()
+	{
+		return m_state == S_OK || m_state == S_FALSE;
+	}
+#endif
+
+	// new_style_context implementation
+
+#if _WIN32
+	inline internal::platform::new_style_context::new_style_context()
+	{
+		// Only create one activation context for the whole app lifetime.
+		static HANDLE hctx = create();
+
+		if (hctx != INVALID_HANDLE_VALUE)
+			ActivateActCtx(hctx, &m_cookie);
+	}
+
+	inline internal::platform::new_style_context::~new_style_context()
+	{
+		DeactivateActCtx(0, m_cookie);
+	}
+
+	inline HANDLE internal::platform::new_style_context::create()
+	{
+		// This “hack” seems to be necessary for this code to work on windows XP.
+		// Without it, dialogs do not show and close immediately. GetError()
+		// returns 0 so I don’t know what causes this. I was not able to reproduce
+		// this behavior on Windows 7 and 10 but just in case, let it be here for
+		// those versions too.
+		// This hack is not required if other dialogs are used (they load comdlg32
+		// automatically), only if message boxes are used.
+		dll comdlg32("comdlg32.dll");
+
+		// Using approach as shown here: https://stackoverflow.com/a/10444161
+		UINT		len = ::GetSystemDirectoryA(nullptr, 0);
+		std::string sys_dir(len, '\0');
+		::GetSystemDirectoryA(&sys_dir[0], len);
+
+		ACTCTXA act_ctx =
+			{
+				// Do not set flag ACTCTX_FLAG_SET_PROCESS_DEFAULT, since it causes a
+				// crash with error “default context is already set”.
+				sizeof(act_ctx),
+				ACTCTX_FLAG_RESOURCE_NAME_VALID | ACTCTX_FLAG_ASSEMBLY_DIRECTORY_VALID,
+				"shell32.dll",
+				0,
+				0,
+				sys_dir.c_str(),
+				(LPCSTR)124,
+				nullptr,
+				0,
+			};
+
+		return ::CreateActCtxA(&act_ctx);
+	}
+#endif // _WIN32
+
+	// dialog implementation
+
+	inline bool internal::dialog::ready(int timeout /* = default_wait_timeout */) const
+	{
+		return m_async->ready(timeout);
+	}
+
+	inline bool internal::dialog::kill() const
+	{
+		return m_async->kill();
+	}
+
+	inline internal::dialog::dialog()
+		: m_async(std::make_shared<executor>())
+	{
+	}
+
+	inline std::vector<std::string> internal::dialog::desktop_helper() const
+	{
+#if __APPLE__
+		return {"osascript"};
+#else
+		return {flags(flag::has_zenity) ? "zenity"
+				: flags(flag::has_matedialog) ? "matedialog"
+				: flags(flag::has_qarma) ? "qarma"
+				: flags(flag::has_kdialog) ? "kdialog"
+										   : "echo"};
+#endif
+	}
+
+	inline std::string internal::dialog::buttons_to_name(choice _choice)
+	{
+		switch (_choice)
+		{
+		case choice::ok_cancel:
+			return "okcancel";
+		case choice::yes_no:
+			return "yesno";
+		case choice::yes_no_cancel:
+			return "yesnocancel";
+		case choice::retry_cancel:
+			return "retrycancel";
+		case choice::abort_retry_ignore:
+			return "abortretryignore";
+		/* case choice::ok: */ default:
+			return "ok";
+		}
+	}
+
+	inline std::string internal::dialog::get_icon_name(icon _icon)
+	{
+		switch (_icon)
+		{
+		case icon::warning:
+			return "warning";
+		case icon::error:
+			return "error";
+		case icon::question:
+			return "question";
+		// Zenity wants "information" but WinForms wants "info"
+		/* case icon::info: */ default:
+#if _WIN32
+			return "info";
+#else
+			return "information";
+#endif
+		}
+	}
+
+	// This is only used for debugging purposes
+	inline std::ostream& operator<<(std::ostream& s, std::vector<std::string> const& v)
+	{
+		int not_first = 0;
+		for (auto& e : v)
+			s << (not_first++ ? " " : "") << e;
+		return s;
+	}
+
+	// Properly quote a string for Powershell: replace ' or " with '' or ""
+	// FIXME: we should probably get rid of newlines!
+	// FIXME: the \" sequence seems unsafe, too!
+	// XXX: this is no longer used but I would like to keep it around just in case
+	inline std::string internal::dialog::powershell_quote(std::string const& str) const
+	{
+		return "'" + std::regex_replace(str, std::regex("['\"]"), "$&$&") + "'";
+	}
+
+	// Properly quote a string for osascript: replace \ or " with \\ or \"
+	// XXX: this also used to replace ' with \' when popen was used, but it would be
+	// smarter to do shell_quote(osascript_quote(...)) if this is needed again.
+	inline std::string internal::dialog::osascript_quote(std::string const& str) const
+	{
+		return "\"" + std::regex_replace(str, std::regex("[\\\\\"]"), "\\$&") + "\"";
+	}
+
+	// Properly quote a string for the shell: just replace ' with '\''
+	// XXX: this is no longer used but I would like to keep it around just in case
+	inline std::string internal::dialog::shell_quote(std::string const& str) const
+	{
+		return "'" + std::regex_replace(str, std::regex("'"), "'\\''") + "'";
+	}
+
+	// file_dialog implementation
+
+	inline internal::file_dialog::file_dialog(type							  in_type,
+											  std::string const&			  title,
+											  std::string const&			  default_path /* = "" */,
+											  std::vector<std::string> const& filters /* = {} */,
+											  opt							  options /* = opt::none */)
+	{
+#if _WIN32
+		std::string filter_list;
+		std::regex	whitespace("  *");
+		for (size_t i = 0; i + 1 < filters.size(); i += 2)
+		{
+			filter_list += filters[i] + '\0';
+			filter_list += std::regex_replace(filters[i + 1], whitespace, ";") + '\0';
+		}
+		filter_list += '\0';
+
+		m_async->start_func([this, in_type, title, default_path, filter_list,
+							 options](int* exit_code) -> std::string {
+			(void)exit_code;
+			m_wtitle		  = internal::str2wstr(title);
+			m_wdefault_path	  = internal::str2wstr(default_path);
+			auto wfilter_list = internal::str2wstr(filter_list);
+
+			// Initialise COM. This is required for the new folder selection window,
+			// (see https://github.com/samhocevar/portable-file-dialogs/pull/21)
+			// and to avoid random crashes with GetOpenFileNameW() (see
+			// https://github.com/samhocevar/portable-file-dialogs/issues/51)
+			ole32_dll ole32;
+
+			// Folder selection uses a different method
+			if (in_type == type::folder)
+			{
+#if PFD_HAS_IFILEDIALOG
+				if (flags(flag::is_vista))
+				{
+					// On Vista and higher we should be able to use IFileDialog for folder selection
+					IFileDialog* ifd;
+					HRESULT		 hr = dll::proc<HRESULT WINAPI(REFCLSID, LPUNKNOWN, DWORD, REFIID, LPVOID*)>(ole32, "CoCreateInstance")(CLSID_FileOpenDialog, nullptr, CLSCTX_INPROC_SERVER, IID_PPV_ARGS(&ifd));
+
+					// In case CoCreateInstance fails (which it should not), try legacy approach
+					if (SUCCEEDED(hr))
+						return select_folder_vista(ifd, options & opt::force_path);
+				}
+#endif
+
+				BROWSEINFOW bi;
+				memset(&bi, 0, sizeof(bi));
+
+				bi.lpfn	  = &bffcallback;
+				bi.lParam = (LPARAM)this;
+
+				if (flags(flag::is_vista))
+				{
+					if (ole32.is_initialized())
+						bi.ulFlags |= BIF_NEWDIALOGSTYLE;
+					bi.ulFlags |= BIF_EDITBOX;
+					bi.ulFlags |= BIF_STATUSTEXT;
+				}
+
+				auto*		list = SHBrowseForFolderW(&bi);
+				std::string ret;
+				if (list)
+				{
+					auto buffer = new wchar_t[MAX_PATH];
+					SHGetPathFromIDListW(list, buffer);
+					dll::proc<void WINAPI(LPVOID)>(ole32, "CoTaskMemFree")(list);
+					ret = internal::wstr2str(buffer);
+					delete[] buffer;
+				}
+				return ret;
+			}
+
+			OPENFILENAMEW ofn;
+			memset(&ofn, 0, sizeof(ofn));
+			ofn.lStructSize = sizeof(OPENFILENAMEW);
+			ofn.hwndOwner	= GetActiveWindow();
+
+			ofn.lpstrFilter = wfilter_list.c_str();
+
+			auto woutput  = std::wstring(MAX_PATH * 256, L'\0');
+			ofn.lpstrFile = (LPWSTR)woutput.data();
+			ofn.nMaxFile  = (DWORD)woutput.size();
+			if (!m_wdefault_path.empty())
+			{
+				// If a directory was provided, use it as the initial directory. If
+				// a valid path was provided, use it as the initial file. Otherwise,
+				// let the Windows API decide.
+				auto path_attr = GetFileAttributesW(m_wdefault_path.c_str());
+				if (path_attr != INVALID_FILE_ATTRIBUTES && (path_attr & FILE_ATTRIBUTE_DIRECTORY))
+					ofn.lpstrInitialDir = m_wdefault_path.c_str();
+				else if (m_wdefault_path.size() <= woutput.size())
+					//second argument is size of buffer, not length of string
+					StringCchCopyW(ofn.lpstrFile, MAX_PATH * 256 + 1, m_wdefault_path.c_str());
+				else
+				{
+					ofn.lpstrFileTitle = (LPWSTR)m_wdefault_path.data();
+					ofn.nMaxFileTitle  = (DWORD)m_wdefault_path.size();
+				}
+			}
+			ofn.lpstrTitle = m_wtitle.c_str();
+			ofn.Flags	   = OFN_NOCHANGEDIR | OFN_EXPLORER;
+
+			dll comdlg32("comdlg32.dll");
+
+			// Apply new visual style (required for windows XP)
+			new_style_context ctx;
+
+			if (in_type == type::save)
+			{
+				if (!(options & opt::force_overwrite))
+					ofn.Flags |= OFN_OVERWRITEPROMPT;
+
+				dll::proc<BOOL WINAPI(LPOPENFILENAMEW)> get_save_file_name(comdlg32, "GetSaveFileNameW");
+				if (get_save_file_name(&ofn) == 0)
+					return "";
+				return internal::wstr2str(woutput.c_str());
+			}
+			else
+			{
+				if (options & opt::multiselect)
+					ofn.Flags |= OFN_ALLOWMULTISELECT;
+				ofn.Flags |= OFN_PATHMUSTEXIST;
+
+				dll::proc<BOOL WINAPI(LPOPENFILENAMEW)> get_open_file_name(comdlg32, "GetOpenFileNameW");
+				if (get_open_file_name(&ofn) == 0)
+					return "";
+			}
+
+			std::string prefix;
+			for (wchar_t const* p = woutput.c_str(); *p;)
+			{
+				auto filename = internal::wstr2str(p);
+				p += wcslen(p);
+				// In multiselect mode, we advance p one wchar further and
+				// check for another filename. If there is one and the
+				// prefix is empty, it means we just read the prefix.
+				if ((options & opt::multiselect) && *++p && prefix.empty())
+				{
+					prefix = filename + "/";
+					continue;
+				}
+
+				m_vector_result.push_back(prefix + filename);
+			}
+
+			return "";
+		});
+#elif __EMSCRIPTEN__
+		// FIXME: do something
+		(void)in_type;
+		(void)title;
+		(void)default_path;
+		(void)filters;
+		(void)options;
+#else
+		auto command = desktop_helper();
+
+		if (is_osascript())
+		{
+			std::string script = "set ret to choose";
+			switch (in_type)
+			{
+			case type::save:
+				script += " file name";
+				break;
+			case type::open:
+			default:
+				script += " file";
+				if (options & opt::multiselect)
+					script += " with multiple selections allowed";
+				break;
+			case type::folder:
+				script += " folder";
+				break;
+			}
+
+			if (default_path.size())
+			{
+				if (in_type == type::folder || is_directory(default_path))
+					script += " default location ";
+				else
+					script += " default name ";
+				script += osascript_quote(default_path);
+			}
+
+			script += " with prompt " + osascript_quote(title);
+
+			if (in_type == type::open)
+			{
+				// Concatenate all user-provided filter patterns
+				std::string patterns;
+				for (size_t i = 0; i < filters.size() / 2; ++i)
+					patterns += " " + filters[2 * i + 1];
+
+				// Split the pattern list to check whether "*" is in there; if it
+				// is, we have to disable filters because there is no mechanism in
+				// OS X for the user to override the filter.
+				std::regex sep("\\s+");
+				std::string filter_list;
+				bool has_filter = true;
+				std::sregex_token_iterator iter(patterns.begin(), patterns.end(), sep, -1);
+				std::sregex_token_iterator end;
+				for (; iter != end; ++iter)
+				{
+					auto pat = iter->str();
+					if (pat == "*" || pat == "*.*")
+						has_filter = false;
+					else if (internal::starts_with(pat, "*."))
+						filter_list += "," + osascript_quote(pat.substr(2, pat.size() - 2));
+				}
+
+				if (has_filter && filter_list.size() > 0)
+				{
+					// There is a weird AppleScript bug where file extensions of length != 3 are
+					// ignored, e.g. type{"txt"} works, but type{"json"} does not. Fortunately if
+					// the whole list starts with a 3-character extension, everything works again.
+					// We use "///" for such an extension because we are sure it cannot appear in
+					// an actual filename.
+					script += " of type {\"///\"" + filter_list + "}";
+				}
+			}
+
+			if (in_type == type::open && (options & opt::multiselect))
+			{
+				script += "\nset s to \"\"";
+				script += "\nrepeat with i in ret";
+				script += "\n  set s to s & (POSIX path of i) & \"\\n\"";
+				script += "\nend repeat";
+				script += "\ncopy s to stdout";
+			}
+			else
+			{
+				script += "\nPOSIX path of ret";
+			}
+
+			command.push_back("-e");
+			command.push_back(script);
+		}
+		else if (is_zenity())
+		{
+			command.push_back("--file-selection");
+
+			// If the default path is a directory, make sure it ends with "/" otherwise zenity will
+			// open the file dialog in the parent directory.
+			auto filename_arg = "--filename=" + default_path;
+			if (in_type != type::folder && !ends_with(default_path, "/") && internal::is_directory(default_path))
+				filename_arg += "/";
+			command.push_back(filename_arg);
+
+			command.push_back("--title");
+			command.push_back(title);
+			command.push_back("--separator=\n");
+
+			for (size_t i = 0; i < filters.size() / 2; ++i)
+			{
+				command.push_back("--file-filter");
+				command.push_back(filters[2 * i] + "|" + filters[2 * i + 1]);
+			}
+
+			if (in_type == type::save)
+				command.push_back("--save");
+			if (in_type == type::folder)
+				command.push_back("--directory");
+			if (!(options & opt::force_overwrite))
+				command.push_back("--confirm-overwrite");
+			if (options & opt::multiselect)
+				command.push_back("--multiple");
+		}
+		else if (is_kdialog())
+		{
+			switch (in_type)
+			{
+			case type::save:
+				command.push_back("--getsavefilename");
+				break;
+			case type::open:
+				command.push_back("--getopenfilename");
+				break;
+			case type::folder:
+				command.push_back("--getexistingdirectory");
+				break;
+			}
+			if (options & opt::multiselect)
+			{
+				command.push_back("--multiple");
+				command.push_back("--separate-output");
+			}
+
+			command.push_back(default_path);
+
+			std::string filter;
+			for (size_t i = 0; i < filters.size() / 2; ++i)
+				filter += (i == 0 ? "" : " | ") + filters[2 * i] + "(" + filters[2 * i + 1] + ")";
+			command.push_back(filter);
+
+			command.push_back("--title");
+			command.push_back(title);
+		}
+
+		if (flags(flag::is_verbose))
+			std::cerr << "pfd: " << command << std::endl;
+
+		m_async->start_process(command);
+#endif
+	}
+
+	inline std::string internal::file_dialog::string_result()
+	{
+#if _WIN32
+		return m_async->result();
+#else
+		auto ret = m_async->result();
+		// Strip potential trailing newline (zenity). Also strip trailing slash
+		// added by osascript for consistency with other backends.
+		while (!ret.empty() && (ret.back() == '\n' || ret.back() == '/'))
+			ret.pop_back();
+		return ret;
+#endif
+	}
+
+	inline std::vector<std::string> internal::file_dialog::vector_result()
+	{
+#if _WIN32
+		m_async->result();
+		return m_vector_result;
+#else
+		std::vector<std::string> ret;
+		auto result = m_async->result();
+		for (;;)
+		{
+			// Split result along newline characters
+			auto i = result.find('\n');
+			if (i == 0 || i == std::string::npos)
+				break;
+			ret.push_back(result.substr(0, i));
+			result = result.substr(i + 1, result.size());
+		}
+		return ret;
+#endif
+	}
+
+#if _WIN32
+	// Use a static function to pass as BFFCALLBACK for legacy folder select
+	inline int CALLBACK internal::file_dialog::bffcallback(HWND hwnd, UINT uMsg, LPARAM, LPARAM pData)
+	{
+		auto inst = (file_dialog*)pData;
+		switch (uMsg)
+		{
+		case BFFM_INITIALIZED:
+			SendMessage(hwnd, BFFM_SETSELECTIONW, TRUE, (LPARAM)inst->m_wdefault_path.c_str());
+			break;
+		}
+		return 0;
+	}
+
+#if PFD_HAS_IFILEDIALOG
+	inline std::string internal::file_dialog::select_folder_vista(IFileDialog* ifd, bool force_path)
+	{
+		std::string result;
+
+		IShellItem* folder;
+
+		// Load library at runtime so app doesn't link it at load time (which will fail on windows XP)
+		dll shell32("shell32.dll");
+		dll::proc<HRESULT WINAPI(PCWSTR, IBindCtx*, REFIID, void**)>
+			create_item(shell32, "SHCreateItemFromParsingName");
+
+		if (!create_item)
+			return "";
+
+		auto hr = create_item(m_wdefault_path.c_str(),
+							  nullptr,
+							  IID_PPV_ARGS(&folder));
+
+		// Set default folder if found. This only sets the default folder. If
+		// Windows has any info about the most recently selected folder, it
+		// will display it instead. Generally, calling SetFolder() to set the
+		// current directory “is not a good or expected user experience and
+		// should therefore be avoided”:
+		// https://docs.microsoft.com/windows/win32/api/shobjidl_core/nf-shobjidl_core-ifiledialog-setfolder
+		if (SUCCEEDED(hr))
+		{
+			if (force_path)
+				ifd->SetFolder(folder);
+			else
+				ifd->SetDefaultFolder(folder);
+			folder->Release();
+		}
+
+		// Set the dialog title and option to select folders
+		ifd->SetOptions(FOS_PICKFOLDERS | FOS_FORCEFILESYSTEM);
+		ifd->SetTitle(m_wtitle.c_str());
+
+		hr = ifd->Show(GetActiveWindow());
+		if (SUCCEEDED(hr))
+		{
+			IShellItem* item;
+			hr = ifd->GetResult(&item);
+			if (SUCCEEDED(hr))
+			{
+				wchar_t* wname = nullptr;
+				// This is unlikely to fail because we use FOS_FORCEFILESYSTEM, but try
+				// to output a debug message just in case.
+				if (SUCCEEDED(item->GetDisplayName(SIGDN_FILESYSPATH, &wname)))
+				{
+					result = internal::wstr2str(std::wstring(wname));
+					dll::proc<void WINAPI(LPVOID)>(ole32_dll(), "CoTaskMemFree")(wname);
+				}
+				else
+				{
+					if (SUCCEEDED(item->GetDisplayName(SIGDN_NORMALDISPLAY, &wname)))
+					{
+						auto name = internal::wstr2str(std::wstring(wname));
+						dll::proc<void WINAPI(LPVOID)>(ole32_dll(), "CoTaskMemFree")(wname);
+						std::cerr << "pfd: failed to get path for " << name << std::endl;
+					}
+					else
+						std::cerr << "pfd: item of unknown type selected" << std::endl;
+				}
+
+				item->Release();
+			}
+		}
+
+		ifd->Release();
+
+		return result;
+	}
+#endif
+#endif
+
+	// notify implementation
+
+	inline notify::notify(std::string const& title,
+						  std::string const& message,
+						  icon				 _icon /* = icon::info */)
+	{
+		if (_icon == icon::question) // Not supported by notifications
+			_icon = icon::info;
+
+#if _WIN32
+		// Use a static shared pointer for notify_icon so that we can delete
+		// it whenever we need to display a new one, and we can also wait
+		// until the program has finished running.
+		struct notify_icon_data : public NOTIFYICONDATAW
+		{
+			~notify_icon_data()
+			{
+				Shell_NotifyIconW(NIM_DELETE, this);
+			}
+		};
+
+		static std::shared_ptr<notify_icon_data> nid;
+
+		// Release the previous notification icon, if any, and allocate a new
+		// one. Note that std::make_shared() does value initialization, so there
+		// is no need to memset the structure.
+		nid = nullptr;
+		nid = std::make_shared<notify_icon_data>();
+
+		// For XP support
+		nid->cbSize = NOTIFYICONDATAW_V2_SIZE;
+		nid->hWnd	= nullptr;
+		nid->uID	= 0;
+
+		// Flag Description:
+		// - NIF_ICON    The hIcon member is valid.
+		// - NIF_MESSAGE The uCallbackMessage member is valid.
+		// - NIF_TIP     The szTip member is valid.
+		// - NIF_STATE   The dwState and dwStateMask members are valid.
+		// - NIF_INFO    Use a balloon ToolTip instead of a standard ToolTip. The szInfo, uTimeout, szInfoTitle, and dwInfoFlags members are valid.
+		// - NIF_GUID    Reserved.
+		nid->uFlags = NIF_MESSAGE | NIF_ICON | NIF_INFO;
+
+		// Flag Description
+		// - NIIF_ERROR     An error icon.
+		// - NIIF_INFO      An information icon.
+		// - NIIF_NONE      No icon.
+		// - NIIF_WARNING   A warning icon.
+		// - NIIF_ICON_MASK Version 6.0. Reserved.
+		// - NIIF_NOSOUND   Version 6.0. Do not play the associated sound. Applies only to balloon ToolTips
+		switch (_icon)
+		{
+		case icon::warning:
+			nid->dwInfoFlags = NIIF_WARNING;
+			break;
+		case icon::error:
+			nid->dwInfoFlags = NIIF_ERROR;
+			break;
+		/* case icon::info: */ default:
+			nid->dwInfoFlags = NIIF_INFO;
+			break;
+		}
+
+		ENUMRESNAMEPROC icon_enum_callback = [](HMODULE, LPCTSTR, LPTSTR lpName, LONG_PTR lParam) -> BOOL {
+			((NOTIFYICONDATAW*)lParam)->hIcon = ::LoadIcon(GetModuleHandle(nullptr), lpName);
+			return false;
+		};
+
+		nid->hIcon = ::LoadIcon(nullptr, IDI_APPLICATION);
+		::EnumResourceNames(nullptr, RT_GROUP_ICON, icon_enum_callback, (LONG_PTR)nid.get());
+
+		nid->uTimeout = 5000;
+
+		StringCchCopyW(nid->szInfoTitle, ARRAYSIZE(nid->szInfoTitle), internal::str2wstr(title).c_str());
+		StringCchCopyW(nid->szInfo, ARRAYSIZE(nid->szInfo), internal::str2wstr(message).c_str());
+
+		// Display the new icon
+		Shell_NotifyIconW(NIM_ADD, nid.get());
+#elif __EMSCRIPTEN__
+		// FIXME: do something
+		(void)title;
+		(void)message;
+#else
+		auto command = desktop_helper();
+
+		if (is_osascript())
+		{
+			command.push_back("-e");
+			command.push_back("display notification " + osascript_quote(message) +
+							  " with title " + osascript_quote(title));
+		}
+		else if (is_zenity())
+		{
+			command.push_back("--notification");
+			command.push_back("--window-icon");
+			command.push_back(get_icon_name(_icon));
+			command.push_back("--text");
+			command.push_back(title + "\n" + message);
+		}
+		else if (is_kdialog())
+		{
+			command.push_back("--icon");
+			command.push_back(get_icon_name(_icon));
+			command.push_back("--title");
+			command.push_back(title);
+			command.push_back("--passivepopup");
+			command.push_back(message);
+			command.push_back("5");
+		}
+
+		if (flags(flag::is_verbose))
+			std::cerr << "pfd: " << command << std::endl;
+
+		m_async->start_process(command);
+#endif
+	}
+
+	// message implementation
+
+	inline message::message(std::string const& title,
+							std::string const& text,
+							choice			   _choice /* = choice::ok_cancel */,
+							icon			   _icon /* = icon::info */)
+	{
+#if _WIN32
+		// Use MB_SYSTEMMODAL rather than MB_TOPMOST to ensure the message window is brought
+		// to front. See https://github.com/samhocevar/portable-file-dialogs/issues/52
+		UINT style = MB_SYSTEMMODAL;
+		switch (_icon)
+		{
+		case icon::warning:
+			style |= MB_ICONWARNING;
+			break;
+		case icon::error:
+			style |= MB_ICONERROR;
+			break;
+		case icon::question:
+			style |= MB_ICONQUESTION;
+			break;
+		/* case icon::info: */ default:
+			style |= MB_ICONINFORMATION;
+			break;
+		}
+
+		switch (_choice)
+		{
+		case choice::ok_cancel:
+			style |= MB_OKCANCEL;
+			break;
+		case choice::yes_no:
+			style |= MB_YESNO;
+			break;
+		case choice::yes_no_cancel:
+			style |= MB_YESNOCANCEL;
+			break;
+		case choice::retry_cancel:
+			style |= MB_RETRYCANCEL;
+			break;
+		case choice::abort_retry_ignore:
+			style |= MB_ABORTRETRYIGNORE;
+			break;
+		/* case choice::ok: */ default:
+			style |= MB_OK;
+			break;
+		}
+
+		m_mappings[IDCANCEL] = button::cancel;
+		m_mappings[IDOK]	 = button::ok;
+		m_mappings[IDYES]	 = button::yes;
+		m_mappings[IDNO]	 = button::no;
+		m_mappings[IDABORT]	 = button::abort;
+		m_mappings[IDRETRY]	 = button::retry;
+		m_mappings[IDIGNORE] = button::ignore;
+
+		m_async->start_func([text, title, style](int* exit_code) -> std::string {
+			auto wtext	= internal::str2wstr(text);
+			auto wtitle = internal::str2wstr(title);
+			// Apply new visual style (required for all Windows versions)
+			new_style_context ctx;
+			*exit_code = MessageBoxW(GetActiveWindow(), wtext.c_str(), wtitle.c_str(), style);
+			return "";
+		});
+
+#elif __EMSCRIPTEN__
+		std::string full_message;
+		switch (_icon)
+		{
+		case icon::warning:
+			full_message = "⚠️";
+			break;
+		case icon::error:
+			full_message = "⛔";
+			break;
+		case icon::question:
+			full_message = "❓";
+			break;
+		/* case icon::info: */ default:
+			full_message = "ℹ";
+			break;
+		}
+
+		full_message += ' ' + title + "\n\n" + text;
+
+		// This does not really start an async task; it just passes the
+		// EM_ASM_INT return value to a fake start() function.
+		m_async->start(EM_ASM_INT(
+			{
+				if ($1)
+					return window.confirm(UTF8ToString($0)) ? 0 : -1;
+				alert(UTF8ToString($0));
+				return 0;
+			},
+			full_message.c_str(), _choice == choice::ok_cancel));
+#else
+		auto command = desktop_helper();
+
+		if (is_osascript())
+		{
+			std::string script = "display dialog " + osascript_quote(text) +
+								 " with title " + osascript_quote(title);
+			auto if_cancel = button::cancel;
+			switch (_choice)
+			{
+			case choice::ok_cancel:
+				script += "buttons {\"OK\", \"Cancel\"}"
+						  " default button \"OK\""
+						  " cancel button \"Cancel\"";
+				break;
+			case choice::yes_no:
+				script += "buttons {\"Yes\", \"No\"}"
+						  " default button \"Yes\""
+						  " cancel button \"No\"";
+				if_cancel = button::no;
+				break;
+			case choice::yes_no_cancel:
+				script += "buttons {\"Yes\", \"No\", \"Cancel\"}"
+						  " default button \"Yes\""
+						  " cancel button \"Cancel\"";
+				break;
+			case choice::retry_cancel:
+				script += "buttons {\"Retry\", \"Cancel\"}"
+						  " default button \"Retry\""
+						  " cancel button \"Cancel\"";
+				break;
+			case choice::abort_retry_ignore:
+				script += "buttons {\"Abort\", \"Retry\", \"Ignore\"}"
+						  " default button \"Abort\""
+						  " cancel button \"Retry\"";
+				if_cancel = button::retry;
+				break;
+			case choice::ok:
+			default:
+				script += "buttons {\"OK\"}"
+						  " default button \"OK\""
+						  " cancel button \"OK\"";
+				if_cancel = button::ok;
+				break;
+			}
+			m_mappings[1] = if_cancel;
+			m_mappings[256] = if_cancel; // XXX: I think this was never correct
+			script += " with icon ";
+			switch (_icon)
+			{
+#define PFD_OSX_ICON(n) "alias ((path to library folder from system domain) as text " \
+						"& \"CoreServices:CoreTypes.bundle:Contents:Resources:" n ".icns\")"
+			case icon::info:
+			default:
+				script += PFD_OSX_ICON("ToolBarInfo");
+				break;
+			case icon::warning:
+				script += "caution";
+				break;
+			case icon::error:
+				script += "stop";
+				break;
+			case icon::question:
+				script += PFD_OSX_ICON("GenericQuestionMarkIcon");
+				break;
+#undef PFD_OSX_ICON
+			}
+
+			command.push_back("-e");
+			command.push_back(script);
+		}
+		else if (is_zenity())
+		{
+			switch (_choice)
+			{
+			case choice::ok_cancel:
+				command.insert(command.end(), {"--question", "--cancel-label=Cancel", "--ok-label=OK"});
+				break;
+			case choice::yes_no:
+				// Do not use standard --question because it causes “No” to return -1,
+				// which is inconsistent with the “Yes/No/Cancel” mode below.
+				command.insert(command.end(), {"--question", "--switch", "--extra-button=No", "--extra-button=Yes"});
+				break;
+			case choice::yes_no_cancel:
+				command.insert(command.end(), {"--question", "--switch", "--extra-button=Cancel", "--extra-button=No", "--extra-button=Yes"});
+				break;
+			case choice::retry_cancel:
+				command.insert(command.end(), {"--question", "--switch", "--extra-button=Cancel", "--extra-button=Retry"});
+				break;
+			case choice::abort_retry_ignore:
+				command.insert(command.end(), {"--question", "--switch", "--extra-button=Ignore", "--extra-button=Abort", "--extra-button=Retry"});
+				break;
+			case choice::ok:
+			default:
+				switch (_icon)
+				{
+				case icon::error:
+					command.push_back("--error");
+					break;
+				case icon::warning:
+					command.push_back("--warning");
+					break;
+				default:
+					command.push_back("--info");
+					break;
+				}
+			}
+
+			command.insert(command.end(), {"--title", title,
+										   "--width=300", "--height=0", // sensible defaults
+										   "--no-markup",				// do not interpret text as Pango markup
+										   "--text", text,
+										   "--icon-name=dialog-" + get_icon_name(_icon)});
+		}
+		else if (is_kdialog())
+		{
+			if (_choice == choice::ok)
+			{
+				switch (_icon)
+				{
+				case icon::error:
+					command.push_back("--error");
+					break;
+				case icon::warning:
+					command.push_back("--sorry");
+					break;
+				default:
+					command.push_back("--msgbox");
+					break;
+				}
+			}
+			else
+			{
+				std::string flag = "--";
+				if (_icon == icon::warning || _icon == icon::error)
+					flag += "warning";
+				flag += "yesno";
+				if (_choice == choice::yes_no_cancel)
+					flag += "cancel";
+				command.push_back(flag);
+				if (_choice == choice::yes_no || _choice == choice::yes_no_cancel)
+				{
+					m_mappings[0] = button::yes;
+					m_mappings[256] = button::no;
+				}
+			}
+
+			command.push_back(text);
+			command.push_back("--title");
+			command.push_back(title);
+
+			// Must be after the above part
+			if (_choice == choice::ok_cancel)
+				command.insert(command.end(), {"--yes-label", "OK", "--no-label", "Cancel"});
+		}
+
+		if (flags(flag::is_verbose))
+			std::cerr << "pfd: " << command << std::endl;
+
+		m_async->start_process(command);
+#endif
+	}
+
+	inline button message::result()
+	{
+		int	 exit_code;
+		auto ret = m_async->result(&exit_code);
+		// osascript will say "button returned:Cancel\n"
+		// and others will just say "Cancel\n"
+		if (internal::ends_with(ret, "Cancel\n"))
+			return button::cancel;
+		if (internal::ends_with(ret, "OK\n"))
+			return button::ok;
+		if (internal::ends_with(ret, "Yes\n"))
+			return button::yes;
+		if (internal::ends_with(ret, "No\n"))
+			return button::no;
+		if (internal::ends_with(ret, "Abort\n"))
+			return button::abort;
+		if (internal::ends_with(ret, "Retry\n"))
+			return button::retry;
+		if (internal::ends_with(ret, "Ignore\n"))
+			return button::ignore;
+		if (m_mappings.count(exit_code) != 0)
+			return m_mappings[exit_code];
+		return exit_code == 0 ? button::ok : button::cancel;
+	}
+
+	// open_file implementation
+
+	inline open_file::open_file(std::string const&				title,
+								std::string const&				default_path /* = "" */,
+								std::vector<std::string> const& filters /* = { "All Files", "*" } */,
+								opt								options /* = opt::none */)
+		: file_dialog(type::open, title, default_path, filters, options)
+	{
+	}
+
+	inline open_file::open_file(std::string const&				title,
+								std::string const&				default_path,
+								std::vector<std::string> const& filters,
+								bool							allow_multiselect)
+		: open_file(title, default_path, filters, (allow_multiselect ? opt::multiselect : opt::none))
+	{
+	}
+
+	inline std::vector<std::string> open_file::result()
+	{
+		return vector_result();
+	}
+
+	// save_file implementation
+
+	inline save_file::save_file(std::string const&				title,
+								std::string const&				default_path /* = "" */,
+								std::vector<std::string> const& filters /* = { "All Files", "*" } */,
+								opt								options /* = opt::none */)
+		: file_dialog(type::save, title, default_path, filters, options)
+	{
+	}
+
+	inline save_file::save_file(std::string const&				title,
+								std::string const&				default_path,
+								std::vector<std::string> const& filters,
+								bool							confirm_overwrite)
+		: save_file(title, default_path, filters, (confirm_overwrite ? opt::none : opt::force_overwrite))
+	{
+	}
+
+	inline std::string save_file::result()
+	{
+		return string_result();
+	}
+
+	// select_folder implementation
+
+	inline select_folder::select_folder(std::string const& title,
+										std::string const& default_path /* = "" */,
+										opt				   options /* = opt::none */)
+		: file_dialog(type::folder, title, default_path, {}, options)
+	{
+	}
+
+	inline std::string select_folder::result()
+	{
+		return string_result();
+	}
+
+#endif // PFD_SKIP_IMPLEMENTATION
+
+} // namespace pfd
\ No newline at end of file