diff options
32 files changed, 9490 insertions, 0 deletions
diff --git a/Ports/AvailablePorts.md b/Ports/AvailablePorts.md index e4a3b509d2..e8e37b7be7 100644 --- a/Ports/AvailablePorts.md +++ b/Ports/AvailablePorts.md @@ -9,6 +9,7 @@ Please make sure to keep this list up to date when adding and updating ports. :^ | [`binutils`](binutils/) | GNU Binutils | 2.32 | https://www.gnu.org/software/binutils/ | | [`byacc`](byacc/) | Berkeley Yacc | 20191125 | https://invisible-island.net/byacc/byacc.html | | [`c-ray`](c-ray/) | C-Ray | | https://github.com/vkoskiv/c-ray | +| [`cmake`](cmake/) | CMake | 3.19.4 | https://cmake.org/ | | [`curl`](curl/) | curl | 7.65.3 | https://curl.se/ | | [`dash`](dash/) | DASH | 0.5.10.2 | http://gondor.apana.org.au/~herbert/dash | | [`diffutils`](diffutils/) | GNU Diffutils | 3.5 | https://www.gnu.org/software/diffutils/ | diff --git a/Ports/cmake/howto.md b/Ports/cmake/howto.md new file mode 100644 index 0000000000..92e86a3bb4 --- /dev/null +++ b/Ports/cmake/howto.md @@ -0,0 +1,40 @@ +## Build Guide + +- Run `./package.sh` here, which should install the dependencies and copy the patched source code to `~anon/Source/cmake` +- Give the vm at least 2G of RAM, and at least 1.5G of free disk space (actual values used may be different, but ~1.3GiB of RAM and 1.2GiB of disk space has been observed) +- Build the bootstrap cmake binary: +```sh +$ cd Source/cmake +$ ./bootstrap +``` +- Go entertain yourself for a few minutes (build takes about 10m) +- The bootstrap binary should be built, but may fail for any of the reasons detailed in [Troubleshooting](#troubleshooting). +- Build and install cmake (this takes a long time, about 80 minutes on my machine) +```sh +$ make +# mount -o bind /usr /usr +# make install +``` +- Optionally, add `/usr/local/bin` to PATH: +```sh +$ export PATH="$PATH:/usr/local/bin" +``` +- Hopefully look back at the experience and laugh at its ease + +## Current Status + +Fully working :P + +## Troubleshooting + +### "Failed to open check cache file for write..." while bootstrap cmake is configuring cmake + +The cause for this is unknown, but it seems to be a transitive state; simply restarting the bootstrap process fixes it: +```sh +$ Bootstrap.cmk/cmake . -C Bootstrap.cmk/InitialCacheFlags.cmake -G 'Unix Makefiles' -DCMAKE_BOOTSTRAP=1 -DBUILD_TESTING=0 +``` +You might have to repeat this many times. + +### "unable to rename '...', reason: File already exists" while making cmake + +Cause unknown. re-running make made it go away. diff --git a/Ports/cmake/package.sh b/Ports/cmake/package.sh new file mode 100755 index 0000000000..05e211f69d --- /dev/null +++ b/Ports/cmake/package.sh @@ -0,0 +1,33 @@ +#!/usr/bin/env -S bash ../.port_include.sh +port=cmake +version=3.19.4 +useconfigure=false +files="https://github.com/Kitware/CMake/releases/download/v$version/cmake-$version.tar.gz cmake-$version.tar.gz" +depends="bash gcc make sed" + +port_path=$(realpath $(dirname ${BASH_SOURCE[0]})) + +build() { + return +} + +install() { + cmake_dir="${SERENITY_ROOT}/Build/Root/home/anon/Source/cmake" + run rm -rf "$cmake_dir" + run mkdir -p "$cmake_dir" + run cp -r . "$cmake_dir" +} + +post_install() { + echo +=================================================================== + echo "| Successfully prepared the sources for cmake v$version!" + echo "| The other half of the install has to be done inside serenity" + echo "| to continue, re-image and run the vm, then do the following:" + echo '| ' + echo '| $ cd Source/cmake' + echo '| $ ./bootstrap' + echo '| $ make && make install' + echo '| ' + echo "| (These instructions are also available in $port_path/howto.md)" + echo +=================================================================== +} diff --git a/Ports/cmake/patches/0000-no_wide_string.patch b/Ports/cmake/patches/0000-no_wide_string.patch new file mode 100644 index 0000000000..b15ea56a8e --- /dev/null +++ b/Ports/cmake/patches/0000-no_wide_string.patch @@ -0,0 +1,6873 @@ +diff -urp a/Source/cmCallVisualStudioMacro.cxx b/Source/cmCallVisualStudioMacro.cxx +--- a/Source/cmCallVisualStudioMacro.cxx 2021-01-28 18:58:45.000000000 +0330 ++++ b/Source/cmCallVisualStudioMacro.cxx 2021-02-11 18:43:33.119174973 +0330 +@@ -61,7 +61,7 @@ HRESULT InstanceCallMacro(IDispatch* vsI + + if (0 != vsIDE) { + DISPID dispid = (DISPID)-1; +- wchar_t execute_command[] = L"ExecuteCommand"; ++ char execute_command[] = "ExecuteCommand"; + OLECHAR* name = execute_command; + + hr = +@@ -147,7 +147,7 @@ HRESULT GetSolutionObject(IDispatch* vsI + + if (0 != vsIDE) { + DISPID dispid = (DISPID)-1; +- wchar_t solution[] = L"Solution"; ++ char solution[] = "Solution"; + OLECHAR* name = solution; + + hr = +@@ -191,7 +191,7 @@ HRESULT GetSolutionFullName(IDispatch* v + + if (0 != vsSolution) { + DISPID dispid = (DISPID)-1; +- wchar_t full_name[] = L"FullName"; ++ char full_name[] = "FullName"; + OLECHAR* name = full_name; + + hr = vsSolution->GetIDsOfNames(IID_NULL, &name, 1, LOCALE_USER_DEFAULT, + +diff -urp a/Source/cmCMakePath.cxx b/Source/cmCMakePath.cxx +--- a/Source/cmCMakePath.cxx 2021-01-28 18:58:45.000000000 +0330 ++++ b/Source/cmCMakePath.cxx 2021-02-12 14:39:55.144860522 +0330 +@@ -123,24 +123,3 @@ void cmCMakePath::GetNativePath(std::str + + path = tmp.string(); + } +-void cmCMakePath::GetNativePath(std::wstring& path) const +-{ +- cm::filesystem::path tmp(this->Path); +- tmp.make_preferred(); +- +- path = tmp.wstring(); +- +-#if defined(_WIN32) +- // Windows long filename +- static std::wstring UNC(L"\\\\?\\UNC"); +- static std::wstring PREFIX(L"\\\\?\\"); +- +- if (this->IsAbsolute() && path.length() > _MAX_PATH - 12) { +- if (this->HasRootName() && path[0] == L'\\') { +- path = UNC + path.substr(1); +- } else { +- path = PREFIX + path; +- } +- } +-#endif +-} +diff -urp a/Source/cmCMakePath.h b/Source/cmCMakePath.h +--- a/Source/cmCMakePath.h 2021-01-28 18:58:45.000000000 +0330 ++++ b/Source/cmCMakePath.h 2021-02-12 14:39:55.144860522 +0330 +@@ -296,7 +296,7 @@ public: + + // Observers + std::string String() const { return this->Path.string(); } +- std::wstring WString() const { return this->Path.wstring(); } ++ std::string WString() const { return this->Path.wstring(); } + + string_type Native() const + { +@@ -312,15 +312,15 @@ public: + + return path; + } +- std::wstring NativeWString() const ++ std::string NativeWString() const + { +- std::wstring path; ++ std::string path; + this->GetNativePath(path); + + return path; + } + std::string GenericString() const { return this->Path.generic_string(); } +- std::wstring GenericWString() const { return this->Path.generic_wstring(); } ++ std::string GenericWString() const { return this->Path.generic_wstring(); } + + // Decomposition + cmCMakePath GetRootName() const { return this->Path.root_name(); } +@@ -449,7 +449,6 @@ private: + } + + void GetNativePath(std::string& path) const; +- void GetNativePath(std::wstring& path) const; + + cm::filesystem::path Path; + }; +diff -urp a/Source/cm_codecvt.cxx b/Source/cm_codecvt.cxx +--- a/Source/cm_codecvt.cxx 2021-01-28 18:58:45.000000000 +0330 ++++ b/Source/cm_codecvt.cxx 2021-02-11 18:43:32.705835074 +0330 +@@ -159,7 +159,7 @@ std::codecvt_base::result codecvt::Decod + buf[lstate.buffered] = *from_next; + + // Convert the encoding. +- wchar_t wbuf[2]; ++ char wbuf[2]; + int wlen = + MultiByteToWideChar(CP_UTF8, MB_ERR_INVALID_CHARS, buf, size, wbuf, 2); + if (wlen <= 0) { +@@ -194,7 +194,7 @@ std::codecvt_base::result codecvt::Decod + State& lstate = reinterpret_cast<State&>(state); + + // Try converting the partial codepoint. +- wchar_t wbuf[2]; ++ char wbuf[2]; + int wlen = MultiByteToWideChar(CP_UTF8, MB_ERR_INVALID_CHARS, lstate.partial, + lstate.buffered, wbuf, 2); + if (wlen <= 0) { +diff -urp a/Source/cmExportCommand.cxx b/Source/cmExportCommand.cxx +--- a/Source/cmExportCommand.cxx 2021-01-28 18:58:45.000000000 +0330 ++++ b/Source/cmExportCommand.cxx 2021-02-11 18:43:33.069174181 +0330 +@@ -316,7 +316,7 @@ static void ReportRegistryError(cmMakefi + std::ostringstream e; + e << msg << "\n" + << " HKEY_CURRENT_USER\\" << key << "\n"; +- wchar_t winmsg[1024]; ++ char winmsg[1024]; + if (FormatMessageW( + FORMAT_MESSAGE_FROM_SYSTEM | FORMAT_MESSAGE_IGNORE_INSERTS, 0, err, + MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT), winmsg, 1024, 0) > 0) { +@@ -339,11 +339,11 @@ static void StorePackageRegistry(cmMakef + return; + } + +- std::wstring wcontent = cmsys::Encoding::ToWide(content); ++ std::string wcontent = cmsys::Encoding::ToWide(content); + err = + RegSetValueExW(hKey, cmsys::Encoding::ToWide(hash).c_str(), 0, REG_SZ, + (BYTE const*)wcontent.c_str(), +- static_cast<DWORD>(wcontent.size() + 1) * sizeof(wchar_t)); ++ static_cast<DWORD>(wcontent.size() + 1) * sizeof(char)); + RegCloseKey(hKey); + if (err != ERROR_SUCCESS) { + std::ostringstream msg; +diff -urp a/Source/cmFileCommand.cxx b/Source/cmFileCommand.cxx +--- a/Source/cmFileCommand.cxx 2021-01-28 18:58:45.000000000 +0330 ++++ b/Source/cmFileCommand.cxx 2021-02-12 14:39:59.851186324 +0330 +@@ -80,7 +80,7 @@ std::string fix_file_url_windows(const s + { + std::string ret = url; + if (strncmp(url.c_str(), "file://", 7) == 0) { +- std::wstring wurl = cmsys::Encoding::ToWide(url); ++ std::string wurl = cmsys::Encoding::ToWide(url); + if (!wurl.empty()) { + int mblen = + WideCharToMultiByte(CP_ACP, 0, wurl.c_str(), -1, NULL, 0, NULL, NULL); +diff -urp a/Source/cmFindPackageCommand.cxx b/Source/cmFindPackageCommand.cxx +--- a/Source/cmFindPackageCommand.cxx 2021-01-28 18:58:45.000000000 +0330 ++++ b/Source/cmFindPackageCommand.cxx 2021-02-11 18:43:32.892504710 +0330 +@@ -1514,15 +1514,15 @@ void cmFindPackageCommand::LoadPackageRe + void cmFindPackageCommand::LoadPackageRegistryWin(bool user, unsigned int view, + cmSearchPath& outPaths) + { +- std::wstring key = L"Software\\Kitware\\CMake\\Packages\\"; ++ std::string key = "Software\\Kitware\\CMake\\Packages\\"; + key += cmsys::Encoding::ToWide(this->Name); +- std::set<std::wstring> bad; ++ std::set<std::string> bad; + HKEY hKey; + if (RegOpenKeyExW(user ? HKEY_CURRENT_USER : HKEY_LOCAL_MACHINE, key.c_str(), + 0, KEY_QUERY_VALUE | view, &hKey) == ERROR_SUCCESS) { + DWORD valueType = REG_NONE; +- wchar_t name[16383]; // RegEnumValue docs limit name to 32767 _bytes_ +- std::vector<wchar_t> data(512); ++ char name[16383]; // RegEnumValue docs limit name to 32767 _bytes_ ++ std::vector<char> data(512); + bool done = false; + DWORD index = 0; + while (!done) { +@@ -1557,7 +1557,7 @@ void cmFindPackageCommand::LoadPackageRe + if (user && !bad.empty() && + RegOpenKeyExW(HKEY_CURRENT_USER, key.c_str(), 0, KEY_SET_VALUE | view, + &hKey) == ERROR_SUCCESS) { +- for (std::wstring const& v : bad) { ++ for (std::string const& v : bad) { + RegDeleteValueW(hKey, v.c_str()); + } + RegCloseKey(hKey); +diff -urp a/Source/cmGccDepfileLexerHelper.cxx b/Source/cmGccDepfileLexerHelper.cxx +--- a/Source/cmGccDepfileLexerHelper.cxx 2021-01-28 18:58:45.000000000 +0330 ++++ b/Source/cmGccDepfileLexerHelper.cxx 2021-02-11 18:43:33.049173864 +0330 +@@ -18,8 +18,8 @@ + bool cmGccDepfileLexerHelper::readFile(const char* filePath) + { + #ifdef _WIN32 +- wchar_t* wpath = cmsysEncoding_DupToWide(filePath); +- FILE* file = _wfopen(wpath, L"rb"); ++ char* wpath = cmsysEncoding_DupToWide(filePath); ++ FILE* file = _wfopen(wpath, "rb"); + free(wpath); + #else + FILE* file = fopen(filePath, "r"); +diff -urp a/Source/cmGlobalVisualStudio8Generator.cxx b/Source/cmGlobalVisualStudio8Generator.cxx +--- a/Source/cmGlobalVisualStudio8Generator.cxx 2021-01-28 18:58:45.000000000 +0330 ++++ b/Source/cmGlobalVisualStudio8Generator.cxx 2021-02-11 18:43:32.972505982 +0330 +@@ -380,10 +380,10 @@ static cmVS7FlagTable cmVS8ExtraFlagTabl + { "EnablePREfast", "analyze-", "", "false", 0 }, + + // Language options +- { "TreatWChar_tAsBuiltInType", "Zc:wchar_t", "wchar_t is a built-in type", ++ { "TreatWChar_tAsBuiltInType", "Zc:char", "char is a built-in type", + "true", 0 }, +- { "TreatWChar_tAsBuiltInType", "Zc:wchar_t-", +- "wchar_t is not a built-in type", "false", 0 }, ++ { "TreatWChar_tAsBuiltInType", "Zc:char-", ++ "char is not a built-in type", "false", 0 }, + + { "", "", "", "", 0 } + }; +diff -urp a/Source/cmGlobalVisualStudioGenerator.cxx b/Source/cmGlobalVisualStudioGenerator.cxx +--- a/Source/cmGlobalVisualStudioGenerator.cxx 2021-01-28 18:58:45.000000000 +0330 ++++ b/Source/cmGlobalVisualStudioGenerator.cxx 2021-02-11 18:43:33.135841903 +0330 +@@ -552,9 +552,9 @@ bool IsVisualStudioMacrosFileRegistered( + 0, KEY_READ, &hkey); + if (ERROR_SUCCESS == result) { + // Iterate the subkeys and look for the values of interest in each subkey: +- wchar_t subkeyname[256]; ++ char subkeyname[256]; + DWORD cch_subkeyname = cm::size(subkeyname); +- wchar_t keyclass[256]; ++ char keyclass[256]; + DWORD cch_keyclass = cm::size(keyclass); + FILETIME lastWriteTime; + lastWriteTime.dwHighDateTime = 0; +@@ -568,19 +568,19 @@ bool IsVisualStudioMacrosFileRegistered( + result = RegOpenKeyExW(hkey, subkeyname, 0, KEY_READ, &hsubkey); + if (ERROR_SUCCESS == result) { + DWORD valueType = REG_SZ; +- wchar_t data1[256]; ++ char data1[256]; + DWORD cch_data1 = sizeof(data1); +- RegQueryValueExW(hsubkey, L"Path", 0, &valueType, (LPBYTE)data1, ++ RegQueryValueExW(hsubkey, "Path", 0, &valueType, (LPBYTE)data1, + &cch_data1); + + DWORD data2 = 0; + DWORD cch_data2 = sizeof(data2); +- RegQueryValueExW(hsubkey, L"Security", 0, &valueType, (LPBYTE)&data2, ++ RegQueryValueExW(hsubkey, "Security", 0, &valueType, (LPBYTE)&data2, + &cch_data2); + + DWORD data3 = 0; + DWORD cch_data3 = sizeof(data3); +- RegQueryValueExW(hsubkey, L"StorageFormat", 0, &valueType, ++ RegQueryValueExW(hsubkey, "StorageFormat", 0, &valueType, + (LPBYTE)&data3, &cch_data3); + + s2 = cmSystemTools::LowerCase(cmsys::Encoding::ToNarrow(data1)); +@@ -643,18 +643,18 @@ bool IsVisualStudioMacrosFileRegistered( + 0, KEY_READ, &hkey); + if (ERROR_SUCCESS == result) { + DWORD valueType = REG_SZ; +- wchar_t data1[256]; ++ char data1[256]; + DWORD cch_data1 = sizeof(data1); +- RegQueryValueExW(hkey, L"Path", 0, &valueType, (LPBYTE)data1, &cch_data1); ++ RegQueryValueExW(hkey, "Path", 0, &valueType, (LPBYTE)data1, &cch_data1); + + DWORD data2 = 0; + DWORD cch_data2 = sizeof(data2); +- RegQueryValueExW(hkey, L"Security", 0, &valueType, (LPBYTE)&data2, ++ RegQueryValueExW(hkey, "Security", 0, &valueType, (LPBYTE)&data2, + &cch_data2); + + DWORD data3 = 0; + DWORD cch_data3 = sizeof(data3); +- RegQueryValueExW(hkey, L"StorageFormat", 0, &valueType, (LPBYTE)&data3, ++ RegQueryValueExW(hkey, "StorageFormat", 0, &valueType, (LPBYTE)&data3, + &cch_data3); + + s2 = cmSystemTools::LowerCase(cmsys::Encoding::ToNarrow(data1)); +@@ -690,7 +690,7 @@ void WriteVSMacrosFileRegistryEntry(cons + if (ERROR_SUCCESS == result) { + // Create the subkey and set the values of interest: + HKEY hsubkey = NULL; +- wchar_t lpClass[] = L""; ++ char lpClass[] = ""; + result = RegCreateKeyExW( + hkey, cmsys::Encoding::ToWide(nextAvailableSubKeyName).c_str(), 0, + lpClass, 0, KEY_READ | KEY_WRITE, 0, &hsubkey, 0); +@@ -699,11 +699,11 @@ void WriteVSMacrosFileRegistryEntry(cons + + std::string s(macrosFile); + std::replace(s.begin(), s.end(), '/', '\\'); +- std::wstring ws = cmsys::Encoding::ToWide(s); ++ std::string ws = cmsys::Encoding::ToWide(s); + + result = +- RegSetValueExW(hsubkey, L"Path", 0, REG_SZ, (LPBYTE)ws.c_str(), +- static_cast<DWORD>(ws.size() + 1) * sizeof(wchar_t)); ++ RegSetValueExW(hsubkey, "Path", 0, REG_SZ, (LPBYTE)ws.c_str(), ++ static_cast<DWORD>(ws.size() + 1) * sizeof(char)); + if (ERROR_SUCCESS != result) { + std::cout << "error result 1: " << result << std::endl; + std::cout << std::endl; +@@ -712,7 +712,7 @@ void WriteVSMacrosFileRegistryEntry(cons + // Security value is always "1" for sample macros files (seems to be "2" + // if you put the file somewhere outside the standard VSMacros folder) + dw = 1; +- result = RegSetValueExW(hsubkey, L"Security", 0, REG_DWORD, (LPBYTE)&dw, ++ result = RegSetValueExW(hsubkey, "Security", 0, REG_DWORD, (LPBYTE)&dw, + sizeof(DWORD)); + if (ERROR_SUCCESS != result) { + std::cout << "error result 2: " << result << std::endl; +@@ -721,7 +721,7 @@ void WriteVSMacrosFileRegistryEntry(cons + + // StorageFormat value is always "0" for sample macros files + dw = 0; +- result = RegSetValueExW(hsubkey, L"StorageFormat", 0, REG_DWORD, ++ result = RegSetValueExW(hsubkey, "StorageFormat", 0, REG_DWORD, + (LPBYTE)&dw, sizeof(DWORD)); + if (ERROR_SUCCESS != result) { + std::cout << "error result 3: " << result << std::endl; +diff -urp a/Source/cmProcessOutput.cxx b/Source/cmProcessOutput.cxx +--- a/Source/cmProcessOutput.cxx 2021-01-28 18:58:45.000000000 +0330 ++++ b/Source/cmProcessOutput.cxx 2021-02-11 18:43:32.995839686 +0330 +@@ -91,7 +91,7 @@ bool cmProcessOutput::DecodeText(std::st + } else { + bool restoreDecoded = false; + std::string firstDecoded = decoded; +- wchar_t lastChar = 0; ++ char lastChar = 0; + for (UINT i = 0; i < cpinfo.MaxCharSize; i++) { + success = DoDecodeText(raw, decoded, &lastChar); + if (success && lastChar != 0) { +@@ -141,12 +141,12 @@ bool cmProcessOutput::DecodeText(std::ve + + #if defined(_WIN32) + bool cmProcessOutput::DoDecodeText(std::string raw, std::string& decoded, +- wchar_t* lastChar) ++ char* lastChar) + { + bool success = false; + const int wlength = + MultiByteToWideChar(codepage, 0, raw.c_str(), int(raw.size()), NULL, 0); +- auto wdata = cm::make_unique<wchar_t[]>(wlength); ++ auto wdata = cm::make_unique<char[]>(wlength); + int r = MultiByteToWideChar(codepage, 0, raw.c_str(), int(raw.size()), + wdata.get(), wlength); + if (r > 0) { +diff -urp a/Source/cmProcessOutput.h b/Source/cmProcessOutput.h +--- a/Source/cmProcessOutput.h 2021-01-28 18:58:45.000000000 +0330 ++++ b/Source/cmProcessOutput.h 2021-02-11 18:43:33.152508833 +0330 +@@ -80,6 +80,6 @@ private: + unsigned int codepage; + unsigned int bufferSize; + std::vector<std::string> rawparts; +- bool DoDecodeText(std::string raw, std::string& decoded, wchar_t* lastChar); ++ bool DoDecodeText(std::string raw, std::string& decoded, char* lastChar); + #endif + }; +diff -urp a/Source/cmSystemTools.cxx b/Source/cmSystemTools.cxx +--- a/Source/cmSystemTools.cxx 2021-01-28 18:58:45.000000000 +0330 ++++ b/Source/cmSystemTools.cxx 2021-02-11 18:43:33.025840162 +0330 +@@ -128,7 +128,7 @@ static int cm_archive_read_open_file(str + int block_size) + { + # if cmsys_STL_HAS_WSTRING +- std::wstring wfile = cmsys::Encoding::ToWide(file); ++ std::string wfile = cmsys::Encoding::ToWide(file); + return archive_read_open_filename_w(a, wfile.c_str(), block_size); + # else + return archive_read_open_filename(a, file, block_size); +@@ -759,7 +759,7 @@ namespace { + class SaveRestoreFileAttributes + { + public: +- SaveRestoreFileAttributes(std::wstring const& path, ++ SaveRestoreFileAttributes(std::string const& path, + uint32_t file_attrs_to_set); + ~SaveRestoreFileAttributes(); + +@@ -767,15 +767,15 @@ public: + SaveRestoreFileAttributes& operator=(SaveRestoreFileAttributes const&) = + delete; + +- void SetPath(std::wstring const& path) { path_ = path; } ++ void SetPath(std::string const& path) { path_ = path; } + + private: +- std::wstring path_; ++ std::string path_; + uint32_t original_attr_bits_; + }; + + SaveRestoreFileAttributes::SaveRestoreFileAttributes( +- std::wstring const& path, uint32_t file_attrs_to_set) ++ std::string const& path, uint32_t file_attrs_to_set) + : path_(path) + , original_attr_bits_(0) + { +@@ -809,14 +809,14 @@ struct WindowsFileRetryInit + bool Explicit; + }; + +-WindowsFileRetryInit InitWindowsFileRetry(wchar_t const* const values[2], ++WindowsFileRetryInit InitWindowsFileRetry(char const* const values[2], + unsigned int const defaults[2]) + { + unsigned int data[2] = { 0, 0 }; + HKEY const keys[2] = { HKEY_CURRENT_USER, HKEY_LOCAL_MACHINE }; + for (int k = 0; k < 2; ++k) { + HKEY hKey; +- if (RegOpenKeyExW(keys[k], L"Software\\Kitware\\CMake\\Config", 0, ++ if (RegOpenKeyExW(keys[k], "Software\\Kitware\\CMake\\Config", 0, + KEY_QUERY_VALUE, &hKey) == ERROR_SUCCESS) { + for (int v = 0; v < 2; ++v) { + DWORD dwData, dwType, dwSize = 4; +@@ -839,16 +839,16 @@ WindowsFileRetryInit InitWindowsFileRetr + + WindowsFileRetryInit InitWindowsFileRetry() + { +- static wchar_t const* const values[2] = { L"FilesystemRetryCount", +- L"FilesystemRetryDelay" }; ++ static char const* const values[2] = { "FilesystemRetryCount", ++ "FilesystemRetryDelay" }; + static unsigned int const defaults[2] = { 5, 500 }; + return InitWindowsFileRetry(values, defaults); + } + + WindowsFileRetryInit InitWindowsDirectoryRetry() + { +- static wchar_t const* const values[2] = { L"FilesystemDirectoryRetryCount", +- L"FilesystemDirectoryRetryDelay" }; ++ static char const* const values[2] = { "FilesystemDirectoryRetryCount", ++ "FilesystemDirectoryRetryDelay" }; + static unsigned int const defaults[2] = { 120, 500 }; + WindowsFileRetryInit dirInit = InitWindowsFileRetry(values, defaults); + if (dirInit.Explicit) { +@@ -861,7 +861,7 @@ WindowsFileRetryInit InitWindowsDirector + return dirInit; + } + +-cmSystemTools::WindowsFileRetry GetWindowsRetry(std::wstring const& path) ++cmSystemTools::WindowsFileRetry GetWindowsRetry(std::string const& path) + { + // If we are performing a directory operation, then try and get the + // appropriate timing info. +@@ -946,7 +946,7 @@ void cmSystemTools::InitializeLibUV() + + #ifdef _WIN32 + namespace { +-bool cmMoveFile(std::wstring const& oldname, std::wstring const& newname) ++bool cmMoveFile(std::string const& oldname, std::string const& newname) + { + // Not only ignore any previous error, but clear any memory of it. + SetLastError(0); +@@ -965,9 +965,9 @@ bool cmSystemTools::RenameFile(const std + # ifndef INVALID_FILE_ATTRIBUTES + # define INVALID_FILE_ATTRIBUTES ((DWORD)-1) + # endif +- std::wstring const oldname_wstr = ++ std::string const oldname_wstr = + SystemTools::ConvertToWindowsExtendedPath(oldname); +- std::wstring const newname_wstr = ++ std::string const newname_wstr = + SystemTools::ConvertToWindowsExtendedPath(newname); + + /* Windows MoveFileEx may not replace read-only or in-use files. If it +@@ -2082,7 +2082,7 @@ void cmSystemTools::FindCMakeResources(c + std::string exe_dir; + #if defined(_WIN32) && !defined(__CYGWIN__) + (void)argv0; // ignore this on windows +- wchar_t modulepath[_MAX_PATH]; ++ char modulepath[_MAX_PATH]; + ::GetModuleFileNameW(NULL, modulepath, sizeof(modulepath)); + std::string path = cmsys::Encoding::ToNarrow(modulepath); + std::string realPath = +diff -urp a/Source/cmVSSetupHelper.cxx b/Source/cmVSSetupHelper.cxx +--- a/Source/cmVSSetupHelper.cxx 2021-01-28 18:58:45.000000000 +0330 ++++ b/Source/cmVSSetupHelper.cxx 2021-02-12 14:39:59.854519416 +0330 +@@ -47,10 +47,10 @@ const CLSID CLSID_SetupConfiguration = { + #endif + + const WCHAR* Win10SDKComponent = +- L"Microsoft.VisualStudio.Component.Windows10SDK"; ++ "Microsoft.VisualStudio.Component.Windows10SDK"; + const WCHAR* Win81SDKComponent = +- L"Microsoft.VisualStudio.Component.Windows81SDK"; +-const WCHAR* ComponentType = L"Component"; ++ "Microsoft.VisualStudio.Component.Windows81SDK"; ++const WCHAR* ComponentType = "Component"; + + std::string VSInstanceInfo::GetInstallLocation() const + { +@@ -124,13 +124,13 @@ bool cmVSSetupAPIHelper::CheckInstalledC + return ret; + } + +- std::wstring id = std::wstring(bstrId); +- std::wstring type = std::wstring(bstrType); ++ std::string id = std::string(bstrId); ++ std::string type = std::string(bstrType); + + // Checks for any version of Win10 SDK. The version is appended at the end of + // the + // component name ex: Microsoft.VisualStudio.Component.Windows10SDK.10240 +- if (id.find(Win10SDKComponent) != std::wstring::npos && ++ if (id.find(Win10SDKComponent) != std::string::npos && + type.compare(ComponentType) == 0) { + bWin10SDK = true; + ret = true; +@@ -154,7 +154,7 @@ bool cmVSSetupAPIHelper::GetVSInstanceIn + + SmartBSTR bstrId; + if (SUCCEEDED(pInstance->GetInstanceId(&bstrId))) { +- vsInstanceInfo.InstanceId = std::wstring(bstrId); ++ vsInstanceInfo.InstanceId = std::string(bstrId); + } else { + return false; + } +@@ -169,7 +169,7 @@ bool cmVSSetupAPIHelper::GetVSInstanceIn + if (FAILED(pInstance->GetInstallationVersion(&bstrVersion))) { + return false; + } else { +- vsInstanceInfo.Version = std::wstring(bstrVersion); ++ vsInstanceInfo.Version = std::string(bstrVersion); + if (FAILED(setupHelper->ParseVersion(bstrVersion, &ullVersion))) { + vsInstanceInfo.ullVersion = 0; + } else { +@@ -183,7 +183,7 @@ bool cmVSSetupAPIHelper::GetVSInstanceIn + if (FAILED(pInstance->GetInstallationPath(&bstrInstallationPath))) { + return false; + } else { +- vsInstanceInfo.VSInstallLocation = std::wstring(bstrInstallationPath); ++ vsInstanceInfo.VSInstallLocation = std::string(bstrInstallationPath); + } + } + +@@ -300,7 +300,7 @@ bool cmVSSetupAPIHelper::IsEWDKEnabled() + bool cmVSSetupAPIHelper::EnumerateAndChooseVSInstance() + { + bool isVSInstanceExists = false; +- if (chosenInstanceInfo.VSInstallLocation.compare(L"") != 0) { ++ if (chosenInstanceInfo.VSInstallLocation.compare("") != 0) { + return true; + } + +@@ -314,9 +314,9 @@ bool cmVSSetupAPIHelper::EnumerateAndCho + return false; + + chosenInstanceInfo.VSInstallLocation = +- std::wstring(envVsInstallDir.begin(), envVsInstallDir.end()); ++ std::string(envVsInstallDir.begin(), envVsInstallDir.end()); + chosenInstanceInfo.Version = +- std::wstring(envVSVersion.begin(), envVSVersion.end()); ++ std::string(envVSVersion.begin(), envVSVersion.end()); + chosenInstanceInfo.VCToolsetVersion = envVSVersion; + chosenInstanceInfo.ullVersion = std::stoi(envVSVersion); + chosenInstanceInfo.IsWin10SDKInstalled = true; +@@ -345,7 +345,7 @@ bool cmVSSetupAPIHelper::EnumerateAndCho + return false; + } + +- std::wstring const wantVersion = std::to_wstring(this->Version) + L'.'; ++ std::string const wantVersion = std::to_wstring(this->Version) + L'.'; + + SmartCOMPtr<ISetupInstance> instance; + while (SUCCEEDED(enumInstances->Next(1, &instance, NULL)) && instance) { +diff -urp a/Source/cmVSSetupHelper.h b/Source/cmVSSetupHelper.h +--- a/Source/cmVSSetupHelper.h 2021-01-28 18:58:45.000000000 +0330 ++++ b/Source/cmVSSetupHelper.h 2021-02-11 18:43:33.159175606 +0330 +@@ -84,9 +84,9 @@ private: + + struct VSInstanceInfo + { +- std::wstring InstanceId; +- std::wstring VSInstallLocation; +- std::wstring Version; ++ std::string InstanceId; ++ std::string VSInstallLocation; ++ std::string Version; + std::string VCToolsetVersion; + ULONGLONG ullVersion = 0; + bool IsWin10SDKInstalled = false; +diff -urp a/Source/CPack/WiX/cmCPackWIXGenerator.cxx b/Source/CPack/WiX/cmCPackWIXGenerator.cxx +--- a/Source/CPack/WiX/cmCPackWIXGenerator.cxx 2021-01-28 18:58:45.000000000 +0330 ++++ b/Source/CPack/WiX/cmCPackWIXGenerator.cxx 2021-02-11 18:43:33.145842061 +0330 +@@ -1008,7 +1008,7 @@ std::string cmCPackWIXGenerator::Generat + UuidToStringW(&guid, &tmp); + + std::string result = +- cmsys::Encoding::ToNarrow(reinterpret_cast<wchar_t*>(tmp)); ++ cmsys::Encoding::ToNarrow(reinterpret_cast<char*>(tmp)); + RpcStringFreeW(&tmp); + #else + uuid_t guid; +diff -urp a/Source/kwsys/ConsoleBuf.hxx.in b/Source/kwsys/ConsoleBuf.hxx.in +--- a/Source/kwsys/ConsoleBuf.hxx.in 2021-01-28 18:58:45.000000000 +0330 ++++ b/Source/kwsys/ConsoleBuf.hxx.in 2021-02-11 18:43:32.755835869 +0330 +@@ -111,7 +111,7 @@ protected: + success = false; + } + if (m_hOutput && !m_obuffer.empty()) { +- const std::wstring wbuffer = getBuffer(m_obuffer); ++ const std::string wbuffer = getBuffer(m_obuffer); + if (m_isConsoleOutput) { + DWORD charsWritten; + success = +@@ -149,7 +149,7 @@ protected: + if (m_isConsoleInput) { + // ReadConsole doesn't tell if there's more input available + // don't support reading more characters than this +- wchar_t wbuffer[8192]; ++ char wbuffer[8192]; + DWORD charsRead; + if (ReadConsoleW(m_hInput, wbuffer, + (sizeof(wbuffer) / sizeof(wbuffer[0])), &charsRead, +@@ -158,9 +158,9 @@ protected: + _setg(true); + return Traits::eof(); + } +- setBuffer(std::wstring(wbuffer, charsRead), m_ibuffer); ++ setBuffer(std::string(wbuffer, charsRead), m_ibuffer); + } else { +- std::wstring wbuffer; ++ std::string wbuffer; + std::string strbuffer; + DWORD bytesRead; + LARGE_INTEGER size; +@@ -320,7 +320,7 @@ private: + this->setp((char_type*)m_obuffer.data(), + (char_type*)m_obuffer.data() + m_obuffer.size()); + } +- bool encodeOutputBuffer(const std::wstring wbuffer, std::string& buffer) ++ bool encodeOutputBuffer(const std::string wbuffer, std::string& buffer) + { + if (wbuffer.size() == 0) { + buffer = std::string(); +@@ -340,11 +340,11 @@ private: + delete[] buf; + return success; + } +- bool decodeInputBuffer(const std::string buffer, std::wstring& wbuffer) ++ bool decodeInputBuffer(const std::string buffer, std::string& wbuffer) + { + size_t length = buffer.length(); + if (length == 0) { +- wbuffer = std::wstring(); ++ wbuffer = std::string(); + return true; + } + int actualCodepage = m_activeInputCodepage; +@@ -359,30 +359,30 @@ private: + } + const size_t wlength = static_cast<size_t>(MultiByteToWideChar( + actualCodepage, 0, data, static_cast<int>(length), nullptr, 0)); +- wchar_t* wbuf = new wchar_t[wlength]; ++ char* wbuf = new char[wlength]; + const bool success = + MultiByteToWideChar(actualCodepage, 0, data, static_cast<int>(length), + wbuf, static_cast<int>(wlength)) > 0 + ? true + : false; +- wbuffer = std::wstring(wbuf, wlength); ++ wbuffer = std::string(wbuf, wlength); + delete[] wbuf; + return success; + } +- std::wstring getBuffer(const std::basic_string<char> buffer) ++ std::string getBuffer(const std::basic_string<char> buffer) + { + return Encoding::ToWide(buffer); + } +- std::wstring getBuffer(const std::basic_string<wchar_t> buffer) ++ std::string getBuffer(const std::basic_string<char> buffer) + { + return buffer; + } +- void setBuffer(const std::wstring wbuffer, std::basic_string<char>& target) ++ void setBuffer(const std::string wbuffer, std::basic_string<char>& target) + { + target = Encoding::ToNarrow(wbuffer); + } +- void setBuffer(const std::wstring wbuffer, +- std::basic_string<wchar_t>& target) ++ void setBuffer(const std::string wbuffer, ++ std::basic_string<char>& target) + { + target = wbuffer; + } +@@ -390,7 +390,7 @@ private: + }; // BasicConsoleBuf class + + typedef BasicConsoleBuf<char> ConsoleBuf; +-typedef BasicConsoleBuf<wchar_t> WConsoleBuf; ++typedef BasicConsoleBuf<char> WConsoleBuf; + + #endif + } // KWSYS_NAMESPACE +diff -urp a/Source/kwsys/Directory.cxx b/Source/kwsys/Directory.cxx +--- a/Source/kwsys/Directory.cxx 2021-01-28 18:58:45.000000000 +0330 ++++ b/Source/kwsys/Directory.cxx 2021-02-11 18:43:32.782502961 +0330 +@@ -117,7 +117,7 @@ bool Directory::Load(const std::string& + + // Now put them into the file array + srchHandle = +- _wfindfirst((wchar_t*)Encoding::ToWindowsExtendedPath(buf).c_str(), &data); ++ _wfindfirst((char*)Encoding::ToWindowsExtendedPath(buf).c_str(), &data); + delete[] buf; + + if (srchHandle == -1) { +@@ -148,7 +148,7 @@ unsigned long Directory::GetNumberOfFile + struct _wfinddata_t data; // data of current file + + // Now put them into the file array +- srchHandle = _wfindfirst((wchar_t*)Encoding::ToWide(buf).c_str(), &data); ++ srchHandle = _wfindfirst((char*)Encoding::ToWide(buf).c_str(), &data); + delete[] buf; + + if (srchHandle == -1) { +diff -urp a/Source/kwsys/DynamicLoader.cxx b/Source/kwsys/DynamicLoader.cxx +--- a/Source/kwsys/DynamicLoader.cxx 2021-01-28 18:58:45.000000000 +0330 ++++ b/Source/kwsys/DynamicLoader.cxx 2021-02-11 18:43:32.762502643 +0330 +@@ -263,7 +263,7 @@ DynamicLoader::SymbolPointer DynamicLoad + + const char* DynamicLoader::LastError() + { +- wchar_t lpMsgBuf[DYNLOAD_ERROR_BUFFER_SIZE + 1]; ++ char lpMsgBuf[DYNLOAD_ERROR_BUFFER_SIZE + 1]; + + DWORD error = GetLastError(); + DWORD length = FormatMessageW( +diff -urp a/Source/kwsys/EncodingC.c b/Source/kwsys/EncodingC.c +--- a/Source/kwsys/EncodingC.c 2021-01-28 18:58:45.000000000 +0330 ++++ b/Source/kwsys/EncodingC.c 2021-02-11 18:43:32.749169097 +0330 +@@ -15,7 +15,7 @@ + # include <windows.h> + #endif + +-size_t kwsysEncoding_mbstowcs(wchar_t* dest, const char* str, size_t n) ++size_t kwsysEncoding_mbstowcs(char* dest, const char* str, size_t n) + { + if (str == 0) { + return (size_t)-1; +@@ -29,12 +29,12 @@ size_t kwsysEncoding_mbstowcs(wchar_t* d + #endif + } + +-wchar_t* kwsysEncoding_DupToWide(const char* str) ++char* kwsysEncoding_DupToWide(const char* str) + { +- wchar_t* ret = NULL; ++ char* ret = NULL; + size_t length = kwsysEncoding_mbstowcs(NULL, str, 0) + 1; + if (length > 0) { +- ret = (wchar_t*)malloc((length) * sizeof(wchar_t)); ++ ret = (char*)malloc((length) * sizeof(char)); + if (ret) { + ret[0] = 0; + kwsysEncoding_mbstowcs(ret, str, length); +@@ -43,7 +43,7 @@ wchar_t* kwsysEncoding_DupToWide(const c + return ret; + } + +-size_t kwsysEncoding_wcstombs(char* dest, const wchar_t* str, size_t n) ++size_t kwsysEncoding_wcstombs(char* dest, const char* str, size_t n) + { + if (str == 0) { + return (size_t)-1; +@@ -57,7 +57,7 @@ size_t kwsysEncoding_wcstombs(char* dest + #endif + } + +-char* kwsysEncoding_DupToNarrow(const wchar_t* str) ++char* kwsysEncoding_DupToNarrow(const char* str) + { + char* ret = NULL; + size_t length = kwsysEncoding_wcstombs(0, str, 0) + 1; +diff -urp a/Source/kwsys/EncodingCXX.cxx b/Source/kwsys/EncodingCXX.cxx +--- a/Source/kwsys/EncodingCXX.cxx 2021-01-28 18:58:45.000000000 +0330 ++++ b/Source/kwsys/EncodingCXX.cxx 2021-02-12 14:39:55.148193613 +0330 +@@ -68,16 +68,6 @@ Encoding::CommandLineArguments::CommandL + this->argv_[ac] = nullptr; + } + +-Encoding::CommandLineArguments::CommandLineArguments(int ac, +- wchar_t const* const* av) +-{ +- this->argv_.resize(ac + 1); +- for (int i = 0; i < ac; i++) { +- this->argv_[i] = kwsysEncoding_DupToNarrow(av[i]); +- } +- this->argv_[ac] = nullptr; +-} +- + Encoding::CommandLineArguments::~CommandLineArguments() + { + for (size_t i = 0; i < this->argv_.size(); i++) { +@@ -124,19 +114,19 @@ char const* const* Encoding::CommandLine + + #if KWSYS_STL_HAS_WSTRING + +-std::wstring Encoding::ToWide(const std::string& str) ++std::string Encoding::ToWide(const std::string& str) + { +- std::wstring wstr; ++ std::string wstr; + # if defined(_WIN32) + const int wlength = + MultiByteToWideChar(KWSYS_ENCODING_DEFAULT_CODEPAGE, 0, str.data(), + int(str.size()), nullptr, 0); + if (wlength > 0) { +- wchar_t* wdata = new wchar_t[wlength]; ++ char* wdata = new char[wlength]; + int r = MultiByteToWideChar(KWSYS_ENCODING_DEFAULT_CODEPAGE, 0, str.data(), + int(str.size()), wdata, wlength); + if (r > 0) { +- wstr = std::wstring(wdata, wlength); ++ wstr = std::string(wdata, wlength); + } + delete[] wdata; + } +@@ -150,14 +140,14 @@ std::wstring Encoding::ToWide(const std: + nullPos = str.find('\0', pos); + if (nullPos != std::string::npos) { + pos = nullPos + 1; +- wstr += wchar_t('\0'); ++ wstr += char('\0'); + } + } while (nullPos != std::string::npos); + # endif + return wstr; + } + +-std::string Encoding::ToNarrow(const std::wstring& str) ++std::string Encoding::ToNarrow(const std::string& str) + { + std::string nstr; + # if defined(_WIN32) +@@ -181,7 +171,7 @@ std::string Encoding::ToNarrow(const std + if (pos < str.size() && str.at(pos) != '\0') { + nstr += ToNarrow(str.c_str() + pos); + } +- nullPos = str.find(wchar_t('\0'), pos); ++ nullPos = str.find(char('\0'), pos); + if (nullPos != std::string::npos) { + pos = nullPos + 1; + nstr += '\0'; +@@ -191,12 +181,12 @@ std::string Encoding::ToNarrow(const std + return nstr; + } + +-std::wstring Encoding::ToWide(const char* cstr) ++std::string Encoding::ToWide(const char* cstr) + { +- std::wstring wstr; ++ std::string wstr; + size_t length = kwsysEncoding_mbstowcs(nullptr, cstr, 0) + 1; + if (length > 0) { +- std::vector<wchar_t> wchars(length); ++ std::vector<char> wchars(length); + if (kwsysEncoding_mbstowcs(&wchars[0], cstr, length) > 0) { + wstr = &wchars[0]; + } +@@ -204,7 +194,7 @@ std::wstring Encoding::ToWide(const char + return wstr; + } + +-std::string Encoding::ToNarrow(const wchar_t* wcstr) ++std::string Encoding::ToNarrow(const char* wcstr) + { + std::string str; + size_t length = kwsysEncoding_wcstombs(nullptr, wcstr, 0) + 1; +@@ -219,19 +209,19 @@ std::string Encoding::ToNarrow(const wch + + # if defined(_WIN32) + // Convert local paths to UNC style paths +-std::wstring Encoding::ToWindowsExtendedPath(std::string const& source) ++std::string Encoding::ToWindowsExtendedPath(std::string const& source) + { + return ToWindowsExtendedPath(ToWide(source)); + } + + // Convert local paths to UNC style paths +-std::wstring Encoding::ToWindowsExtendedPath(const char* source) ++std::string Encoding::ToWindowsExtendedPath(const char* source) + { + return ToWindowsExtendedPath(ToWide(source)); + } + + // Convert local paths to UNC style paths +-std::wstring Encoding::ToWindowsExtendedPath(std::wstring const& wsource) ++std::string Encoding::ToWindowsExtendedPath(std::string const& wsource) + { + // Resolve any relative paths + DWORD wfull_len; +@@ -239,7 +229,7 @@ std::wstring Encoding::ToWindowsExtended + /* The +3 is a workaround for a bug in some versions of GetFullPathNameW that + * won't return a large enough buffer size if the input is too small */ + wfull_len = GetFullPathNameW(wsource.c_str(), 0, nullptr, nullptr) + 3; +- std::vector<wchar_t> wfull(wfull_len); ++ std::vector<char> wfull(wfull_len); + GetFullPathNameW(wsource.c_str(), wfull_len, &wfull[0], nullptr); + + /* This should get the correct size without any extra padding from the +@@ -248,7 +238,7 @@ std::wstring Encoding::ToWindowsExtended + + if (wfull_len >= 2 && isalpha(wfull[0]) && + wfull[1] == L':') { /* C:\Foo\bar\FooBar.txt */ +- return L"\\\\?\\" + std::wstring(&wfull[0]); ++ return "\\\\?\\" + std::string(&wfull[0]); + } else if (wfull_len >= 2 && wfull[0] == L'\\' && + wfull[1] == L'\\') { /* Starts with \\ */ + if (wfull_len >= 4 && wfull[2] == L'?' && +@@ -256,24 +246,24 @@ std::wstring Encoding::ToWindowsExtended + if (wfull_len >= 8 && wfull[4] == L'U' && wfull[5] == L'N' && + wfull[6] == L'C' && + wfull[7] == L'\\') { /* \\?\UNC\Foo\bar\FooBar.txt */ +- return std::wstring(&wfull[0]); ++ return std::string(&wfull[0]); + } else if (wfull_len >= 6 && isalpha(wfull[4]) && + wfull[5] == L':') { /* \\?\C:\Foo\bar\FooBar.txt */ +- return std::wstring(&wfull[0]); ++ return std::string(&wfull[0]); + } else if (wfull_len >= 5) { /* \\?\Foo\bar\FooBar.txt */ +- return L"\\\\?\\UNC\\" + std::wstring(&wfull[4]); ++ return "\\\\?\\UNC\\" + std::string(&wfull[4]); + } + } else if (wfull_len >= 4 && wfull[2] == L'.' && + wfull[3] == L'\\') { /* Starts with \\.\ a device name */ + if (wfull_len >= 6 && isalpha(wfull[4]) && + wfull[5] == L':') { /* \\.\C:\Foo\bar\FooBar.txt */ +- return L"\\\\?\\" + std::wstring(&wfull[4]); ++ return "\\\\?\\" + std::string(&wfull[4]); + } else if (wfull_len >= + 5) { /* \\.\Foo\bar\ Device name is left unchanged */ +- return std::wstring(&wfull[0]); ++ return std::string(&wfull[0]); + } + } else if (wfull_len >= 3) { /* \\Foo\bar\FooBar.txt */ +- return L"\\\\?\\UNC\\" + std::wstring(&wfull[2]); ++ return "\\\\?\\UNC\\" + std::string(&wfull[2]); + } + } + +diff -urp a/Source/kwsys/Encoding.h.in b/Source/kwsys/Encoding.h.in +--- a/Source/kwsys/Encoding.h.in 2021-01-28 18:58:45.000000000 +0330 ++++ b/Source/kwsys/Encoding.h.in 2021-02-11 18:43:32.759169256 +0330 +@@ -31,22 +31,22 @@ extern "C" { + On Windows, UTF-8 is assumed, and on other platforms, + the current locale is assumed. + */ +-kwsysEXPORT size_t kwsysEncoding_mbstowcs(wchar_t* dest, const char* src, ++kwsysEXPORT size_t kwsysEncoding_mbstowcs(char* dest, const char* src, + size_t n); + + /* Convert a narrow string to a wide string. + This can return NULL if the conversion fails. */ +-kwsysEXPORT wchar_t* kwsysEncoding_DupToWide(const char* src); ++kwsysEXPORT char* kwsysEncoding_DupToWide(const char* src); + + /* Convert a wide string to a narrow string. + On Windows, UTF-8 is assumed, and on other platforms, + the current locale is assumed. */ +-kwsysEXPORT size_t kwsysEncoding_wcstombs(char* dest, const wchar_t* src, ++kwsysEXPORT size_t kwsysEncoding_wcstombs(char* dest, const char* src, + size_t n); + + /* Convert a wide string to a narrow string. + This can return NULL if the conversion fails. */ +-kwsysEXPORT char* kwsysEncoding_DupToNarrow(const wchar_t* str); ++kwsysEXPORT char* kwsysEncoding_DupToNarrow(const char* str); + + #if defined(__cplusplus) + } /* extern "C" */ +diff -urp a/Source/kwsys/Encoding.hxx.in b/Source/kwsys/Encoding.hxx.in +--- a/Source/kwsys/Encoding.hxx.in 2021-01-28 18:58:45.000000000 +0330 ++++ b/Source/kwsys/Encoding.hxx.in 2021-02-12 14:39:55.148193613 +0330 +@@ -27,9 +27,6 @@ public: + // in the encoding used by this module. + CommandLineArguments(int argc, char const* const* argv); + +- // Construct CommandLineArguments with the given +- // argc and wide argv. This is useful if wmain() is used. +- CommandLineArguments(int argc, wchar_t const* const* argv); + ~CommandLineArguments(); + CommandLineArguments(const CommandLineArguments&); + CommandLineArguments& operator=(const CommandLineArguments&); +@@ -42,7 +39,7 @@ public: + }; + + /** +- * Convert between char and wchar_t ++ * Convert between char and char + */ + + #if @KWSYS_NAMESPACE@_STL_HAS_WSTRING +@@ -50,14 +47,14 @@ public: + // Convert a narrow string to a wide string. + // On Windows, UTF-8 is assumed, and on other platforms, + // the current locale is assumed. +- static std::wstring ToWide(const std::string& str); +- static std::wstring ToWide(const char* str); ++ static std::string ToWide(const std::string& str); ++ static std::string ToWide(const char* str); + + // Convert a wide string to a narrow string. + // On Windows, UTF-8 is assumed, and on other platforms, + // the current locale is assumed. +- static std::string ToNarrow(const std::wstring& str); +- static std::string ToNarrow(const wchar_t* str); ++ static std::string ToNarrow(const std::string& str); ++ static std::string ToNarrow(const char* str); + + # if defined(_WIN32) + /** +@@ -67,9 +64,8 @@ public: + * will be prefixed with \\?\UNC\. All output will also be converted to + * absolute paths with Windows-style backslashes. + **/ +- static std::wstring ToWindowsExtendedPath(std::string const&); +- static std::wstring ToWindowsExtendedPath(const char* source); +- static std::wstring ToWindowsExtendedPath(std::wstring const& wsource); ++ static std::string ToWindowsExtendedPath(std::string const&); ++ static std::string ToWindowsExtendedPath(const char* source); + # endif + + #endif // @KWSYS_NAMESPACE@_STL_HAS_WSTRING +diff -urp a/Source/kwsys/FStream.hxx.in b/Source/kwsys/FStream.hxx.in +--- a/Source/kwsys/FStream.hxx.in 2021-01-28 18:58:45.000000000 +0330 ++++ b/Source/kwsys/FStream.hxx.in 2021-02-11 18:43:32.765836028 +0330 +@@ -33,7 +33,7 @@ public: + typedef std::basic_filebuf<CharType, Traits> my_base_type; + basic_filebuf* open(char const* s, std::ios_base::openmode mode) + { +- const std::wstring wstr = Encoding::ToWindowsExtendedPath(s); ++ const std::string wstr = Encoding::ToWindowsExtendedPath(s); + return static_cast<basic_filebuf*>(my_base_type::open(wstr.c_str(), mode)); + } + # endif +@@ -41,28 +41,28 @@ public: + + # else + +-inline std::wstring getcmode(const std::ios_base::openmode mode) ++inline std::string getcmode(const std::ios_base::openmode mode) + { +- std::wstring cmode; ++ std::string cmode; + bool plus = false; + if (mode & std::ios_base::app) { +- cmode += L"a"; ++ cmode += "a"; + plus = mode & std::ios_base::in ? true : false; + } else if (mode & std::ios_base::trunc || + (mode & std::ios_base::out && (mode & std::ios_base::in) == 0)) { +- cmode += L"w"; ++ cmode += "w"; + plus = mode & std::ios_base::in ? true : false; + } else { +- cmode += L"r"; ++ cmode += "r"; + plus = mode & std::ios_base::out ? true : false; + } + if (plus) { +- cmode += L"+"; ++ cmode += "+"; + } + if (mode & std::ios_base::binary) { +- cmode += L"b"; ++ cmode += "b"; + } else { +- cmode += L"t"; ++ cmode += "t"; + } + return cmode; + }; +@@ -93,9 +93,9 @@ public: + # if defined(_MSC_VER) + const bool success = buf_->open(file_name, mode) != 0; + # else +- const std::wstring wstr = Encoding::ToWindowsExtendedPath(file_name); ++ const std::string wstr = Encoding::ToWindowsExtendedPath(file_name); + bool success = false; +- std::wstring cmode = getcmode(mode); ++ std::string cmode = getcmode(mode); + file_ = _wfopen(wstr.c_str(), cmode.c_str()); + if (file_) { + if (buf_) { +diff -urp a/Source/kwsys/kwsysPlatformTestsCXX.cxx b/Source/kwsys/kwsysPlatformTestsCXX.cxx +--- a/Source/kwsys/kwsysPlatformTestsCXX.cxx 2021-01-28 18:58:45.000000000 +0330 ++++ b/Source/kwsys/kwsysPlatformTestsCXX.cxx 2021-02-12 14:39:59.854519416 +0330 +@@ -156,7 +156,7 @@ int main() + + #ifdef TEST_KWSYS_STL_HAS_WSTRING + # include <string> +-void f(std::wstring*) ++void f(std::string*) + { + } + int main() +diff -urp a/Source/kwsys/ProcessWin32.c b/Source/kwsys/ProcessWin32.c +--- a/Source/kwsys/ProcessWin32.c 2021-01-28 18:58:45.000000000 +0330 ++++ b/Source/kwsys/ProcessWin32.c 2021-02-11 18:43:32.785836347 +0330 +@@ -202,14 +202,14 @@ struct kwsysProcess_s + int State; + + /* The command lines to execute. */ +- wchar_t** Commands; ++ char** Commands; + int NumberOfCommands; + + /* The exit code of each command. */ + DWORD* CommandExitCodes; + + /* The working directory for the child process. */ +- wchar_t* WorkingDirectory; ++ char* WorkingDirectory; + + /* Whether to create the child as a detached process. */ + int OptionDetach; +@@ -301,7 +301,7 @@ struct kwsysProcess_s + + /* Real working directory of our own process. */ + DWORD RealWorkingDirectoryLength; +- wchar_t* RealWorkingDirectory; ++ char* RealWorkingDirectory; + + /* Own handles for the child's ends of the pipes in the parent process. + Used temporarily during process creation. */ +@@ -549,7 +549,7 @@ int kwsysProcess_SetCommand(kwsysProcess + int kwsysProcess_AddCommand(kwsysProcess* cp, char const* const* command) + { + int newNumberOfCommands; +- wchar_t** newCommands; ++ char** newCommands; + + /* Make sure we have a command to add. */ + if (!cp || !command || !*command) { +@@ -559,7 +559,7 @@ int kwsysProcess_AddCommand(kwsysProcess + /* Allocate a new array for command pointers. */ + newNumberOfCommands = cp->NumberOfCommands + 1; + if (!(newCommands = +- (wchar_t**)malloc(sizeof(wchar_t*) * newNumberOfCommands))) { ++ (char**)malloc(sizeof(char*) * newNumberOfCommands))) { + /* Out of memory. */ + return 0; + } +@@ -664,11 +664,11 @@ int kwsysProcess_SetWorkingDirectory(kws + cp->WorkingDirectory = 0; + } + if (dir && dir[0]) { +- wchar_t* wdir = kwsysEncoding_DupToWide(dir); ++ char* wdir = kwsysEncoding_DupToWide(dir); + /* We must convert the working directory to a full path. */ + DWORD length = GetFullPathNameW(wdir, 0, 0, 0); + if (length > 0) { +- wchar_t* work_dir = malloc(length * sizeof(wchar_t)); ++ char* work_dir = malloc(length * sizeof(char)); + if (!work_dir) { + free(wdir); + return 0; +@@ -968,7 +968,7 @@ void kwsysProcess_Execute(kwsysProcess* + /* Setup the stdin pipe for the first process. */ + if (cp->PipeFileSTDIN) { + /* Create a handle to read a file for stdin. */ +- wchar_t* wstdin = kwsysEncoding_DupToWide(cp->PipeFileSTDIN); ++ char* wstdin = kwsysEncoding_DupToWide(cp->PipeFileSTDIN); + DWORD error; + cp->PipeChildStd[0] = + CreateFileW(wstdin, GENERIC_READ, FILE_SHARE_READ | FILE_SHARE_WRITE, 0, +@@ -1630,7 +1630,7 @@ int kwsysProcessInitialize(kwsysProcess* + cp->RealWorkingDirectoryLength = GetCurrentDirectoryW(0, 0); + if (cp->RealWorkingDirectoryLength > 0) { + cp->RealWorkingDirectory = +- malloc(cp->RealWorkingDirectoryLength * sizeof(wchar_t)); ++ malloc(cp->RealWorkingDirectoryLength * sizeof(char)); + if (!cp->RealWorkingDirectory) { + return 0; + } +@@ -1796,7 +1796,7 @@ void kwsysProcessDestroy(kwsysProcess* c + DWORD kwsysProcessSetupOutputPipeFile(PHANDLE phandle, const char* name) + { + HANDLE fout; +- wchar_t* wname; ++ char* wname; + DWORD error; + if (!name) { + return ERROR_INVALID_PARAMETER; +@@ -1857,7 +1857,7 @@ void kwsysProcessCleanup(kwsysProcess* c + /* Construct an error message if one has not been provided already. */ + if (cp->ErrorMessage[0] == 0) { + /* Format the error message. */ +- wchar_t err_msg[KWSYSPE_PIPE_BUFFER_SIZE]; ++ char err_msg[KWSYSPE_PIPE_BUFFER_SIZE]; + DWORD length = FormatMessageW( + FORMAT_MESSAGE_FROM_SYSTEM | FORMAT_MESSAGE_IGNORE_INSERTS, 0, error, + MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT), err_msg, +@@ -2347,7 +2347,7 @@ static int kwsysProcess_List__New_NT4(kw + loaded in this program. This does not actually increment the + reference count to the module so we do not need to close the + handle. */ +- HMODULE hNT = GetModuleHandleW(L"ntdll.dll"); ++ HMODULE hNT = GetModuleHandleW("ntdll.dll"); + if (hNT) { + /* Get pointers to the needed API functions. */ + self->P_ZwQuerySystemInformation = +@@ -2428,7 +2428,7 @@ static int kwsysProcess_List__New_Snapsh + loaded in this program. This does not actually increment the + reference count to the module so we do not need to close the + handle. */ +- HMODULE hKernel = GetModuleHandleW(L"kernel32.dll"); ++ HMODULE hKernel = GetModuleHandleW("kernel32.dll"); + if (hKernel) { + self->P_CreateToolhelp32Snapshot = + ((CreateToolhelp32SnapshotType)GetProcAddress( +diff -urp a/Source/kwsys/SystemInformation.cxx b/Source/kwsys/SystemInformation.cxx +--- a/Source/kwsys/SystemInformation.cxx 2021-01-28 18:58:45.000000000 +0330 ++++ b/Source/kwsys/SystemInformation.cxx 2021-02-12 14:39:59.854519416 +0330 +@@ -2559,7 +2559,7 @@ bool SystemInformationImplementation::Re + HKEY hKey = nullptr; + LONG err = + RegOpenKeyExW(HKEY_LOCAL_MACHINE, +- L"HARDWARE\\DESCRIPTION\\System\\CentralProcessor\\0", 0, ++ "HARDWARE\\DESCRIPTION\\System\\CentralProcessor\\0", 0, + KEY_READ, &hKey); + + if (ERROR_SUCCESS == err) { +@@ -2568,7 +2568,7 @@ bool SystemInformationImplementation::Re + DWORD dwSize = sizeof(DWORD); + + err = +- RegQueryValueExW(hKey, L"~MHz", 0, &dwType, (LPBYTE)&data, &dwSize); ++ RegQueryValueExW(hKey, "~MHz", 0, &dwType, (LPBYTE)&data, &dwSize); + + if (ERROR_SUCCESS == err) { + this->CPUSpeedInMHz = (float)data; +@@ -3836,7 +3836,7 @@ double SystemInformationImplementation:: + typedef BOOL(WINAPI * GetSystemTimesType)(LPFILETIME, LPFILETIME, + LPFILETIME); + static GetSystemTimesType pGetSystemTimes = +- (GetSystemTimesType)GetProcAddress(GetModuleHandleW(L"kernel32"), ++ (GetSystemTimesType)GetProcAddress(GetModuleHandleW("kernel32"), + "GetSystemTimes"); + FILETIME idleTime, kernelTime, userTime; + if (pGetSystemTimes && pGetSystemTimes(&idleTime, &kernelTime, &userTime)) { +@@ -4383,7 +4383,7 @@ void SystemInformationImplementation::CP + PSYSTEM_LOGICAL_PROCESSOR_INFORMATION, PDWORD); + static GetLogicalProcessorInformationType pGetLogicalProcessorInformation = + (GetLogicalProcessorInformationType)GetProcAddress( +- GetModuleHandleW(L"kernel32"), "GetLogicalProcessorInformation"); ++ GetModuleHandleW("kernel32"), "GetLogicalProcessorInformation"); + + if (!pGetLogicalProcessorInformation) { + // Fallback to approximate implementation on ancient Windows versions. +@@ -5267,21 +5267,21 @@ bool SystemInformationImplementation::Qu + # endif // VER_NT_WORKSTATION + { + HKEY hKey; +- wchar_t szProductType[80]; ++ char szProductType[80]; + DWORD dwBufLen; + + // Query the registry to retrieve information. + RegOpenKeyExW(HKEY_LOCAL_MACHINE, +- L"SYSTEM\\CurrentControlSet\\Control\\ProductOptions", 0, ++ "SYSTEM\\CurrentControlSet\\Control\\ProductOptions", 0, + KEY_QUERY_VALUE, &hKey); +- RegQueryValueExW(hKey, L"ProductType", nullptr, nullptr, ++ RegQueryValueExW(hKey, "ProductType", nullptr, nullptr, + (LPBYTE)szProductType, &dwBufLen); + RegCloseKey(hKey); + +- if (lstrcmpiW(L"WINNT", szProductType) == 0) { ++ if (lstrcmpiW("WINNT", szProductType) == 0) { + this->OSRelease += " Professional"; + } +- if (lstrcmpiW(L"LANMANNT", szProductType) == 0) { ++ if (lstrcmpiW("LANMANNT", szProductType) == 0) { + // Decide between Windows 2000 Advanced Server and Windows .NET + // Enterprise Server. + if (osvi.dwMajorVersion == 5 && osvi.dwMinorVersion == 1) { +@@ -5290,7 +5290,7 @@ bool SystemInformationImplementation::Qu + this->OSRelease += " Server"; + } + } +- if (lstrcmpiW(L"SERVERNT", szProductType) == 0) { ++ if (lstrcmpiW("SERVERNT", szProductType) == 0) { + // Decide between Windows 2000 Advanced Server and Windows .NET + // Enterprise Server. + if (osvi.dwMajorVersion == 5 && osvi.dwMinorVersion == 1) { +@@ -5315,7 +5315,7 @@ bool SystemInformationImplementation::Qu + LPFNPROC DLLProc; + + // Load the Kernel32 DLL. +- hKernelDLL = LoadLibraryW(L"kernel32"); ++ hKernelDLL = LoadLibraryW("kernel32"); + if (hKernelDLL != nullptr) { + // Only XP and .NET Server support IsWOW64Process so... Load + // dynamically! +diff -urp a/Source/kwsys/SystemTools.cxx b/Source/kwsys/SystemTools.cxx +--- a/Source/kwsys/SystemTools.cxx 2021-01-28 18:58:45.000000000 +0330 ++++ b/Source/kwsys/SystemTools.cxx 2021-02-12 14:39:59.854519416 +0330 +@@ -223,7 +223,7 @@ inline int Rmdir(const std::string& dir) + } + inline const char* Getcwd(char* buf, unsigned int len) + { +- std::vector<wchar_t> w_buf(len); ++ std::vector<char> w_buf(len); + if (_wgetcwd(&w_buf[0], len)) { + size_t nlen = kwsysEncoding_wcstombs(buf, &w_buf[0], len); + if (nlen == static_cast<size_t>(-1)) { +@@ -246,9 +246,9 @@ inline int Chdir(const std::string& dir) + inline void Realpath(const std::string& path, std::string& resolved_path, + std::string* errorMessage = 0) + { +- std::wstring tmp = KWSYS_NAMESPACE::Encoding::ToWide(path); +- wchar_t* ptemp; +- wchar_t fullpath[MAX_PATH]; ++ std::string tmp = KWSYS_NAMESPACE::Encoding::ToWide(path); ++ char* ptemp; ++ char fullpath[MAX_PATH]; + DWORD bufferLen = GetFullPathNameW( + tmp.c_str(), sizeof(fullpath) / sizeof(fullpath[0]), fullpath, &ptemp); + if (bufferLen < sizeof(fullpath) / sizeof(fullpath[0])) { +@@ -351,7 +351,7 @@ double SystemTools::GetTime() + + /* Type of character storing the environment. */ + #if defined(_WIN32) +-typedef wchar_t envchar; ++typedef char envchar; + #else + using envchar = char; + #endif +@@ -362,8 +362,8 @@ struct kwsysEnvCompare + bool operator()(const envchar* l, const envchar* r) const + { + #if defined(_WIN32) +- const wchar_t* leq = wcschr(l, L'='); +- const wchar_t* req = wcschr(r, L'='); ++ const char* leq = wcschr(l, L'='); ++ const char* req = wcschr(r, L'='); + size_t llen = leq ? (leq - l) : wcslen(l); + size_t rlen = req ? (req - r) : wcslen(r); + if (llen == rlen) { +@@ -642,8 +642,8 @@ const char* SystemTools::GetEnv(const st + bool SystemTools::GetEnv(const char* key, std::string& result) + { + #if defined(_WIN32) +- const std::wstring wkey = Encoding::ToWide(key); +- const wchar_t* wv = _wgetenv(wkey.c_str()); ++ const std::string wkey = Encoding::ToWide(key); ++ const char* wv = _wgetenv(wkey.c_str()); + if (wv) { + result = Encoding::ToNarrow(wv); + return true; +@@ -666,8 +666,8 @@ bool SystemTools::GetEnv(const std::stri + bool SystemTools::HasEnv(const char* key) + { + #if defined(_WIN32) +- const std::wstring wkey = Encoding::ToWide(key); +- const wchar_t* v = _wgetenv(wkey.c_str()); ++ const std::string wkey = Encoding::ToWide(key); ++ const char* v = _wgetenv(wkey.c_str()); + #else + const char* v = getenv(key); + #endif +@@ -733,11 +733,11 @@ static kwsysEnvSet kwsysUnPutEnvSet; + + static int kwsysUnPutEnv(std::string const& env) + { +- std::wstring wEnv = Encoding::ToWide(env); ++ std::string wEnv = Encoding::ToWide(env); + size_t const pos = wEnv.find('='); + size_t const len = pos == std::string::npos ? wEnv.size() : pos; + wEnv.resize(len + 1, L'='); +- wchar_t* newEnv = _wcsdup(wEnv.c_str()); ++ char* newEnv = _wcsdup(wEnv.c_str()); + if (!newEnv) { + return -1; + } +@@ -820,8 +820,8 @@ public: + bool Put(const char* env) + { + # if defined(_WIN32) +- const std::wstring wEnv = Encoding::ToWide(env); +- wchar_t* newEnv = _wcsdup(wEnv.c_str()); ++ const std::string wEnv = Encoding::ToWide(env); ++ char* newEnv = _wcsdup(wEnv.c_str()); + # else + char* newEnv = strdup(env); + # endif +@@ -836,7 +836,7 @@ public: + bool UnPut(const char* env) + { + # if defined(_WIN32) +- const std::wstring wEnv = Encoding::ToWide(env); ++ const std::string wEnv = Encoding::ToWide(env); + Free oldEnv(this->Release(wEnv.c_str())); + # else + Free oldEnv(this->Release(env)); +@@ -872,7 +872,7 @@ FILE* SystemTools::Fopen(const std::stri + { + #ifdef _WIN32 + // Remove any 'e', which is supported on UNIX, but not Windows. +- std::wstring trimmedMode = Encoding::ToWide(mode); ++ std::string trimmedMode = Encoding::ToWide(mode); + trimmedMode.erase(std::remove(trimmedMode.begin(), trimmedMode.end(), L'e'), + trimmedMode.end()); + return _wfopen(Encoding::ToWindowsExtendedPath(file).c_str(), +@@ -1005,7 +1005,7 @@ static bool hasPrefix(const std::string& + } + + static bool SystemToolsParseRegistryKey(const std::string& key, +- HKEY& primaryKey, std::wstring& second, ++ HKEY& primaryKey, std::string& second, + std::string* valuename) + { + size_t start = key.find('\\'); +@@ -1040,7 +1040,7 @@ static DWORD SystemToolsMakeRegistryMode + { + // only add the modes when on a system that supports Wow64. + static FARPROC wow64p = +- GetProcAddress(GetModuleHandleW(L"kernel32"), "IsWow64Process"); ++ GetProcAddress(GetModuleHandleW("kernel32"), "IsWow64Process"); + if (wow64p == nullptr) { + return mode; + } +@@ -1060,7 +1060,7 @@ bool SystemTools::GetRegistrySubKeys(con + KeyWOW64 view) + { + HKEY primaryKey = HKEY_CURRENT_USER; +- std::wstring second; ++ std::string second; + if (!SystemToolsParseRegistryKey(key, primaryKey, second, nullptr)) { + return false; + } +@@ -1071,7 +1071,7 @@ bool SystemTools::GetRegistrySubKeys(con + &hKey) != ERROR_SUCCESS) { + return false; + } else { +- wchar_t name[1024]; ++ char name[1024]; + DWORD dwNameSize = sizeof(name) / sizeof(name[0]); + + DWORD i = 0; +@@ -1106,7 +1106,7 @@ bool SystemTools::ReadRegistryValue(cons + { + bool valueset = false; + HKEY primaryKey = HKEY_CURRENT_USER; +- std::wstring second; ++ std::string second; + std::string valuename; + if (!SystemToolsParseRegistryKey(key, primaryKey, second, &valuename)) { + return false; +@@ -1120,14 +1120,14 @@ bool SystemTools::ReadRegistryValue(cons + } else { + DWORD dwType, dwSize; + dwSize = 1023; +- wchar_t data[1024]; ++ char data[1024]; + if (RegQueryValueExW(hKey, Encoding::ToWide(valuename).c_str(), nullptr, + &dwType, (BYTE*)data, &dwSize) == ERROR_SUCCESS) { + if (dwType == REG_SZ) { + value = Encoding::ToNarrow(data); + valueset = true; + } else if (dwType == REG_EXPAND_SZ) { +- wchar_t expanded[1024]; ++ char expanded[1024]; + DWORD dwExpandedSize = sizeof(expanded) / sizeof(expanded[0]); + if (ExpandEnvironmentStringsW(data, expanded, dwExpandedSize)) { + value = Encoding::ToNarrow(expanded); +@@ -1160,7 +1160,7 @@ bool SystemTools::WriteRegistryValue(con + const std::string& value, KeyWOW64 view) + { + HKEY primaryKey = HKEY_CURRENT_USER; +- std::wstring second; ++ std::string second; + std::string valuename; + if (!SystemToolsParseRegistryKey(key, primaryKey, second, &valuename)) { + return false; +@@ -1168,7 +1168,7 @@ bool SystemTools::WriteRegistryValue(con + + HKEY hKey; + DWORD dwDummy; +- wchar_t lpClass[] = L""; ++ char lpClass[] = ""; + if (RegCreateKeyExW(primaryKey, second.c_str(), 0, lpClass, + REG_OPTION_NON_VOLATILE, + SystemToolsMakeRegistryMode(KEY_WRITE, view), nullptr, +@@ -1176,10 +1176,10 @@ bool SystemTools::WriteRegistryValue(con + return false; + } + +- std::wstring wvalue = Encoding::ToWide(value); ++ std::string wvalue = Encoding::ToWide(value); + if (RegSetValueExW(hKey, Encoding::ToWide(valuename).c_str(), 0, REG_SZ, + (CONST BYTE*)wvalue.c_str(), +- (DWORD)(sizeof(wchar_t) * (wvalue.size() + 1))) == ++ (DWORD)(sizeof(char) * (wvalue.size() + 1))) == + ERROR_SUCCESS) { + return true; + } +@@ -1204,7 +1204,7 @@ bool SystemTools::WriteRegistryValue(con + bool SystemTools::DeleteRegistryValue(const std::string& key, KeyWOW64 view) + { + HKEY primaryKey = HKEY_CURRENT_USER; +- std::wstring second; ++ std::string second; + std::string valuename; + if (!SystemToolsParseRegistryKey(key, primaryKey, second, &valuename)) { + return false; +@@ -1404,7 +1404,7 @@ int SystemTools::Stat(const std::string& + // Ideally we should use Encoding::ToWindowsExtendedPath to support + // long paths, but _wstat64 rejects paths with '?' in them, thinking + // they are wildcards. +- std::wstring const& wpath = Encoding::ToWide(path); ++ std::string const& wpath = Encoding::ToWide(path); + return _wstat64(wpath.c_str(), buf); + #else + return stat(path.c_str(), buf); +@@ -2035,7 +2035,7 @@ void SystemTools::ConvertToUnixSlashes(s + } + + #ifdef _WIN32 +-std::wstring SystemTools::ConvertToWindowsExtendedPath( ++std::string SystemTools::ConvertToWindowsExtendedPath( + const std::string& source) + { + return Encoding::ToWindowsExtendedPath(source); +@@ -2556,7 +2556,7 @@ std::string SystemTools::GetLastSystemEr + bool SystemTools::RemoveFile(const std::string& source) + { + #ifdef _WIN32 +- std::wstring const& ws = Encoding::ToWindowsExtendedPath(source); ++ std::string const& ws = Encoding::ToWindowsExtendedPath(source); + if (DeleteFileW(ws.c_str())) { + return true; + } +@@ -2960,7 +2960,7 @@ bool SystemTools::FileIsExecutable(const + bool SystemTools::FileIsSymlink(const std::string& name) + { + #if defined(_WIN32) +- std::wstring path = Encoding::ToWindowsExtendedPath(name); ++ std::string path = Encoding::ToWindowsExtendedPath(name); + DWORD attr = GetFileAttributesW(path.c_str()); + if (attr != INVALID_FILE_ATTRIBUTES) { + if ((attr & FILE_ATTRIBUTE_REPARSE_POINT) != 0) { +@@ -3971,9 +3971,9 @@ bool SystemTools::GetShortPath(const std + tempPath.erase(0, 1); + } + +- std::wstring wtempPath = Encoding::ToWide(tempPath); ++ std::string wtempPath = Encoding::ToWide(tempPath); + DWORD ret = GetShortPathNameW(wtempPath.c_str(), nullptr, 0); +- std::vector<wchar_t> buffer(ret); ++ std::vector<char> buffer(ret); + if (ret != 0) { + ret = GetShortPathNameW(wtempPath.c_str(), &buffer[0], + static_cast<DWORD>(buffer.size())); +@@ -4368,19 +4368,19 @@ std::string SystemTools::GetOperatingSys + else { + HKEY hKey; + # define BUFSIZE 80 +- wchar_t szProductType[BUFSIZE]; ++ char szProductType[BUFSIZE]; + DWORD dwBufLen = BUFSIZE; + LONG lRet; + + lRet = + RegOpenKeyExW(HKEY_LOCAL_MACHINE, +- L"SYSTEM\\CurrentControlSet\\Control\\ProductOptions", ++ "SYSTEM\\CurrentControlSet\\Control\\ProductOptions", + 0, KEY_QUERY_VALUE, &hKey); + if (lRet != ERROR_SUCCESS) { + return 0; + } + +- lRet = RegQueryValueExW(hKey, L"ProductType", nullptr, nullptr, ++ lRet = RegQueryValueExW(hKey, "ProductType", nullptr, nullptr, + (LPBYTE)szProductType, &dwBufLen); + + if ((lRet != ERROR_SUCCESS) || (dwBufLen > BUFSIZE)) { +@@ -4389,13 +4389,13 @@ std::string SystemTools::GetOperatingSys + + RegCloseKey(hKey); + +- if (lstrcmpiW(L"WINNT", szProductType) == 0) { ++ if (lstrcmpiW("WINNT", szProductType) == 0) { + res += " Workstation"; + } +- if (lstrcmpiW(L"LANMANNT", szProductType) == 0) { ++ if (lstrcmpiW("LANMANNT", szProductType) == 0) { + res += " Server"; + } +- if (lstrcmpiW(L"SERVERNT", szProductType) == 0) { ++ if (lstrcmpiW("SERVERNT", szProductType) == 0) { + res += " Advanced Server"; + } + +@@ -4418,7 +4418,7 @@ std::string SystemTools::GetOperatingSys + + lRet = RegOpenKeyExW( + HKEY_LOCAL_MACHINE, +- L"SOFTWARE\\Microsoft\\Windows NT\\CurrentVersion\\Hotfix\\Q246009", ++ "SOFTWARE\\Microsoft\\Windows NT\\CurrentVersion\\Hotfix\\Q246009", + 0, KEY_QUERY_VALUE, &hKey); + + if (lRet == ERROR_SUCCESS) { +diff -urp a/Source/kwsys/SystemTools.hxx.in b/Source/kwsys/SystemTools.hxx.in +--- a/Source/kwsys/SystemTools.hxx.in 2021-01-28 18:58:45.000000000 +0330 ++++ b/Source/kwsys/SystemTools.hxx.in 2021-02-11 18:43:32.762502643 +0330 +@@ -258,7 +258,7 @@ public: + + #ifdef _WIN32 + /** Calls Encoding::ToWindowsExtendedPath. */ +- static std::wstring ConvertToWindowsExtendedPath(const std::string&); ++ static std::string ConvertToWindowsExtendedPath(const std::string&); + #endif + + /** +diff -urp a/Source/kwsys/testConsoleBufChild.cxx b/Source/kwsys/testConsoleBufChild.cxx +--- a/Source/kwsys/testConsoleBufChild.cxx 2021-01-28 18:58:45.000000000 +0330 ++++ b/Source/kwsys/testConsoleBufChild.cxx 2021-02-11 18:43:32.759169256 +0330 +@@ -27,8 +27,8 @@ int main(int argc, const char* argv[]) + std::cout << argv[1] << std::endl; + std::cerr << argv[1] << std::endl; + } else { +- std::string str = kwsys::Encoding::ToNarrow(std::wstring( +- UnicodeTestString, sizeof(UnicodeTestString) / sizeof(wchar_t) - 1)); ++ std::string str = kwsys::Encoding::ToNarrow(std::string( ++ UnicodeTestString, sizeof(UnicodeTestString) / sizeof(char) - 1)); + std::cout << str << std::endl; + std::cerr << str << std::endl; + } +diff -urp a/Source/kwsys/testConsoleBuf.cxx b/Source/kwsys/testConsoleBuf.cxx +--- a/Source/kwsys/testConsoleBuf.cxx 2021-01-28 18:58:45.000000000 +0330 ++++ b/Source/kwsys/testConsoleBuf.cxx 2021-02-11 18:43:32.759169256 +0330 +@@ -33,7 +33,7 @@ + # endif + // يونيكود + static const WCHAR UnicodeInputTestString[] = +- L"\u064A\u0648\u0646\u064A\u0643\u0648\u062F!"; ++ "\u064A\u0648\u0646\u064A\u0643\u0648\u062F!"; + static UINT TestCodepage = KWSYS_ENCODING_DEFAULT_CODEPAGE; + + static const DWORD waitTimeout = 10 * 1000; +@@ -68,7 +68,7 @@ std::basic_streambuf<char>* errstream(co + return std::cerr.rdbuf(); + } + +-std::basic_streambuf<wchar_t>* errstream(const wchar_t* unused) ++std::basic_streambuf<char>* errstream(const char* unused) + { + static_cast<void>(unused); + return std::wcerr.rdbuf(); +@@ -133,7 +133,7 @@ static bool createProcess(HANDLE hIn, HA + p--; + *(p + 1) = 0; + wcscat(cmd, cmdConsoleBufChild); +- wcscat(cmd, L".exe"); ++ wcscat(cmd, ".exe"); + + bool success = + CreateProcessW(nullptr, // No module name (use command line) +@@ -374,9 +374,9 @@ static int testFile() + HANDLE outFile = INVALID_HANDLE_VALUE; + HANDLE errFile = INVALID_HANDLE_VALUE; + try { +- if ((inFile = createFile(L"stdinFile.txt")) == INVALID_HANDLE_VALUE || +- (outFile = createFile(L"stdoutFile.txt")) == INVALID_HANDLE_VALUE || +- (errFile = createFile(L"stderrFile.txt")) == INVALID_HANDLE_VALUE) { ++ if ((inFile = createFile("stdinFile.txt")) == INVALID_HANDLE_VALUE || ++ (outFile = createFile("stdoutFile.txt")) == INVALID_HANDLE_VALUE || ++ (errFile = createFile("stderrFile.txt")) == INVALID_HANDLE_VALUE) { + throw std::runtime_error("createFile failed!"); + } + DWORD bytesWritten = 0; +@@ -488,7 +488,7 @@ static int testConsole() + bool newConsole = false; + bool forceNewConsole = false; + bool restoreConsole = false; +- LPCWSTR TestFaceName = L"Lucida Console"; ++ LPCWSTR TestFaceName = "Lucida Console"; + const DWORD TestFontFamily = 0x00000036; + const DWORD TestFontSize = 0x000c0000; + HKEY hConsoleKey; +@@ -518,23 +518,23 @@ static int testConsole() + # endif + # endif + if (!isVistaOrGreater) { +- if (RegOpenKeyExW(HKEY_CURRENT_USER, L"Console", 0, KEY_READ | KEY_WRITE, ++ if (RegOpenKeyExW(HKEY_CURRENT_USER, "Console", 0, KEY_READ | KEY_WRITE, + &hConsoleKey) == ERROR_SUCCESS) { + DWORD dwordSize = sizeof(DWORD); +- if (RegQueryValueExW(hConsoleKey, L"FontFamily", nullptr, nullptr, ++ if (RegQueryValueExW(hConsoleKey, "FontFamily", nullptr, nullptr, + (LPBYTE)&FontFamily, &dwordSize) == ERROR_SUCCESS) { + if (FontFamily != TestFontFamily) { +- RegQueryValueExW(hConsoleKey, L"FaceName", nullptr, nullptr, ++ RegQueryValueExW(hConsoleKey, "FaceName", nullptr, nullptr, + (LPBYTE)FaceName, &FaceNameSize); +- RegQueryValueExW(hConsoleKey, L"FontSize", nullptr, nullptr, ++ RegQueryValueExW(hConsoleKey, "FontSize", nullptr, nullptr, + (LPBYTE)&FontSize, &dwordSize); + +- RegSetValueExW(hConsoleKey, L"FontFamily", 0, REG_DWORD, ++ RegSetValueExW(hConsoleKey, "FontFamily", 0, REG_DWORD, + (BYTE*)&TestFontFamily, sizeof(TestFontFamily)); +- RegSetValueExW(hConsoleKey, L"FaceName", 0, REG_SZ, ++ RegSetValueExW(hConsoleKey, "FaceName", 0, REG_SZ, + (BYTE*)TestFaceName, + (DWORD)((wcslen(TestFaceName) + 1) * sizeof(WCHAR))); +- RegSetValueExW(hConsoleKey, L"FontSize", 0, REG_DWORD, ++ RegSetValueExW(hConsoleKey, "FontSize", 0, REG_DWORD, + (BYTE*)&TestFontSize, sizeof(TestFontSize)); + + restoreConsole = true; +@@ -560,7 +560,7 @@ static int testConsole() + securityAttributes.nLength = sizeof(SECURITY_ATTRIBUTES); + securityAttributes.bInheritHandle = TRUE; + securityAttributes.lpSecurityDescriptor = nullptr; +- hIn = CreateFileW(L"CONIN$", GENERIC_READ | GENERIC_WRITE, ++ hIn = CreateFileW("CONIN$", GENERIC_READ | GENERIC_WRITE, + FILE_SHARE_READ | FILE_SHARE_WRITE, &securityAttributes, + OPEN_EXISTING, 0, nullptr); + if (hIn == INVALID_HANDLE_VALUE) { +@@ -568,7 +568,7 @@ static int testConsole() + std::cerr << "CreateFile(CONIN$)" << std::endl; + displayError(lastError); + } +- hOut = CreateFileW(L"CONOUT$", GENERIC_READ | GENERIC_WRITE, ++ hOut = CreateFileW("CONOUT$", GENERIC_READ | GENERIC_WRITE, + FILE_SHARE_READ | FILE_SHARE_WRITE, &securityAttributes, + OPEN_EXISTING, 0, nullptr); + if (hOut == INVALID_HANDLE_VALUE) { +@@ -587,7 +587,7 @@ static int testConsole() + CONSOLE_FONT_INFOEX consoleFont; + memset(&consoleFont, 0, sizeof(consoleFont)); + consoleFont.cbSize = sizeof(consoleFont); +- HMODULE kernel32 = LoadLibraryW(L"kernel32.dll"); ++ HMODULE kernel32 = LoadLibraryW("kernel32.dll"); + typedef BOOL(WINAPI * GetCurrentConsoleFontExFunc)( + HANDLE hConsoleOutput, BOOL bMaximumWindow, + PCONSOLE_FONT_INFOEX lpConsoleCurrentFontEx); +@@ -614,17 +614,17 @@ static int testConsole() + } else { + # endif + if (restoreConsole && +- RegOpenKeyExW(HKEY_CURRENT_USER, L"Console", 0, KEY_WRITE, ++ RegOpenKeyExW(HKEY_CURRENT_USER, "Console", 0, KEY_WRITE, + &hConsoleKey) == ERROR_SUCCESS) { +- RegSetValueExW(hConsoleKey, L"FontFamily", 0, REG_DWORD, ++ RegSetValueExW(hConsoleKey, "FontFamily", 0, REG_DWORD, + (BYTE*)&FontFamily, sizeof(FontFamily)); + if (FaceName[0] != 0) { +- RegSetValueExW(hConsoleKey, L"FaceName", 0, REG_SZ, (BYTE*)FaceName, ++ RegSetValueExW(hConsoleKey, "FaceName", 0, REG_SZ, (BYTE*)FaceName, + FaceNameSize); + } else { +- RegDeleteValueW(hConsoleKey, L"FaceName"); ++ RegDeleteValueW(hConsoleKey, "FaceName"); + } +- RegSetValueExW(hConsoleKey, L"FontSize", 0, REG_DWORD, (BYTE*)&FontSize, ++ RegSetValueExW(hConsoleKey, "FontSize", 0, REG_DWORD, (BYTE*)&FontSize, + sizeof(FontSize)); + RegCloseKey(hConsoleKey); + } +@@ -690,34 +690,34 @@ static int testConsole() + delete[] outputBuffer; + throw std::runtime_error("ReadConsoleOutputCharacter failed!"); + } +- std::wstring wideTestString = kwsys::Encoding::ToWide(encodedTestString); ++ std::string wideTestString = kwsys::Encoding::ToWide(encodedTestString); + std::replace(wideTestString.begin(), wideTestString.end(), '\0', ' '); +- std::wstring wideInputTestString = ++ std::string wideInputTestString = + kwsys::Encoding::ToWide(encodedInputTestString); + if (memcmp(outputBuffer, wideTestString.c_str(), +- wideTestString.size() * sizeof(wchar_t)) == 0 && ++ wideTestString.size() * sizeof(char)) == 0 && + memcmp(outputBuffer + screenBufferInfo.dwSize.X * 1, + wideTestString.c_str(), +- wideTestString.size() * sizeof(wchar_t)) == 0 && ++ wideTestString.size() * sizeof(char)) == 0 && + memcmp(outputBuffer + screenBufferInfo.dwSize.X * 2, + UnicodeInputTestString, + sizeof(UnicodeInputTestString) - sizeof(WCHAR)) == 0 && + memcmp(outputBuffer + screenBufferInfo.dwSize.X * 3, + wideInputTestString.c_str(), +- (wideInputTestString.size() - 1) * sizeof(wchar_t)) == 0) { ++ (wideInputTestString.size() - 1) * sizeof(char)) == 0) { + didFail = 0; + } else { + std::cerr << "Console's output didn't match expected output!" + << std::endl; +- dumpBuffers<wchar_t>(wideTestString.c_str(), outputBuffer, ++ dumpBuffers<char>(wideTestString.c_str(), outputBuffer, + wideTestString.size()); +- dumpBuffers<wchar_t>(wideTestString.c_str(), ++ dumpBuffers<char>(wideTestString.c_str(), + outputBuffer + screenBufferInfo.dwSize.X * 1, + wideTestString.size()); +- dumpBuffers<wchar_t>( ++ dumpBuffers<char>( + UnicodeInputTestString, outputBuffer + screenBufferInfo.dwSize.X * 2, + (sizeof(UnicodeInputTestString) - 1) / sizeof(WCHAR)); +- dumpBuffers<wchar_t>(wideInputTestString.c_str(), ++ dumpBuffers<char>(wideInputTestString.c_str(), + outputBuffer + screenBufferInfo.dwSize.X * 3, + wideInputTestString.size() - 1); + } +@@ -763,11 +763,11 @@ int testConsoleBuf(int, char* []) + return 1; + } + +- encodedTestString = kwsys::Encoding::ToNarrow(std::wstring( +- UnicodeTestString, sizeof(UnicodeTestString) / sizeof(wchar_t) - 1)); ++ encodedTestString = kwsys::Encoding::ToNarrow(std::string( ++ UnicodeTestString, sizeof(UnicodeTestString) / sizeof(char) - 1)); + encodedInputTestString = kwsys::Encoding::ToNarrow( +- std::wstring(UnicodeInputTestString, +- sizeof(UnicodeInputTestString) / sizeof(wchar_t) - 1)); ++ std::string(UnicodeInputTestString, ++ sizeof(UnicodeInputTestString) / sizeof(char) - 1)); + encodedInputTestString += "\n"; + + ret |= testPipe(); +diff -urp a/Source/kwsys/testConsoleBuf.hxx b/Source/kwsys/testConsoleBuf.hxx +--- a/Source/kwsys/testConsoleBuf.hxx 2021-01-28 18:58:45.000000000 +0330 ++++ b/Source/kwsys/testConsoleBuf.hxx 2021-02-11 18:43:32.762502643 +0330 +@@ -3,15 +3,15 @@ + #ifndef testConsoleBuf_hxx + #define testConsoleBuf_hxx + +-static const wchar_t cmdConsoleBufChild[] = L"testConsoleBufChild"; ++static const char cmdConsoleBufChild[] = "testConsoleBufChild"; + +-static const wchar_t BeforeInputEventName[] = L"BeforeInputEvent"; +-static const wchar_t AfterOutputEventName[] = L"AfterOutputEvent"; ++static const char BeforeInputEventName[] = "BeforeInputEvent"; ++static const char AfterOutputEventName[] = "AfterOutputEvent"; + + // यूनिकोड είναι здорово! +-static const wchar_t UnicodeTestString[] = +- L"\u092F\u0942\u0928\u093F\u0915\u094B\u0921 " +- L"\u03B5\u03AF\u03BD\0\u03B1\u03B9 " +- L"\u0437\u0434\u043E\u0440\u043E\u0432\u043E!"; ++static const char UnicodeTestString[] = ++ "\u092F\u0942\u0928\u093F\u0915\u094B\u0921 " ++ "\u03B5\u03AF\u03BD\0\u03B1\u03B9 " ++ "\u0437\u0434\u043E\u0440\u043E\u0432\u043E!"; + + #endif +diff -urp a/Source/kwsys/testEncoding.cxx b/Source/kwsys/testEncoding.cxx +--- a/Source/kwsys/testEncoding.cxx 2021-01-28 18:58:45.000000000 +0330 ++++ b/Source/kwsys/testEncoding.cxx 2021-02-11 18:43:32.815836824 +0330 +@@ -55,9 +55,9 @@ static int testHelloWorldEncoding() + for (int i = 0; helloWorldStrings[i][0] != 0; i++) { + std::string str = reinterpret_cast<const char*>(helloWorldStrings[i]); + std::cout << str << std::endl; +- std::wstring wstr = kwsys::Encoding::ToWide(str); ++ std::string wstr = kwsys::Encoding::ToWide(str); + std::string str2 = kwsys::Encoding::ToNarrow(wstr); +- wchar_t* c_wstr = kwsysEncoding_DupToWide(str.c_str()); ++ char* c_wstr = kwsysEncoding_DupToWide(str.c_str()); + char* c_str2 = kwsysEncoding_DupToNarrow(c_wstr); + if (!wstr.empty() && (str != str2 || strcmp(c_str2, str.c_str()) != 0)) { + std::cout << "converted string was different: " << str2 << std::endl; +@@ -82,11 +82,11 @@ static int testRobustEncoding() + int ret = 0; + char cstr[] = { (char)-1, 0 }; + // this conversion could fail +- std::wstring wstr = kwsys::Encoding::ToWide(cstr); ++ std::string wstr = kwsys::Encoding::ToWide(cstr); + + wstr = kwsys::Encoding::ToWide(nullptr); + if (!wstr.empty()) { +- const wchar_t* wcstr = wstr.c_str(); ++ const char* wcstr = wstr.c_str(); + std::cout << "ToWide(NULL) returned"; + for (size_t i = 0; i < wstr.size(); i++) { + std::cout << " " << std::hex << (int)wcstr[i]; +@@ -96,7 +96,7 @@ static int testRobustEncoding() + } + wstr = kwsys::Encoding::ToWide(""); + if (!wstr.empty()) { +- const wchar_t* wcstr = wstr.c_str(); ++ const char* wcstr = wstr.c_str(); + std::cout << "ToWide(\"\") returned"; + for (size_t i = 0; i < wstr.size(); i++) { + std::cout << " " << std::hex << (int)wcstr[i]; +@@ -106,8 +106,8 @@ static int testRobustEncoding() + } + + #ifdef _WIN32 +- // 16 bit wchar_t - we make an invalid surrogate pair +- wchar_t cwstr[] = { 0xD801, 0xDA00, 0 }; ++ // 16 bit char - we make an invalid surrogate pair ++ char cwstr[] = { 0xD801, 0xDA00, 0 }; + // this conversion could fail + std::string win_str = kwsys::Encoding::ToNarrow(cwstr); + #endif +@@ -118,7 +118,7 @@ static int testRobustEncoding() + ret++; + } + +- str = kwsys::Encoding::ToNarrow(L""); ++ str = kwsys::Encoding::ToNarrow(""); + if (!wstr.empty()) { + std::cout << "ToNarrow(\"\") returned " << str << std::endl; + ret++; +@@ -141,7 +141,7 @@ static int testWithNulls() + strings.push_back(std::string("\0\0\0\0", 4) + "lmn" + + std::string("\0\0\0\0", 4)); + for (auto& string : strings) { +- std::wstring wstr = kwsys::Encoding::ToWide(string); ++ std::string wstr = kwsys::Encoding::ToWide(string); + std::string str = kwsys::Encoding::ToNarrow(wstr); + std::string s(string); + std::replace(s.begin(), s.end(), '\0', ' '); +@@ -188,7 +188,7 @@ static int testToWindowsExtendedPath() + int ret = 0; + if (kwsys::Encoding::ToWindowsExtendedPath( + "L:\\Local Mojo\\Hex Power Pack\\Iffy Voodoo") != +- L"\\\\?\\L:\\Local Mojo\\Hex Power Pack\\Iffy Voodoo") { ++ "\\\\?\\L:\\Local Mojo\\Hex Power Pack\\Iffy Voodoo") { + std::cout << "Problem with ToWindowsExtendedPath " + << "\"L:\\Local Mojo\\Hex Power Pack\\Iffy Voodoo\"" + << std::endl; +@@ -197,7 +197,7 @@ static int testToWindowsExtendedPath() + + if (kwsys::Encoding::ToWindowsExtendedPath( + "L:/Local Mojo/Hex Power Pack/Iffy Voodoo") != +- L"\\\\?\\L:\\Local Mojo\\Hex Power Pack\\Iffy Voodoo") { ++ "\\\\?\\L:\\Local Mojo\\Hex Power Pack\\Iffy Voodoo") { + std::cout << "Problem with ToWindowsExtendedPath " + << "\"L:/Local Mojo/Hex Power Pack/Iffy Voodoo\"" << std::endl; + ++ret; +@@ -205,7 +205,7 @@ static int testToWindowsExtendedPath() + + if (kwsys::Encoding::ToWindowsExtendedPath( + "\\\\Foo\\Local Mojo\\Hex Power Pack\\Iffy Voodoo") != +- L"\\\\?\\UNC\\Foo\\Local Mojo\\Hex Power Pack\\Iffy Voodoo") { ++ "\\\\?\\UNC\\Foo\\Local Mojo\\Hex Power Pack\\Iffy Voodoo") { + std::cout << "Problem with ToWindowsExtendedPath " + << "\"\\\\Foo\\Local Mojo\\Hex Power Pack\\Iffy Voodoo\"" + << std::endl; +@@ -214,40 +214,40 @@ static int testToWindowsExtendedPath() + + if (kwsys::Encoding::ToWindowsExtendedPath( + "//Foo/Local Mojo/Hex Power Pack/Iffy Voodoo") != +- L"\\\\?\\UNC\\Foo\\Local Mojo\\Hex Power Pack\\Iffy Voodoo") { ++ "\\\\?\\UNC\\Foo\\Local Mojo\\Hex Power Pack\\Iffy Voodoo") { + std::cout << "Problem with ToWindowsExtendedPath " + << "\"//Foo/Local Mojo/Hex Power Pack/Iffy Voodoo\"" + << std::endl; + ++ret; + } + +- if (kwsys::Encoding::ToWindowsExtendedPath("//") != L"//") { ++ if (kwsys::Encoding::ToWindowsExtendedPath("//") != "//") { + std::cout << "Problem with ToWindowsExtendedPath " + << "\"//\"" << std::endl; + ++ret; + } + +- if (kwsys::Encoding::ToWindowsExtendedPath("\\\\.\\") != L"\\\\.\\") { ++ if (kwsys::Encoding::ToWindowsExtendedPath("\\\\.\\") != "\\\\.\\") { + std::cout << "Problem with ToWindowsExtendedPath " + << "\"\\\\.\\\"" << std::endl; + ++ret; + } + +- if (kwsys::Encoding::ToWindowsExtendedPath("\\\\.\\X") != L"\\\\.\\X") { ++ if (kwsys::Encoding::ToWindowsExtendedPath("\\\\.\\X") != "\\\\.\\X") { + std::cout << "Problem with ToWindowsExtendedPath " + << "\"\\\\.\\X\"" << std::endl; + ++ret; + } + +- if (kwsys::Encoding::ToWindowsExtendedPath("\\\\.\\X:") != L"\\\\?\\X:") { ++ if (kwsys::Encoding::ToWindowsExtendedPath("\\\\.\\X:") != "\\\\?\\X:") { + std::cout << "Problem with ToWindowsExtendedPath " + << "\"\\\\.\\X:\"" << std::endl; + ++ret; + } + + if (kwsys::Encoding::ToWindowsExtendedPath("\\\\.\\X:\\") != +- L"\\\\?\\X:\\") { ++ "\\\\?\\X:\\") { + std::cout << "Problem with ToWindowsExtendedPath " + << "\"\\\\.\\X:\\\"" << std::endl; + ++ret; + } +diff -urp a/Source/LexerParser/cmListFileLexer.c b/Source/LexerParser/cmListFileLexer.c +--- a/Source/LexerParser/cmListFileLexer.c 2021-01-28 18:58:45.000000000 +0330 ++++ b/Source/LexerParser/cmListFileLexer.c 2021-02-11 18:43:32.715835234 +0330 +@@ -2746,8 +2746,8 @@ int cmListFileLexer_SetFileName(cmListFi + cmListFileLexerDestroy(lexer); + if (name) { + #ifdef _WIN32 +- wchar_t* wname = cmsysEncoding_DupToWide(name); +- lexer->file = _wfopen(wname, L"rb"); ++ char* wname = cmsysEncoding_DupToWide(name); ++ lexer->file = _wfopen(wname, "rb"); + free(wname); + #else + lexer->file = fopen(name, "rb"); +diff -urp a/Source/LexerParser/cmListFileLexer.in.l b/Source/LexerParser/cmListFileLexer.in.l +--- a/Source/LexerParser/cmListFileLexer.in.l 2021-01-28 18:58:45.000000000 +0330 ++++ b/Source/LexerParser/cmListFileLexer.in.l 2021-02-11 18:43:32.725835393 +0330 +@@ -459,8 +459,8 @@ int cmListFileLexer_SetFileName(cmListFi + cmListFileLexerDestroy(lexer); + if (name) { + #ifdef _WIN32 +- wchar_t* wname = cmsysEncoding_DupToWide(name); +- lexer->file = _wfopen(wname, L"rb"); ++ char* wname = cmsysEncoding_DupToWide(name); ++ lexer->file = _wfopen(wname, "rb"); + free(wname); + #else + lexer->file = fopen(name, "rb"); +diff -urp a/Templates/MSBuild/FlagTables/v10_CL.json b/Templates/MSBuild/FlagTables/v10_CL.json +--- a/Templates/MSBuild/FlagTables/v10_CL.json 2021-01-28 18:58:45.000000000 +0330 ++++ b/Templates/MSBuild/FlagTables/v10_CL.json 2021-02-11 18:43:34.969204192 +0330 +@@ -678,14 +678,14 @@ + }, + { + "name": "TreatWChar_tAsBuiltInType", +- "switch": "Zc:wchar_t-", ++ "switch": "Zc:char-", + "comment": "Treat WChar_t As Built in Type", + "value": "false", + "flags": [] + }, + { + "name": "TreatWChar_tAsBuiltInType", +- "switch": "Zc:wchar_t", ++ "switch": "Zc:char", + "comment": "Treat WChar_t As Built in Type", + "value": "true", + "flags": [] +diff -urp a/Templates/MSBuild/FlagTables/v11_CL.json b/Templates/MSBuild/FlagTables/v11_CL.json +--- a/Templates/MSBuild/FlagTables/v11_CL.json 2021-01-28 18:58:45.000000000 +0330 ++++ b/Templates/MSBuild/FlagTables/v11_CL.json 2021-02-11 18:43:34.969204192 +0330 +@@ -741,14 +741,14 @@ + }, + { + "name": "TreatWChar_tAsBuiltInType", +- "switch": "Zc:wchar_t-", ++ "switch": "Zc:char-", + "comment": "Treat WChar_t As Built in Type", + "value": "false", + "flags": [] + }, + { + "name": "TreatWChar_tAsBuiltInType", +- "switch": "Zc:wchar_t", ++ "switch": "Zc:char", + "comment": "Treat WChar_t As Built in Type", + "value": "true", + "flags": [] +diff -urp a/Templates/MSBuild/FlagTables/v12_CL.json b/Templates/MSBuild/FlagTables/v12_CL.json +--- a/Templates/MSBuild/FlagTables/v12_CL.json 2021-01-28 18:58:45.000000000 +0330 ++++ b/Templates/MSBuild/FlagTables/v12_CL.json 2021-02-11 18:43:34.955870650 +0330 +@@ -755,14 +755,14 @@ + }, + { + "name": "TreatWChar_tAsBuiltInType", +- "switch": "Zc:wchar_t-", ++ "switch": "Zc:char-", + "comment": "Treat WChar_t As Built in Type", + "value": "false", + "flags": [] + }, + { + "name": "TreatWChar_tAsBuiltInType", +- "switch": "Zc:wchar_t", ++ "switch": "Zc:char", + "comment": "Treat WChar_t As Built in Type", + "value": "true", + "flags": [] +diff -urp a/Templates/MSBuild/FlagTables/v140_CL.json b/Templates/MSBuild/FlagTables/v140_CL.json +--- a/Templates/MSBuild/FlagTables/v140_CL.json 2021-01-28 18:58:45.000000000 +0330 ++++ b/Templates/MSBuild/FlagTables/v140_CL.json 2021-02-11 18:43:34.965870807 +0330 +@@ -762,14 +762,14 @@ + }, + { + "name": "TreatWChar_tAsBuiltInType", +- "switch": "Zc:wchar_t-", ++ "switch": "Zc:char-", + "comment": "Treat WChar_t As Built in Type", + "value": "false", + "flags": [] + }, + { + "name": "TreatWChar_tAsBuiltInType", +- "switch": "Zc:wchar_t", ++ "switch": "Zc:char", + "comment": "Treat WChar_t As Built in Type", + "value": "true", + "flags": [] +diff -urp a/Templates/MSBuild/FlagTables/v141_CL.json b/Templates/MSBuild/FlagTables/v141_CL.json +--- a/Templates/MSBuild/FlagTables/v141_CL.json 2021-01-28 18:58:45.000000000 +0330 ++++ b/Templates/MSBuild/FlagTables/v141_CL.json 2021-02-11 18:43:34.969204192 +0330 +@@ -825,14 +825,14 @@ + }, + { + "name": "TreatWChar_tAsBuiltInType", +- "switch": "Zc:wchar_t-", ++ "switch": "Zc:char-", + "comment": "Treat WChar_t As Built in Type", + "value": "false", + "flags": [] + }, + { + "name": "TreatWChar_tAsBuiltInType", +- "switch": "Zc:wchar_t", ++ "switch": "Zc:char", + "comment": "Treat WChar_t As Built in Type", + "value": "true", + "flags": [] +diff -urp a/Templates/MSBuild/FlagTables/v142_CL.json b/Templates/MSBuild/FlagTables/v142_CL.json +--- a/Templates/MSBuild/FlagTables/v142_CL.json 2021-01-28 18:58:45.000000000 +0330 ++++ b/Templates/MSBuild/FlagTables/v142_CL.json 2021-02-11 18:43:34.965870807 +0330 +@@ -860,14 +860,14 @@ + }, + { + "name": "TreatWChar_tAsBuiltInType", +- "switch": "Zc:wchar_t-", ++ "switch": "Zc:char-", + "comment": "Treat WChar_t As Built in Type", + "value": "false", + "flags": [] + }, + { + "name": "TreatWChar_tAsBuiltInType", +- "switch": "Zc:wchar_t", ++ "switch": "Zc:char", + "comment": "Treat WChar_t As Built in Type", + "value": "true", + "flags": [] +diff -urp a/Tests/CMakeLib/testCMFilesystemPath.cxx b/Tests/CMakeLib/testCMFilesystemPath.cxx +--- a/Tests/CMakeLib/testCMFilesystemPath.cxx 2021-01-28 18:58:45.000000000 +0330 ++++ b/Tests/CMakeLib/testCMFilesystemPath.cxx 2021-02-11 18:43:30.792471215 +0330 +@@ -66,7 +66,7 @@ bool testConstructors() + #endif + } + { +- std::wstring s(L"/a/b/c"); ++ std::string s("/a/b/c"); + fs::path p1(s); + fs::path p2(s.begin(), s.end()); + if (p1 != p2) { +@@ -76,7 +76,7 @@ bool testConstructors() + result = false; + } + #if CM_FILESYSTEM_SOURCE_TRAITS_ITERATOR +- std::wstring s2(s); ++ std::string s2(s); + s2 += L'\0'; + fs::path p3(s2.begin()); + if (p1 != p3 || p3.wstring() != s) { +@@ -276,7 +276,7 @@ bool testObservers() + } + { + std::string s("a//b//c"); +- std::wstring ws(L"a//b//c"); ++ std::string ws("a//b//c"); + fs::path p(s); + if (p.string() != s || p.wstring() != ws) { + result = false; +@@ -284,9 +284,9 @@ bool testObservers() + } + { + std::string s("a/b/c"); +- std::wstring ws; ++ std::string ws; + for (auto c : s) { +- ws += static_cast<std::wstring::value_type>(c); ++ ws += static_cast<std::string::value_type>(c); + } + std::string ns(s); + std::replace( +@@ -861,7 +861,7 @@ bool testIterators() + { + fs::path p("/a/b/"); + #if defined(_WIN32) +- std::vector<fs::path::string_type> ref{ L"/", L"a", L"b", L"" }; ++ std::vector<fs::path::string_type> ref{ "/", "a", "b", "" }; + #else + std::vector<fs::path::string_type> ref{ "/", "a", "b", "" }; + #endif +@@ -883,7 +883,7 @@ bool testIterators() + { + fs::path p("/a/b/"); + #if defined(_WIN32) +- std::vector<fs::path::string_type> ref{ L"", L"b", L"a", L"/" }; ++ std::vector<fs::path::string_type> ref{ "", "b", "a", "/" }; + #else + std::vector<fs::path::string_type> ref{ "", "b", "a", "/" }; + #endif +diff -urp a/Tests/FindPython/display_time.c b/Tests/FindPython/display_time.c +--- a/Tests/FindPython/display_time.c 2021-01-28 18:58:45.000000000 +0330 ++++ b/Tests/FindPython/display_time.c 2021-02-11 18:43:30.875805885 +0330 +@@ -9,7 +9,7 @@ + void display_time() + { + #if defined(PYTHON3) +- wchar_t* program = Py_DecodeLocale("display_time", NULL); ++ char* program = Py_DecodeLocale("display_time", NULL); + if (program == NULL) { + fprintf(stderr, "Fatal error: cannot decode argv[0]\n"); + exit(1); +diff -urp a/Tests/Plugin/src/DynamicLoader.cxx b/Tests/Plugin/src/DynamicLoader.cxx +--- a/Tests/Plugin/src/DynamicLoader.cxx 2021-01-28 18:58:45.000000000 +0330 ++++ b/Tests/Plugin/src/DynamicLoader.cxx 2021-02-11 18:43:30.512466723 +0330 +@@ -94,7 +94,7 @@ DynamicLoader::LibraryHandle DynamicLoad + { + DynamicLoader::LibraryHandle lh; + int length = MultiByteToWideChar(CP_UTF8, 0, libname.c_str(), -1, NULL, 0); +- wchar_t* wchars = new wchar_t[length + 1]; ++ char* wchars = new char[length + 1]; + wchars[0] = '\0'; + MultiByteToWideChar(CP_UTF8, 0, libname.c_str(), -1, wchars, length); + lh = LoadLibraryW(wchars); +diff -urp a/Tests/VSWindowsFormsResx/WindowsFormsResx/MyForm.h b/Tests/VSWindowsFormsResx/WindowsFormsResx/MyForm.h +--- a/Tests/VSWindowsFormsResx/WindowsFormsResx/MyForm.h 2021-01-28 18:58:45.000000000 +0330 ++++ b/Tests/VSWindowsFormsResx/WindowsFormsResx/MyForm.h 2021-02-11 18:43:32.605833485 +0330 +@@ -58,10 +58,10 @@ private: + // button1 + // + this->button1->Location = System::Drawing::Point(13, 13); +- this->button1->Name = L"button1"; ++ this->button1->Name = "button1"; + this->button1->Size = System::Drawing::Size(75, 23); + this->button1->TabIndex = 0; +- this->button1->Text = L"button1"; ++ this->button1->Text = "button1"; + this->button1->UseVisualStyleBackColor = true; + // + // MyForm +@@ -70,8 +70,8 @@ private: + this->AutoScaleMode = System::Windows::Forms::AutoScaleMode::Font; + this->ClientSize = System::Drawing::Size(284, 261); + this->Controls->Add(this->button1); +- this->Name = L"MyForm"; +- this->Text = L"MyForm"; ++ this->Name = "MyForm"; ++ this->Text = "MyForm"; + this->ResumeLayout(false); + } + #pragma endregion +diff -urp a/Utilities/cmcurl/lib/curl_multibyte.c b/Utilities/cmcurl/lib/curl_multibyte.c +--- a/Utilities/cmcurl/lib/curl_multibyte.c 2021-01-28 18:58:45.000000000 +0330 ++++ b/Utilities/cmcurl/lib/curl_multibyte.c 2021-02-11 18:43:33.732518016 +0330 +@@ -34,15 +34,15 @@ + * MultiByte conversions using Windows kernel32 library. + */ + +-wchar_t *curlx_convert_UTF8_to_wchar(const char *str_utf8) ++char *curlx_convert_UTF8_to_wchar(const char *str_utf8) + { +- wchar_t *str_w = NULL; ++ char *str_w = NULL; + + if(str_utf8) { + int str_w_len = MultiByteToWideChar(CP_UTF8, MB_ERR_INVALID_CHARS, + str_utf8, -1, NULL, 0); + if(str_w_len > 0) { +- str_w = malloc(str_w_len * sizeof(wchar_t)); ++ str_w = malloc(str_w_len * sizeof(char)); + if(str_w) { + if(MultiByteToWideChar(CP_UTF8, 0, str_utf8, -1, str_w, + str_w_len) == 0) { +@@ -56,7 +56,7 @@ wchar_t *curlx_convert_UTF8_to_wchar(con + return str_w; + } + +-char *curlx_convert_wchar_to_UTF8(const wchar_t *str_w) ++char *curlx_convert_charo_UTF8(const char *str_w) + { + char *str_utf8 = NULL; + +@@ -86,8 +86,8 @@ FILE *curlx_win32_fopen(const char *file + { + #ifdef _UNICODE + FILE *result = NULL; +- wchar_t *filename_w = curlx_convert_UTF8_to_wchar(filename); +- wchar_t *mode_w = curlx_convert_UTF8_to_wchar(mode); ++ char *filename_w = curlx_convert_UTF8_to_wchar(filename); ++ char *mode_w = curlx_convert_UTF8_to_wchar(mode); + if(filename_w && mode_w) + result = _wfopen(filename_w, mode_w); + free(filename_w); +@@ -103,7 +103,7 @@ int curlx_win32_stat(const char *path, s + { + int result = -1; + #ifdef _UNICODE +- wchar_t *path_w = curlx_convert_UTF8_to_wchar(path); ++ char *path_w = curlx_convert_UTF8_to_wchar(path); + #endif /* _UNICODE */ + + #if defined(USE_WIN32_SMALL_FILES) +@@ -133,7 +133,7 @@ int curlx_win32_access(const char *path, + { + int result = -1; + #ifdef _UNICODE +- wchar_t *path_w = curlx_convert_UTF8_to_wchar(path); ++ char *path_w = curlx_convert_UTF8_to_wchar(path); + #endif /* _UNICODE */ + + #if defined(_UNICODE) +diff -urp a/Utilities/cmcurl/lib/curl_multibyte.h b/Utilities/cmcurl/lib/curl_multibyte.h +--- a/Utilities/cmcurl/lib/curl_multibyte.h 2021-01-28 18:58:45.000000000 +0330 ++++ b/Utilities/cmcurl/lib/curl_multibyte.h 2021-02-11 18:43:33.832519600 +0330 +@@ -29,8 +29,8 @@ + * MultiByte conversions using Windows kernel32 library. + */ + +-wchar_t *curlx_convert_UTF8_to_wchar(const char *str_utf8); +-char *curlx_convert_wchar_to_UTF8(const wchar_t *str_w); ++char *curlx_convert_UTF8_to_wchar(const char *str_utf8); ++char *curlx_convert_charo_UTF8(const char *str_w); + + #endif /* WIN32 */ + +@@ -55,7 +55,7 @@ char *curlx_convert_wchar_to_UTF8(const + #if defined(UNICODE) && defined(WIN32) + + #define curlx_convert_UTF8_to_tchar(ptr) curlx_convert_UTF8_to_wchar((ptr)) +-#define curlx_convert_tchar_to_UTF8(ptr) curlx_convert_wchar_to_UTF8((ptr)) ++#define curlx_convert_tchar_to_UTF8(ptr) curlx_convert_charo_UTF8((ptr)) + #define curlx_unicodefree(ptr) \ + do { \ + if(ptr) { \ +diff -urp a/Utilities/cmcurl/lib/curl_setup_once.h b/Utilities/cmcurl/lib/curl_setup_once.h +--- a/Utilities/cmcurl/lib/curl_setup_once.h 2021-01-28 18:58:45.000000000 +0330 ++++ b/Utilities/cmcurl/lib/curl_setup_once.h 2021-02-11 18:43:33.869186847 +0330 +@@ -482,7 +482,7 @@ typedef int sig_atomic_t; + #ifdef __VMS + #define argv_item_t __char_ptr32 + #elif defined(_UNICODE) +-#define argv_item_t wchar_t * ++#define argv_item_t char * + #else + #define argv_item_t char * + #endif +diff -urp a/Utilities/cmcurl/lib/curl_sspi.c b/Utilities/cmcurl/lib/curl_sspi.c +--- a/Utilities/cmcurl/lib/curl_sspi.c 2021-01-28 18:58:45.000000000 +0330 ++++ b/Utilities/cmcurl/lib/curl_sspi.c 2021-02-11 18:43:33.792518966 +0330 +@@ -41,7 +41,7 @@ typedef PSecurityFunctionTable (APIENTRY + /* See definition of SECURITY_ENTRYPOINT in sspi.h */ + #ifdef UNICODE + # ifdef _WIN32_WCE +-# define SECURITYENTRYPOINT L"InitSecurityInterfaceW" ++# define SECURITYENTRYPOINT "InitSecurityInterfaceW" + # else + # define SECURITYENTRYPOINT "InitSecurityInterfaceW" + # endif +diff -urp a/Utilities/cmcurl/lib/curlx.h b/Utilities/cmcurl/lib/curlx.h +--- a/Utilities/cmcurl/lib/curlx.h 2021-01-28 18:58:45.000000000 +0330 ++++ b/Utilities/cmcurl/lib/curlx.h 2021-02-11 18:43:33.722517857 +0330 +@@ -57,7 +57,7 @@ + /* "curl_multibyte.h" provides these functions and macros: + + curlx_convert_UTF8_to_wchar() +- curlx_convert_wchar_to_UTF8() ++ curlx_convert_charo_UTF8() + curlx_convert_UTF8_to_tchar() + curlx_convert_tchar_to_UTF8() + curlx_unicodefree() +diff -urp a/Utilities/cmcurl/lib/idn_win32.c b/Utilities/cmcurl/lib/idn_win32.c +--- a/Utilities/cmcurl/lib/idn_win32.c 2021-01-28 18:58:45.000000000 +0330 ++++ b/Utilities/cmcurl/lib/idn_win32.c 2021-02-11 18:43:33.875853618 +0330 +@@ -72,13 +72,13 @@ bool curl_win32_idn_to_ascii(const char + { + bool success = FALSE; + +- wchar_t *in_w = curlx_convert_UTF8_to_wchar(in); ++ char *in_w = curlx_convert_UTF8_to_wchar(in); + if(in_w) { +- wchar_t punycode[IDN_MAX_LENGTH]; ++ char punycode[IDN_MAX_LENGTH]; + int chars = IdnToAscii(0, in_w, -1, punycode, IDN_MAX_LENGTH); + free(in_w); + if(chars) { +- *out = curlx_convert_wchar_to_UTF8(punycode); ++ *out = curlx_convert_charo_UTF8(punycode); + if(*out) + success = TRUE; + } +@@ -91,15 +91,15 @@ bool curl_win32_ascii_to_idn(const char + { + bool success = FALSE; + +- wchar_t *in_w = curlx_convert_UTF8_to_wchar(in); ++ char *in_w = curlx_convert_UTF8_to_wchar(in); + if(in_w) { + size_t in_len = wcslen(in_w) + 1; +- wchar_t unicode[IDN_MAX_LENGTH]; ++ char unicode[IDN_MAX_LENGTH]; + int chars = IdnToUnicode(0, in_w, curlx_uztosi(in_len), + unicode, IDN_MAX_LENGTH); + free(in_w); + if(chars) { +- *out = curlx_convert_wchar_to_UTF8(unicode); ++ *out = curlx_convert_charo_UTF8(unicode); + if(*out) + success = TRUE; + } +diff -urp a/Utilities/cmcurl/lib/memdebug.c b/Utilities/cmcurl/lib/memdebug.c +--- a/Utilities/cmcurl/lib/memdebug.c 2021-01-28 18:58:45.000000000 +0330 ++++ b/Utilities/cmcurl/lib/memdebug.c 2021-02-11 18:43:33.732518016 +0330 +@@ -238,9 +238,9 @@ char *curl_dbg_strdup(const char *str, i + } + + #if defined(WIN32) && defined(UNICODE) +-wchar_t *curl_dbg_wcsdup(const wchar_t *str, int line, const char *source) ++char *curl_dbg_wcsdup(const char *str, int line, const char *source) + { +- wchar_t *mem; ++ char *mem; + size_t wsiz, bsiz; + + DEBUGASSERT(str != NULL); +@@ -249,7 +249,7 @@ wchar_t *curl_dbg_wcsdup(const wchar_t * + return NULL; + + wsiz = wcslen(str) + 1; +- bsiz = wsiz * sizeof(wchar_t); ++ bsiz = wsiz * sizeof(char); + + mem = curl_dbg_malloc(bsiz, 0, NULL); /* NULL prevents logging */ + if(mem) +diff -urp a/Utilities/cmcurl/lib/memdebug.h b/Utilities/cmcurl/lib/memdebug.h +--- a/Utilities/cmcurl/lib/memdebug.h 2021-01-28 18:58:45.000000000 +0330 ++++ b/Utilities/cmcurl/lib/memdebug.h 2021-02-11 18:43:33.832519600 +0330 +@@ -41,7 +41,7 @@ CURL_EXTERN void *curl_dbg_realloc(void + CURL_EXTERN void curl_dbg_free(void *ptr, int line, const char *source); + CURL_EXTERN char *curl_dbg_strdup(const char *str, int line, const char *src); + #if defined(WIN32) && defined(UNICODE) +-CURL_EXTERN wchar_t *curl_dbg_wcsdup(const wchar_t *str, int line, ++CURL_EXTERN char *curl_dbg_wcsdup(const char *str, int line, + const char *source); + #endif + +diff -urp a/Utilities/cmcurl/lib/setup-win32.h b/Utilities/cmcurl/lib/setup-win32.h +--- a/Utilities/cmcurl/lib/setup-win32.h 2021-01-28 18:58:45.000000000 +0330 ++++ b/Utilities/cmcurl/lib/setup-win32.h 2021-02-11 18:43:33.872520232 +0330 +@@ -54,7 +54,7 @@ + # endif + # include <tchar.h> + # ifdef UNICODE +- typedef wchar_t *(*curl_wcsdup_callback)(const wchar_t *str); ++ typedef char *(*curl_wcsdup_callback)(const char *str); + # endif + #endif + +diff -urp a/Utilities/cmcurl/lib/strerror.c b/Utilities/cmcurl/lib/strerror.c +--- a/Utilities/cmcurl/lib/strerror.c 2021-01-28 18:58:45.000000000 +0330 ++++ b/Utilities/cmcurl/lib/strerror.c 2021-02-11 18:43:33.752518332 +0330 +@@ -660,12 +660,12 @@ get_winapi_error(int err, char *buf, siz + + #ifdef _WIN32_WCE + { +- wchar_t wbuf[256]; ++ char wbuf[256]; + wbuf[0] = L'\0'; + + if(FormatMessage((FORMAT_MESSAGE_FROM_SYSTEM | + FORMAT_MESSAGE_IGNORE_INSERTS), NULL, err, +- LANG_NEUTRAL, wbuf, sizeof(wbuf)/sizeof(wchar_t), NULL)) { ++ LANG_NEUTRAL, wbuf, sizeof(wbuf)/sizeof(char), NULL)) { + size_t written = wcstombs(buf, wbuf, buflen - 1); + if(written != (size_t)-1) + buf[written] = '\0'; +diff -urp a/Utilities/cmcurl/lib/system_win32.c b/Utilities/cmcurl/lib/system_win32.c +--- a/Utilities/cmcurl/lib/system_win32.c 2021-01-28 18:58:45.000000000 +0330 ++++ b/Utilities/cmcurl/lib/system_win32.c 2021-02-11 18:43:33.832519600 +0330 +@@ -152,7 +152,7 @@ typedef HMODULE (APIENTRY *LOADLIBRARYEX + /* See function definitions in winbase.h */ + #ifdef UNICODE + # ifdef _WIN32_WCE +-# define LOADLIBARYEX L"LoadLibraryExW" ++# define LOADLIBARYEX "LoadLibraryExW" + # else + # define LOADLIBARYEX "LoadLibraryExW" + # endif +diff -urp a/Utilities/cmcurl/lib/vtls/schannel.c b/Utilities/cmcurl/lib/vtls/schannel.c +--- a/Utilities/cmcurl/lib/vtls/schannel.c 2021-01-28 18:58:45.000000000 +0330 ++++ b/Utilities/cmcurl/lib/vtls/schannel.c 2021-02-11 18:43:33.765851877 +0330 +@@ -70,7 +70,7 @@ + #endif + + #ifndef UNISP_NAME_W +-#define UNISP_NAME_W L"Microsoft Unified Security Protocol Provider" ++#define UNISP_NAME_W "Microsoft Unified Security Protocol Provider" + #endif + + #ifndef UNISP_NAME +diff -urp a/Utilities/cmcurl/lib/vtls/schannel_verify.c b/Utilities/cmcurl/lib/vtls/schannel_verify.c +--- a/Utilities/cmcurl/lib/vtls/schannel_verify.c 2021-01-28 18:58:45.000000000 +0330 ++++ b/Utilities/cmcurl/lib/vtls/schannel_verify.c 2021-02-11 18:43:33.769185263 +0330 +@@ -384,7 +384,7 @@ static DWORD cert_get_name_string(struct + /* Iterate over the alternate names and populate host_names. */ + for(i = 0; i < alt_name_info->cAltEntry; i++) { + const CERT_ALT_NAME_ENTRY *entry = &alt_name_info->rgAltEntry[i]; +- wchar_t *dns_w = NULL; ++ char *dns_w = NULL; + size_t current_length = 0; + + if(entry->dwAltNameChoice != CERT_ALT_NAME_DNS_NAME) { +diff -urp a/Utilities/cmexpat/lib/expat_external.h b/Utilities/cmexpat/lib/expat_external.h +--- a/Utilities/cmexpat/lib/expat_external.h 2021-01-28 18:58:45.000000000 +0330 ++++ b/Utilities/cmexpat/lib/expat_external.h 2021-02-11 18:43:34.099190481 +0330 +@@ -129,14 +129,14 @@ extern "C" { + # define XML_UNICODE + # endif + # if defined(__SIZEOF_WCHAR_T__) && (__SIZEOF_WCHAR_T__ != 2) +-# error "sizeof(wchar_t) != 2; Need -fshort-wchar for both Expat and libc" ++# error "sizeof(char) != 2; Need -fshort-wchar for both Expat and libc" + # endif + #endif + + #ifdef XML_UNICODE /* Information is UTF-16 encoded. */ + # ifdef XML_UNICODE_WCHAR_T +-typedef wchar_t XML_Char; +-typedef wchar_t XML_LChar; ++typedef char XML_Char; ++typedef char XML_LChar; + # else + typedef unsigned short XML_Char; + typedef char XML_LChar; +diff -urp a/Utilities/cmexpat/lib/xmlparse.c b/Utilities/cmexpat/lib/xmlparse.c +--- a/Utilities/cmexpat/lib/xmlparse.c 2021-01-28 18:58:45.000000000 +0330 ++++ b/Utilities/cmexpat/lib/xmlparse.c 2021-02-11 18:43:34.095857094 +0330 +@@ -157,7 +157,7 @@ typedef char ICHAR; + #ifdef XML_UNICODE + + # ifdef XML_UNICODE_WCHAR_T +-# define XML_T(x) (const wchar_t) x ++# define XML_T(x) (const char) x + # define XML_L(x) L##x + # else + # define XML_T(x) (const unsigned short)x +diff -urp a/Utilities/cmexpat/README.md b/Utilities/cmexpat/README.md +--- a/Utilities/cmexpat/README.md 2021-01-28 18:58:45.000000000 +0330 ++++ b/Utilities/cmexpat/README.md 2021-02-11 18:43:34.062523237 +0330 +@@ -99,7 +99,7 @@ support this mode of compilation (yet): + 1. For UTF-16 output as unsigned short (and version/error strings as char), + run:<br/> + `./configure CPPFLAGS=-DXML_UNICODE --without-xmlwf`<br/> +- For UTF-16 output as `wchar_t` (incl. version/error strings), run:<br/> ++ For UTF-16 output as `char` (incl. version/error strings), run:<br/> + `./configure CFLAGS="-g -O2 -fshort-wchar" CPPFLAGS=-DXML_UNICODE_WCHAR_T + --without-xmlwf` + <br/>Note: The latter requires libc compiled with `-fshort-wchar`, as well. +@@ -165,7 +165,7 @@ EXPAT_BUILD_TESTS:BOOL=ON + // build the xmlwf tool for expat library + EXPAT_BUILD_TOOLS:BOOL=ON + +-// Character type to use (char|ushort|wchar_t) [default=char] ++// Character type to use (char|ushort|char) [default=char] + EXPAT_CHAR_TYPE:STRING=char + + // install expat files in cmake install target +diff -urp a/Utilities/cmlibarchive/build/cmake/config.h.in b/Utilities/cmlibarchive/build/cmake/config.h.in +--- a/Utilities/cmlibarchive/build/cmake/config.h.in 2021-01-28 18:58:45.000000000 +0330 ++++ b/Utilities/cmlibarchive/build/cmake/config.h.in 2021-02-12 14:39:59.857852509 +0330 +@@ -931,7 +931,7 @@ + /* Define to 1 if you have the <wchar.h> header file. */ + #cmakedefine HAVE_WCHAR_H 1 + +-/* Define to 1 if the system has the type `wchar_t'. */ ++/* Define to 1 if the system has the type `char'. */ + #cmakedefine HAVE_WCHAR_T 1 + + /* Define to 1 if you have the `wcrtomb' function. */ +@@ -1027,7 +1027,7 @@ + /* Define to 1 if your C compiler doesn't accept -c and -o together. */ + #cmakedefine NO_MINUS_C_MINUS_O 1 + +-/* The size of `wchar_t', as computed by sizeof. */ ++/* The size of `char', as computed by sizeof. */ + #cmakedefine SIZEOF_WCHAR_T ${SIZEOF_WCHAR_T} + + /* Define to 1 if strerror_r returns char *. */ +diff -urp a/Utilities/cmlibarchive/CMakeLists.txt b/Utilities/cmlibarchive/CMakeLists.txt +--- a/Utilities/cmlibarchive/CMakeLists.txt 2021-01-28 18:58:45.000000000 +0330 ++++ b/Utilities/cmlibarchive/CMakeLists.txt 2021-02-12 14:39:59.857852509 +0330 +@@ -1612,7 +1612,7 @@ IF(NOT HAVE_PID_T) + ENDIF(WIN32) + ENDIF(NOT HAVE_PID_T) + # +-CHECK_TYPE_SIZE(wchar_t SIZEOF_WCHAR_T) ++CHECK_TYPE_SIZE(char SIZEOF_WCHAR_T) + IF(HAVE_SIZEOF_WCHAR_T) + SET(HAVE_WCHAR_T 1) + ENDIF(HAVE_SIZEOF_WCHAR_T) +diff -urp a/Utilities/cmlibarchive/libarchive/archive_acl.c b/Utilities/cmlibarchive/libarchive/archive_acl.c +--- a/Utilities/cmlibarchive/libarchive/archive_acl.c 2021-01-28 18:58:45.000000000 +0330 ++++ b/Utilities/cmlibarchive/libarchive/archive_acl.c 2021-02-11 18:43:34.425862296 +0330 +@@ -46,7 +46,7 @@ __FBSDID("$FreeBSD$"); + + #ifndef HAVE_WMEMCMP + /* Good enough for simple equality testing, but not for sorting. */ +-#define wmemcmp(a,b,i) memcmp((a), (b), (i) * sizeof(wchar_t)) ++#define wmemcmp(a,b,i) memcmp((a), (b), (i) * sizeof(char)) + #endif + + static int acl_special(struct archive_acl *acl, +@@ -60,17 +60,17 @@ static int archive_acl_text_want_type(st + static ssize_t archive_acl_text_len(struct archive_acl *acl, int want_type, + int flags, int wide, struct archive *a, + struct archive_string_conv *sc); +-static int isint_w(const wchar_t *start, const wchar_t *end, int *result); +-static int ismode_w(const wchar_t *start, const wchar_t *end, int *result); +-static int is_nfs4_flags_w(const wchar_t *start, const wchar_t *end, ++static int isint_w(const char *start, const char *end, int *result); ++static int ismode_w(const char *start, const char *end, int *result); ++static int is_nfs4_flags_w(const char *start, const char *end, + int *result); +-static int is_nfs4_perms_w(const wchar_t *start, const wchar_t *end, ++static int is_nfs4_perms_w(const char *start, const char *end, + int *result); +-static void next_field_w(const wchar_t **wp, const wchar_t **start, +- const wchar_t **end, wchar_t *sep); +-static void append_entry_w(wchar_t **wp, const wchar_t *prefix, int type, +- int tag, int flags, const wchar_t *wname, int perm, int id); +-static void append_id_w(wchar_t **wp, int id); ++static void next_field_w(const char **wp, const char **start, ++ const char **end, char *sep); ++static void append_entry_w(char **wp, const char *prefix, int type, ++ int tag, int flags, const char *wname, int perm, int id); ++static void append_id_w(char **wp, int id); + static int isint(const char *start, const char *end, int *result); + static int ismode(const char *start, const char *end, int *result); + static int is_nfs4_flags(const char *start, const char *end, +@@ -86,7 +86,7 @@ static void append_id(char **p, int id); + static const struct { + const int perm; + const char c; +- const wchar_t wc; ++ const char wc; + } nfsv4_acl_perm_map[] = { + { ARCHIVE_ENTRY_ACL_READ_DATA | ARCHIVE_ENTRY_ACL_LIST_DIRECTORY, 'r', + L'r' }, +@@ -113,7 +113,7 @@ static const int nfsv4_acl_perm_map_size + static const struct { + const int perm; + const char c; +- const wchar_t wc; ++ const char wc; + } nfsv4_acl_flag_map[] = { + { ARCHIVE_ENTRY_ACL_ENTRY_FILE_INHERIT, 'f', L'f' }, + { ARCHIVE_ENTRY_ACL_ENTRY_DIRECTORY_INHERIT, 'd', L'd' }, +@@ -187,7 +187,7 @@ archive_acl_add_entry(struct archive_acl + + int + archive_acl_add_entry_w_len(struct archive_acl *acl, +- int type, int permset, int tag, int id, const wchar_t *name, size_t len) ++ int type, int permset, int tag, int id, const char *name, size_t len) + { + struct archive_acl_entry *ap; + +@@ -534,7 +534,7 @@ archive_acl_text_len(struct archive_acl + int wide, struct archive *a, struct archive_string_conv *sc) { + struct archive_acl_entry *ap; + const char *name; +- const wchar_t *wname; ++ const char *wname; + int count, idlen, tmp, r; + ssize_t length; + size_t len; +@@ -660,19 +660,19 @@ archive_acl_text_len(struct archive_acl + * Generate a wide text version of the ACL. The flags parameter controls + * the type and style of the generated ACL. + */ +-wchar_t * ++char * + archive_acl_to_text_w(struct archive_acl *acl, ssize_t *text_len, int flags, + struct archive *a) + { + int count; + ssize_t length; + size_t len; +- const wchar_t *wname; +- const wchar_t *prefix; +- wchar_t separator; ++ const char *wname; ++ const char *prefix; ++ char separator; + struct archive_acl_entry *ap; + int id, r, want_type; +- wchar_t *wp, *ws; ++ char *wp, *ws; + + want_type = archive_acl_text_want_type(acl, flags); + +@@ -694,7 +694,7 @@ archive_acl_to_text_w(struct archive_acl + separator = L'\n'; + + /* Now, allocate the string and actually populate it. */ +- wp = ws = (wchar_t *)malloc(length * sizeof(wchar_t)); ++ wp = ws = (char *)malloc(length * sizeof(char)); + if (wp == NULL) { + if (errno == ENOMEM) + __archive_errx(1, "No memory"); +@@ -731,7 +731,7 @@ archive_acl_to_text_w(struct archive_acl + continue; + if (ap->type == ARCHIVE_ENTRY_ACL_TYPE_DEFAULT && + (flags & ARCHIVE_ENTRY_ACL_STYLE_MARK_DEFAULT) != 0) +- prefix = L"default:"; ++ prefix = "default:"; + else + prefix = NULL; + r = archive_mstring_get_wcs(a, &ap->name, &wname); +@@ -766,18 +766,18 @@ archive_acl_to_text_w(struct archive_acl + } + + static void +-append_id_w(wchar_t **wp, int id) ++append_id_w(char **wp, int id) + { + if (id < 0) + id = 0; + if (id > 9) + append_id_w(wp, id / 10); +- *(*wp)++ = L"0123456789"[id % 10]; ++ *(*wp)++ = "0123456789"[id % 10]; + } + + static void +-append_entry_w(wchar_t **wp, const wchar_t *prefix, int type, +- int tag, int flags, const wchar_t *wname, int perm, int id) ++append_entry_w(char **wp, const char *prefix, int type, ++ int tag, int flags, const char *wname, int perm, int id) + { + int i; + +@@ -790,36 +790,36 @@ append_entry_w(wchar_t **wp, const wchar + wname = NULL; + id = -1; + if ((type & ARCHIVE_ENTRY_ACL_TYPE_NFS4) != 0) { +- wcscpy(*wp, L"owner@"); ++ wcscpy(*wp, "owner@"); + break; + } + /* FALLTHROUGH */ + case ARCHIVE_ENTRY_ACL_USER: +- wcscpy(*wp, L"user"); ++ wcscpy(*wp, "user"); + break; + case ARCHIVE_ENTRY_ACL_GROUP_OBJ: + wname = NULL; + id = -1; + if ((type & ARCHIVE_ENTRY_ACL_TYPE_NFS4) != 0) { +- wcscpy(*wp, L"group@"); ++ wcscpy(*wp, "group@"); + break; + } + /* FALLTHROUGH */ + case ARCHIVE_ENTRY_ACL_GROUP: +- wcscpy(*wp, L"group"); ++ wcscpy(*wp, "group"); + break; + case ARCHIVE_ENTRY_ACL_MASK: +- wcscpy(*wp, L"mask"); ++ wcscpy(*wp, "mask"); + wname = NULL; + id = -1; + break; + case ARCHIVE_ENTRY_ACL_OTHER: +- wcscpy(*wp, L"other"); ++ wcscpy(*wp, "other"); + wname = NULL; + id = -1; + break; + case ARCHIVE_ENTRY_ACL_EVERYONE: +- wcscpy(*wp, L"everyone@"); ++ wcscpy(*wp, "everyone@"); + wname = NULL; + id = -1; + break; +@@ -867,16 +867,16 @@ append_entry_w(wchar_t **wp, const wchar + *(*wp)++ = L':'; + switch (type) { + case ARCHIVE_ENTRY_ACL_TYPE_ALLOW: +- wcscpy(*wp, L"allow"); ++ wcscpy(*wp, "allow"); + break; + case ARCHIVE_ENTRY_ACL_TYPE_DENY: +- wcscpy(*wp, L"deny"); ++ wcscpy(*wp, "deny"); + break; + case ARCHIVE_ENTRY_ACL_TYPE_AUDIT: +- wcscpy(*wp, L"audit"); ++ wcscpy(*wp, "audit"); + break; + case ARCHIVE_ENTRY_ACL_TYPE_ALARM: +- wcscpy(*wp, L"alarm"); ++ wcscpy(*wp, "alarm"); + break; + default: + break; +@@ -1134,20 +1134,20 @@ append_entry(char **p, const char *prefi + * ARCHIVE_ENTRY_ACL_TYPE_DEFAULT unless type is ARCHIVE_ENTRY_ACL_TYPE_NFS4 + */ + int +-archive_acl_from_text_w(struct archive_acl *acl, const wchar_t *text, ++archive_acl_from_text_w(struct archive_acl *acl, const char *text, + int want_type) + { + struct { +- const wchar_t *start; +- const wchar_t *end; ++ const char *start; ++ const char *end; + } field[6], name; + +- const wchar_t *s, *st; ++ const char *s, *st; + + int numfields, fields, n, r, sol, ret; + int type, types, tag, permset, id; + size_t len; +- wchar_t sep; ++ char sep; + + ret = ARCHIVE_OK; + types = 0; +@@ -1174,7 +1174,7 @@ archive_acl_from_text_w(struct archive_a + */ + fields = 0; + do { +- const wchar_t *start, *end; ++ const char *start, *end; + next_field_w(&text, &start, &end, &sep); + if (fields < numfields) { + field[fields].start = start; +@@ -1211,7 +1211,7 @@ archive_acl_from_text_w(struct archive_a + s = field[0].start; + len = field[0].end - field[0].start; + if (*s == L'd' && (len == 1 || (len >= 7 +- && wmemcmp((s + 1), L"efault", 6) == 0))) { ++ && wmemcmp((s + 1), "efault", 6) == 0))) { + type = ARCHIVE_ENTRY_ACL_TYPE_DEFAULT; + if (len > 7) + field[0].start += 7; +@@ -1235,22 +1235,22 @@ archive_acl_from_text_w(struct archive_a + switch (*s) { + case L'u': + if (len == 1 || (len == 4 +- && wmemcmp(st, L"ser", 3) == 0)) ++ && wmemcmp(st, "ser", 3) == 0)) + tag = ARCHIVE_ENTRY_ACL_USER_OBJ; + break; + case L'g': + if (len == 1 || (len == 5 +- && wmemcmp(st, L"roup", 4) == 0)) ++ && wmemcmp(st, "roup", 4) == 0)) + tag = ARCHIVE_ENTRY_ACL_GROUP_OBJ; + break; + case L'o': + if (len == 1 || (len == 5 +- && wmemcmp(st, L"ther", 4) == 0)) ++ && wmemcmp(st, "ther", 4) == 0)) + tag = ARCHIVE_ENTRY_ACL_OTHER; + break; + case L'm': + if (len == 1 || (len == 4 +- && wmemcmp(st, L"ask", 3) == 0)) ++ && wmemcmp(st, "ask", 3) == 0)) + tag = ARCHIVE_ENTRY_ACL_MASK; + break; + default: +@@ -1308,21 +1308,21 @@ archive_acl_from_text_w(struct archive_a + + switch (len) { + case 4: +- if (wmemcmp(s, L"user", 4) == 0) ++ if (wmemcmp(s, "user", 4) == 0) + tag = ARCHIVE_ENTRY_ACL_USER; + break; + case 5: +- if (wmemcmp(s, L"group", 5) == 0) ++ if (wmemcmp(s, "group", 5) == 0) + tag = ARCHIVE_ENTRY_ACL_GROUP; + break; + case 6: +- if (wmemcmp(s, L"owner@", 6) == 0) ++ if (wmemcmp(s, "owner@", 6) == 0) + tag = ARCHIVE_ENTRY_ACL_USER_OBJ; +- else if (wmemcmp(s, L"group@", len) == 0) ++ else if (wmemcmp(s, "group@", len) == 0) + tag = ARCHIVE_ENTRY_ACL_GROUP_OBJ; + break; + case 9: +- if (wmemcmp(s, L"everyone@", 9) == 0) ++ if (wmemcmp(s, "everyone@", 9) == 0) + tag = ARCHIVE_ENTRY_ACL_EVERYONE; + default: + break; +@@ -1356,14 +1356,14 @@ archive_acl_from_text_w(struct archive_a + len = field[3 + n].end - field[3 + n].start; + type = 0; + if (len == 4) { +- if (wmemcmp(s, L"deny", 4) == 0) ++ if (wmemcmp(s, "deny", 4) == 0) + type = ARCHIVE_ENTRY_ACL_TYPE_DENY; + } else if (len == 5) { +- if (wmemcmp(s, L"allow", 5) == 0) ++ if (wmemcmp(s, "allow", 5) == 0) + type = ARCHIVE_ENTRY_ACL_TYPE_ALLOW; +- else if (wmemcmp(s, L"audit", 5) == 0) ++ else if (wmemcmp(s, "audit", 5) == 0) + type = ARCHIVE_ENTRY_ACL_TYPE_AUDIT; +- else if (wmemcmp(s, L"alarm", 5) == 0) ++ else if (wmemcmp(s, "alarm", 5) == 0) + type = ARCHIVE_ENTRY_ACL_TYPE_ALARM; + } + if (type == 0) { +@@ -1396,7 +1396,7 @@ archive_acl_from_text_w(struct archive_a + * false otherwise. + */ + static int +-isint_w(const wchar_t *start, const wchar_t *end, int *result) ++isint_w(const char *start, const char *end, int *result) + { + int n = 0; + if (start >= end) +@@ -1423,9 +1423,9 @@ isint_w(const wchar_t *start, const wcha + * false otherwise. + */ + static int +-ismode_w(const wchar_t *start, const wchar_t *end, int *permset) ++ismode_w(const char *start, const char *end, int *permset) + { +- const wchar_t *p; ++ const char *p; + + if (start >= end) + return (0); +@@ -1457,9 +1457,9 @@ ismode_w(const wchar_t *start, const wch + * permission characters, false otherwise + */ + static int +-is_nfs4_perms_w(const wchar_t *start, const wchar_t *end, int *permset) ++is_nfs4_perms_w(const char *start, const char *end, int *permset) + { +- const wchar_t *p = start; ++ const char *p = start; + + while (p < end) { + switch (*p++) { +@@ -1520,9 +1520,9 @@ is_nfs4_perms_w(const wchar_t *start, co + * flag characters, false otherwise + */ + static int +-is_nfs4_flags_w(const wchar_t *start, const wchar_t *end, int *permset) ++is_nfs4_flags_w(const char *start, const char *end, int *permset) + { +- const wchar_t *p = start; ++ const char *p = start; + + while (p < end) { + switch(*p++) { +@@ -1566,8 +1566,8 @@ is_nfs4_flags_w(const wchar_t *start, co + * whitespace. + */ + static void +-next_field_w(const wchar_t **wp, const wchar_t **start, +- const wchar_t **end, wchar_t *sep) ++next_field_w(const char **wp, const char **start, ++ const char **end, char *sep) + { + /* Skip leading whitespace to find start of field. */ + while (**wp == L' ' || **wp == L'\t' || **wp == L'\n') { +diff -urp a/Utilities/cmlibarchive/libarchive/archive_acl_private.h b/Utilities/cmlibarchive/libarchive/archive_acl_private.h +--- a/Utilities/cmlibarchive/libarchive/archive_acl_private.h 2021-01-28 18:58:45.000000000 +0330 ++++ b/Utilities/cmlibarchive/libarchive/archive_acl_private.h 2021-02-11 18:43:34.392528437 +0330 +@@ -48,7 +48,7 @@ struct archive_acl { + struct archive_acl_entry *acl_head; + struct archive_acl_entry *acl_p; + int acl_state; /* See acl_next for details. */ +- wchar_t *acl_text_w; ++ char *acl_text_w; + char *acl_text; + int acl_types; + }; +@@ -63,11 +63,11 @@ int archive_acl_next(struct archive *, s + + int archive_acl_add_entry(struct archive_acl *, int, int, int, int, const char *); + int archive_acl_add_entry_w_len(struct archive_acl *, +- int, int, int, int, const wchar_t *, size_t); ++ int, int, int, int, const char *, size_t); + int archive_acl_add_entry_len(struct archive_acl *, + int, int, int, int, const char *, size_t); + +-wchar_t *archive_acl_to_text_w(struct archive_acl *, ssize_t *, int, ++char *archive_acl_to_text_w(struct archive_acl *, ssize_t *, int, + struct archive *); + char *archive_acl_to_text_l(struct archive_acl *, ssize_t *, int, + struct archive_string_conv *); +@@ -75,7 +75,7 @@ char *archive_acl_to_text_l(struct archi + /* + * ACL text parser. + */ +-int archive_acl_from_text_w(struct archive_acl *, const wchar_t * /* wtext */, ++int archive_acl_from_text_w(struct archive_acl *, const char * /* wtext */, + int /* type */); + int archive_acl_from_text_l(struct archive_acl *, const char * /* text */, + int /* type */, struct archive_string_conv *); +diff -urp a/Utilities/cmlibarchive/libarchive/archive_entry_acl.3 b/Utilities/cmlibarchive/libarchive/archive_entry_acl.3 +--- a/Utilities/cmlibarchive/libarchive/archive_entry_acl.3 2021-01-28 18:58:45.000000000 +0330 ++++ b/Utilities/cmlibarchive/libarchive/archive_entry_acl.3 2021-02-11 18:43:34.399195209 +0330 +@@ -59,7 +59,7 @@ Streaming Archive Library (libarchive, - + .Fa "int permset" + .Fa "int tag" + .Fa "int qualifier" +-.Fa "const wchar_t *name" ++.Fa "const char *name" + .Fc + .Ft void + .Fn archive_entry_acl_clear "struct archive_entry *a" +@@ -74,7 +74,7 @@ Streaming Archive Library (libarchive, - + .Ft int + .Fo archive_entry_acl_from_text_w + .Fa "struct archive_entry *a" +-.Fa "const wchar_t *text" ++.Fa "const char *text" + .Fa "int type" + .Fc + .Ft int +@@ -95,7 +95,7 @@ Streaming Archive Library (libarchive, - + .Fa "ssize_t *len_p" + .Fa "int flags" + .Fc +-.Ft wchar_t * ++.Ft char * + .Fo archive_entry_acl_to_text_w + .Fa "struct archive_entry *a" + .Fa "ssize_t *len_p" +diff -urp a/Utilities/cmlibarchive/libarchive/archive_entry.c b/Utilities/cmlibarchive/libarchive/archive_entry.c +--- a/Utilities/cmlibarchive/libarchive/archive_entry.c 2021-01-28 18:58:45.000000000 +0330 ++++ b/Utilities/cmlibarchive/libarchive/archive_entry.c 2021-02-11 18:43:34.392528437 +0330 +@@ -117,24 +117,24 @@ __FBSDID("$FreeBSD: head/lib/libarchive/ + } while (0) + + static char * ae_fflagstostr(unsigned long bitset, unsigned long bitclear); +-static const wchar_t *ae_wcstofflags(const wchar_t *stringp, ++static const char *ae_wcstofflags(const char *stringp, + unsigned long *setp, unsigned long *clrp); + static const char *ae_strtofflags(const char *stringp, + unsigned long *setp, unsigned long *clrp); + + #ifndef HAVE_WCSCPY +-static wchar_t * wcscpy(wchar_t *s1, const wchar_t *s2) ++static char * wcscpy(char *s1, const char *s2) + { +- wchar_t *dest = s1; ++ char *dest = s1; + while ((*s1 = *s2) != L'\0') + ++s1, ++s2; + return dest; + } + #endif + #ifndef HAVE_WCSLEN +-static size_t wcslen(const wchar_t *s) ++static size_t wcslen(const char *s) + { +- const wchar_t *p = s; ++ const char *p = s; + while (*p != L'\0') + ++p; + return p - s; +@@ -142,7 +142,7 @@ static size_t wcslen(const wchar_t *s) + #endif + #ifndef HAVE_WMEMCMP + /* Good enough for simple equality testing, but not for sorting. */ +-#define wmemcmp(a,b,i) memcmp((a), (b), (i) * sizeof(wchar_t)) ++#define wmemcmp(a,b,i) memcmp((a), (b), (i) * sizeof(char)) + #endif + + /**************************************************************************** +@@ -435,10 +435,10 @@ archive_entry_gname_utf8(struct archive_ + } + + +-const wchar_t * ++const char * + archive_entry_gname_w(struct archive_entry *entry) + { +- const wchar_t *p; ++ const char *p; + if (archive_mstring_get_wcs(entry->archive, &entry->ae_gname, &p) == 0) + return (p); + if (errno == ENOMEM) +@@ -481,10 +481,10 @@ archive_entry_hardlink_utf8(struct archi + return (NULL); + } + +-const wchar_t * ++const char * + archive_entry_hardlink_w(struct archive_entry *entry) + { +- const wchar_t *p; ++ const char *p; + if ((entry->ae_set & AE_SET_HARDLINK) == 0) + return (NULL); + if (archive_mstring_get_wcs( +@@ -579,10 +579,10 @@ archive_entry_pathname_utf8(struct archi + return (NULL); + } + +-const wchar_t * ++const char * + archive_entry_pathname_w(struct archive_entry *entry) + { +- const wchar_t *p; ++ const char *p; + if (archive_mstring_get_wcs( + entry->archive, &entry->ae_pathname, &p) == 0) + return (p); +@@ -656,10 +656,10 @@ archive_entry_sourcepath(struct archive_ + return (NULL); + } + +-const wchar_t * ++const char * + archive_entry_sourcepath_w(struct archive_entry *entry) + { +- const wchar_t *p; ++ const char *p; + if (archive_mstring_get_wcs( + entry->archive, &entry->ae_sourcepath, &p) == 0) + return (p); +@@ -700,10 +700,10 @@ archive_entry_symlink_utf8(struct archiv + return (NULL); + } + +-const wchar_t * ++const char * + archive_entry_symlink_w(struct archive_entry *entry) + { +- const wchar_t *p; ++ const char *p; + if ((entry->ae_set & AE_SET_SYMLINK) == 0) + return (NULL); + if (archive_mstring_get_wcs( +@@ -754,10 +754,10 @@ archive_entry_uname_utf8(struct archive_ + return (NULL); + } + +-const wchar_t * ++const char * + archive_entry_uname_w(struct archive_entry *entry) + { +- const wchar_t *p; ++ const char *p; + if (archive_mstring_get_wcs(entry->archive, &entry->ae_uname, &p) == 0) + return (p); + if (errno == ENOMEM) +@@ -820,9 +820,9 @@ archive_entry_copy_fflags_text(struct ar + &entry->ae_fflags_set, &entry->ae_fflags_clear)); + } + +-const wchar_t * ++const char * + archive_entry_copy_fflags_text_w(struct archive_entry *entry, +- const wchar_t *flags) ++ const char *flags) + { + archive_mstring_copy_wcs(&entry->ae_fflags_text, flags); + return (ae_wcstofflags(flags, +@@ -855,7 +855,7 @@ archive_entry_copy_gname(struct archive_ + } + + void +-archive_entry_copy_gname_w(struct archive_entry *entry, const wchar_t *name) ++archive_entry_copy_gname_w(struct archive_entry *entry, const char *name) + { + archive_mstring_copy_wcs(&entry->ae_gname, name); + } +@@ -925,7 +925,7 @@ archive_entry_copy_hardlink(struct archi + } + + void +-archive_entry_copy_hardlink_w(struct archive_entry *entry, const wchar_t *target) ++archive_entry_copy_hardlink_w(struct archive_entry *entry, const char *target) + { + archive_mstring_copy_wcs(&entry->ae_hardlink, target); + if (target != NULL) +@@ -1073,7 +1073,7 @@ archive_entry_copy_link(struct archive_e + + /* Set symlink if symlink is already set, else set hardlink. */ + void +-archive_entry_copy_link_w(struct archive_entry *entry, const wchar_t *target) ++archive_entry_copy_link_w(struct archive_entry *entry, const char *target) + { + if (entry->ae_set & AE_SET_SYMLINK) + archive_mstring_copy_wcs(&entry->ae_symlink, target); +@@ -1163,7 +1163,7 @@ archive_entry_copy_pathname(struct archi + } + + void +-archive_entry_copy_pathname_w(struct archive_entry *entry, const wchar_t *name) ++archive_entry_copy_pathname_w(struct archive_entry *entry, const char *name) + { + archive_mstring_copy_wcs(&entry->ae_pathname, name); + } +@@ -1241,7 +1241,7 @@ archive_entry_copy_sourcepath(struct arc + } + + void +-archive_entry_copy_sourcepath_w(struct archive_entry *entry, const wchar_t *path) ++archive_entry_copy_sourcepath_w(struct archive_entry *entry, const char *path) + { + archive_mstring_copy_wcs(&entry->ae_sourcepath, path); + } +@@ -1283,7 +1283,7 @@ archive_entry_copy_symlink(struct archiv + } + + void +-archive_entry_copy_symlink_w(struct archive_entry *entry, const wchar_t *linkname) ++archive_entry_copy_symlink_w(struct archive_entry *entry, const char *linkname) + { + archive_mstring_copy_wcs(&entry->ae_symlink, linkname); + if (linkname != NULL) +@@ -1348,7 +1348,7 @@ archive_entry_copy_uname(struct archive_ + } + + void +-archive_entry_copy_uname_w(struct archive_entry *entry, const wchar_t *name) ++archive_entry_copy_uname_w(struct archive_entry *entry, const char *name) + { + archive_mstring_copy_wcs(&entry->ae_uname, name); + } +@@ -1452,7 +1452,7 @@ archive_entry_acl_add_entry(struct archi + */ + int + archive_entry_acl_add_entry_w(struct archive_entry *entry, +- int type, int permset, int tag, int id, const wchar_t *name) ++ int type, int permset, int tag, int id, const char *name) + { + return archive_acl_add_entry_w_len(&entry->acl, + type, permset, tag, id, name, wcslen(name)); +@@ -1507,7 +1507,7 @@ archive_entry_acl_next(struct archive_en + * Generate a text version of the ACL. The flags parameter controls + * the style of the generated ACL. + */ +-wchar_t * ++char * + archive_entry_acl_to_text_w(struct archive_entry *entry, la_ssize_t *len, + int flags) + { +@@ -1534,7 +1534,7 @@ _archive_entry_acl_to_text_l(struct arch + */ + int + archive_entry_acl_from_text_w(struct archive_entry *entry, +- const wchar_t *wtext, int type) ++ const char *wtext, int type) + { + return (archive_acl_from_text_w(&entry->acl, wtext, type)); + } +@@ -1574,7 +1574,7 @@ archive_entry_acl_text_compat(int *flags + } + + /* Deprecated */ +-const wchar_t * ++const char * + archive_entry_acl_text_w(struct archive_entry *entry, int flags) + { + free(entry->acl.acl_text_w); +@@ -1696,166 +1696,166 @@ _archive_entry_acl_text_l(struct archive + + static const struct flag { + const char *name; +- const wchar_t *wname; ++ const char *wname; + unsigned long set; + unsigned long clear; + } fileflags[] = { + /* Preferred (shorter) names per flag first, all prefixed by "no" */ + #ifdef SF_APPEND +- { "nosappnd", L"nosappnd", SF_APPEND, 0}, +- { "nosappend", L"nosappend", SF_APPEND, 0}, ++ { "nosappnd", "nosappnd", SF_APPEND, 0}, ++ { "nosappend", "nosappend", SF_APPEND, 0}, + #endif + #if defined(FS_APPEND_FL) /* 'a' */ +- { "nosappnd", L"nosappnd", FS_APPEND_FL, 0}, +- { "nosappend", L"nosappend", FS_APPEND_FL, 0}, ++ { "nosappnd", "nosappnd", FS_APPEND_FL, 0}, ++ { "nosappend", "nosappend", FS_APPEND_FL, 0}, + #elif defined(EXT2_APPEND_FL) /* 'a' */ +- { "nosappnd", L"nosappnd", EXT2_APPEND_FL, 0}, +- { "nosappend", L"nosappend", EXT2_APPEND_FL, 0}, ++ { "nosappnd", "nosappnd", EXT2_APPEND_FL, 0}, ++ { "nosappend", "nosappend", EXT2_APPEND_FL, 0}, + #endif + #ifdef SF_ARCHIVED +- { "noarch", L"noarch", SF_ARCHIVED, 0}, +- { "noarchived", L"noarchived", SF_ARCHIVED, 0}, ++ { "noarch", "noarch", SF_ARCHIVED, 0}, ++ { "noarchived", "noarchived", SF_ARCHIVED, 0}, + #endif + #ifdef SF_IMMUTABLE +- { "noschg", L"noschg", SF_IMMUTABLE, 0}, +- { "noschange", L"noschange", SF_IMMUTABLE, 0}, +- { "nosimmutable", L"nosimmutable", SF_IMMUTABLE, 0}, ++ { "noschg", "noschg", SF_IMMUTABLE, 0}, ++ { "noschange", "noschange", SF_IMMUTABLE, 0}, ++ { "nosimmutable", "nosimmutable", SF_IMMUTABLE, 0}, + #endif + #if defined(FS_IMMUTABLE_FL) /* 'i' */ +- { "noschg", L"noschg", FS_IMMUTABLE_FL, 0}, +- { "noschange", L"noschange", FS_IMMUTABLE_FL, 0}, +- { "nosimmutable", L"nosimmutable", FS_IMMUTABLE_FL, 0}, ++ { "noschg", "noschg", FS_IMMUTABLE_FL, 0}, ++ { "noschange", "noschange", FS_IMMUTABLE_FL, 0}, ++ { "nosimmutable", "nosimmutable", FS_IMMUTABLE_FL, 0}, + #elif defined(EXT2_IMMUTABLE_FL) /* 'i' */ +- { "noschg", L"noschg", EXT2_IMMUTABLE_FL, 0}, +- { "noschange", L"noschange", EXT2_IMMUTABLE_FL, 0}, +- { "nosimmutable", L"nosimmutable", EXT2_IMMUTABLE_FL, 0}, ++ { "noschg", "noschg", EXT2_IMMUTABLE_FL, 0}, ++ { "noschange", "noschange", EXT2_IMMUTABLE_FL, 0}, ++ { "nosimmutable", "nosimmutable", EXT2_IMMUTABLE_FL, 0}, + #endif + #ifdef SF_NOUNLINK +- { "nosunlnk", L"nosunlnk", SF_NOUNLINK, 0}, +- { "nosunlink", L"nosunlink", SF_NOUNLINK, 0}, ++ { "nosunlnk", "nosunlnk", SF_NOUNLINK, 0}, ++ { "nosunlink", "nosunlink", SF_NOUNLINK, 0}, + #endif + #ifdef UF_APPEND +- { "nouappnd", L"nouappnd", UF_APPEND, 0}, +- { "nouappend", L"nouappend", UF_APPEND, 0}, ++ { "nouappnd", "nouappnd", UF_APPEND, 0}, ++ { "nouappend", "nouappend", UF_APPEND, 0}, + #endif + #ifdef UF_IMMUTABLE +- { "nouchg", L"nouchg", UF_IMMUTABLE, 0}, +- { "nouchange", L"nouchange", UF_IMMUTABLE, 0}, +- { "nouimmutable", L"nouimmutable", UF_IMMUTABLE, 0}, ++ { "nouchg", "nouchg", UF_IMMUTABLE, 0}, ++ { "nouchange", "nouchange", UF_IMMUTABLE, 0}, ++ { "nouimmutable", "nouimmutable", UF_IMMUTABLE, 0}, + #endif + #ifdef UF_NODUMP +- { "nodump", L"nodump", 0, UF_NODUMP}, ++ { "nodump", "nodump", 0, UF_NODUMP}, + #endif + #if defined(FS_NODUMP_FL) /* 'd' */ +- { "nodump", L"nodump", 0, FS_NODUMP_FL}, ++ { "nodump", "nodump", 0, FS_NODUMP_FL}, + #elif defined(EXT2_NODUMP_FL) +- { "nodump", L"nodump", 0, EXT2_NODUMP_FL}, ++ { "nodump", "nodump", 0, EXT2_NODUMP_FL}, + #endif + #ifdef UF_OPAQUE +- { "noopaque", L"noopaque", UF_OPAQUE, 0}, ++ { "noopaque", "noopaque", UF_OPAQUE, 0}, + #endif + #ifdef UF_NOUNLINK +- { "nouunlnk", L"nouunlnk", UF_NOUNLINK, 0}, +- { "nouunlink", L"nouunlink", UF_NOUNLINK, 0}, ++ { "nouunlnk", "nouunlnk", UF_NOUNLINK, 0}, ++ { "nouunlink", "nouunlink", UF_NOUNLINK, 0}, + #endif + #ifdef UF_COMPRESSED + /* Mac OS */ +- { "nocompressed", L"nocompressed", UF_COMPRESSED, 0}, ++ { "nocompressed", "nocompressed", UF_COMPRESSED, 0}, + #endif + #ifdef UF_HIDDEN +- { "nohidden", L"nohidden", UF_HIDDEN, 0}, +- { "nouhidden", L"nouhidden", UF_HIDDEN, 0}, ++ { "nohidden", "nohidden", UF_HIDDEN, 0}, ++ { "nouhidden", "nouhidden", UF_HIDDEN, 0}, + #endif + #ifdef FILE_ATTRIBUTE_HIDDEN +- { "nohidden", L"nohidden", FILE_ATTRIBUTE_HIDDEN, 0}, +- { "nouhidden", L"nouhidden", FILE_ATTRIBUTE_HIDDEN, 0}, ++ { "nohidden", "nohidden", FILE_ATTRIBUTE_HIDDEN, 0}, ++ { "nouhidden", "nouhidden", FILE_ATTRIBUTE_HIDDEN, 0}, + #endif + #ifdef UF_OFFLINE +- { "nooffline", L"nooffline", UF_OFFLINE, 0}, +- { "nouoffline", L"nouoffline", UF_OFFLINE, 0}, ++ { "nooffline", "nooffline", UF_OFFLINE, 0}, ++ { "nouoffline", "nouoffline", UF_OFFLINE, 0}, + #endif + #ifdef UF_READONLY +- { "nordonly", L"nordonly", UF_READONLY, 0}, +- { "nourdonly", L"nourdonly", UF_READONLY, 0}, +- { "noreadonly", L"noreadonly", UF_READONLY, 0}, ++ { "nordonly", "nordonly", UF_READONLY, 0}, ++ { "nourdonly", "nourdonly", UF_READONLY, 0}, ++ { "noreadonly", "noreadonly", UF_READONLY, 0}, + #endif + #ifdef FILE_ATTRIBUTE_READONLY +- { "nordonly", L"nordonly", FILE_ATTRIBUTE_READONLY, 0}, +- { "nourdonly", L"nourdonly", FILE_ATTRIBUTE_READONLY, 0}, +- { "noreadonly", L"noreadonly", FILE_ATTRIBUTE_READONLY, 0}, ++ { "nordonly", "nordonly", FILE_ATTRIBUTE_READONLY, 0}, ++ { "nourdonly", "nourdonly", FILE_ATTRIBUTE_READONLY, 0}, ++ { "noreadonly", "noreadonly", FILE_ATTRIBUTE_READONLY, 0}, + #endif + #ifdef UF_SPARSE +- { "nosparse", L"nosparse", UF_SPARSE, 0}, +- { "nousparse", L"nousparse", UF_SPARSE, 0}, ++ { "nosparse", "nosparse", UF_SPARSE, 0}, ++ { "nousparse", "nousparse", UF_SPARSE, 0}, + #endif + #ifdef UF_REPARSE +- { "noreparse", L"noreparse", UF_REPARSE, 0}, +- { "noureparse", L"noureparse", UF_REPARSE, 0}, ++ { "noreparse", "noreparse", UF_REPARSE, 0}, ++ { "noureparse", "noureparse", UF_REPARSE, 0}, + #endif + #ifdef UF_SYSTEM +- { "nosystem", L"nosystem", UF_SYSTEM, 0}, +- { "nousystem", L"nousystem", UF_SYSTEM, 0}, ++ { "nosystem", "nosystem", UF_SYSTEM, 0}, ++ { "nousystem", "nousystem", UF_SYSTEM, 0}, + #endif + #ifdef FILE_ATTRIBUTE_SYSTEM +- { "nosystem", L"nosystem", FILE_ATTRIBUTE_SYSTEM, 0}, +- { "nousystem", L"nousystem", FILE_ATTRIBUTE_SYSTEM, 0}, ++ { "nosystem", "nosystem", FILE_ATTRIBUTE_SYSTEM, 0}, ++ { "nousystem", "nousystem", FILE_ATTRIBUTE_SYSTEM, 0}, + #endif + #if defined(FS_UNRM_FL) /* 'u' */ +- { "noundel", L"noundel", FS_UNRM_FL, 0}, ++ { "noundel", "noundel", FS_UNRM_FL, 0}, + #elif defined(EXT2_UNRM_FL) +- { "noundel", L"noundel", EXT2_UNRM_FL, 0}, ++ { "noundel", "noundel", EXT2_UNRM_FL, 0}, + #endif + + #if defined(FS_COMPR_FL) /* 'c' */ +- { "nocompress", L"nocompress", FS_COMPR_FL, 0}, ++ { "nocompress", "nocompress", FS_COMPR_FL, 0}, + #elif defined(EXT2_COMPR_FL) +- { "nocompress", L"nocompress", EXT2_COMPR_FL, 0}, ++ { "nocompress", "nocompress", EXT2_COMPR_FL, 0}, + #endif + + #if defined(FS_NOATIME_FL) /* 'A' */ +- { "noatime", L"noatime", 0, FS_NOATIME_FL}, ++ { "noatime", "noatime", 0, FS_NOATIME_FL}, + #elif defined(EXT2_NOATIME_FL) +- { "noatime", L"noatime", 0, EXT2_NOATIME_FL}, ++ { "noatime", "noatime", 0, EXT2_NOATIME_FL}, + #endif + #if defined(FS_DIRSYNC_FL) /* 'D' */ +- { "nodirsync", L"nodirsync", FS_DIRSYNC_FL, 0}, ++ { "nodirsync", "nodirsync", FS_DIRSYNC_FL, 0}, + #elif defined(EXT2_DIRSYNC_FL) +- { "nodirsync", L"nodirsync", EXT2_DIRSYNC_FL, 0}, ++ { "nodirsync", "nodirsync", EXT2_DIRSYNC_FL, 0}, + #endif + #if defined(FS_JOURNAL_DATA_FL) /* 'j' */ +- { "nojournal-data",L"nojournal-data", FS_JOURNAL_DATA_FL, 0}, +- { "nojournal", L"nojournal", FS_JOURNAL_DATA_FL, 0}, ++ { "nojournal-data","nojournal-data", FS_JOURNAL_DATA_FL, 0}, ++ { "nojournal", "nojournal", FS_JOURNAL_DATA_FL, 0}, + #elif defined(EXT3_JOURNAL_DATA_FL) +- { "nojournal-data",L"nojournal-data", EXT3_JOURNAL_DATA_FL, 0}, +- { "nojournal", L"nojournal", EXT3_JOURNAL_DATA_FL, 0}, ++ { "nojournal-data","nojournal-data", EXT3_JOURNAL_DATA_FL, 0}, ++ { "nojournal", "nojournal", EXT3_JOURNAL_DATA_FL, 0}, + #endif + #if defined(FS_SECRM_FL) /* 's' */ +- { "nosecdel", L"nosecdel", FS_SECRM_FL, 0}, +- { "nosecuredeletion",L"nosecuredeletion",FS_SECRM_FL, 0}, ++ { "nosecdel", "nosecdel", FS_SECRM_FL, 0}, ++ { "nosecuredeletion","nosecuredeletion",FS_SECRM_FL, 0}, + #elif defined(EXT2_SECRM_FL) +- { "nosecdel", L"nosecdel", EXT2_SECRM_FL, 0}, +- { "nosecuredeletion",L"nosecuredeletion",EXT2_SECRM_FL, 0}, ++ { "nosecdel", "nosecdel", EXT2_SECRM_FL, 0}, ++ { "nosecuredeletion","nosecuredeletion",EXT2_SECRM_FL, 0}, + #endif + #if defined(FS_SYNC_FL) /* 'S' */ +- { "nosync", L"nosync", FS_SYNC_FL, 0}, ++ { "nosync", "nosync", FS_SYNC_FL, 0}, + #elif defined(EXT2_SYNC_FL) +- { "nosync", L"nosync", EXT2_SYNC_FL, 0}, ++ { "nosync", "nosync", EXT2_SYNC_FL, 0}, + #endif + #if defined(FS_NOTAIL_FL) /* 't' */ +- { "notail", L"notail", 0, FS_NOTAIL_FL}, ++ { "notail", "notail", 0, FS_NOTAIL_FL}, + #elif defined(EXT2_NOTAIL_FL) +- { "notail", L"notail", 0, EXT2_NOTAIL_FL}, ++ { "notail", "notail", 0, EXT2_NOTAIL_FL}, + #endif + #if defined(FS_TOPDIR_FL) /* 'T' */ +- { "notopdir", L"notopdir", FS_TOPDIR_FL, 0}, ++ { "notopdir", "notopdir", FS_TOPDIR_FL, 0}, + #elif defined(EXT2_TOPDIR_FL) +- { "notopdir", L"notopdir", EXT2_TOPDIR_FL, 0}, ++ { "notopdir", "notopdir", EXT2_TOPDIR_FL, 0}, + #endif + #ifdef FS_NOCOW_FL /* 'C' */ +- { "nocow", L"nocow", 0, FS_NOCOW_FL}, ++ { "nocow", "nocow", 0, FS_NOCOW_FL}, + #endif + #ifdef FS_PROJINHERIT_FL /* 'P' */ +- { "noprojinherit",L"noprojinherit", FS_PROJINHERIT_FL, 0}, ++ { "noprojinherit","noprojinherit", FS_PROJINHERIT_FL, 0}, + #endif + { NULL, NULL, 0, 0} + }; +@@ -1987,13 +1987,13 @@ ae_strtofflags(const char *s, unsigned l + * This version is also const-correct and does not modify the + * provided string. + */ +-static const wchar_t * +-ae_wcstofflags(const wchar_t *s, unsigned long *setp, unsigned long *clrp) ++static const char * ++ae_wcstofflags(const char *s, unsigned long *setp, unsigned long *clrp) + { +- const wchar_t *start, *end; ++ const char *start, *end; + const struct flag *flag; + unsigned long set, clear; +- const wchar_t *failed; ++ const char *failed; + + set = clear = 0; + start = s; +@@ -2053,14 +2053,14 @@ main(int argc, char **argv) + { + struct archive_entry *entry = archive_entry_new(); + unsigned long set, clear; +- const wchar_t *remainder; ++ const char *remainder; + +- remainder = archive_entry_copy_fflags_text_w(entry, L"nosappnd dump archive,,,,,,,"); ++ remainder = archive_entry_copy_fflags_text_w(entry, "nosappnd dump archive,,,,,,,"); + archive_entry_fflags(entry, &set, &clear); + +- wprintf(L"set=0x%lX clear=0x%lX remainder='%ls'\n", set, clear, remainder); ++ wprintf("set=0x%lX clear=0x%lX remainder='%ls'\n", set, clear, remainder); + +- wprintf(L"new flags='%s'\n", archive_entry_fflags_text(entry)); ++ wprintf("new flags='%s'\n", archive_entry_fflags_text(entry)); + return (0); + } + #endif +diff -urp a/Utilities/cmlibarchive/libarchive/archive_entry.h b/Utilities/cmlibarchive/libarchive/archive_entry.h +--- a/Utilities/cmlibarchive/libarchive/archive_entry.h 2021-01-28 18:58:45.000000000 +0330 ++++ b/Utilities/cmlibarchive/libarchive/archive_entry.h 2021-02-11 18:43:34.442529226 +0330 +@@ -41,7 +41,7 @@ + */ + + #include <sys/types.h> +-#include <stddef.h> /* for wchar_t */ ++#include <stddef.h> /* for char */ + #include <stdint.h> + #include <time.h> + +@@ -253,10 +253,10 @@ __LA_DECL const char *archive_entry_ffla + __LA_DECL la_int64_t archive_entry_gid(struct archive_entry *); + __LA_DECL const char *archive_entry_gname(struct archive_entry *); + __LA_DECL const char *archive_entry_gname_utf8(struct archive_entry *); +-__LA_DECL const wchar_t *archive_entry_gname_w(struct archive_entry *); ++__LA_DECL const char *archive_entry_gname_w(struct archive_entry *); + __LA_DECL const char *archive_entry_hardlink(struct archive_entry *); + __LA_DECL const char *archive_entry_hardlink_utf8(struct archive_entry *); +-__LA_DECL const wchar_t *archive_entry_hardlink_w(struct archive_entry *); ++__LA_DECL const char *archive_entry_hardlink_w(struct archive_entry *); + __LA_DECL la_int64_t archive_entry_ino(struct archive_entry *); + __LA_DECL la_int64_t archive_entry_ino64(struct archive_entry *); + __LA_DECL int archive_entry_ino_is_set(struct archive_entry *); +@@ -267,24 +267,24 @@ __LA_DECL int archive_entry_mtime_is_s + __LA_DECL unsigned int archive_entry_nlink(struct archive_entry *); + __LA_DECL const char *archive_entry_pathname(struct archive_entry *); + __LA_DECL const char *archive_entry_pathname_utf8(struct archive_entry *); +-__LA_DECL const wchar_t *archive_entry_pathname_w(struct archive_entry *); ++__LA_DECL const char *archive_entry_pathname_w(struct archive_entry *); + __LA_DECL __LA_MODE_T archive_entry_perm(struct archive_entry *); + __LA_DECL dev_t archive_entry_rdev(struct archive_entry *); + __LA_DECL dev_t archive_entry_rdevmajor(struct archive_entry *); + __LA_DECL dev_t archive_entry_rdevminor(struct archive_entry *); + __LA_DECL const char *archive_entry_sourcepath(struct archive_entry *); +-__LA_DECL const wchar_t *archive_entry_sourcepath_w(struct archive_entry *); ++__LA_DECL const char *archive_entry_sourcepath_w(struct archive_entry *); + __LA_DECL la_int64_t archive_entry_size(struct archive_entry *); + __LA_DECL int archive_entry_size_is_set(struct archive_entry *); + __LA_DECL const char *archive_entry_strmode(struct archive_entry *); + __LA_DECL const char *archive_entry_symlink(struct archive_entry *); + __LA_DECL const char *archive_entry_symlink_utf8(struct archive_entry *); + __LA_DECL int archive_entry_symlink_type(struct archive_entry *); +-__LA_DECL const wchar_t *archive_entry_symlink_w(struct archive_entry *); ++__LA_DECL const char *archive_entry_symlink_w(struct archive_entry *); + __LA_DECL la_int64_t archive_entry_uid(struct archive_entry *); + __LA_DECL const char *archive_entry_uname(struct archive_entry *); + __LA_DECL const char *archive_entry_uname_utf8(struct archive_entry *); +-__LA_DECL const wchar_t *archive_entry_uname_w(struct archive_entry *); ++__LA_DECL const char *archive_entry_uname_w(struct archive_entry *); + __LA_DECL int archive_entry_is_data_encrypted(struct archive_entry *); + __LA_DECL int archive_entry_is_metadata_encrypted(struct archive_entry *); + __LA_DECL int archive_entry_is_encrypted(struct archive_entry *); +@@ -317,25 +317,25 @@ __LA_DECL void archive_entry_set_fflags( + /* Note that all recognized tokens are processed, regardless. */ + __LA_DECL const char *archive_entry_copy_fflags_text(struct archive_entry *, + const char *); +-__LA_DECL const wchar_t *archive_entry_copy_fflags_text_w(struct archive_entry *, +- const wchar_t *); ++__LA_DECL const char *archive_entry_copy_fflags_text_w(struct archive_entry *, ++ const char *); + __LA_DECL void archive_entry_set_gid(struct archive_entry *, la_int64_t); + __LA_DECL void archive_entry_set_gname(struct archive_entry *, const char *); + __LA_DECL void archive_entry_set_gname_utf8(struct archive_entry *, const char *); + __LA_DECL void archive_entry_copy_gname(struct archive_entry *, const char *); +-__LA_DECL void archive_entry_copy_gname_w(struct archive_entry *, const wchar_t *); ++__LA_DECL void archive_entry_copy_gname_w(struct archive_entry *, const char *); + __LA_DECL int archive_entry_update_gname_utf8(struct archive_entry *, const char *); + __LA_DECL void archive_entry_set_hardlink(struct archive_entry *, const char *); + __LA_DECL void archive_entry_set_hardlink_utf8(struct archive_entry *, const char *); + __LA_DECL void archive_entry_copy_hardlink(struct archive_entry *, const char *); +-__LA_DECL void archive_entry_copy_hardlink_w(struct archive_entry *, const wchar_t *); ++__LA_DECL void archive_entry_copy_hardlink_w(struct archive_entry *, const char *); + __LA_DECL int archive_entry_update_hardlink_utf8(struct archive_entry *, const char *); + __LA_DECL void archive_entry_set_ino(struct archive_entry *, la_int64_t); + __LA_DECL void archive_entry_set_ino64(struct archive_entry *, la_int64_t); + __LA_DECL void archive_entry_set_link(struct archive_entry *, const char *); + __LA_DECL void archive_entry_set_link_utf8(struct archive_entry *, const char *); + __LA_DECL void archive_entry_copy_link(struct archive_entry *, const char *); +-__LA_DECL void archive_entry_copy_link_w(struct archive_entry *, const wchar_t *); ++__LA_DECL void archive_entry_copy_link_w(struct archive_entry *, const char *); + __LA_DECL int archive_entry_update_link_utf8(struct archive_entry *, const char *); + __LA_DECL void archive_entry_set_mode(struct archive_entry *, __LA_MODE_T); + __LA_DECL void archive_entry_set_mtime(struct archive_entry *, time_t, long); +@@ -344,7 +344,7 @@ __LA_DECL void archive_entry_set_nlink(s + __LA_DECL void archive_entry_set_pathname(struct archive_entry *, const char *); + __LA_DECL void archive_entry_set_pathname_utf8(struct archive_entry *, const char *); + __LA_DECL void archive_entry_copy_pathname(struct archive_entry *, const char *); +-__LA_DECL void archive_entry_copy_pathname_w(struct archive_entry *, const wchar_t *); ++__LA_DECL void archive_entry_copy_pathname_w(struct archive_entry *, const char *); + __LA_DECL int archive_entry_update_pathname_utf8(struct archive_entry *, const char *); + __LA_DECL void archive_entry_set_perm(struct archive_entry *, __LA_MODE_T); + __LA_DECL void archive_entry_set_rdev(struct archive_entry *, dev_t); +@@ -353,18 +353,18 @@ __LA_DECL void archive_entry_set_rdevmin + __LA_DECL void archive_entry_set_size(struct archive_entry *, la_int64_t); + __LA_DECL void archive_entry_unset_size(struct archive_entry *); + __LA_DECL void archive_entry_copy_sourcepath(struct archive_entry *, const char *); +-__LA_DECL void archive_entry_copy_sourcepath_w(struct archive_entry *, const wchar_t *); ++__LA_DECL void archive_entry_copy_sourcepath_w(struct archive_entry *, const char *); + __LA_DECL void archive_entry_set_symlink(struct archive_entry *, const char *); + __LA_DECL void archive_entry_set_symlink_type(struct archive_entry *, int); + __LA_DECL void archive_entry_set_symlink_utf8(struct archive_entry *, const char *); + __LA_DECL void archive_entry_copy_symlink(struct archive_entry *, const char *); +-__LA_DECL void archive_entry_copy_symlink_w(struct archive_entry *, const wchar_t *); ++__LA_DECL void archive_entry_copy_symlink_w(struct archive_entry *, const char *); + __LA_DECL int archive_entry_update_symlink_utf8(struct archive_entry *, const char *); + __LA_DECL void archive_entry_set_uid(struct archive_entry *, la_int64_t); + __LA_DECL void archive_entry_set_uname(struct archive_entry *, const char *); + __LA_DECL void archive_entry_set_uname_utf8(struct archive_entry *, const char *); + __LA_DECL void archive_entry_copy_uname(struct archive_entry *, const char *); +-__LA_DECL void archive_entry_copy_uname_w(struct archive_entry *, const wchar_t *); ++__LA_DECL void archive_entry_copy_uname_w(struct archive_entry *, const char *); + __LA_DECL int archive_entry_update_uname_utf8(struct archive_entry *, const char *); + __LA_DECL void archive_entry_set_is_data_encrypted(struct archive_entry *, char is_encrypted); + __LA_DECL void archive_entry_set_is_metadata_encrypted(struct archive_entry *, char is_encrypted); +@@ -510,7 +510,7 @@ __LA_DECL int archive_entry_acl_add_ent + int /* qual */, const char * /* name */); + __LA_DECL int archive_entry_acl_add_entry_w(struct archive_entry *, + int /* type */, int /* permset */, int /* tag */, +- int /* qual */, const wchar_t * /* name */); ++ int /* qual */, const char * /* name */); + + /* + * To retrieve the ACL, first "reset", then repeatedly ask for the +@@ -550,12 +550,12 @@ __LA_DECL int archive_entry_acl_next(st + #define ARCHIVE_ENTRY_ACL_STYLE_SEPARATOR_COMMA 0x00000008 + #define ARCHIVE_ENTRY_ACL_STYLE_COMPACT 0x00000010 + +-__LA_DECL wchar_t *archive_entry_acl_to_text_w(struct archive_entry *, ++__LA_DECL char *archive_entry_acl_to_text_w(struct archive_entry *, + la_ssize_t * /* len */, int /* flags */); + __LA_DECL char *archive_entry_acl_to_text(struct archive_entry *, + la_ssize_t * /* len */, int /* flags */); + __LA_DECL int archive_entry_acl_from_text_w(struct archive_entry *, +- const wchar_t * /* wtext */, int /* type */); ++ const char * /* wtext */, int /* type */); + __LA_DECL int archive_entry_acl_from_text(struct archive_entry *, + const char * /* text */, int /* type */); + +@@ -564,7 +564,7 @@ __LA_DECL int archive_entry_acl_from_tex + #define OLD_ARCHIVE_ENTRY_ACL_STYLE_MARK_DEFAULT 2048 + + /* Deprecated functions */ +-__LA_DECL const wchar_t *archive_entry_acl_text_w(struct archive_entry *, ++__LA_DECL const char *archive_entry_acl_text_w(struct archive_entry *, + int /* flags */) __LA_DEPRECATED; + __LA_DECL const char *archive_entry_acl_text(struct archive_entry *, + int /* flags */) __LA_DEPRECATED; +diff -urp a/Utilities/cmlibarchive/libarchive/archive_entry_paths.3 b/Utilities/cmlibarchive/libarchive/archive_entry_paths.3 +--- a/Utilities/cmlibarchive/libarchive/archive_entry_paths.3 2021-01-28 18:58:45.000000000 +0330 ++++ b/Utilities/cmlibarchive/libarchive/archive_entry_paths.3 2021-02-11 18:43:34.415862139 +0330 +@@ -57,14 +57,14 @@ Streaming Archive Library (libarchive, - + .In archive_entry.h + .Ft const char * + .Fn archive_entry_hardlink "struct archive_entry *a" +-.Ft const wchar_t * ++.Ft const char * + .Fn archive_entry_hardlink_w "struct archive_entry *a" + .Ft void + .Fn archive_entry_set_hardlink "struct archive_entry *a" "const char *path" + .Ft void + .Fn archive_entry_copy_hardlink "struct archive_entry *a" "const char *path" + .Ft void +-.Fn archive_entry_copy_hardlink_w "struct archive_entry *a "const wchar_t *path" ++.Fn archive_entry_copy_hardlink_w "struct archive_entry *a "const char *path" + .Ft int + .Fn archive_entry_update_hardlink_utf8 "struct archive_entry *a" "const char *path" + .Ft void +@@ -72,19 +72,19 @@ Streaming Archive Library (libarchive, - + .Ft void + .Fn archive_entry_copy_link "struct archive_entry *a" " const char *path" + .Ft void +-.Fn archive_entry_copy_link_w "struct archive_entry *a" " const wchar_t *path" ++.Fn archive_entry_copy_link_w "struct archive_entry *a" " const char *path" + .Ft int + .Fn archive_entry_update_link_utf8 "struct archive_entry *a" " const char *path" + .Ft const char * + .Fn archive_entry_pathname "struct archive_entry *a" +-.Ft const wchar_t * ++.Ft const char * + .Fn archive_entry_pathname_w "struct archive_entry *a" + .Ft void + .Fn archive_entry_set_pathname "struct archive_entry *a" "const char *path" + .Ft void + .Fn archive_entry_copy_pathname "struct archive_entry *a" "const char *path" + .Ft void +-.Fn archive_entry_copy_pathname_w "struct archive_entry *a" "const wchar_t *path" ++.Fn archive_entry_copy_pathname_w "struct archive_entry *a" "const char *path" + .Ft int + .Fn archive_entry_update_pathname_utf8 "struct archive_entry *a" "const char *path" + .Ft const char * +@@ -93,14 +93,14 @@ Streaming Archive Library (libarchive, - + .Fn archive_entry_copy_sourcepath "struct archive_entry *a" "const char *path" + .Ft const char * + .Fn archive_entry_symlink "struct archive_entry *a" +-.Ft const wchar_t * ++.Ft const char * + .Fn archive_entry_symlink_w "struct archive_entry *a" + .Ft void + .Fn archive_entry_set_symlink "struct archive_entry *a" "const char *path" + .Ft void + .Fn archive_entry_copy_symlink "struct archive_entry *a" "const char *path" + .Ft void +-.Fn archive_entry_copy_symlink_w "struct archive_entry *a" "const wchar_t *path" ++.Fn archive_entry_copy_symlink_w "struct archive_entry *a" "const char *path" + .Ft int + .Fn archive_entry_update_symlink_utf8 "struct archive_entry *a" "const char *path" + .Sh DESCRIPTION +@@ -124,10 +124,10 @@ Destination of the symbolic link. + .El + .Pp + Path names can be provided in one of three different ways: +-.Bl -tag -width "wchar_t *" ++.Bl -tag -width "char *" + .It char * + Multibyte strings in the current locale. +-.It wchar_t * ++.It char * + Wide character strings in the current locale. + The accessor functions are named + .Fn XXX_w . +diff -urp a/Utilities/cmlibarchive/libarchive/archive_entry_perms.3 b/Utilities/cmlibarchive/libarchive/archive_entry_perms.3 +--- a/Utilities/cmlibarchive/libarchive/archive_entry_perms.3 2021-01-28 18:58:45.000000000 +0330 ++++ b/Utilities/cmlibarchive/libarchive/archive_entry_perms.3 2021-02-11 18:43:34.412528752 +0330 +@@ -72,26 +72,26 @@ Streaming Archive Library (libarchive, - + .Fn archive_entry_strmode "struct archive_entry *a" + .Ft const char * + .Fn archive_entry_gname "struct archive_entry *a" +-.Ft const wchar_t * ++.Ft const char * + .Fn archive_entry_gname_w "struct archive_entry *a" + .Ft void + .Fn archive_entry_set_gname "struct archive_entry *a" "const char *a" + .Ft void + .Fn archive_entry_copy_gname "struct archive_entry *a" "const char *name" + .Ft void +-.Fn archive_entry_copy_gname_w "struct archive_entry *a" "const wchar_t *name" ++.Fn archive_entry_copy_gname_w "struct archive_entry *a" "const char *name" + .Ft int + .Fn archive_entry_update_gname_utf8 "struct archive_entry *a" "const char *name" + .Ft const char * + .Fn archive_entry_uname "struct archive_entry *a" +-.Ft const wchar_t * ++.Ft const char * + .Fn archive_entry_uname_w "struct archive_entry *a" + .Ft void + .Fn archive_entry_set_uname "struct archive_entry *a" "const char *name" + .Ft void + .Fn archive_entry_copy_uname "struct archive_entry *a" "const char *name" + .Ft void +-.Fn archive_entry_copy_uname_w "struct archive_entry *a" "const wchar_t *name" ++.Fn archive_entry_copy_uname_w "struct archive_entry *a" "const char *name" + .Ft int + .Fn archive_entry_update_uname_utf8 "struct archive_entry *a" "const char *name" + .Ft void +@@ -110,8 +110,8 @@ Streaming Archive Library (libarchive, - + .Fc + .Ft const char * + .Fn archive_entry_copy_fflags_text "struct archive_entry *a" "const char *text" +-.Ft const wchar_t * +-.Fn archive_entry_copy_fflags_text_w "struct archive_entry *a" "const wchar_t *text" ++.Ft const char * ++.Fn archive_entry_copy_fflags_text_w "struct archive_entry *a" "const char *text" + .Sh DESCRIPTION + .Ss User id, group id and mode + The functions +@@ -134,10 +134,10 @@ returns a string representation of the p + .Xr ls 1 . + .Ss User and group name + User and group names can be provided in one of three different ways: +-.Bl -tag -width "wchar_t *" ++.Bl -tag -width "char *" + .It char * + Multibyte strings in the current locale. +-.It wchar_t * ++.It char * + Wide character strings in the current locale. + The accessor functions are named + .Fn XXX_w . +diff -urp a/Utilities/cmlibarchive/libarchive/archive.h b/Utilities/cmlibarchive/libarchive/archive.h +--- a/Utilities/cmlibarchive/libarchive/archive.h 2021-01-28 18:58:45.000000000 +0330 ++++ b/Utilities/cmlibarchive/libarchive/archive.h 2021-02-11 18:43:34.382528279 +0330 +@@ -39,7 +39,7 @@ + #define ARCHIVE_VERSION_NUMBER 3004002 + + #include <sys/stat.h> +-#include <stddef.h> /* for wchar_t */ ++#include <stddef.h> /* for char */ + #include <stdio.h> /* For FILE * */ + #include <time.h> /* For time_t */ + +@@ -525,7 +525,7 @@ __LA_DECL int archive_read_open_filename + __LA_DECL int archive_read_open_filenames(struct archive *, + const char **_filenames, size_t _block_size); + __LA_DECL int archive_read_open_filename_w(struct archive *, +- const wchar_t *_filename, size_t _block_size); ++ const char *_filename, size_t _block_size); + /* archive_read_open_file() is a deprecated synonym for ..._open_filename(). */ + __LA_DECL int archive_read_open_file(struct archive *, + const char *_filename, size_t _block_size) __LA_DEPRECATED; +@@ -820,7 +820,7 @@ __LA_DECL int archive_write_open(struct + __LA_DECL int archive_write_open_fd(struct archive *, int _fd); + __LA_DECL int archive_write_open_filename(struct archive *, const char *_file); + __LA_DECL int archive_write_open_filename_w(struct archive *, +- const wchar_t *_file); ++ const char *_file); + /* A deprecated synonym for archive_write_open_filename() */ + __LA_DECL int archive_write_open_file(struct archive *, const char *_file) + __LA_DEPRECATED; +@@ -976,7 +976,7 @@ __LA_DECL int archive_read_disk_set_unam + void (* /* cleanup_fn */)(void *)); + /* Start traversal. */ + __LA_DECL int archive_read_disk_open(struct archive *, const char *); +-__LA_DECL int archive_read_disk_open_w(struct archive *, const wchar_t *); ++__LA_DECL int archive_read_disk_open_w(struct archive *, const char *); + /* + * Request that current entry be visited. If you invoke it on every + * directory, you'll get a physical traversal. This is ignored if the +@@ -1099,21 +1099,21 @@ __LA_DECL int archive_match_set_inclusio + /* Add exclusion pathname pattern. */ + __LA_DECL int archive_match_exclude_pattern(struct archive *, const char *); + __LA_DECL int archive_match_exclude_pattern_w(struct archive *, +- const wchar_t *); ++ const char *); + /* Add exclusion pathname pattern from file. */ + __LA_DECL int archive_match_exclude_pattern_from_file(struct archive *, + const char *, int _nullSeparator); + __LA_DECL int archive_match_exclude_pattern_from_file_w(struct archive *, +- const wchar_t *, int _nullSeparator); ++ const char *, int _nullSeparator); + /* Add inclusion pathname pattern. */ + __LA_DECL int archive_match_include_pattern(struct archive *, const char *); + __LA_DECL int archive_match_include_pattern_w(struct archive *, +- const wchar_t *); ++ const char *); + /* Add inclusion pathname pattern from file. */ + __LA_DECL int archive_match_include_pattern_from_file(struct archive *, + const char *, int _nullSeparator); + __LA_DECL int archive_match_include_pattern_from_file_w(struct archive *, +- const wchar_t *, int _nullSeparator); ++ const char *, int _nullSeparator); + /* + * How to get statistic information for inclusion patterns. + */ +@@ -1124,7 +1124,7 @@ __LA_DECL int archive_match_path_unmatch + __LA_DECL int archive_match_path_unmatched_inclusions_next( + struct archive *, const char **); + __LA_DECL int archive_match_path_unmatched_inclusions_next_w( +- struct archive *, const wchar_t **); ++ struct archive *, const char **); + + /* + * Test if a file is excluded by its time stamp. +@@ -1154,12 +1154,12 @@ __LA_DECL int archive_match_include_time + __LA_DECL int archive_match_include_date(struct archive *, int _flag, + const char *_datestr); + __LA_DECL int archive_match_include_date_w(struct archive *, int _flag, +- const wchar_t *_datestr); ++ const char *_datestr); + /* Set inclusion time by a particular file. */ + __LA_DECL int archive_match_include_file_time(struct archive *, + int _flag, const char *_pathname); + __LA_DECL int archive_match_include_file_time_w(struct archive *, +- int _flag, const wchar_t *_pathname); ++ int _flag, const char *_pathname); + /* Add exclusion entry. */ + __LA_DECL int archive_match_exclude_entry(struct archive *, + int _flag, struct archive_entry *); +@@ -1175,10 +1175,10 @@ __LA_DECL int archive_match_include_uid( + __LA_DECL int archive_match_include_gid(struct archive *, la_int64_t); + __LA_DECL int archive_match_include_uname(struct archive *, const char *); + __LA_DECL int archive_match_include_uname_w(struct archive *, +- const wchar_t *); ++ const char *); + __LA_DECL int archive_match_include_gname(struct archive *, const char *); + __LA_DECL int archive_match_include_gname_w(struct archive *, +- const wchar_t *); ++ const char *); + + /* Utility functions */ + /* Convenience function to sort a NULL terminated list of strings */ +diff -urp a/Utilities/cmlibarchive/libarchive/archive_match.c b/Utilities/cmlibarchive/libarchive/archive_match.c +--- a/Utilities/cmlibarchive/libarchive/archive_match.c 2021-01-28 18:58:45.000000000 +0330 ++++ b/Utilities/cmlibarchive/libarchive/archive_match.c 2021-02-11 18:43:34.449195998 +0330 +@@ -144,7 +144,7 @@ static int add_owner_name(struct archive + static int add_pattern_mbs(struct archive_match *, struct match_list *, + const char *); + static int add_pattern_wcs(struct archive_match *, struct match_list *, +- const wchar_t *); ++ const char *); + static int cmp_key_mbs(const struct archive_rb_node *, const void *); + static int cmp_key_wcs(const struct archive_rb_node *, const void *); + static int cmp_node_mbs(const struct archive_rb_node *, +@@ -166,7 +166,7 @@ static int match_owner_name_mbs(struct a + struct match_list *, const char *); + #else + static int match_owner_name_wcs(struct archive_match *, +- struct match_list *, const wchar_t *); ++ struct match_list *, const char *); + #endif + static int match_path_exclusion(struct archive_match *, + struct match *, int, const void *); +@@ -180,10 +180,10 @@ static int set_timefilter(struct archive + static int set_timefilter_pathname_mbs(struct archive_match *, + int, const char *); + static int set_timefilter_pathname_wcs(struct archive_match *, +- int, const wchar_t *); ++ int, const char *); + static int set_timefilter_date(struct archive_match *, int, const char *); + static int set_timefilter_date_w(struct archive_match *, int, +- const wchar_t *); ++ const char *); + static int time_excluded(struct archive_match *, + struct archive_entry *); + static int validate_time_flag(struct archive *, int, const char *); +@@ -329,7 +329,7 @@ archive_match_exclude_pattern(struct arc + } + + int +-archive_match_exclude_pattern_w(struct archive *_a, const wchar_t *pattern) ++archive_match_exclude_pattern_w(struct archive *_a, const char *pattern) + { + struct archive_match *a; + int r; +@@ -363,7 +363,7 @@ archive_match_exclude_pattern_from_file( + + int + archive_match_exclude_pattern_from_file_w(struct archive *_a, +- const wchar_t *pathname, int nullSeparator) ++ const char *pathname, int nullSeparator) + { + struct archive_match *a; + +@@ -395,7 +395,7 @@ archive_match_include_pattern(struct arc + } + + int +-archive_match_include_pattern_w(struct archive *_a, const wchar_t *pattern) ++archive_match_include_pattern_w(struct archive *_a, const char *pattern) + { + struct archive_match *a; + int r; +@@ -429,7 +429,7 @@ archive_match_include_pattern_from_file( + + int + archive_match_include_pattern_from_file_w(struct archive *_a, +- const wchar_t *pathname, int nullSeparator) ++ const char *pathname, int nullSeparator) + { + struct archive_match *a; + +@@ -530,7 +530,7 @@ archive_match_path_unmatched_inclusions_ + + int + archive_match_path_unmatched_inclusions_next_w(struct archive *_a, +- const wchar_t **_p) ++ const char **_p) + { + struct archive_match *a; + const void *v; +@@ -541,7 +541,7 @@ archive_match_path_unmatched_inclusions_ + a = (struct archive_match *)_a; + + r = match_list_unmatched_inclusions_next(a, &(a->inclusions), 0, &v); +- *_p = (const wchar_t *)v; ++ *_p = (const char *)v; + return (r); + } + +@@ -570,7 +570,7 @@ add_pattern_mbs(struct archive_match *a, + + static int + add_pattern_wcs(struct archive_match *a, struct match_list *list, +- const wchar_t *pattern) ++ const char *pattern) + { + struct match *match; + size_t len; +@@ -788,10 +788,10 @@ match_path_exclusion(struct archive_matc + if (r == 0) + return (archive_pathmatch(p, (const char *)pn, flag)); + } else { +- const wchar_t *p; ++ const char *p; + r = archive_mstring_get_wcs(&(a->archive), &(m->pattern), &p); + if (r == 0) +- return (archive_pathmatch_w(p, (const wchar_t *)pn, ++ return (archive_pathmatch_w(p, (const char *)pn, + flag)); + } + if (errno == ENOMEM) +@@ -819,10 +819,10 @@ match_path_inclusion(struct archive_matc + if (r == 0) + return (archive_pathmatch(p, (const char *)pn, flag)); + } else { +- const wchar_t *p; ++ const char *p; + r = archive_mstring_get_wcs(&(a->archive), &(m->pattern), &p); + if (r == 0) +- return (archive_pathmatch_w(p, (const wchar_t *)pn, ++ return (archive_pathmatch_w(p, (const char *)pn, + flag)); + } + if (errno == ENOMEM) +@@ -892,13 +892,13 @@ match_list_unmatched_inclusions_next(str + p = ""; + *vp = p; + } else { +- const wchar_t *p; ++ const char *p; + r = archive_mstring_get_wcs(&(a->archive), + &(m->pattern), &p); + if (r < 0 && errno == ENOMEM) + return (error_nomem(a)); + if (p == NULL) +- p = L""; ++ p = ""; + *vp = p; + } + list->unmatched_next = m->next; +@@ -941,7 +941,7 @@ archive_match_include_date(struct archiv + + int + archive_match_include_date_w(struct archive *_a, int flag, +- const wchar_t *datestr) ++ const char *datestr) + { + int r; + +@@ -967,7 +967,7 @@ archive_match_include_file_time(struct a + + int + archive_match_include_file_time_w(struct archive *_a, int flag, +- const wchar_t *pathname) ++ const char *pathname) + { + int r; + +@@ -1117,7 +1117,7 @@ set_timefilter_date(struct archive_match + + static int + set_timefilter_date_w(struct archive_match *a, int timetype, +- const wchar_t *datestr) ++ const char *datestr) + { + struct archive_string as; + time_t t; +@@ -1207,7 +1207,7 @@ set_timefilter_pathname_mbs(struct archi + + static int + set_timefilter_pathname_wcs(struct archive_match *a, int timetype, +- const wchar_t *path) ++ const char *path) + { + HANDLE h; + WIN32_FIND_DATAW d; +@@ -1270,7 +1270,7 @@ set_timefilter_pathname_mbs(struct archi + + static int + set_timefilter_pathname_wcs(struct archive_match *a, int timetype, +- const wchar_t *path) ++ const char *path) + { + struct archive_string as; + int r; +@@ -1336,7 +1336,7 @@ cmp_node_wcs(const struct archive_rb_nod + { + struct match_file *f1 = (struct match_file *)(uintptr_t)n1; + struct match_file *f2 = (struct match_file *)(uintptr_t)n2; +- const wchar_t *p1, *p2; ++ const char *p1, *p2; + + archive_mstring_get_wcs(NULL, &(f1->pathname), &p1); + archive_mstring_get_wcs(NULL, &(f2->pathname), &p2); +@@ -1351,12 +1351,12 @@ static int + cmp_key_wcs(const struct archive_rb_node *n, const void *key) + { + struct match_file *f = (struct match_file *)(uintptr_t)n; +- const wchar_t *p; ++ const char *p; + + archive_mstring_get_wcs(NULL, &(f->pathname), &p); + if (p == NULL) + return (-1); +- return (wcscmp(p, (const wchar_t *)key)); ++ return (wcscmp(p, (const char *)key)); + } + + static void +@@ -1644,7 +1644,7 @@ archive_match_include_uname(struct archi + } + + int +-archive_match_include_uname_w(struct archive *_a, const wchar_t *uname) ++archive_match_include_uname_w(struct archive *_a, const char *uname) + { + struct archive_match *a; + +@@ -1666,7 +1666,7 @@ archive_match_include_gname(struct archi + } + + int +-archive_match_include_gname_w(struct archive *_a, const wchar_t *gname) ++archive_match_include_gname_w(struct archive *_a, const char *gname) + { + struct archive_match *a; + +@@ -1803,10 +1803,10 @@ match_owner_name_mbs(struct archive_matc + #else + static int + match_owner_name_wcs(struct archive_match *a, struct match_list *list, +- const wchar_t *name) ++ const char *name) + { + struct match *m; +- const wchar_t *p; ++ const char *p; + + if (name == NULL || *name == L'\0') + return (0); +diff -urp a/Utilities/cmlibarchive/libarchive/archive_pathmatch.c b/Utilities/cmlibarchive/libarchive/archive_pathmatch.c +--- a/Utilities/cmlibarchive/libarchive/archive_pathmatch.c 2021-01-28 18:58:45.000000000 +0330 ++++ b/Utilities/cmlibarchive/libarchive/archive_pathmatch.c 2021-02-11 18:43:34.425862296 +0330 +@@ -100,10 +100,10 @@ pm_list(const char *start, const char *e + } + + static int +-pm_list_w(const wchar_t *start, const wchar_t *end, const wchar_t c, int flags) ++pm_list_w(const char *start, const char *end, const char c, int flags) + { +- const wchar_t *p = start; +- wchar_t rangeStart = L'\0', nextRangeStart; ++ const char *p = start; ++ char rangeStart = L'\0', nextRangeStart; + int match = 1, nomatch = 0; + + /* This will be used soon... */ +@@ -125,7 +125,7 @@ pm_list_w(const wchar_t *start, const wc + if (*p == c) + return (match); + } else { +- wchar_t rangeEnd = *++p; ++ char rangeEnd = *++p; + if (rangeEnd == L'\\') + rangeEnd = *++p; + if ((rangeStart <= c) && (c <= rangeEnd)) +@@ -158,8 +158,8 @@ pm_slashskip(const char *s) { + return (s); + } + +-static const wchar_t * +-pm_slashskip_w(const wchar_t *s) { ++static const char * ++pm_slashskip_w(const char *s) { + while ((*s == L'/') + || (s[0] == L'.' && s[1] == L'/') + || (s[0] == L'.' && s[1] == L'\0')) +@@ -273,9 +273,9 @@ pm(const char *p, const char *s, int fla + } + + static int +-pm_w(const wchar_t *p, const wchar_t *s, int flags) ++pm_w(const char *p, const char *s, int flags) + { +- const wchar_t *end; ++ const char *end; + + /* + * Ignore leading './', './/', '././', etc. +@@ -419,7 +419,7 @@ __archive_pathmatch(const char *p, const + } + + int +-__archive_pathmatch_w(const wchar_t *p, const wchar_t *s, int flags) ++__archive_pathmatch_w(const char *p, const char *s, int flags) + { + /* Empty pattern only matches the empty string. */ + if (p == NULL || *p == L'\0') +diff -urp a/Utilities/cmlibarchive/libarchive/archive_pathmatch.h b/Utilities/cmlibarchive/libarchive/archive_pathmatch.h +--- a/Utilities/cmlibarchive/libarchive/archive_pathmatch.h 2021-01-28 18:58:45.000000000 +0330 ++++ b/Utilities/cmlibarchive/libarchive/archive_pathmatch.h 2021-02-11 18:43:34.392528437 +0330 +@@ -44,7 +44,7 @@ + * flag above. */ + + int __archive_pathmatch(const char *p, const char *s, int flags); +-int __archive_pathmatch_w(const wchar_t *p, const wchar_t *s, int flags); ++int __archive_pathmatch_w(const char *p, const char *s, int flags); + + #define archive_pathmatch(p, s, f) __archive_pathmatch(p, s, f) + #define archive_pathmatch_w(p, s, f) __archive_pathmatch_w(p, s, f) +diff -urp a/Utilities/cmlibarchive/libarchive/archive_private.h b/Utilities/cmlibarchive/libarchive/archive_private.h +--- a/Utilities/cmlibarchive/libarchive/archive_private.h 2021-01-28 18:58:45.000000000 +0330 ++++ b/Utilities/cmlibarchive/libarchive/archive_private.h 2021-02-11 18:43:34.379194894 +0330 +@@ -154,7 +154,7 @@ void __archive_errx(int retvalue, const + void __archive_ensure_cloexec_flag(int fd); + int __archive_mktemp(const char *tmpdir); + #if defined(_WIN32) && !defined(__CYGWIN__) +-int __archive_mkstemp(wchar_t *template); ++int __archive_mkstemp(char *template); + #else + int __archive_mkstemp(char *template); + #endif +diff -urp a/Utilities/cmlibarchive/libarchive/archive_read_disk_posix.c b/Utilities/cmlibarchive/libarchive/archive_read_disk_posix.c +--- a/Utilities/cmlibarchive/libarchive/archive_read_disk_posix.c 2021-01-28 18:58:45.000000000 +0330 ++++ b/Utilities/cmlibarchive/libarchive/archive_read_disk_posix.c 2021-02-12 14:39:59.857852509 +0330 +@@ -1333,7 +1333,7 @@ archive_read_disk_open(struct archive *_ + } + + int +-archive_read_disk_open_w(struct archive *_a, const wchar_t *pathname) ++archive_read_disk_open_w(struct archive *_a, const char *pathname) + { + struct archive_read_disk *a = (struct archive_read_disk *)_a; + struct archive_string path; +@@ -1344,7 +1344,7 @@ archive_read_disk_open_w(struct archive + "archive_read_disk_open_w"); + archive_clear_error(&a->archive); + +- /* Make a char string from a wchar_t string. */ ++ /* Make a char string from a char string. */ + archive_string_init(&path); + if (archive_string_append_from_wcs(&path, pathname, + wcslen(pathname)) != 0) { +diff -urp a/Utilities/cmlibarchive/libarchive/archive_read_disk_windows.c b/Utilities/cmlibarchive/libarchive/archive_read_disk_windows.c +--- a/Utilities/cmlibarchive/libarchive/archive_read_disk_windows.c 2021-01-28 18:58:45.000000000 +0330 ++++ b/Utilities/cmlibarchive/libarchive/archive_read_disk_windows.c 2021-02-11 18:43:34.362527965 +0330 +@@ -72,7 +72,7 @@ __FBSDID("$FreeBSD$"); + */ + + struct restore_time { +- const wchar_t *full_path; ++ const char *full_path; + FILETIME lastWriteTime; + FILETIME lastAccessTime; + mode_t filetype; +@@ -142,7 +142,7 @@ struct tree { + struct archive_wstring path; + + /* Last path element */ +- const wchar_t *basename; ++ const char *basename; + /* Leading dir length */ + size_t dirname_length; + +@@ -207,14 +207,14 @@ struct tree { + #define needsRestoreTimes 128 + + static int +-tree_dir_next_windows(struct tree *t, const wchar_t *pattern); ++tree_dir_next_windows(struct tree *t, const char *pattern); + + /* Initiate/terminate a tree traversal. */ +-static struct tree *tree_open(const wchar_t *, int, int); +-static struct tree *tree_reopen(struct tree *, const wchar_t *, int); ++static struct tree *tree_open(const char *, int, int); ++static struct tree *tree_reopen(struct tree *, const char *, int); + static void tree_close(struct tree *); + static void tree_free(struct tree *); +-static void tree_push(struct tree *, const wchar_t *, const wchar_t *, ++static void tree_push(struct tree *, const char *, const char *, + int, int64_t, int64_t, struct restore_time *); + + /* +@@ -254,8 +254,8 @@ static int tree_next(struct tree *); + * current path. + * + */ +-static const wchar_t *tree_current_path(struct tree *); +-static const wchar_t *tree_current_access_path(struct tree *); ++static const char *tree_current_path(struct tree *); ++static const char *tree_current_access_path(struct tree *); + + /* + * Request the lstat() or stat() data for the current path. Since the +@@ -283,7 +283,7 @@ static int setup_current_filesystem(stru + static int tree_target_is_same_as_parent(struct tree *, + const BY_HANDLE_FILE_INFORMATION *); + +-static int _archive_read_disk_open_w(struct archive *, const wchar_t *); ++static int _archive_read_disk_open_w(struct archive *, const char *); + static int _archive_read_free(struct archive *); + static int _archive_read_close(struct archive *); + static int _archive_read_data_block(struct archive *, +@@ -299,10 +299,10 @@ static int close_and_restore_time(HANDLE + struct restore_time *); + static int setup_sparse_from_disk(struct archive_read_disk *, + struct archive_entry *, HANDLE); +-static int la_linkname_from_handle(HANDLE, wchar_t **, int *); +-static int la_linkname_from_pathw(const wchar_t *, wchar_t **, int *); ++static int la_linkname_from_handle(HANDLE, char **, int *); ++static int la_linkname_from_pathw(const char *, char **, int *); + static void entry_symlink_from_pathw(struct archive_entry *, +- const wchar_t *path); ++ const char *path); + + typedef struct _REPARSE_DATA_BUFFER { + ULONG ReparseTag; +@@ -337,7 +337,7 @@ typedef struct _REPARSE_DATA_BUFFER { + * outbuf is allocated in the function + */ + static int +-la_linkname_from_handle(HANDLE h, wchar_t **linkname, int *linktype) ++la_linkname_from_handle(HANDLE h, char **linkname, int *linktype) + { + DWORD inbytes; + REPARSE_DATA_BUFFER *buf; +@@ -345,7 +345,7 @@ la_linkname_from_handle(HANDLE h, wchar_ + size_t len; + BOOL ret; + BYTE *indata; +- wchar_t *tbuf; ++ char *tbuf; + + ret = GetFileInformationByHandle(h, &st); + if (ret == 0 || +@@ -376,7 +376,7 @@ la_linkname_from_handle(HANDLE h, wchar_ + return (-1); + } + +- tbuf = malloc(len + 1 * sizeof(wchar_t)); ++ tbuf = malloc(len + 1 * sizeof(char)); + if (tbuf == NULL) { + free(indata); + return (-1); +@@ -386,7 +386,7 @@ la_linkname_from_handle(HANDLE h, wchar_ + [buf->SymbolicLinkReparseBuffer.SubstituteNameOffset], len); + free(indata); + +- tbuf[len / sizeof(wchar_t)] = L'\0'; ++ tbuf[len / sizeof(char)] = L'\0'; + + *linkname = tbuf; + +@@ -411,7 +411,7 @@ la_linkname_from_handle(HANDLE h, wchar_ + * Returns AE_SYMLINK_TYPE_FILE, AE_SYMLINK_TYPE_DIRECTORY or -1 on error + */ + static int +-la_linkname_from_pathw(const wchar_t *path, wchar_t **outbuf, int *linktype) ++la_linkname_from_pathw(const char *path, char **outbuf, int *linktype) + { + HANDLE h; + const DWORD flag = FILE_FLAG_BACKUP_SEMANTICS | +@@ -432,9 +432,9 @@ la_linkname_from_pathw(const wchar_t *pa + } + + static void +-entry_symlink_from_pathw(struct archive_entry *entry, const wchar_t *path) ++entry_symlink_from_pathw(struct archive_entry *entry, const char *path) + { +- wchar_t *linkname = NULL; ++ char *linkname = NULL; + int ret, linktype; + + ret = la_linkname_from_pathw(path, &linkname, &linktype); +@@ -1332,7 +1332,7 @@ archive_read_disk_open(struct archive *_ + "archive_read_disk_open"); + archive_clear_error(&a->archive); + +- /* Make a wchar_t string from a char string. */ ++ /* Make a char string from a char string. */ + archive_string_init(&wpath); + if (archive_wstring_append_from_mbs(&wpath, pathname, + strlen(pathname)) != 0) { +@@ -1341,7 +1341,7 @@ archive_read_disk_open(struct archive *_ + "Can't allocate memory"); + else + archive_set_error(&a->archive, ARCHIVE_ERRNO_MISC, +- "Can't convert a path to a wchar_t string"); ++ "Can't convert a path to a char string"); + a->archive.state = ARCHIVE_STATE_FATAL; + ret = ARCHIVE_FATAL; + } else +@@ -1352,7 +1352,7 @@ archive_read_disk_open(struct archive *_ + } + + int +-archive_read_disk_open_w(struct archive *_a, const wchar_t *pathname) ++archive_read_disk_open_w(struct archive *_a, const char *pathname) + { + struct archive_read_disk *a = (struct archive_read_disk *)_a; + +@@ -1365,7 +1365,7 @@ archive_read_disk_open_w(struct archive + } + + static int +-_archive_read_disk_open_w(struct archive *_a, const wchar_t *pathname) ++_archive_read_disk_open_w(struct archive *_a, const char *pathname) + { + struct archive_read_disk *a = (struct archive_read_disk *)_a; + +@@ -1480,11 +1480,11 @@ archive_read_disk_current_filesystem_is_ + * If symlink is broken, statfs or statvfs will fail. + * Use its directory path instead. + */ +-static wchar_t * ++static char * + safe_path_for_statfs(struct tree *t) + { +- const wchar_t *path; +- wchar_t *cp, *p = NULL; ++ const char *path; ++ char *cp, *p = NULL; + + path = tree_current_access_path(t); + if (tree_current_stat(t) == NULL) { +@@ -1507,8 +1507,8 @@ static int + setup_current_filesystem(struct archive_read_disk *a) + { + struct tree *t = a->tree; +- wchar_t vol[256]; +- wchar_t *path; ++ char vol[256]; ++ char *path; + + t->current_filesystem->synthetic = -1;/* Not supported */ + path = safe_path_for_statfs(t); +@@ -1584,7 +1584,7 @@ close_and_restore_time(HANDLE h, struct + * Add a directory path to the current stack. + */ + static void +-tree_push(struct tree *t, const wchar_t *path, const wchar_t *full_path, ++tree_push(struct tree *t, const char *path, const char *full_path, + int filesystem_id, int64_t dev, int64_t ino, struct restore_time *rt) + { + struct tree_entry *te; +@@ -1617,7 +1617,7 @@ tree_push(struct tree *t, const wchar_t + * Append a name to the current dir path. + */ + static void +-tree_append(struct tree *t, const wchar_t *name, size_t name_length) ++tree_append(struct tree *t, const char *name, size_t name_length) + { + size_t size_needed; + +@@ -1654,7 +1654,7 @@ tree_append(struct tree *t, const wchar_ + * Open a directory tree for traversal. + */ + static struct tree * +-tree_open(const wchar_t *path, int symlink_mode, int restore_time) ++tree_open(const char *path, int symlink_mode, int restore_time) + { + struct tree *t; + +@@ -1667,10 +1667,10 @@ tree_open(const wchar_t *path, int symli + } + + static struct tree * +-tree_reopen(struct tree *t, const wchar_t *path, int restore_time) ++tree_reopen(struct tree *t, const char *path, int restore_time) + { + struct archive_wstring ws; +- wchar_t *pathname, *p, *base; ++ char *pathname, *p, *base; + + t->flags = (restore_time != 0)?needsRestoreTimes:0; + t->visit_type = 0; +@@ -1689,7 +1689,7 @@ tree_reopen(struct tree *t, const wchar_ + t->entry_remaining_bytes = 0; + t->initial_filesystem_id = -1; + +- /* Get wchar_t strings from char strings. */ ++ /* Get char strings from char strings. */ + archive_string_init(&ws); + archive_wstrcpy(&ws, path); + pathname = ws.s; +@@ -1834,7 +1834,7 @@ tree_next(struct tree *t) + } + + if (t->stack->flags & needsFirstVisit) { +- wchar_t *d = t->stack->name.s; ++ char *d = t->stack->name.s; + t->stack->flags &= ~needsFirstVisit; + if (!(d[0] == L'/' && d[1] == L'/' && + d[2] == L'?' && d[3] == L'/') && +@@ -1877,7 +1877,7 @@ tree_next(struct tree *t) + return (t->visit_type); + } else if (t->stack->flags & needsOpen) { + t->stack->flags &= ~needsOpen; +- r = tree_dir_next_windows(t, L"*"); ++ r = tree_dir_next_windows(t, "*"); + if (r == 0) + continue; + return (r); +@@ -1898,9 +1898,9 @@ tree_next(struct tree *t) + } + + static int +-tree_dir_next_windows(struct tree *t, const wchar_t *pattern) ++tree_dir_next_windows(struct tree *t, const char *pattern) + { +- const wchar_t *name; ++ const char *name; + size_t namelen; + int r; + +@@ -1967,7 +1967,7 @@ fileTimeToUtc(const FILETIME *filetime, + } + + static void +-entry_copy_bhfi(struct archive_entry *entry, const wchar_t *path, ++entry_copy_bhfi(struct archive_entry *entry, const char *path, + const WIN32_FIND_DATAW *findData, + const BY_HANDLE_FILE_INFORMATION *bhfi) + { +@@ -2006,7 +2006,7 @@ entry_copy_bhfi(struct archive_entry *en + } else if (bhfi->dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY) + mode |= S_IFDIR | S_IXUSR | S_IXGRP | S_IXOTH; + else { +- const wchar_t *p; ++ const char *p; + + mode |= S_IFREG; + p = wcsrchr(path, L'.'); +@@ -2152,7 +2152,7 @@ tree_target_is_same_as_parent(struct tre + /* + * Return the access path for the entry just returned from tree_next(). + */ +-static const wchar_t * ++static const char * + tree_current_access_path(struct tree *t) + { + return (t->full_path.s); +@@ -2161,7 +2161,7 @@ tree_current_access_path(struct tree *t) + /* + * Return the full path for the entry just returned from tree_next(). + */ +-static const wchar_t * ++static const char * + tree_current_path(struct tree *t) + { + return (t->path.s); +@@ -2223,8 +2223,8 @@ archive_read_disk_entry_from_file(struct + struct archive_entry *entry, int fd, const struct stat *st) + { + struct archive_read_disk *a = (struct archive_read_disk *)_a; +- const wchar_t *path; +- const wchar_t *wname; ++ const char *path; ++ const char *wname; + const char *name; + HANDLE h; + BY_HANDLE_FILE_INFORMATION bhfi; +diff -urp a/Utilities/cmlibarchive/libarchive/archive_read_open_filename.c b/Utilities/cmlibarchive/libarchive/archive_read_open_filename.c +--- a/Utilities/cmlibarchive/libarchive/archive_read_open_filename.c 2021-01-28 18:58:45.000000000 +0330 ++++ b/Utilities/cmlibarchive/libarchive/archive_read_open_filename.c 2021-02-11 18:43:34.452529383 +0330 +@@ -79,7 +79,7 @@ struct read_file_data { + enum fnt_e { FNT_STDIN, FNT_MBS, FNT_WCS } filename_type; + union { + char m[1];/* MBS filename. */ +- wchar_t w[1];/* WCS filename. */ ++ char w[1];/* WCS filename. */ + } filename; /* Must be last! */ + }; + +@@ -156,11 +156,11 @@ no_memory: + } + + int +-archive_read_open_filename_w(struct archive *a, const wchar_t *wfilename, ++archive_read_open_filename_w(struct archive *a, const char *wfilename, + size_t block_size) + { + struct read_file_data *mine = (struct read_file_data *)calloc(1, +- sizeof(*mine) + wcslen(wfilename) * sizeof(wchar_t)); ++ sizeof(*mine) + wcslen(wfilename) * sizeof(char)); + if (!mine) + { + archive_set_error(a, ENOMEM, "No memory"); +@@ -177,8 +177,8 @@ archive_read_open_filename_w(struct arch + wcscpy(mine->filename.w, wfilename); + #else + /* +- * POSIX system does not support a wchar_t interface for +- * open() system call, so we have to translate a wchar_t ++ * POSIX system does not support a char interface for ++ * open() system call, so we have to translate a char + * filename to multi-byte one and use it. + */ + struct archive_string fn; +@@ -221,7 +221,7 @@ file_open(struct archive *a, void *clien + struct read_file_data *mine = (struct read_file_data *)client_data; + void *buffer; + const char *filename = NULL; +- const wchar_t *wfilename = NULL; ++ const char *wfilename = NULL; + int fd = -1; + int is_disk_like = 0; + #if defined(__FreeBSD__) || defined(__FreeBSD_kernel__) +@@ -262,7 +262,7 @@ file_open(struct archive *a, void *clien + wfilename = mine->filename.w; + fd = _wopen(wfilename, O_RDONLY | O_BINARY); + if (fd < 0 && errno == ENOENT) { +- wchar_t *fullpath; ++ char *fullpath; + fullpath = __la_win_permissive_name_w(wfilename); + if (fullpath != NULL) { + fd = _wopen(fullpath, O_RDONLY | O_BINARY); +diff -urp a/Utilities/cmlibarchive/libarchive/archive_read_support_format_7zip.c b/Utilities/cmlibarchive/libarchive/archive_read_support_format_7zip.c +--- a/Utilities/cmlibarchive/libarchive/archive_read_support_format_7zip.c 2021-01-28 18:58:45.000000000 +0330 ++++ b/Utilities/cmlibarchive/libarchive/archive_read_support_format_7zip.c 2021-02-11 18:43:34.365861350 +0330 +@@ -184,7 +184,7 @@ struct _7zip_entry { + size_t name_len; + unsigned char *utf16name; + #if defined(_WIN32) && !defined(__CYGWIN__) && defined(_DEBUG) +- const wchar_t *wname; ++ const char *wname; + #endif + uint32_t folderIndex; + uint32_t ssIndex; +@@ -2514,7 +2514,7 @@ read_Header(struct archive_read *a, stru + for (i = 0; i < zip->numFiles; i++) { + entries[i].utf16name = np; + #if defined(_WIN32) && !defined(__CYGWIN__) && defined(_DEBUG) +- entries[i].wname = (wchar_t *)np; ++ entries[i].wname = (char *)np; + #endif + + /* Find a terminator. */ +diff -urp a/Utilities/cmlibarchive/libarchive/archive_read_support_format_cab.c b/Utilities/cmlibarchive/libarchive/archive_read_support_format_cab.c +--- a/Utilities/cmlibarchive/libarchive/archive_read_support_format_cab.c 2021-01-28 18:58:45.000000000 +0330 ++++ b/Utilities/cmlibarchive/libarchive/archive_read_support_format_cab.c 2021-02-11 18:43:34.445862611 +0330 +@@ -596,7 +596,7 @@ cab_convert_path_separator_1(struct arch + static void + cab_convert_path_separator_2(struct cab *cab, struct archive_entry *entry) + { +- const wchar_t *wp; ++ const char *wp; + size_t i; + + /* If a conversion to wide character failed, force the replacement. */ +diff -urp a/Utilities/cmlibarchive/libarchive/archive_read_support_format_lha.c b/Utilities/cmlibarchive/libarchive/archive_read_support_format_lha.c +--- a/Utilities/cmlibarchive/libarchive/archive_read_support_format_lha.c 2021-01-28 18:58:45.000000000 +0330 ++++ b/Utilities/cmlibarchive/libarchive/archive_read_support_format_lha.c 2021-02-11 18:43:34.455862768 +0330 +@@ -482,7 +482,7 @@ archive_read_format_lha_read_header(stru + const char *signature; + int err; + struct archive_mstring conv_buffer; +- const wchar_t *conv_buffer_p; ++ const char *conv_buffer_p; + + lha_crc16_init(); + +@@ -753,7 +753,7 @@ archive_read_format_lha_read_header(stru + static void + lha_replace_path_separator(struct lha *lha, struct archive_entry *entry) + { +- const wchar_t *wp; ++ const char *wp; + size_t i; + + if ((wp = archive_entry_pathname_w(entry)) != NULL) { +@@ -1695,7 +1695,7 @@ static int + lha_parse_linkname(struct archive_wstring *linkname, + struct archive_wstring *pathname) + { +- wchar_t * linkptr; ++ char * linkptr; + size_t symlen; + + linkptr = wcschr(pathname->s, L'|'); +diff -urp a/Utilities/cmlibarchive/libarchive/archive_read_support_format_tar.c b/Utilities/cmlibarchive/libarchive/archive_read_support_format_tar.c +--- a/Utilities/cmlibarchive/libarchive/archive_read_support_format_tar.c 2021-01-28 18:58:45.000000000 +0330 ++++ b/Utilities/cmlibarchive/libarchive/archive_read_support_format_tar.c 2021-02-11 18:43:34.399195209 +0330 +@@ -511,7 +511,7 @@ archive_read_format_tar_read_header(stru + static int default_dev; + struct tar *tar; + const char *p; +- const wchar_t *wp; ++ const char *wp; + int r; + size_t l, unconsumed = 0; + +@@ -1398,7 +1398,7 @@ read_mac_metadata_blob(struct archive_re + int64_t size; + const void *data; + const char *p, *name; +- const wchar_t *wp, *wname; ++ const char *wp, *wname; + + (void)h; /* UNUSED */ + +diff -urp a/Utilities/cmlibarchive/libarchive/archive_read_support_format_zip.c b/Utilities/cmlibarchive/libarchive/archive_read_support_format_zip.c +--- a/Utilities/cmlibarchive/libarchive/archive_read_support_format_zip.c 2021-01-28 18:58:45.000000000 +0330 ++++ b/Utilities/cmlibarchive/libarchive/archive_read_support_format_zip.c 2021-02-11 18:43:34.375861508 +0330 +@@ -908,7 +908,7 @@ zip_read_local_file_header(struct archiv + { + const char *p; + const void *h; +- const wchar_t *wp; ++ const char *wp; + const char *cp; + size_t len, filename_length, extra_length; + struct archive_string_conv *sconv; +diff -urp a/Utilities/cmlibarchive/libarchive/archive_string.c b/Utilities/cmlibarchive/libarchive/archive_string.c +--- a/Utilities/cmlibarchive/libarchive/archive_string.c 2021-01-28 18:58:45.000000000 +0330 ++++ b/Utilities/cmlibarchive/libarchive/archive_string.c 2021-02-11 18:43:34.372528122 +0330 +@@ -68,11 +68,11 @@ __FBSDID("$FreeBSD: head/lib/libarchive/ + #include "archive_string_composition.h" + + #if !defined(HAVE_WMEMCPY) && !defined(wmemcpy) +-#define wmemcpy(a,b,i) (wchar_t *)memcpy((a), (b), (i) * sizeof(wchar_t)) ++#define wmemcpy(a,b,i) (char *)memcpy((a), (b), (i) * sizeof(char)) + #endif + + #if !defined(HAVE_WMEMMOVE) && !defined(wmemmove) +-#define wmemmove(a,b,i) (wchar_t *)memmove((a), (b), (i) * sizeof(wchar_t)) ++#define wmemmove(a,b,i) (char *)memmove((a), (b), (i) * sizeof(char)) + #endif + + #undef max +@@ -154,7 +154,7 @@ static int archive_wstring_append_from_m + struct archive_wstring *, const char *, size_t, + struct archive_string_conv *); + static int archive_string_append_from_wcs_in_codepage(struct archive_string *, +- const wchar_t *, size_t, struct archive_string_conv *); ++ const char *, size_t, struct archive_string_conv *); + static int is_big_endian(void); + static int strncat_in_codepage(struct archive_string *, const void *, + size_t, struct archive_string_conv *); +@@ -213,7 +213,7 @@ archive_string_append(struct archive_str + } + + static struct archive_wstring * +-archive_wstring_append(struct archive_wstring *as, const wchar_t *p, size_t s) ++archive_wstring_append(struct archive_wstring *as, const char *p, size_t s) + { + if (archive_wstring_ensure(as, as->length + s + 1) == NULL) + return (NULL); +@@ -268,7 +268,7 @@ archive_wstring_ensure(struct archive_ws + { + return (struct archive_wstring *) + archive_string_ensure((struct archive_string *)as, +- s * sizeof(wchar_t)); ++ s * sizeof(char)); + } + + /* Returns NULL on any allocation failure. */ +@@ -355,10 +355,10 @@ archive_strncat(struct archive_string *a + } + + struct archive_wstring * +-archive_wstrncat(struct archive_wstring *as, const wchar_t *p, size_t n) ++archive_wstrncat(struct archive_wstring *as, const char *p, size_t n) + { + size_t s; +- const wchar_t *pp; ++ const char *pp; + + /* Like strlen(p), except won't examine positions beyond p[n]. */ + s = 0; +@@ -385,7 +385,7 @@ archive_strcat(struct archive_string *as + } + + struct archive_wstring * +-archive_wstrcat(struct archive_wstring *as, const wchar_t *p) ++archive_wstrcat(struct archive_wstring *as, const char *p) + { + /* Ditto. */ + return archive_wstrncat(as, p, 0x1000000); +@@ -400,7 +400,7 @@ archive_strappend_char(struct archive_st + } + + struct archive_wstring * +-archive_wstrappend_wchar(struct archive_wstring *as, wchar_t c) ++archive_wstrappend_wchar(struct archive_wstring *as, char c) + { + if ((as = archive_wstring_append(as, &c, 1)) == NULL) + __archive_errx(1, "Out of memory"); +@@ -463,7 +463,7 @@ archive_wstring_append_from_mbs_in_codep + /* + * "C" locale special processing. + */ +- wchar_t *ws; ++ char *ws; + const unsigned char *mp; + + if (NULL == archive_wstring_ensure(dest, +@@ -474,14 +474,14 @@ archive_wstring_append_from_mbs_in_codep + mp = (const unsigned char *)s; + count = 0; + while (count < (int)length && *mp) { +- *ws++ = (wchar_t)*mp++; ++ *ws++ = (char)*mp++; + count++; + } + } else if (sc != NULL && + (sc->flag & (SCONV_NORMALIZATION_C | SCONV_NORMALIZATION_D))) { + /* + * Normalize UTF-8 and UTF-16BE and convert it directly +- * to UTF-16 as wchar_t. ++ * to UTF-16 as char. + */ + struct archive_string u16; + int saved_flag = sc->flag;/* save current flag. */ +@@ -511,7 +511,7 @@ archive_wstring_append_from_mbs_in_codep + ret = archive_string_normalize_C(&u16, s, count, sc); + else + ret = archive_string_normalize_D(&u16, s, count, sc); +- dest->s = (wchar_t *)u16.s; ++ dest->s = (char *)u16.s; + dest->length = u16.length >> 1; + dest->buffer_length = u16.buffer_length; + sc->flag = saved_flag;/* restore the saved flag. */ +@@ -523,7 +523,7 @@ archive_wstring_append_from_mbs_in_codep + if (NULL == archive_wstring_ensure(dest, + dest->length + count + 1)) + return (-1); +- wmemcpy(dest->s + dest->length, (const wchar_t *)s, count); ++ wmemcpy(dest->s + dest->length, (const char *)s, count); + if ((sc->flag & SCONV_FROM_UTF16BE) && !is_big_endian()) { + uint16_t *u16 = (uint16_t *)(dest->s + dest->length); + int b; +@@ -597,7 +597,7 @@ archive_wstring_append_from_mbs(struct a + // size_t wcs_length = len; + size_t mbs_length = len; + const char *mbs = p; +- wchar_t *wcs; ++ char *wcs; + #if HAVE_MBRTOWC + mbstate_t shift_state; + +@@ -668,14 +668,14 @@ archive_wstring_append_from_mbs(struct a + */ + int + archive_string_append_from_wcs(struct archive_string *as, +- const wchar_t *w, size_t len) ++ const char *w, size_t len) + { + return archive_string_append_from_wcs_in_codepage(as, w, len, NULL); + } + + static int + archive_string_append_from_wcs_in_codepage(struct archive_string *as, +- const wchar_t *ws, size_t len, struct archive_string_conv *sc) ++ const char *ws, size_t len, struct archive_string_conv *sc) + { + BOOL defchar_used, *dp; + int count, ret = 0; +@@ -691,7 +691,7 @@ archive_string_append_from_wcs_in_codepa + /* + * "C" locale special processing. + */ +- const wchar_t *wp = ws; ++ const char *wp = ws; + char *p; + + if (NULL == archive_string_ensure(as, +@@ -773,7 +773,7 @@ archive_string_append_from_wcs_in_codepa + */ + int + archive_string_append_from_wcs(struct archive_string *as, +- const wchar_t *w, size_t len) ++ const char *w, size_t len) + { + /* We cannot use the standard wcstombs() here because it + * cannot tell us how big the output buffer should be. So +@@ -847,7 +847,7 @@ archive_string_append_from_wcs(struct ar + */ + int + archive_string_append_from_wcs(struct archive_string *as, +- const wchar_t *w, size_t len) ++ const char *w, size_t len) + { + (void)as;/* UNUSED */ + (void)w;/* UNUSED */ +@@ -1846,7 +1846,7 @@ archive_string_conversion_set_opt(struct + switch (opt) { + /* + * A filename in UTF-8 was made with libarchive 2.x in a wrong +- * assumption that wchar_t was Unicode. ++ * assumption that char was Unicode. + * This option enables simulating the assumption in order to read + * that filename correctly. + */ +@@ -1854,7 +1854,7 @@ archive_string_conversion_set_opt(struct + #if (defined(_WIN32) && !defined(__CYGWIN__)) \ + || defined(__STDC_ISO_10646__) || defined(__APPLE__) + /* +- * Nothing to do for it since wchar_t on these platforms ++ * Nothing to do for it since char on these platforms + * is really Unicode. + */ + (void)sc; /* UNUSED */ +@@ -2194,7 +2194,7 @@ invalid_mbs(const void *_p, size_t n, st + mbtowc(NULL, NULL, 0); + #endif + while (n) { +- wchar_t wc; ++ char wc; + + #if HAVE_MBRTOWC + r = mbrtowc(&wc, p, n, &shift_state); +@@ -2597,7 +2597,7 @@ unicode_to_utf16be(char *p, size_t remai + + if (uc > 0xffff) { + /* We have a code point that won't fit into a +- * wchar_t; convert it to a surrogate pair. */ ++ * char; convert it to a surrogate pair. */ + if (remaining < 4) + return (0); + uc -= 0x10000; +@@ -2619,7 +2619,7 @@ unicode_to_utf16le(char *p, size_t remai + + if (uc > 0xffff) { + /* We have a code point that won't fit into a +- * wchar_t; convert it to a surrogate pair. */ ++ * char; convert it to a surrogate pair. */ + if (remaining < 4) + return (0); + uc -= 0x10000; +@@ -3445,7 +3445,7 @@ strncat_from_utf8_libarchive2(struct arc + p = as->s + as->length; + end = as->s + as->buffer_length - MB_CUR_MAX -1; + while ((n = _utf8_to_unicode(&unicode, s, len)) != 0) { +- wchar_t wc; ++ char wc; + + if (p >= end) { + as->length = p - as->s; +@@ -3466,7 +3466,7 @@ strncat_from_utf8_libarchive2(struct arc + n *= -1; + wc = L'?'; + } else +- wc = (wchar_t)unicode; ++ wc = (char)unicode; + + s += n; + len -= n; +@@ -3935,7 +3935,7 @@ archive_mstring_get_mbs(struct archive * + + int + archive_mstring_get_wcs(struct archive *a, struct archive_mstring *aes, +- const wchar_t **wp) ++ const char **wp) + { + int r, ret = 0; + +@@ -4053,7 +4053,7 @@ archive_mstring_copy_mbs_len(struct arch + } + + int +-archive_mstring_copy_wcs(struct archive_mstring *aes, const wchar_t *wcs) ++archive_mstring_copy_wcs(struct archive_mstring *aes, const char *wcs) + { + return archive_mstring_copy_wcs_len(aes, wcs, + wcs == NULL ? 0 : wcslen(wcs)); +@@ -4074,7 +4074,7 @@ archive_mstring_copy_utf8(struct archive + } + + int +-archive_mstring_copy_wcs_len(struct archive_mstring *aes, const wchar_t *wcs, ++archive_mstring_copy_wcs_len(struct archive_mstring *aes, const char *wcs, + size_t len) + { + if (wcs == NULL) { +@@ -4120,7 +4120,7 @@ archive_mstring_copy_mbs_len_l(struct ar + /* + * This case happens only when MultiByteToWideChar() cannot + * handle sc->from_cp, and we have to iconv in order to +- * translate character-set to wchar_t,UTF-16. ++ * translate character-set to char,UTF-16. + */ + iconv_t cd = sc->cd; + unsigned from_cp; +diff -urp a/Utilities/cmlibarchive/libarchive/archive_string.h b/Utilities/cmlibarchive/libarchive/archive_string.h +--- a/Utilities/cmlibarchive/libarchive/archive_string.h 2021-01-28 18:58:45.000000000 +0330 ++++ b/Utilities/cmlibarchive/libarchive/archive_string.h 2021-02-11 18:43:34.445862611 +0330 +@@ -37,7 +37,7 @@ + + #include <stdarg.h> + #ifdef HAVE_STDLIB_H +-#include <stdlib.h> /* required for wchar_t on some systems */ ++#include <stdlib.h> /* required for char on some systems */ + #endif + #ifdef HAVE_STRING_H + #include <string.h> +@@ -62,7 +62,7 @@ struct archive_string { + }; + + struct archive_wstring { +- wchar_t *s; /* Pointer to the storage */ ++ char *s; /* Pointer to the storage */ + size_t length; /* Length of 's' in characters */ + size_t buffer_length; /* Length of malloc-ed storage in bytes. */ + }; +@@ -77,9 +77,9 @@ struct archive_string_conv; + struct archive_string * + archive_strappend_char(struct archive_string *, char); + +-/* Ditto for a wchar_t and an archive_wstring. */ ++/* Ditto for a char and an archive_wstring. */ + struct archive_wstring * +-archive_wstrappend_wchar(struct archive_wstring *, wchar_t); ++archive_wstrappend_wchar(struct archive_wstring *, char); + + /* Append a raw array to an archive_string, resizing as necessary */ + struct archive_string * +@@ -88,7 +88,7 @@ archive_array_append(struct archive_stri + /* Convert a Unicode string to current locale and append the result. */ + /* Returns -1 if conversion fails. */ + int +-archive_string_append_from_wcs(struct archive_string *, const wchar_t *, size_t); ++archive_string_append_from_wcs(struct archive_string *, const char *, size_t); + + + /* Create a string conversion object. +@@ -155,13 +155,13 @@ archive_wstring_ensure(struct archive_ws + struct archive_string * + archive_strncat(struct archive_string *, const void *, size_t); + struct archive_wstring * +-archive_wstrncat(struct archive_wstring *, const wchar_t *, size_t); ++archive_wstrncat(struct archive_wstring *, const char *, size_t); + + /* Append a C string to an archive_string, resizing as necessary. */ + struct archive_string * + archive_strcat(struct archive_string *, const void *); + struct archive_wstring * +-archive_wstrcat(struct archive_wstring *, const wchar_t *); ++archive_wstrcat(struct archive_wstring *, const char *); + + /* Copy a C string to an archive_string, resizing as necessary. */ + #define archive_strcpy(as,p) \ +@@ -225,16 +225,16 @@ void archive_mstring_clean(struct archiv + void archive_mstring_copy(struct archive_mstring *dest, struct archive_mstring *src); + int archive_mstring_get_mbs(struct archive *, struct archive_mstring *, const char **); + int archive_mstring_get_utf8(struct archive *, struct archive_mstring *, const char **); +-int archive_mstring_get_wcs(struct archive *, struct archive_mstring *, const wchar_t **); ++int archive_mstring_get_wcs(struct archive *, struct archive_mstring *, const char **); + int archive_mstring_get_mbs_l(struct archive_mstring *, const char **, + size_t *, struct archive_string_conv *); + int archive_mstring_copy_mbs(struct archive_mstring *, const char *mbs); + int archive_mstring_copy_mbs_len(struct archive_mstring *, const char *mbs, + size_t); + int archive_mstring_copy_utf8(struct archive_mstring *, const char *utf8); +-int archive_mstring_copy_wcs(struct archive_mstring *, const wchar_t *wcs); ++int archive_mstring_copy_wcs(struct archive_mstring *, const char *wcs); + int archive_mstring_copy_wcs_len(struct archive_mstring *, +- const wchar_t *wcs, size_t); ++ const char *wcs, size_t); + int archive_mstring_copy_mbs_len_l(struct archive_mstring *, + const char *mbs, size_t, struct archive_string_conv *); + int archive_mstring_update_utf8(struct archive *, struct archive_mstring *aes, const char *utf8); +diff -urp a/Utilities/cmlibarchive/libarchive/archive_string_sprintf.c b/Utilities/cmlibarchive/libarchive/archive_string_sprintf.c +--- a/Utilities/cmlibarchive/libarchive/archive_string_sprintf.c 2021-01-28 18:58:45.000000000 +0330 ++++ b/Utilities/cmlibarchive/libarchive/archive_string_sprintf.c 2021-02-11 18:43:34.449195998 +0330 +@@ -95,7 +95,7 @@ archive_string_vsprintf(struct archive_s + intmax_t s; /* Signed integer temp. */ + uintmax_t u; /* Unsigned integer temp. */ + const char *p, *p2; +- const wchar_t *pw; ++ const char *pw; + + if (archive_string_ensure(as, 64) == NULL) + __archive_errx(1, "Out of memory"); +@@ -145,9 +145,9 @@ archive_string_vsprintf(struct archive_s + case 's': + switch(long_flag) { + case 'l': +- pw = va_arg(ap, wchar_t *); ++ pw = va_arg(ap, char *); + if (pw == NULL) +- pw = L"(null)"; ++ pw = "(null)"; + if (archive_string_append_from_wcs(as, pw, + wcslen(pw)) != 0 && errno == ENOMEM) + __archive_errx(1, "Out of memory"); +@@ -161,9 +161,9 @@ archive_string_vsprintf(struct archive_s + } + break; + case 'S': +- pw = va_arg(ap, wchar_t *); ++ pw = va_arg(ap, char *); + if (pw == NULL) +- pw = L"(null)"; ++ pw = "(null)"; + if (archive_string_append_from_wcs(as, pw, + wcslen(pw)) != 0 && errno == ENOMEM) + __archive_errx(1, "Out of memory"); +diff -urp a/Utilities/cmlibarchive/libarchive/archive_util.c b/Utilities/cmlibarchive/libarchive/archive_util.c +--- a/Utilities/cmlibarchive/libarchive/archive_util.c 2021-01-28 18:58:45.000000000 +0330 ++++ b/Utilities/cmlibarchive/libarchive/archive_util.c 2021-02-11 18:43:34.399195209 +0330 +@@ -219,11 +219,11 @@ __archive_errx(int retvalue, const char + * are not secure. + */ + static int +-__archive_mktempx(const char *tmpdir, wchar_t *template) ++__archive_mktempx(const char *tmpdir, char *template) + { +- static const wchar_t prefix[] = L"libarchive_"; +- static const wchar_t suffix[] = L"XXXXXXXXXX"; +- static const wchar_t num[] = { ++ static const char prefix[] = "libarchive_"; ++ static const char suffix[] = "XXXXXXXXXX"; ++ static const char num[] = { + L'0', L'1', L'2', L'3', L'4', L'5', L'6', L'7', + L'8', L'9', L'A', L'B', L'C', L'D', L'E', L'F', + L'G', L'H', L'I', L'J', L'K', L'L', L'M', L'N', +@@ -235,9 +235,9 @@ __archive_mktempx(const char *tmpdir, wc + }; + HCRYPTPROV hProv; + struct archive_wstring temp_name; +- wchar_t *ws; ++ char *ws; + DWORD attr; +- wchar_t *xp, *ep; ++ char *xp, *ep; + int fd; + + hProv = (HCRYPTPROV)NULL; +@@ -250,14 +250,14 @@ __archive_mktempx(const char *tmpdir, wc + /* Get a temporary directory. */ + if (tmpdir == NULL) { + size_t l; +- wchar_t *tmp; ++ char *tmp; + + l = GetTempPathW(0, NULL); + if (l == 0) { + la_dosmaperr(GetLastError()); + goto exit_tmpfile; + } +- tmp = malloc(l*sizeof(wchar_t)); ++ tmp = malloc(l*sizeof(char)); + if (tmp == NULL) { + errno = ENOMEM; + goto exit_tmpfile; +@@ -321,12 +321,12 @@ __archive_mktempx(const char *tmpdir, wc + } + + for (;;) { +- wchar_t *p; ++ char *p; + HANDLE h; + + /* Generate a random file name through CryptGenRandom(). */ + p = xp; +- if (!CryptGenRandom(hProv, (DWORD)(ep - p)*sizeof(wchar_t), ++ if (!CryptGenRandom(hProv, (DWORD)(ep - p)*sizeof(char), + (BYTE*)p)) { + la_dosmaperr(GetLastError()); + goto exit_tmpfile; +@@ -386,7 +386,7 @@ __archive_mktemp(const char *tmpdir) + } + + int +-__archive_mkstemp(wchar_t *template) ++__archive_mkstemp(char *template) + { + return __archive_mktempx(NULL, template); + } +diff -urp a/Utilities/cmlibarchive/libarchive/archive_windows.c b/Utilities/cmlibarchive/libarchive/archive_windows.c +--- a/Utilities/cmlibarchive/libarchive/archive_windows.c 2021-01-28 18:58:45.000000000 +0330 ++++ b/Utilities/cmlibarchive/libarchive/archive_windows.c 2021-02-11 18:43:34.419195524 +0330 +@@ -119,15 +119,15 @@ getino(struct ustat *ub) + * characters. + * see also http://msdn.microsoft.com/en-us/library/aa365247.aspx + */ +-wchar_t * ++char * + __la_win_permissive_name(const char *name) + { +- wchar_t *wn; +- wchar_t *ws; ++ char *wn; ++ char *ws; + size_t ll; + + ll = strlen(name); +- wn = malloc((ll + 1) * sizeof(wchar_t)); ++ wn = malloc((ll + 1) * sizeof(char)); + if (wn == NULL) + return (NULL); + ll = mbstowcs(wn, name, ll); +@@ -141,11 +141,11 @@ __la_win_permissive_name(const char *nam + return (ws); + } + +-wchar_t * +-__la_win_permissive_name_w(const wchar_t *wname) ++char * ++__la_win_permissive_name_w(const char *wname) + { +- wchar_t *wn, *wnp; +- wchar_t *ws, *wsp; ++ char *wn, *wnp; ++ char *ws, *wsp; + DWORD l, len, slen; + int unc; + +@@ -158,7 +158,7 @@ __la_win_permissive_name_w(const wchar_t + * have to add three to the size to allocate a sufficient buffer + * size for the full-pathname of the file name. */ + l += 3; +- wnp = malloc(l * sizeof(wchar_t)); ++ wnp = malloc(l * sizeof(char)); + if (wnp == NULL) + return (NULL); + len = GetFullPathNameW(wname, l, wnp, NULL); +@@ -181,13 +181,13 @@ __la_win_permissive_name_w(const wchar_t + + unc = 0; + if (wnp[0] == L'\\' && wnp[1] == L'\\' && wnp[2] != L'\\') { +- wchar_t *p = &wnp[2]; ++ char *p = &wnp[2]; + + /* Skip server-name letters. */ + while (*p != L'\\' && *p != L'\0') + ++p; + if (*p == L'\\') { +- wchar_t *rp = ++p; ++ char *rp = ++p; + /* Skip share-name letters. */ + while (*p != L'\\' && *p != L'\0') + ++p; +@@ -202,18 +202,18 @@ __la_win_permissive_name_w(const wchar_t + } + + slen = 4 + (unc * 4) + len + 1; +- ws = wsp = malloc(slen * sizeof(wchar_t)); ++ ws = wsp = malloc(slen * sizeof(char)); + if (ws == NULL) { + free(wn); + return (NULL); + } + /* prepend "\\?\" */ +- wcsncpy(wsp, L"\\\\?\\", 4); ++ wcsncpy(wsp, "\\\\?\\", 4); + wsp += 4; + slen -= 4; + if (unc) { + /* append "UNC\" ---> "\\?\UNC\" */ +- wcsncpy(wsp, L"UNC\\", 4); ++ wcsncpy(wsp, "UNC\\", 4); + wsp += 4; + slen -= 4; + } +@@ -232,7 +232,7 @@ la_CreateFile(const char *path, DWORD dw + LPSECURITY_ATTRIBUTES lpSecurityAttributes, DWORD dwCreationDisposition, + DWORD dwFlagsAndAttributes, HANDLE hTemplateFile) + { +- wchar_t *wpath; ++ char *wpath; + HANDLE handle; + + handle = CreateFileA(path, dwDesiredAccess, dwShareMode, +@@ -291,7 +291,7 @@ int + __la_open(const char *path, int flags, ...) + { + va_list ap; +- wchar_t *ws; ++ char *ws; + int r, pmode; + DWORD attr; + +@@ -683,9 +683,9 @@ __la_write(int fd, const void *buf, size + * Replace the Windows path separator '\' with '/'. + */ + static int +-replace_pathseparator(struct archive_wstring *ws, const wchar_t *wp) ++replace_pathseparator(struct archive_wstring *ws, const char *wp) + { +- wchar_t *w; ++ char *w; + size_t path_length; + + if (wp == NULL) +@@ -707,7 +707,7 @@ static int + fix_pathseparator(struct archive_entry *entry) + { + struct archive_wstring ws; +- const wchar_t *wp; ++ const char *wp; + int ret = ARCHIVE_OK; + + archive_string_init(&ws); +@@ -749,7 +749,7 @@ struct archive_entry * + __la_win_entry_in_posix_pathseparator(struct archive_entry *entry) + { + struct archive_entry *entry_main; +- const wchar_t *wp; ++ const char *wp; + int has_backslash = 0; + int ret; + +diff -urp a/Utilities/cmlibarchive/libarchive/archive_windows.h b/Utilities/cmlibarchive/libarchive/archive_windows.h +--- a/Utilities/cmlibarchive/libarchive/archive_windows.h 2021-01-28 18:58:45.000000000 +0330 ++++ b/Utilities/cmlibarchive/libarchive/archive_windows.h 2021-02-11 18:43:34.439195839 +0330 +@@ -288,8 +288,8 @@ extern ssize_t __la_write(int fd, const + #define WIFEXITED(sts) ((sts & 0x100) == 0) + #define WEXITSTATUS(sts) (sts & 0x0FF) + +-extern wchar_t *__la_win_permissive_name(const char *name); +-extern wchar_t *__la_win_permissive_name_w(const wchar_t *wname); ++extern char *__la_win_permissive_name(const char *name); ++extern char *__la_win_permissive_name_w(const char *wname); + extern void __la_dosmaperr(unsigned long e); + #define la_dosmaperr(e) __la_dosmaperr(e) + extern struct archive_entry *__la_win_entry_in_posix_pathseparator( +@@ -297,7 +297,7 @@ extern struct archive_entry *__la_win_en + + #if defined(HAVE_WCRTOMB) && defined(__BORLANDC__) + typedef int mbstate_t; +-size_t wcrtomb(char *, wchar_t, mbstate_t *); ++size_t wcrtomb(char *, char, mbstate_t *); + #endif + + #if defined(_MSC_VER) && _MSC_VER < 1300 +diff -urp a/Utilities/cmlibarchive/libarchive/archive_write_disk_posix.c b/Utilities/cmlibarchive/libarchive/archive_write_disk_posix.c +--- a/Utilities/cmlibarchive/libarchive/archive_write_disk_posix.c 2021-01-28 18:58:45.000000000 +0330 ++++ b/Utilities/cmlibarchive/libarchive/archive_write_disk_posix.c 2021-02-12 14:39:59.857852509 +0330 +@@ -2978,7 +2978,7 @@ check_symlinks(struct archive_write_disk + static void + cleanup_pathname_win(char *path) + { +- wchar_t wc; ++ char wc; + char *p; + size_t alen, l; + int mb, complete, utf8; +diff -urp a/Utilities/cmlibarchive/libarchive/archive_write_disk_windows.c b/Utilities/cmlibarchive/libarchive/archive_write_disk_windows.c +--- a/Utilities/cmlibarchive/libarchive/archive_write_disk_windows.c 2021-01-28 18:58:45.000000000 +0330 ++++ b/Utilities/cmlibarchive/libarchive/archive_write_disk_windows.c 2021-02-11 18:43:34.419195524 +0330 +@@ -99,7 +99,7 @@ struct fixup_entry { + unsigned long ctime_nanos; + unsigned long fflags_set; + int fixup; /* bitmask of what needs fixing */ +- wchar_t *name; ++ char *name; + }; + + /* +@@ -163,9 +163,9 @@ struct archive_write_disk { + + /* Information about the object being restored right now. */ + struct archive_entry *entry; /* Entry being extracted. */ +- wchar_t *name; /* Name of entry, possibly edited. */ ++ char *name; /* Name of entry, possibly edited. */ + struct archive_wstring _name_data; /* backing store for 'name' */ +- wchar_t *tmpname; /* Temporary name */ ++ char *tmpname; /* Temporary name */ + struct archive_wstring _tmpname_data; /* backing store for 'tmpname' */ + /* Tasks remaining for this object. */ + int todo; +@@ -207,31 +207,31 @@ struct archive_write_disk { + #define MINIMUM_DIR_MODE 0700 + #define MAXIMUM_DIR_MODE 0775 + +-static int disk_unlink(const wchar_t *); +-static int disk_rmdir(const wchar_t *); ++static int disk_unlink(const char *); ++static int disk_rmdir(const char *); + static int check_symlinks(struct archive_write_disk *); + static int create_filesystem_object(struct archive_write_disk *); + static struct fixup_entry *current_fixup(struct archive_write_disk *, +- const wchar_t *pathname); ++ const char *pathname); + static int cleanup_pathname(struct archive_write_disk *); +-static int create_dir(struct archive_write_disk *, wchar_t *); +-static int create_parent_dir(struct archive_write_disk *, wchar_t *); +-static int la_chmod(const wchar_t *, mode_t); ++static int create_dir(struct archive_write_disk *, char *); ++static int create_parent_dir(struct archive_write_disk *, char *); ++static int la_chmod(const char *, mode_t); + static int la_mktemp(struct archive_write_disk *); + static int older(BY_HANDLE_FILE_INFORMATION *, struct archive_entry *); + static int permissive_name_w(struct archive_write_disk *); + static int restore_entry(struct archive_write_disk *); + static int set_acls(struct archive_write_disk *, HANDLE h, +- const wchar_t *, struct archive_acl *); ++ const char *, struct archive_acl *); + static int set_xattrs(struct archive_write_disk *); + static int clear_nochange_fflags(struct archive_write_disk *); + static int set_fflags(struct archive_write_disk *); +-static int set_fflags_platform(const wchar_t *, unsigned long, ++static int set_fflags_platform(const char *, unsigned long, + unsigned long); + static int set_ownership(struct archive_write_disk *); + static int set_mode(struct archive_write_disk *, int mode); + static int set_times(struct archive_write_disk *, HANDLE, int, +- const wchar_t *, time_t, long, time_t, long, time_t, ++ const char *, time_t, long, time_t, long, time_t, + long, time_t, long); + static int set_times_from_entry(struct archive_write_disk *); + static struct fixup_entry *sort_dir_list(struct fixup_entry *p); +@@ -261,7 +261,7 @@ static ssize_t _archive_write_disk_data_ + ((((int64_t)(bhfi)->nFileSizeHigh) << 32) + (bhfi)->nFileSizeLow) + + static int +-file_information(struct archive_write_disk *a, wchar_t *path, ++file_information(struct archive_write_disk *a, char *path, + BY_HANDLE_FILE_INFORMATION *st, mode_t *mode, int sim_lstat) + { + HANDLE h; +@@ -273,7 +273,7 @@ file_information(struct archive_write_di + h = FindFirstFileW(path, &findData); + if (h == INVALID_HANDLE_VALUE && + GetLastError() == ERROR_INVALID_NAME) { +- wchar_t *full; ++ char *full; + full = __la_win_permissive_name_w(path); + h = FindFirstFileW(full, &findData); + free(full); +@@ -296,7 +296,7 @@ file_information(struct archive_write_di + OPEN_EXISTING, flag, NULL); + if (h == INVALID_HANDLE_VALUE && + GetLastError() == ERROR_INVALID_NAME) { +- wchar_t *full; ++ char *full; + full = __la_win_permissive_name_w(path); + h = CreateFileW(full, 0, 0, NULL, + OPEN_EXISTING, flag, NULL); +@@ -325,7 +325,7 @@ file_information(struct archive_write_di + else if (st->dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY) + *mode |= S_IFDIR | S_IXUSR | S_IXGRP | S_IXOTH; + else { +- const wchar_t *p; ++ const char *p; + + *mode |= S_IFREG; + p = wcsrchr(path, L'.'); +@@ -364,8 +364,8 @@ file_information(struct archive_write_di + static int + permissive_name_w(struct archive_write_disk *a) + { +- wchar_t *wn, *wnp; +- wchar_t *ws, *wsp; ++ char *wn, *wnp; ++ char *ws, *wsp; + DWORD l; + + wnp = a->name; +@@ -397,7 +397,7 @@ permissive_name_w(struct archive_write_d + archive_wstring_ensure(&(a->_name_data), 4 + wcslen(wn) + 1); + a->name = a->_name_data.s; + /* Prepend "\\?\" */ +- archive_wstrncpy(&(a->_name_data), L"\\\\?\\", 4); ++ archive_wstrncpy(&(a->_name_data), "\\\\?\\", 4); + archive_wstrcat(&(a->_name_data), wn); + free(wn); + return (0); +@@ -408,13 +408,13 @@ permissive_name_w(struct archive_write_d + * like "\\<server-name>\<share-name>\file". + */ + if (wnp[0] == L'\\' && wnp[1] == L'\\' && wnp[2] != L'\\') { +- const wchar_t *p = &wnp[2]; ++ const char *p = &wnp[2]; + + /* Skip server-name letters. */ + while (*p != L'\\' && *p != L'\0') + ++p; + if (*p == L'\\') { +- const wchar_t *rp = ++p; ++ const char *rp = ++p; + /* Skip share-name letters. */ + while (*p != L'\\' && *p != L'\0') + ++p; +@@ -429,7 +429,7 @@ permissive_name_w(struct archive_write_d + a->name = a->_name_data.s; + /* Prepend "\\?\UNC\" */ + archive_wstrncpy(&(a->_name_data), +- L"\\\\?\\UNC\\", 8); ++ "\\\\?\\UNC\\", 8); + archive_wstrcat(&(a->_name_data), wn+2); + free(wn); + return (0); +@@ -444,7 +444,7 @@ permissive_name_w(struct archive_write_d + l = GetCurrentDirectoryW(0, NULL); + if (l == 0) + return (-1); +- ws = malloc(l * sizeof(wchar_t)); ++ ws = malloc(l * sizeof(char)); + l = GetCurrentDirectoryW(l, ws); + if (l == 0) { + free(ws); +@@ -463,7 +463,7 @@ permissive_name_w(struct archive_write_d + 4 + 2 + wcslen(wn) + 1); + a->name = a->_name_data.s; + /* Prepend "\\?\" and drive name. */ +- archive_wstrncpy(&(a->_name_data), L"\\\\?\\", 4); ++ archive_wstrncpy(&(a->_name_data), "\\\\?\\", 4); + archive_wstrncat(&(a->_name_data), wsp, 2); + archive_wstrcat(&(a->_name_data), wn); + free(wsp); +@@ -484,15 +484,15 @@ permissive_name_w(struct archive_write_d + } + else if (l > 2 && wsp[0] == L'\\' && wsp[1] == L'\\' && wsp[2] != L'\\') + { +- archive_wstrncpy(&(a->_name_data), L"\\\\?\\UNC\\", 8); ++ archive_wstrncpy(&(a->_name_data), "\\\\?\\UNC\\", 8); + archive_wstrncat(&(a->_name_data), wsp+2, l-2); + } + else + { +- archive_wstrncpy(&(a->_name_data), L"\\\\?\\", 4); ++ archive_wstrncpy(&(a->_name_data), "\\\\?\\", 4); + archive_wstrncat(&(a->_name_data), wsp, l); + } +- archive_wstrncat(&(a->_name_data), L"\\", 1); ++ archive_wstrncat(&(a->_name_data), "\\", 1); + archive_wstrcat(&(a->_name_data), wn); + a->name = a->_name_data.s; + free(wsp); +@@ -501,11 +501,11 @@ permissive_name_w(struct archive_write_d + } + + static int +-la_chmod(const wchar_t *path, mode_t mode) ++la_chmod(const char *path, mode_t mode) + { + DWORD attr; + BOOL r; +- wchar_t *fullname; ++ char *fullname; + int ret = 0; + + fullname = NULL; +@@ -545,7 +545,7 @@ la_mktemp(struct archive_write_disk *a) + + archive_wstring_empty(&(a->_tmpname_data)); + archive_wstrcpy(&(a->_tmpname_data), a->name); +- archive_wstrcat(&(a->_tmpname_data), L".XXXXXX"); ++ archive_wstrcat(&(a->_tmpname_data), ".XXXXXX"); + a->tmpname = a->_tmpname_data.s; + + fd = __archive_mkstemp(a->tmpname); +@@ -576,7 +576,7 @@ la_GetFunctionKernel32(const char *name) + } + + static int +-la_CreateHardLinkW(wchar_t *linkname, wchar_t *target) ++la_CreateHardLinkW(char *linkname, char *target) + { + static BOOLEAN (WINAPI *f)(LPWSTR, LPWSTR, LPSECURITY_ATTRIBUTES); + static int set; +@@ -598,12 +598,12 @@ la_CreateHardLinkW(wchar_t *linkname, wc + (name[1] == L'N' || name[1] == L'n') && \ + (name[2] == L'C' || name[2] == L'c') && \ + name[3] == L'\\') +- if (!wcsncmp(linkname,L"\\\\?\\", 4)) { ++ if (!wcsncmp(linkname,"\\\\?\\", 4)) { + linkname += 4; + if (IS_UNC(linkname)) + linkname += 4; + } +- if (!wcsncmp(target,L"\\\\?\\", 4)) { ++ if (!wcsncmp(target,"\\\\?\\", 4)) { + target += 4; + if (IS_UNC(target)) + target += 4; +@@ -621,11 +621,11 @@ la_CreateHardLinkW(wchar_t *linkname, wc + * the link target + */ + static int +-la_CreateSymbolicLinkW(const wchar_t *linkname, const wchar_t *target, ++la_CreateSymbolicLinkW(const char *linkname, const char *target, + int linktype) { + static BOOLEAN (WINAPI *f)(LPCWSTR, LPCWSTR, DWORD); + static int set; +- wchar_t *ttarget, *p; ++ char *ttarget, *p; + int len; + DWORD attrs = 0; + DWORD flags = 0; +@@ -648,7 +648,7 @@ la_CreateSymbolicLinkW(const wchar_t *li + * When writing path targets, we need to translate slashes + * to backslashes + */ +- ttarget = malloc((len + 1) * sizeof(wchar_t)); ++ ttarget = malloc((len + 1) * sizeof(char)); + if (ttarget == NULL) + return(0); + +@@ -1381,9 +1381,9 @@ archive_write_disk_new(void) + } + + static int +-disk_unlink(const wchar_t *path) ++disk_unlink(const char *path) + { +- wchar_t *fullname; ++ char *fullname; + int r; + + r = _wunlink(path); +@@ -1396,9 +1396,9 @@ disk_unlink(const wchar_t *path) + } + + static int +-disk_rmdir(const wchar_t *path) ++disk_rmdir(const char *path) + { +- wchar_t *fullname; ++ char *fullname; + int r; + + r = _wrmdir(path); +@@ -1450,7 +1450,7 @@ restore_entry(struct archive_write_disk + + if ((en == ENOTDIR || en == ENOENT) + && !(a->flags & ARCHIVE_EXTRACT_NO_AUTODIR)) { +- wchar_t *full; ++ char *full; + /* If the parent dir doesn't exist, try creating it. */ + create_parent_dir(a, a->name); + /* Now try to create the object again. */ +@@ -1652,8 +1652,8 @@ static int + create_filesystem_object(struct archive_write_disk *a) + { + /* Create the entry. */ +- const wchar_t *linkname; +- wchar_t *fullname; ++ const char *linkname; ++ char *fullname; + mode_t final_mode, mode; + int r; + DWORD attrs = 0; +@@ -1662,7 +1662,7 @@ create_filesystem_object(struct archive_ + /* Since link(2) and symlink(2) don't handle modes, we're done here. */ + linkname = archive_entry_hardlink_w(a->entry); + if (linkname != NULL) { +- wchar_t *linkfull, *namefull; ++ char *linkfull, *namefull; + + linkfull = __la_win_permissive_name_w(linkname); + namefull = __la_win_permissive_name_w(a->name); +@@ -1736,7 +1736,7 @@ create_filesystem_object(struct archive_ + return symlink(linkname, a->name) ? errno : 0; + #else + errno = 0; +- r = la_CreateSymbolicLinkW((const wchar_t *)a->name, linkname, ++ r = la_CreateSymbolicLinkW((const char *)a->name, linkname, + archive_entry_symlink_type(a->entry)); + if (r == 0) { + if (errno == 0) +@@ -2006,7 +2006,7 @@ sort_dir_list(struct fixup_entry *p) + * structure rather than a simple list of names. + */ + static struct fixup_entry * +-new_fixup(struct archive_write_disk *a, const wchar_t *pathname) ++new_fixup(struct archive_write_disk *a, const char *pathname) + { + struct fixup_entry *fe; + +@@ -2025,7 +2025,7 @@ new_fixup(struct archive_write_disk *a, + * Returns a fixup structure for the current entry. + */ + static struct fixup_entry * +-current_fixup(struct archive_write_disk *a, const wchar_t *pathname) ++current_fixup(struct archive_write_disk *a, const char *pathname) + { + if (a->current_fixup == NULL) + a->current_fixup = new_fixup(a, pathname); +@@ -2044,8 +2044,8 @@ current_fixup(struct archive_write_disk + static int + check_symlinks(struct archive_write_disk *a) + { +- wchar_t *pn, *p; +- wchar_t c; ++ char *pn, *p; ++ char c; + int r; + BY_HANDLE_FILE_INFORMATION st; + mode_t st_mode; +@@ -2153,7 +2153,7 @@ check_symlinks(struct archive_write_disk + } + + static int +-guidword(wchar_t *p, int n) ++guidword(char *p, int n) + { + int i; + +@@ -2177,8 +2177,8 @@ guidword(wchar_t *p, int n) + static int + cleanup_pathname(struct archive_write_disk *a) + { +- wchar_t *dest, *src, *p, *top; +- wchar_t separator = L'\0'; ++ char *dest, *src, *p, *top; ++ char separator = L'\0'; + + p = a->name; + if (*p == L'\0') { +@@ -2349,9 +2349,9 @@ cleanup_pathname(struct archive_write_di + * is already in mutable storage. + */ + static int +-create_parent_dir(struct archive_write_disk *a, wchar_t *path) ++create_parent_dir(struct archive_write_disk *a, char *path) + { +- wchar_t *slash; ++ char *slash; + int r; + + /* Remove tail element to obtain parent name. */ +@@ -2372,11 +2372,11 @@ create_parent_dir(struct archive_write_d + * Assumes path is in mutable storage; path is unchanged on exit. + */ + static int +-create_dir(struct archive_write_disk *a, wchar_t *path) ++create_dir(struct archive_write_disk *a, char *path) + { + BY_HANDLE_FILE_INFORMATION st; + struct fixup_entry *le; +- wchar_t *slash, *base, *full; ++ char *slash, *base, *full; + mode_t mode_final, mode, st_mode; + int r; + +@@ -2512,7 +2512,7 @@ set_ownership(struct archive_write_disk + + static int + set_times(struct archive_write_disk *a, +- HANDLE h, int mode, const wchar_t *name, ++ HANDLE h, int mode, const char *name, + time_t atime, long atime_nanos, + time_t birthtime, long birthtime_nanos, + time_t mtime, long mtime_nanos, +@@ -2533,7 +2533,7 @@ set_times(struct archive_write_disk *a, + if (h != INVALID_HANDLE_VALUE) { + hw = NULL; + } else { +- wchar_t *ws; ++ char *ws; + + if (S_ISLNK(mode)) + return (ARCHIVE_OK); +@@ -2695,11 +2695,11 @@ set_mode(struct archive_write_disk *a, i + return (r); + } + +-static int set_fflags_platform(const wchar_t *name, unsigned long fflags_set, ++static int set_fflags_platform(const char *name, unsigned long fflags_set, + unsigned long fflags_clear) + { + DWORD oldflags, newflags; +- wchar_t *fullname; ++ char *fullname; + + const DWORD settable_flags = + FILE_ATTRIBUTE_ARCHIVE | +@@ -2750,7 +2750,7 @@ set_fflags(struct archive_write_disk *a) + + /* Default empty function body to satisfy mainline code. */ + static int +-set_acls(struct archive_write_disk *a, HANDLE h, const wchar_t *name, ++set_acls(struct archive_write_disk *a, HANDLE h, const char *name, + struct archive_acl *acl) + { + (void)a; /* UNUSED */ +diff -urp a/Utilities/cmlibarchive/libarchive/archive_write_open_filename.c b/Utilities/cmlibarchive/libarchive/archive_write_open_filename.c +--- a/Utilities/cmlibarchive/libarchive/archive_write_open_filename.c 2021-01-28 18:58:45.000000000 +0330 ++++ b/Utilities/cmlibarchive/libarchive/archive_write_open_filename.c 2021-02-11 18:43:34.379194894 +0330 +@@ -83,7 +83,7 @@ archive_write_open_filename(struct archi + } + + int +-archive_write_open_filename_w(struct archive *a, const wchar_t *filename) ++archive_write_open_filename_w(struct archive *a, const char *filename) + { + + if (filename == NULL || filename[0] == L'\0') +@@ -119,7 +119,7 @@ open_filename(struct archive *a, int mbs + else + archive_set_error(a, ARCHIVE_ERRNO_MISC, + "Can't convert '%S' to MBS", +- (const wchar_t *)filename); ++ (const char *)filename); + return (ARCHIVE_FAILED); + } + mine->fd = -1; +@@ -134,9 +134,9 @@ file_open(struct archive *a, void *clien + struct write_file_data *mine; + struct stat st; + #if defined(_WIN32) && !defined(__CYGWIN__) +- wchar_t *fullpath; ++ char *fullpath; + #endif +- const wchar_t *wcs; ++ const char *wcs; + const char *mbs; + + mine = (struct write_file_data *)client_data; +diff -urp a/Utilities/cmlibarchive/libarchive/archive_write_set_format_gnutar.c b/Utilities/cmlibarchive/libarchive/archive_write_set_format_gnutar.c +--- a/Utilities/cmlibarchive/libarchive/archive_write_set_format_gnutar.c 2021-01-28 18:58:45.000000000 +0330 ++++ b/Utilities/cmlibarchive/libarchive/archive_write_set_format_gnutar.c 2021-02-11 18:43:34.422528911 +0330 +@@ -309,7 +309,7 @@ archive_write_gnutar_header(struct archi + * the client sees the change. + */ + #if defined(_WIN32) && !defined(__CYGWIN__) +- const wchar_t *wp; ++ const char *wp; + + wp = archive_entry_pathname_w(entry); + if (wp != NULL && wp[wcslen(wp) -1] != L'/') { +diff -urp a/Utilities/cmlibarchive/libarchive/archive_write_set_format_iso9660.c b/Utilities/cmlibarchive/libarchive/archive_write_set_format_iso9660.c +--- a/Utilities/cmlibarchive/libarchive/archive_write_set_format_iso9660.c 2021-01-28 18:58:45.000000000 +0330 ++++ b/Utilities/cmlibarchive/libarchive/archive_write_set_format_iso9660.c 2021-02-11 18:43:34.419195524 +0330 +@@ -4692,7 +4692,7 @@ cleanup_backslash_1(char *p) + } + + static void +-cleanup_backslash_2(wchar_t *p) ++cleanup_backslash_2(char *p) + { + + /* Convert a path-separator from '\' to '/' */ +@@ -4824,7 +4824,7 @@ isofile_gen_utility_names(struct archive + * Convert a path-separator from '\' to '/' + */ + if (cleanup_backslash_1(file->parentdir.s) != 0) { +- const wchar_t *wp = archive_entry_pathname_w(file->entry); ++ const char *wp = archive_entry_pathname_w(file->entry); + struct archive_wstring ws; + + if (wp != NULL) { +@@ -4938,7 +4938,7 @@ isofile_gen_utility_names(struct archive + */ + if (archive_strlen(&(file->symlink)) > 0 && + cleanup_backslash_1(file->symlink.s) != 0) { +- const wchar_t *wp = ++ const char *wp = + archive_entry_symlink_w(file->entry); + struct archive_wstring ws; + +diff -urp a/Utilities/cmlibarchive/libarchive/archive_write_set_format_mtree.c b/Utilities/cmlibarchive/libarchive/archive_write_set_format_mtree.c +--- a/Utilities/cmlibarchive/libarchive/archive_write_set_format_mtree.c 2021-01-28 18:58:45.000000000 +0330 ++++ b/Utilities/cmlibarchive/libarchive/archive_write_set_format_mtree.c 2021-02-11 18:43:34.459196155 +0330 +@@ -1702,7 +1702,7 @@ cleanup_backslash_1(char *p) + } + + static void +-cleanup_backslash_2(wchar_t *p) ++cleanup_backslash_2(char *p) + { + + /* Convert a path-separator from '\' to '/' */ +@@ -1732,7 +1732,7 @@ mtree_entry_setup_filenames(struct archi + * Convert a path-separator from '\' to '/' + */ + if (cleanup_backslash_1(file->pathname.s) != 0) { +- const wchar_t *wp = archive_entry_pathname_w(entry); ++ const char *wp = archive_entry_pathname_w(entry); + struct archive_wstring ws; + + if (wp != NULL) { +diff -urp a/Utilities/cmlibarchive/libarchive/archive_write_set_format_pax.c b/Utilities/cmlibarchive/libarchive/archive_write_set_format_pax.c +--- a/Utilities/cmlibarchive/libarchive/archive_write_set_format_pax.c 2021-01-28 18:58:45.000000000 +0330 ++++ b/Utilities/cmlibarchive/libarchive/archive_write_set_format_pax.c 2021-02-11 18:43:34.369194737 +0330 +@@ -653,7 +653,7 @@ archive_write_pax_header(struct archive_ + * entry so the client sees the change. + */ + #if defined(_WIN32) && !defined(__CYGWIN__) +- const wchar_t *wp; ++ const char *wp; + + wp = archive_entry_pathname_w(entry_original); + if (wp != NULL && wp[wcslen(wp) -1] != L'/') { +diff -urp a/Utilities/cmlibarchive/libarchive/archive_write_set_format_ustar.c b/Utilities/cmlibarchive/libarchive/archive_write_set_format_ustar.c +--- a/Utilities/cmlibarchive/libarchive/archive_write_set_format_ustar.c 2021-01-28 18:58:45.000000000 +0330 ++++ b/Utilities/cmlibarchive/libarchive/archive_write_set_format_ustar.c 2021-02-11 18:43:34.375861508 +0330 +@@ -276,7 +276,7 @@ archive_write_ustar_header(struct archiv + * the client sees the change. + */ + #if defined(_WIN32) && !defined(__CYGWIN__) +- const wchar_t *wp; ++ const char *wp; + + wp = archive_entry_pathname_w(entry); + if (wp != NULL && wp[wcslen(wp) -1] != L'/') { +diff -urp a/Utilities/cmlibarchive/libarchive/archive_write_set_format_v7tar.c b/Utilities/cmlibarchive/libarchive/archive_write_set_format_v7tar.c +--- a/Utilities/cmlibarchive/libarchive/archive_write_set_format_v7tar.c 2021-01-28 18:58:45.000000000 +0330 ++++ b/Utilities/cmlibarchive/libarchive/archive_write_set_format_v7tar.c 2021-02-11 18:43:34.372528122 +0330 +@@ -254,7 +254,7 @@ archive_write_v7tar_header(struct archiv + * the client sees the change. + */ + #if defined(_WIN32) && !defined(__CYGWIN__) +- const wchar_t *wp; ++ const char *wp; + + wp = archive_entry_pathname_w(entry); + if (wp != NULL && wp[wcslen(wp) -1] != L'/') { +diff -urp a/Utilities/cmlibarchive/libarchive/libarchive_changes.3 b/Utilities/cmlibarchive/libarchive/libarchive_changes.3 +--- a/Utilities/cmlibarchive/libarchive/libarchive_changes.3 2021-01-28 18:58:45.000000000 +0330 ++++ b/Utilities/cmlibarchive/libarchive/libarchive_changes.3 2021-02-11 18:43:34.365861350 +0330 +@@ -52,7 +52,7 @@ extends the write pipeline with another + Libarchive2 assumed that the local platform uses + .Tn Unicode + as the native +-.Tn wchar_t ++.Tn char + encoding, which is true on + .Tn Windows , + modern +@@ -63,7 +63,7 @@ systems, since pax format requires + .Tn UTF-8 + and libarchive 2 incorrectly + assumed that +-.Tn wchar_t ++.Tn char + strings can be easily converted to + .Tn UTF-8 . + .Pp +diff -urp a/Utilities/cmlibrhash/librhash/rhash.c b/Utilities/cmlibrhash/librhash/rhash.c +--- a/Utilities/cmlibrhash/librhash/rhash.c 2021-01-28 18:58:45.000000000 +0330 ++++ b/Utilities/cmlibrhash/librhash/rhash.c 2021-02-11 18:43:33.965855044 +0330 +@@ -380,7 +380,7 @@ RHASH_API int rhash_file(unsigned hash_i + #ifdef _WIN32 /* windows only function */ + #include <share.h> + +-RHASH_API int rhash_wfile(unsigned hash_id, const wchar_t* filepath, unsigned char* result) ++RHASH_API int rhash_wfile(unsigned hash_id, const char* filepath, unsigned char* result) + { + FILE* fd; + rhash ctx; +@@ -392,7 +392,7 @@ RHASH_API int rhash_wfile(unsigned hash_ + return -1; + } + +- if ((fd = _wfsopen(filepath, L"rb", _SH_DENYWR)) == NULL) return -1; ++ if ((fd = _wfsopen(filepath, "rb", _SH_DENYWR)) == NULL) return -1; + + if ((ctx = rhash_init(hash_id)) == NULL) { + fclose(fd); +diff -urp a/Utilities/cmlibrhash/librhash/rhash.h b/Utilities/cmlibrhash/librhash/rhash.h +--- a/Utilities/cmlibrhash/librhash/rhash.h 2021-01-28 18:58:45.000000000 +0330 ++++ b/Utilities/cmlibrhash/librhash/rhash.h 2021-02-11 18:43:33.965855044 +0330 +@@ -164,7 +164,7 @@ RHASH_API int rhash_file(unsigned hash_i + * @param result buffer to receive hash value with the lowest requested id + * @return 0 on success, -1 on error, -1 on error and errno is set + */ +-RHASH_API int rhash_wfile(unsigned hash_id, const wchar_t* filepath, unsigned char* result); ++RHASH_API int rhash_wfile(unsigned hash_id, const char* filepath, unsigned char* result); + #endif + + +diff -urp a/Utilities/cmlibuv/src/win/core.c b/Utilities/cmlibuv/src/win/core.c +--- a/Utilities/cmlibuv/src/win/core.c 2021-01-28 18:58:45.000000000 +0330 ++++ b/Utilities/cmlibuv/src/win/core.c 2021-02-11 18:43:34.115857411 +0330 +@@ -71,8 +71,8 @@ UV_THREAD_LOCAL int uv__crt_assert_enabl + + + #if !defined(__MINGW32__) || __MSVCRT_VERSION__ >= 0x800 +-static void uv__crt_invalid_parameter_handler(const wchar_t* expression, +- const wchar_t* function, const wchar_t * file, unsigned int line, ++static void uv__crt_invalid_parameter_handler(const char* expression, ++ const char* function, const char * file, unsigned int line, + uintptr_t reserved) { + /* No-op. */ + } +diff -urp a/Utilities/cmlibuv/src/win/fs.c b/Utilities/cmlibuv/src/win/fs.c +--- a/Utilities/cmlibuv/src/win/fs.c 2021-01-28 18:58:45.000000000 +0330 ++++ b/Utilities/cmlibuv/src/win/fs.c 2021-02-11 18:43:34.102523866 +0330 +@@ -124,13 +124,13 @@ + + #define MIN(a,b) (((a) < (b)) ? (a) : (b)) + +-const WCHAR JUNCTION_PREFIX[] = L"\\??\\"; ++const WCHAR JUNCTION_PREFIX[] = "\\??\\"; + const WCHAR JUNCTION_PREFIX_LEN = 4; + +-const WCHAR LONG_PATH_PREFIX[] = L"\\\\?\\"; ++const WCHAR LONG_PATH_PREFIX[] = "\\\\?\\"; + const WCHAR LONG_PATH_PREFIX_LEN = 4; + +-const WCHAR UNC_PATH_PREFIX[] = L"\\\\?\\UNC\\"; ++const WCHAR UNC_PATH_PREFIX[] = "\\\\?\\UNC\\"; + const WCHAR UNC_PATH_PREFIX_LEN = 8; + + static int uv__file_symlink_usermode_flag = SYMBOLIC_LINK_FLAG_ALLOW_UNPRIVILEGED_CREATE; +@@ -1234,7 +1234,7 @@ typedef int (*uv__fs_mktemp_func)(uv_fs_ + /* OpenBSD original: lib/libc/stdio/mktemp.c */ + void fs__mktemp(uv_fs_t* req, uv__fs_mktemp_func func) { + static const WCHAR *tempchars = +- L"abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789"; ++ "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789"; + static const size_t num_chars = 62; + static const size_t num_x = 6; + WCHAR *cp, *ep; +@@ -1246,7 +1246,7 @@ void fs__mktemp(uv_fs_t* req, uv__fs_mkt + path = (char*)req->path; + len = wcslen(req->file.pathw); + ep = req->file.pathw + len; +- if (len < num_x || wcsncmp(ep - num_x, L"XXXXXX", num_x)) { ++ if (len < num_x || wcsncmp(ep - num_x, "XXXXXX", num_x)) { + SET_REQ_UV_ERROR(req, UV_EINVAL, ERROR_INVALID_PARAMETER); + goto clobber; + } +@@ -1592,11 +1592,11 @@ void fs__opendir(uv_fs_t* req) { + len = wcslen(pathw); + + if (len == 0) +- fmt = L"./*"; ++ fmt = "./*"; + else if (IS_SLASH(pathw[len - 1])) +- fmt = L"%s*"; ++ fmt = "%s*"; + else +- fmt = L"%s\\*"; ++ fmt = "%s\\*"; + + find_path = uv__malloc(sizeof(WCHAR) * (len + 4)); + if (find_path == NULL) { +diff -urp a/Utilities/cmlibuv/src/win/fs-event.c b/Utilities/cmlibuv/src/win/fs-event.c +--- a/Utilities/cmlibuv/src/win/fs-event.c 2021-01-28 18:58:45.000000000 +0330 ++++ b/Utilities/cmlibuv/src/win/fs-event.c 2021-02-11 18:43:34.112524024 +0330 +@@ -487,7 +487,7 @@ void uv_process_fs_event_req(uv_loop_t* + uv_fatal_error(ERROR_OUTOFMEMORY, "uv__malloc"); + } + +- _snwprintf(filenamew, size, L"%s\\%.*s", handle->dirw, ++ _snwprintf(filenamew, size, "%s\\%.*s", handle->dirw, + file_info->FileNameLength / (DWORD)sizeof(WCHAR), + file_info->FileName); + +diff -urp a/Utilities/cmlibuv/src/win/getaddrinfo.c b/Utilities/cmlibuv/src/win/getaddrinfo.c +--- a/Utilities/cmlibuv/src/win/getaddrinfo.c 2021-01-28 18:58:45.000000000 +0330 ++++ b/Utilities/cmlibuv/src/win/getaddrinfo.c 2021-02-11 18:43:34.119190796 +0330 +@@ -398,7 +398,7 @@ error: + + int uv_if_indextoname(unsigned int ifindex, char* buffer, size_t* size) { + NET_LUID luid; +- wchar_t wname[NDIS_IF_MAX_STRING_SIZE + 1]; /* Add one for the NUL. */ ++ char wname[NDIS_IF_MAX_STRING_SIZE + 1]; /* Add one for the NUL. */ + DWORD bufsize; + int r; + +diff -urp a/Utilities/cmlibuv/src/win/process.c b/Utilities/cmlibuv/src/win/process.c +--- a/Utilities/cmlibuv/src/win/process.c 2021-01-28 18:58:45.000000000 +0330 ++++ b/Utilities/cmlibuv/src/win/process.c 2021-02-11 18:43:34.109190639 +0330 +@@ -43,7 +43,7 @@ typedef struct env_var { + const size_t len; /* including null or '=' */ + } env_var_t; + +-#define E_V(str) { L##str, L##str L"=", sizeof(str) } ++#define E_V(str) { L##str, L##str "=", sizeof(str) } + + static const env_var_t required_vars[] = { /* keep me sorted */ + E_V("HOMEDRIVE"), +@@ -203,7 +203,7 @@ static WCHAR* search_path_join_test(cons + result_pos += cwd_len; + + /* Add a path separator if cwd didn't end with one */ +- if (cwd_len && wcsrchr(L"\\/:", result_pos[-1]) == NULL) { ++ if (cwd_len && wcsrchr("\\/:", result_pos[-1]) == NULL) { + result_pos[0] = L'\\'; + result_pos++; + } +@@ -213,7 +213,7 @@ static WCHAR* search_path_join_test(cons + result_pos += dir_len; + + /* Add a separator if the dir didn't end with one */ +- if (dir_len && wcsrchr(L"\\/:", result_pos[-1]) == NULL) { ++ if (dir_len && wcsrchr("\\/:", result_pos[-1]) == NULL) { + result_pos[0] = L'\\'; + result_pos++; + } +@@ -265,7 +265,7 @@ static WCHAR* path_search_walk_ext(const + if (name_has_ext) { + result = search_path_join_test(dir, dir_len, + name, name_len, +- L"", 0, ++ "", 0, + cwd, cwd_len); + if (result != NULL) { + return result; +@@ -275,7 +275,7 @@ static WCHAR* path_search_walk_ext(const + /* Try .com extension */ + result = search_path_join_test(dir, dir_len, + name, name_len, +- L"com", 3, ++ "com", 3, + cwd, cwd_len); + if (result != NULL) { + return result; +@@ -284,7 +284,7 @@ static WCHAR* path_search_walk_ext(const + /* Try .exe extension */ + result = search_path_join_test(dir, dir_len, + name, name_len, +- L"exe", 3, ++ "exe", 3, + cwd, cwd_len); + if (result != NULL) { + return result; +@@ -386,7 +386,7 @@ static WCHAR* search_path(const WCHAR *f + dir_end = path; + + /* The file is really only a name; look in cwd first, then scan path */ +- result = path_search_walk_ext(L"", 0, ++ result = path_search_walk_ext("", 0, + file, file_len, + cwd, cwd_len, + name_has_ext); +@@ -463,14 +463,14 @@ WCHAR* quote_cmd_arg(const WCHAR *source + return target; + } + +- if (NULL == wcspbrk(source, L" \t\"")) { ++ if (NULL == wcspbrk(source, " \t\"")) { + /* No quotation needed */ + wcsncpy(target, source, len); + target += len; + return target; + } + +- if (NULL == wcspbrk(source, L"\"\\")) { ++ if (NULL == wcspbrk(source, "\"\\")) { + /* + * No embedded double quotes or backlashes, so I can just wrap + * quote marks around the whole thing. +@@ -613,11 +613,11 @@ error: + } + + +-int env_strncmp(const wchar_t* a, int na, const wchar_t* b) { +- wchar_t* a_eq; +- wchar_t* b_eq; +- wchar_t* A; +- wchar_t* B; ++int env_strncmp(const char* a, int na, const char* b) { ++ char* a_eq; ++ char* b_eq; ++ char* A; ++ char* B; + int nb; + int r; + +@@ -632,8 +632,8 @@ int env_strncmp(const wchar_t* a, int na + assert(b_eq); + nb = b_eq - b; + +- A = alloca((na+1) * sizeof(wchar_t)); +- B = alloca((nb+1) * sizeof(wchar_t)); ++ A = alloca((na+1) * sizeof(char)); ++ B = alloca((nb+1) * sizeof(char)); + + r = LCMapStringW(LOCALE_INVARIANT, LCMAP_UPPERCASE, a, na, A, na); + assert(r==na); +@@ -643,8 +643,8 @@ int env_strncmp(const wchar_t* a, int na + B[nb] = L'\0'; + + while (1) { +- wchar_t AA = *A++; +- wchar_t BB = *B++; ++ char AA = *A++; ++ char BB = *B++; + if (AA < BB) { + return -1; + } else if (AA > BB) { +@@ -657,8 +657,8 @@ int env_strncmp(const wchar_t* a, int na + + + static int qsort_wcscmp(const void *a, const void *b) { +- wchar_t* astr = *(wchar_t* const*)a; +- wchar_t* bstr = *(wchar_t* const*)b; ++ char* astr = *(char* const*)a; ++ char* bstr = *(char* const*)b; + return env_strncmp(astr, -1, bstr); + } + +@@ -741,7 +741,7 @@ int make_program_env(char* env_block[], + assert(env_len == 0 || env_len == (size_t) (ptr - dst_copy)); + + /* sort our (UTF-16) copy */ +- qsort(env_copy, env_block_count-1, sizeof(wchar_t*), qsort_wcscmp); ++ qsort(env_copy, env_block_count-1, sizeof(char*), qsort_wcscmp); + + /* third pass: check for required variables */ + for (ptr_copy = env_copy, i = 0; i < ARRAY_SIZE(required_vars); ) { +@@ -1024,7 +1024,7 @@ int uv_spawn(uv_loop_t* loop, + if (path == NULL) { + DWORD path_len, r; + +- path_len = GetEnvironmentVariableW(L"PATH", NULL, 0); ++ path_len = GetEnvironmentVariableW("PATH", NULL, 0); + if (path_len == 0) { + err = GetLastError(); + goto done; +@@ -1037,7 +1037,7 @@ int uv_spawn(uv_loop_t* loop, + } + path = alloc_path; + +- r = GetEnvironmentVariableW(L"PATH", path, path_len); ++ r = GetEnvironmentVariableW("PATH", path, path_len); + if (r == 0 || r >= path_len) { + err = GetLastError(); + goto done; +diff -urp a/Utilities/cmlibuv/src/win/util.c b/Utilities/cmlibuv/src/win/util.c +--- a/Utilities/cmlibuv/src/win/util.c 2021-01-28 18:58:45.000000000 +0330 ++++ b/Utilities/cmlibuv/src/win/util.c 2021-02-11 18:43:34.119190796 +0330 +@@ -548,7 +548,7 @@ int uv_uptime(double* uptime) { + + data_size = (DWORD) buffer_size; + result = RegQueryValueExW(HKEY_PERFORMANCE_DATA, +- L"2", ++ "2", + NULL, + NULL, + buffer, +@@ -580,7 +580,7 @@ int uv_uptime(double* uptime) { + + data_block = (PERF_DATA_BLOCK*) buffer; + +- if (wmemcmp(data_block->Signature, L"PERF", 4) != 0) ++ if (wmemcmp(data_block->Signature, "PERF", 4) != 0) + goto internalError; + + if (data_size < data_block->HeaderLength + sizeof(*object_type)) +@@ -686,7 +686,7 @@ int uv_cpu_info(uv_cpu_info_t** cpu_info + + len = _snwprintf(key_name, + ARRAY_SIZE(key_name), +- L"HARDWARE\\DESCRIPTION\\System\\CentralProcessor\\%d", ++ "HARDWARE\\DESCRIPTION\\System\\CentralProcessor\\%d", + i); + + assert(len > 0 && len < ARRAY_SIZE(key_name)); +@@ -701,7 +701,7 @@ int uv_cpu_info(uv_cpu_info_t** cpu_info + } + + err = RegQueryValueExW(processor_key, +- L"~MHz", ++ "~MHz", + NULL, + NULL, + (BYTE*)&cpu_speed, +@@ -712,7 +712,7 @@ int uv_cpu_info(uv_cpu_info_t** cpu_info + } + + err = RegQueryValueExW(processor_key, +- L"ProcessorNameString", ++ "ProcessorNameString", + NULL, + NULL, + (BYTE*)&cpu_brand, +@@ -1195,7 +1195,7 @@ int uv_os_homedir(char* buffer, size_t* + + + int uv_os_tmpdir(char* buffer, size_t* size) { +- wchar_t *path; ++ char *path; + DWORD bufsize; + size_t len; + +@@ -1209,7 +1209,7 @@ int uv_os_tmpdir(char* buffer, size_t* s + } + /* Include space for terminating null char. */ + len += 1; +- path = uv__malloc(len * sizeof(wchar_t)); ++ path = uv__malloc(len * sizeof(char)); + if (path == NULL) { + return UV_ENOMEM; + } +@@ -1368,8 +1368,8 @@ int uv__convert_utf8_to_utf16(const char + + int uv__getpwuid_r(uv_passwd_t* pwd) { + HANDLE token; +- wchar_t username[UNLEN + 1]; +- wchar_t *path; ++ char username[UNLEN + 1]; ++ char *path; + DWORD bufsize; + int r; + +@@ -1388,7 +1388,7 @@ int uv__getpwuid_r(uv_passwd_t* pwd) { + return uv_translate_sys_error(r); + } + +- path = uv__malloc(bufsize * sizeof(wchar_t)); ++ path = uv__malloc(bufsize * sizeof(char)); + if (path == NULL) { + CloseHandle(token); + return UV_ENOMEM; +@@ -1445,8 +1445,8 @@ int uv_os_get_passwd(uv_passwd_t* pwd) { + + + int uv_os_environ(uv_env_item_t** envitems, int* count) { +- wchar_t* env; +- wchar_t* penv; ++ char* env; ++ char* penv; + int i, cnt; + uv_env_item_t* envitem; + +@@ -1516,10 +1516,10 @@ fail: + + + int uv_os_getenv(const char* name, char* buffer, size_t* size) { +- wchar_t fastvar[512]; +- wchar_t* var; ++ char fastvar[512]; ++ char* var; + DWORD varlen; +- wchar_t* name_w; ++ char* name_w; + DWORD bufsize; + size_t len; + int r; +@@ -1611,8 +1611,8 @@ fail: + + + int uv_os_setenv(const char* name, const char* value) { +- wchar_t* name_w; +- wchar_t* value_w; ++ char* name_w; ++ char* value_w; + int r; + + if (name == NULL || value == NULL) +@@ -1642,7 +1642,7 @@ int uv_os_setenv(const char* name, const + + + int uv_os_unsetenv(const char* name) { +- wchar_t* name_w; ++ char* name_w; + int r; + + if (name == NULL) +@@ -1820,7 +1820,7 @@ int uv_os_uname(uv_utsname_t* buffer) { + /* Populate the version field. */ + version_size = 0; + r = RegOpenKeyExW(HKEY_LOCAL_MACHINE, +- L"SOFTWARE\\Microsoft\\Windows NT\\CurrentVersion", ++ "SOFTWARE\\Microsoft\\Windows NT\\CurrentVersion", + 0, + KEY_QUERY_VALUE, + ®istry_key); +@@ -1829,7 +1829,7 @@ int uv_os_uname(uv_utsname_t* buffer) { + product_name_w_size = sizeof(product_name_w); + r = RegGetValueW(registry_key, + NULL, +- L"ProductName", ++ "ProductName", + RRF_RT_REG_SZ, + NULL, + (PVOID) product_name_w, +diff -urp a/Utilities/Release/WiX/CustomAction/detect_nsis_overwrite.cpp b/Utilities/Release/WiX/CustomAction/detect_nsis_overwrite.cpp +--- a/Utilities/Release/WiX/CustomAction/detect_nsis_overwrite.cpp 2021-01-28 18:58:45.000000000 +0330 ++++ b/Utilities/Release/WiX/CustomAction/detect_nsis_overwrite.cpp 2021-02-11 18:43:33.649183363 +0330 +@@ -6,39 +6,39 @@ + #include <msi.h> + #include <msiquery.h> + +-std::wstring get_property(MSIHANDLE msi_handle, std::wstring const& name) ++std::string get_property(MSIHANDLE msi_handle, std::string const& name) + { + DWORD size = 0; + +- WCHAR value_buffer[] = L""; ++ WCHAR value_buffer[] = ""; + UINT status = MsiGetPropertyW(msi_handle, name.c_str(), value_buffer, &size); + + if (status == ERROR_MORE_DATA) { +- std::vector<wchar_t> buffer(size + 1); ++ std::vector<char> buffer(size + 1); + MsiGetPropertyW(msi_handle, name.c_str(), &buffer[0], &size); +- return std::wstring(&buffer[0]); ++ return std::string(&buffer[0]); + } else { +- return std::wstring(); ++ return std::string(); + } + } + +-void set_property(MSIHANDLE msi_handle, std::wstring const& name, +- std::wstring const& value) ++void set_property(MSIHANDLE msi_handle, std::string const& name, ++ std::string const& value) + { + MsiSetPropertyW(msi_handle, name.c_str(), value.c_str()); + } + + extern "C" UINT __stdcall DetectNsisOverwrite(MSIHANDLE msi_handle) + { +- std::wstring install_root = get_property(msi_handle, L"INSTALL_ROOT"); ++ std::string install_root = get_property(msi_handle, "INSTALL_ROOT"); + +- std::wstring uninstall_exe = install_root + L"\\uninstall.exe"; ++ std::string uninstall_exe = install_root + "\\uninstall.exe"; + + bool uninstall_exe_exists = + GetFileAttributesW(uninstall_exe.c_str()) != INVALID_FILE_ATTRIBUTES; + +- set_property(msi_handle, L"CMAKE_NSIS_OVERWRITE_DETECTED", +- uninstall_exe_exists ? L"1" : L"0"); ++ set_property(msi_handle, "CMAKE_NSIS_OVERWRITE_DETECTED", ++ uninstall_exe_exists ? "1" : "0"); + + return ERROR_SUCCESS; + } +diff -urp a/Utilities/std/cm/filesystem b/Utilities/std/cm/filesystem +--- a/Utilities/std/cm/filesystem 2021-01-28 18:58:45.000000000 +0330 ++++ b/Utilities/std/cm/filesystem 2021-02-12 14:39:55.154859796 +0330 +@@ -98,7 +98,7 @@ class unicode<Char, typename std::enable + { + public: + // UTF32 -> UTF8 +- static std::string to_utf8(const std::wstring& str) ++ static std::string to_utf8(const std::string& str) + { + std::string result; + for (auto c : str) { +@@ -114,9 +114,9 @@ public: + } + + // UTF8 -> UTF32 +- static std::wstring from_utf8(const std::string& str) ++ static std::string from_utf8(const std::string& str) + { +- std::wstring result; ++ std::string result; + result.reserve(str.length()); + auto iter = str.begin(); + utf8_state state = s_start; +@@ -124,29 +124,29 @@ public: + while (iter < str.end()) { + if ((state = decode(state, static_cast<std::uint8_t>(*iter++), + codepoint)) == s_start) { +- result += static_cast<std::wstring::value_type>(codepoint); ++ result += static_cast<std::string::value_type>(codepoint); + codepoint = 0; + } else if (state == s_reject) { +- result += static_cast<std::wstring::value_type>(0xfffd); ++ result += static_cast<std::string::value_type>(0xfffd); + state = s_start; + codepoint = 0; + } + } + if (state) { +- result += static_cast<std::wstring::value_type>(0xfffd); ++ result += static_cast<std::string::value_type>(0xfffd); + } + return result; + } +- static std::wstring from_utf8(char c) ++ static std::string from_utf8(char c) + { +- std::wstring result; ++ std::string result; + utf8_state state = s_start; + std::uint32_t codepoint = 0; + if ((state = decode(state, static_cast<std::uint8_t>(c), codepoint)) == + s_start) { +- result += static_cast<std::wstring::value_type>(codepoint); ++ result += static_cast<std::string::value_type>(codepoint); + } else { +- result += static_cast<std::wstring::value_type>(0xfffd); ++ result += static_cast<std::string::value_type>(0xfffd); + } + + return result; +@@ -159,7 +159,7 @@ class unicode<Char, typename std::enable + { + public: + // UTF16 -> UTF8 +- static std::string to_utf8(const std::wstring& str) ++ static std::string to_utf8(const std::string& str) + { + std::string result; + for (auto iter = str.begin(); iter != str.end(); ++iter) { +@@ -193,9 +193,9 @@ public: + } + + // UTF8 -> UTF16 +- static std::wstring from_utf8(const std::string& str) ++ static std::string from_utf8(const std::string& str) + { +- std::wstring result; ++ std::string result; + result.reserve(str.length()); + auto iter = str.begin(); + utf8_state state = s_start; +@@ -204,95 +204,91 @@ public: + if ((state = decode(state, static_cast<std::uint8_t>(*iter++), + codepoint)) == s_start) { + if (codepoint <= 0xffff) { +- result += static_cast<std::wstring::value_type>(codepoint); ++ result += static_cast<std::string::value_type>(codepoint); + } else { + codepoint -= 0x10000; + result += +- static_cast<std::wstring::value_type>((codepoint >> 10) + 0xd800); +- result += static_cast<std::wstring::value_type>((codepoint & 0x3ff) + ++ static_cast<std::string::value_type>((codepoint >> 10) + 0xd800); ++ result += static_cast<std::string::value_type>((codepoint & 0x3ff) + + 0xdc00); + } + codepoint = 0; + } else if (state == s_reject) { +- result += static_cast<std::wstring::value_type>(0xfffd); ++ result += static_cast<std::string::value_type>(0xfffd); + state = s_start; + codepoint = 0; + } + } + if (state) { +- result += static_cast<std::wstring::value_type>(0xfffd); ++ result += static_cast<std::string::value_type>(0xfffd); + } + return result; + } +- static std::wstring from_utf8(char c) ++ static std::string from_utf8(char c) + { +- std::wstring result; ++ std::string result; + utf8_state state = s_start; + std::uint32_t codepoint = 0; + if ((state = decode(state, static_cast<std::uint8_t>(c), codepoint)) == + s_start) { + if (codepoint <= 0xffff) { +- result += static_cast<std::wstring::value_type>(codepoint); ++ result += static_cast<std::string::value_type>(codepoint); + } else { + codepoint -= 0x10000; + result += +- static_cast<std::wstring::value_type>((codepoint >> 10) + 0xd800); ++ static_cast<std::string::value_type>((codepoint >> 10) + 0xd800); + result += +- static_cast<std::wstring::value_type>((codepoint & 0x3ff) + 0xdc00); ++ static_cast<std::string::value_type>((codepoint & 0x3ff) + 0xdc00); + } + } else { +- result += static_cast<std::wstring::value_type>(0xfffd); ++ result += static_cast<std::string::value_type>(0xfffd); + } + return result; + } + }; + +-template <typename In, typename Out> +-class unicode_converter; +- +-template <> +-class unicode_converter<char, wchar_t> ++template <typename Char> ++class unicode<Char, typename std::enable_if<(sizeof(Char) == 1)>::type> ++ : public unicode_helper + { + public: +- std::wstring operator()(const std::string& in) ++ // UTF8 -> UTF8 ++ static std::string to_utf8(const std::string& str) + { +- return unicode<wchar_t>::from_utf8(in); ++ return str; + } +- std::wstring operator()(const char* in) ++ static std::string to_utf8(Char c) + { +- return unicode<wchar_t>::from_utf8(in); ++ return c; + } +- std::wstring operator()(char in) { return unicode<wchar_t>::from_utf8(in); } +-}; +-template <> +-class unicode_converter<wchar_t, char> +-{ +-public: +- std::string operator()(const std::wstring& in) ++ ++ // UTF8 -> UTF8 ++ static std::string from_utf8(const std::string& str) + { +- return unicode<wchar_t>::to_utf8(in); ++ return str; + } +- std::string operator()(const wchar_t* in) ++ static std::string from_utf8(char c) + { +- return unicode<wchar_t>::to_utf8(in); ++ return std::string(1, c); + } +- std::string operator()(wchar_t in) { return unicode<wchar_t>::to_utf8(in); } + }; ++ ++template <typename In, typename Out> ++class unicode_converter; ++ + template <> + class unicode_converter<char, char> + { + public: +- std::string operator()(const std::string& in) { return in; } +- std::string operator()(const char* in) { return std::string(in); } +- std::string operator()(char in) { return std::string(1, in); } +-}; +-template <> +-class unicode_converter<wchar_t, wchar_t> +-{ +-public: +- std::wstring operator()(const std::wstring& in) { return in; } +- std::wstring operator()(const wchar_t* in) { return std::wstring(in); } +- std::wstring operator()(wchar_t in) { return std::wstring(1, in); } ++ std::string operator()(const std::string& in) ++ { ++ return unicode<char>::from_utf8(in); ++ } ++ std::string operator()(const char* in) ++ { ++ return unicode<char>::from_utf8(in); ++ } ++ std::string operator()(char in) { return unicode<char>::from_utf8(in); } + }; + + template <typename In> +@@ -344,50 +340,6 @@ struct string_converter<char> + return std::basic_string<Char>(unicode_converter<char, Char>()(in)); + } + }; +-template <> +-struct string_converter<wchar_t> +-{ +- // some compilers, like gcc 4.8 does not implement the following C++11 +- // signature: +- // std::string::string(const string&, const Allocator&) +- // As workaround, use char* pointer. +- template <typename Char, typename Traits, typename Alloc> +- static std::basic_string<Char, Traits, Alloc> to(const std::wstring& in, +- const Alloc& a) +- { +- return std::basic_string<Char, Traits, Alloc>( +- unicode_converter<wchar_t, Char>()(in).c_str(), a); +- } +- template <typename Char, typename Traits, typename Alloc> +- static std::basic_string<Char, Traits, Alloc> to(const wchar_t* in, +- const Alloc& a) +- { +- return std::basic_string<Char, Traits, Alloc>( +- unicode_converter<wchar_t, Char>()(in).c_str(), a); +- } +- template <typename Char, typename Traits, typename Alloc> +- static std::basic_string<Char, Traits, Alloc> to(wchar_t in, const Alloc& a) +- { +- return std::basic_string<Char, Traits, Alloc>( +- unicode_converter<wchar_t, Char>()(in).c_str(), a); +- } +- +- template <typename Char> +- static std::basic_string<Char> to(const std::wstring& in) +- { +- return std::basic_string<Char>(unicode_converter<wchar_t, Char>()(in)); +- } +- template <typename Char> +- static std::basic_string<Char> to(const wchar_t* in) +- { +- return std::basic_string<Char>(unicode_converter<wchar_t, Char>()(in)); +- } +- template <typename Char> +- static std::basic_string<Char> to(wchar_t in) +- { +- return std::basic_string<Char>(unicode_converter<wchar_t, Char>()(in)); +- } +-}; + + template <typename T, typename = void> + struct source_traits +@@ -470,54 +422,6 @@ struct source_converter<char, char> + static void set_source(std::string& p, std::string&& s) { p = std::move(s); } + }; + +-template <> +-struct source_converter<wchar_t, char> +-{ +- template <typename Iterator> +- static void append_range(std::string& p, Iterator b, Iterator e) +- { +- if (b == e) { +- return; +- } +- +- std::wstring tmp(b, e); +- std::string dest = string_converter<wchar_t>::to<char>(tmp); +- p.append(dest.begin(), dest.end()); +- } +- template <typename Iterator> +- static void append_range(std::string& p, Iterator b) +- { +- wchar_t e = '\0'; +- +- if (*b == e) { +- return; +- } +- std::wstring tmp; +- for (; *b != e; ++b) { +- tmp.push_back(*b); +- } +- +- std::string dest = string_converter<wchar_t>::to<char>(tmp); +- p.append(dest.begin(), dest.end()); +- } +- +- template <typename Traits, typename Alloc> +- static void append_source(std::string& p, +- const std::basic_string<wchar_t, Traits, Alloc>& s) +- { +- append_range(p, s.begin(), s.end()); +- } +- template <typename Source> +- static void append_source(std::string& p, const Source& s) +- { +- append_range(p, s); +- } +- +- static void set_source(std::string& p, std::wstring&& s) +- { +- p = string_converter<wchar_t>::to<char>(s); +- } +-}; + + template <typename T> + struct is_pathable_string : std::false_type +@@ -528,11 +432,6 @@ struct is_pathable_string<std::basic_str + : std::true_type + { + }; +-template <typename Traits, typename Alloc> +-struct is_pathable_string<std::basic_string<wchar_t, Traits, Alloc>> +- : std::true_type +-{ +-}; + template <> + struct is_pathable_string<cm::string_view> : std::true_type + { +@@ -547,10 +446,10 @@ struct is_pathable_char_array< + T, + cm::enable_if_t< + std::is_same<char*, typename std::decay<T>::type>::value || +- std::is_same<wchar_t*, typename std::decay<T>::type>::value, ++ std::is_same<char*, typename std::decay<T>::type>::value, + void>> + : bool_constant<std::is_same<char*, typename std::decay<T>::type>::value || +- std::is_same<wchar_t*, typename std::decay<T>::type>::value> ++ std::is_same<char*, typename std::decay<T>::type>::value> + { + }; + +@@ -566,7 +465,7 @@ struct is_pathable_iterator< + (std::is_same<char, + typename std::iterator_traits< + typename std::decay<T>::type>::value_type>::value || +- std::is_same<wchar_t, ++ std::is_same<char, + typename std::iterator_traits< + typename std::decay<T>::type>::value_type>::value), + void>> +@@ -574,7 +473,7 @@ struct is_pathable_iterator< + std::is_same<char, + typename std::iterator_traits< + typename std::decay<T>::type>::value_type>::value || +- std::is_same<wchar_t, ++ std::is_same<char, + typename std::iterator_traits< + typename std::decay<T>::type>::value_type>::value> + { +@@ -616,7 +515,7 @@ class path + + public: + # if defined(_WIN32) && !defined(__CYGWIN__) +- using value_type = wchar_t; ++ using value_type = char; + # else + using value_type = char; + # endif +@@ -860,8 +759,8 @@ public: + typename Alloc = std::allocator<Char>, + cm::enable_if_t<(std::is_same<Char, char>::value && + std::is_same<Traits, std::char_traits<char>>::value) || +- (std::is_same<Char, wchar_t>::value && +- std::is_same<Traits, std::char_traits<wchar_t>>::value), ++ (std::is_same<Char, char>::value && ++ std::is_same<Traits, std::char_traits<char>>::value), + int> = 1> + std::basic_string<Char, Traits, Alloc> string(const Alloc& a = Alloc()) const + { +@@ -870,11 +769,11 @@ public: + this->path_, a); + } + const std::string string() const { return this->path_; } +- std::wstring wstring() const ++ std::string wstring() const + { + std::string out = this->string(); + return internals::string_converter<path_type::value_type>::to< +- std::wstring::value_type>(out); ++ std::string::value_type>(out); + } + + template < +@@ -882,8 +781,8 @@ public: + typename Alloc = std::allocator<Char>, + cm::enable_if_t<(std::is_same<Char, char>::value && + std::is_same<Traits, std::char_traits<char>>::value) || +- (std::is_same<Char, wchar_t>::value && +- std::is_same<Traits, std::char_traits<wchar_t>>::value), ++ (std::is_same<Char, char>::value && ++ std::is_same<Traits, std::char_traits<char>>::value), + int> = 1> + std::basic_string<Char, Traits, Alloc> generic_string( + const Alloc& a = Alloc()) const +@@ -893,11 +792,11 @@ public: + this->get_generic(), a); + } + std::string generic_string() const { return this->get_generic(); } +- std::wstring generic_wstring() const ++ std::string generic_wstring() const + { + auto dest = this->generic_string(); + return internals::string_converter<path_type::value_type>::to< +- std::wstring::value_type>(dest); ++ std::string::value_type>(dest); + } + + // Compare diff --git a/Ports/cmake/patches/0002-stoi-atoi.patch b/Ports/cmake/patches/0002-stoi-atoi.patch new file mode 100644 index 0000000000..c508c046f1 --- /dev/null +++ b/Ports/cmake/patches/0002-stoi-atoi.patch @@ -0,0 +1,62 @@ +From f9a88260a01aff91971ca88030b74e916a5daa39 Mon Sep 17 00:00:00 2001 +From: AnotherTest <ali.mpfard@gmail.com> +Date: Thu, 11 Feb 2021 19:25:37 +0330 +Subject: [PATCH 02/11] stoi -> atoi + +--- + Source/cmForEachCommand.cxx | 2 +- + Source/cmStandardLevelResolver.cxx | 4 ++-- + Source/cmVSSetupHelper.cxx | 2 +- + 3 files changed, 4 insertions(+), 4 deletions(-) + +diff --git a/Source/cmForEachCommand.cxx b/Source/cmForEachCommand.cxx +index bcacb15..c74cbdb 100644 +--- a/Source/cmForEachCommand.cxx ++++ b/Source/cmForEachCommand.cxx +@@ -359,7 +359,7 @@ bool HandleInMode(std::vector<std::string> const& args, + bool TryParseInteger(cmExecutionStatus& status, const std::string& str, int& i) + { + try { +- i = std::stoi(str); ++ i = atoi((str).c_str()); + } catch (std::invalid_argument&) { + std::ostringstream e; + e << "Invalid integer: '" << str << "'"; +diff --git a/Source/cmStandardLevelResolver.cxx b/Source/cmStandardLevelResolver.cxx +index 8672f61..c418b09 100644 +--- a/Source/cmStandardLevelResolver.cxx ++++ b/Source/cmStandardLevelResolver.cxx +@@ -116,7 +116,7 @@ struct StanardLevelComputer + int standardValue = -1; + int defaultValue = -1; + try { +- standardValue = std::stoi(standardStr); ++ standardValue = atoi((standardStr).c_str()); + defaultValue = std::stoi(*defaultStd); + } catch (std::invalid_argument&) { + // fall through as we want an error +@@ -532,7 +532,7 @@ bool cmStandardLevelResolver::IsLaterStandard(std::string const& lang, + { + auto mapping = StandardComputerMapping.find(lang); + if (mapping != cm::cend(StandardComputerMapping)) { +- return mapping->second.IsLaterStandard(std::stoi(lhs), std::stoi(rhs)); ++ return mapping->second.IsLaterStandard(atoi((lhs).c_str()), atoi((rhs).c_str())); + } + return false; + } +diff --git a/Source/cmVSSetupHelper.cxx b/Source/cmVSSetupHelper.cxx +index 6aa0d15..a4dac5e 100644 +--- a/Source/cmVSSetupHelper.cxx ++++ b/Source/cmVSSetupHelper.cxx +@@ -318,7 +318,7 @@ bool cmVSSetupAPIHelper::EnumerateAndChooseVSInstance() + chosenInstanceInfo.Version = + std::string(envVSVersion.begin(), envVSVersion.end()); + chosenInstanceInfo.VCToolsetVersion = envVSVersion; +- chosenInstanceInfo.ullVersion = std::stoi(envVSVersion); ++ chosenInstanceInfo.ullVersion = atoi((envVSVersion).c_str()); + chosenInstanceInfo.IsWin10SDKInstalled = true; + chosenInstanceInfo.IsWin81SDKInstalled = !envWindowsSdkDir81.empty(); + return true; +-- +2.30.1 + diff --git a/Ports/cmake/patches/0003-stoi-atoi-2.patch b/Ports/cmake/patches/0003-stoi-atoi-2.patch new file mode 100644 index 0000000000..8d55dcc0af --- /dev/null +++ b/Ports/cmake/patches/0003-stoi-atoi-2.patch @@ -0,0 +1,122 @@ +From ba18f1f52135b3dc08e4c7889f214807ce6bb966 Mon Sep 17 00:00:00 2001 +From: AnotherTest <ali.mpfard@gmail.com> +Date: Thu, 11 Feb 2021 19:35:50 +0330 +Subject: [PATCH 03/11] stoi -> atoi 2 + +--- + Source/cmFileCommand.cxx | 2 +- + Source/cmListCommand.cxx | 22 +++++++++++----------- + Source/cmStandardLevelResolver.cxx | 8 ++++---- + 3 files changed, 16 insertions(+), 16 deletions(-) + +diff --git a/Source/cmFileCommand.cxx b/Source/cmFileCommand.cxx +index 372179c..ea9631a 100644 +--- a/Source/cmFileCommand.cxx ++++ b/Source/cmFileCommand.cxx +@@ -3104,7 +3104,7 @@ bool HandleArchiveCreateCommand(std::vector<std::string> const& args, + cmSystemTools::SetFatalErrorOccured(); + return false; + } +- compressionLevel = std::stoi(parsedArgs.CompressionLevel); ++ compressionLevel = atoi((parsedArgs.CompressionLevel).c_str()); + if (compressionLevel < 0 || compressionLevel > 9) { + status.SetError(cmStrCat("compression level ", + parsedArgs.CompressionLevel, +diff --git a/Source/cmListCommand.cxx b/Source/cmListCommand.cxx +index 687273e..a79074d 100644 +--- a/Source/cmListCommand.cxx ++++ b/Source/cmListCommand.cxx +@@ -901,12 +901,12 @@ bool HandleTransformCommand(std::vector<std::string> const& args, + // get all specified indexes + std::vector<int> indexes; + while (args.size() > ++index) { +- std::size_t pos; ++ char* pos; + int value; + + try { +- value = std::stoi(args[index], &pos); +- if (pos != args[index].length()) { ++ value = strtol(args[index].c_str(), &pos, 10); ++ if (pos != args[index].c_str() + args[index]) { + // this is not a number, stop processing + break; + } +@@ -944,15 +944,15 @@ bool HandleTransformCommand(std::vector<std::string> const& args, + int step = 1; + bool valid = true; + try { +- std::size_t pos; ++ char* pos; + +- start = std::stoi(args[index], &pos); +- if (pos != args[index].length()) { ++ start = strtol(args[index].c_str(), &pos, 10); ++ if (pos != args[index].c_str() + args[index].length()) { + // this is not a number + valid = false; + } else { +- stop = std::stoi(args[++index], &pos); +- if (pos != args[index].length()) { ++ start = strtol(args[++index].c_str(), &pos, 10); ++ if (pos != args[index].c_str() + args[index].length()) { + // this is not a number + valid = false; + } +@@ -969,10 +969,10 @@ bool HandleTransformCommand(std::vector<std::string> const& args, + // try to read a third numeric value for step + if (args.size() > ++index) { + try { +- std::size_t pos; ++ char* pos; + +- step = std::stoi(args[index], &pos); +- if (pos != args[index].length()) { ++ start = strtol(args[index].c_str(), &pos, 10); ++ if (pos != args[index].c_str() + args[index].length()) { + // this is not a number + step = 1; + } else { +diff --git a/Source/cmStandardLevelResolver.cxx b/Source/cmStandardLevelResolver.cxx +index c418b09..50510e4 100644 +--- a/Source/cmStandardLevelResolver.cxx ++++ b/Source/cmStandardLevelResolver.cxx +@@ -117,7 +117,7 @@ struct StanardLevelComputer + int defaultValue = -1; + try { + standardValue = atoi((standardStr).c_str()); +- defaultValue = std::stoi(*defaultStd); ++ defaultValue = atoi((*defaultStd).c_str()); + } catch (std::invalid_argument&) { + // fall through as we want an error + // when we can't find the bad value in the `stds` vector +@@ -195,7 +195,7 @@ struct StanardLevelComputer + if (existingStandard) { + existingLevelIter = + std::find(cm::cbegin(this->Levels), cm::cend(this->Levels), +- std::stoi(*existingStandard)); ++ atoi((*existingStandard).c_str())); + if (existingLevelIter == cm::cend(this->Levels)) { + const std::string e = + cmStrCat("The ", this->Language, "_STANDARD property on target \"", +@@ -240,7 +240,7 @@ struct StanardLevelComputer + } + // convert defaultStandard to an integer + if (std::find(cm::cbegin(this->Levels), cm::cend(this->Levels), +- std::stoi(*defaultStandard)) == cm::cend(this->Levels)) { ++ atoi((*defaultStandard).c_str())) == cm::cend(this->Levels)) { + const std::string e = cmStrCat("The CMAKE_", this->Language, + "_STANDARD_DEFAULT variable contains an " + "invalid value: \"", +@@ -257,7 +257,7 @@ struct StanardLevelComputer + + auto existingLevelIter = + std::find(cm::cbegin(this->Levels), cm::cend(this->Levels), +- std::stoi(*existingStandard)); ++ atoi((*existingStandard).c_str())); + if (existingLevelIter == cm::cend(this->Levels)) { + const std::string e = + cmStrCat("The ", this->Language, "_STANDARD property on target \"", +-- +2.30.1 + diff --git a/Ports/cmake/patches/0004-snprintf.patch b/Ports/cmake/patches/0004-snprintf.patch new file mode 100644 index 0000000000..1c92b59791 --- /dev/null +++ b/Ports/cmake/patches/0004-snprintf.patch @@ -0,0 +1,113 @@ +From a624e066281d23fe8d5e36768e15ddf847693179 Mon Sep 17 00:00:00 2001 +From: AnotherTest <ali.mpfard@gmail.com> +Date: Thu, 11 Feb 2021 21:04:56 +0330 +Subject: [PATCH 04/11] snprintf! + +--- + Modules/FindCUDA/select_compute_arch.cmake | 2 +- + Source/cmProjectCommand.cxx | 2 +- + Source/cmStringAlgorithms.cxx | 2 +- + Tests/RunCMake/Android/android.cxx | 2 +- + Utilities/cmjsoncpp/src/lib_json/json_reader.cpp | 4 ++-- + Utilities/cmjsoncpp/src/lib_json/json_writer.cpp | 4 ++-- + 6 files changed, 8 insertions(+), 8 deletions(-) + +diff --git a/Modules/FindCUDA/select_compute_arch.cmake b/Modules/FindCUDA/select_compute_arch.cmake +index 9351288..6b31fc2 100644 +--- a/Modules/FindCUDA/select_compute_arch.cmake ++++ b/Modules/FindCUDA/select_compute_arch.cmake +@@ -132,7 +132,7 @@ function(CUDA_DETECT_INSTALLED_GPUS OUT_VARIABLE) + " {\n" + " cudaDeviceProp prop;\n" + " if (cudaSuccess == cudaGetDeviceProperties(&prop, device))\n" +- " std::printf(\"%d.%d \", prop.major, prop.minor);\n" ++ " printf(\"%d.%d \", prop.major, prop.minor);\n" + " }\n" + " return 0;\n" + "}\n") +diff --git a/Source/cmProjectCommand.cxx b/Source/cmProjectCommand.cxx +index f8678b9..05a76ad 100644 +--- a/Source/cmProjectCommand.cxx ++++ b/Source/cmProjectCommand.cxx +@@ -237,7 +237,7 @@ bool cmProjectCommand(std::vector<std::string> const& args, + &v[2], &v[3]); + for (auto i = 0u; i < MAX_VERSION_COMPONENTS; ++i) { + if (int(i) < vc) { +- std::sprintf(vb[i], "%u", v[i]); ++ sprintf(vb[i], "%u", v[i]); + version_string += &"."[std::size_t(i == 0)]; + version_string += vb[i]; + version_components[i] = vb[i]; +diff --git a/Source/cmStringAlgorithms.cxx b/Source/cmStringAlgorithms.cxx +index e0af281..f0a50cc 100644 +--- a/Source/cmStringAlgorithms.cxx ++++ b/Source/cmStringAlgorithms.cxx +@@ -152,7 +152,7 @@ template <std::size_t N, typename T> + inline void MakeDigits(cm::string_view& view, char (&digits)[N], + const char* pattern, T value) + { +- int res = std::snprintf(digits, N, pattern, value); ++ int res = snprintf(digits, N, pattern, value); + if (res > 0 && res < static_cast<int>(N)) { + view = cm::string_view(digits, static_cast<std::size_t>(res)); + } +diff --git a/Tests/RunCMake/Android/android.cxx b/Tests/RunCMake/Android/android.cxx +index a6d8c55..f47611e 100644 +--- a/Tests/RunCMake/Android/android.cxx ++++ b/Tests/RunCMake/Android/android.cxx +@@ -20,7 +20,7 @@ int main() + { + #if !defined(STL_NONE) + // Require -lm implied by linking as C++. +- std::printf("%p\n", static_cast<double (*)(double)>(&std::sin)); ++ printf("%p\n", static_cast<double (*)(double)>(&std::sin)); + #endif + #if defined(STL_NONE) + return 0; +diff --git a/Utilities/cmjsoncpp/src/lib_json/json_reader.cpp b/Utilities/cmjsoncpp/src/lib_json/json_reader.cpp +index 6eeba0e..80389e5 100644 +--- a/Utilities/cmjsoncpp/src/lib_json/json_reader.cpp ++++ b/Utilities/cmjsoncpp/src/lib_json/json_reader.cpp +@@ -24,7 +24,7 @@ + #if !defined(WINCE) && defined(__STDC_SECURE_LIB__) && _MSC_VER >= 1500 // VC++ 9.0 and above + #define snprintf sprintf_s + #elif _MSC_VER >= 1900 // VC++ 14.0 and above +-#define snprintf std::snprintf ++#define snprintf snprintf + #else + #define snprintf _snprintf + #endif +@@ -32,7 +32,7 @@ + #define snprintf snprintf + #elif __cplusplus >= 201103L + #if !defined(__MINGW32__) && !defined(__CYGWIN__) +-#define snprintf std::snprintf ++#define snprintf snprintf + #endif + #endif + +diff --git a/Utilities/cmjsoncpp/src/lib_json/json_writer.cpp b/Utilities/cmjsoncpp/src/lib_json/json_writer.cpp +index fc86505..abaa661 100644 +--- a/Utilities/cmjsoncpp/src/lib_json/json_writer.cpp ++++ b/Utilities/cmjsoncpp/src/lib_json/json_writer.cpp +@@ -50,7 +50,7 @@ + #if !defined(WINCE) && defined(__STDC_SECURE_LIB__) && _MSC_VER >= 1500 // VC++ 9.0 and above + #define snprintf sprintf_s + #elif _MSC_VER >= 1900 // VC++ 14.0 and above +-#define snprintf std::snprintf ++#define snprintf snprintf + #else + #define snprintf _snprintf + #endif +@@ -58,7 +58,7 @@ + #define snprintf snprintf + #elif __cplusplus >= 201103L + #if !defined(__MINGW32__) && !defined(__CYGWIN__) +-#define snprintf std::snprintf ++#define snprintf snprintf + #endif + #endif + +-- +2.30.1 + diff --git a/Ports/cmake/patches/0005-stod.patch b/Ports/cmake/patches/0005-stod.patch new file mode 100644 index 0000000000..dbb3e9f898 --- /dev/null +++ b/Ports/cmake/patches/0005-stod.patch @@ -0,0 +1,207 @@ +From edc401ceb014f8ec5d80d3d2b7b7e9c1e86a27ed Mon Sep 17 00:00:00 2001 +From: AnotherTest <ali.mpfard@gmail.com> +Date: Thu, 11 Feb 2021 21:22:45 +0330 +Subject: [PATCH 05/11] stod + +--- + Help/guide/importing-exporting/Downstream/main.cc | 2 +- + Help/guide/importing-exporting/DownstreamComponents/main.cc | 2 +- + Help/guide/tutorial/Complete/tutorial.cxx | 2 +- + Help/guide/tutorial/Step10/tutorial.cxx | 2 +- + Help/guide/tutorial/Step11/tutorial.cxx | 2 +- + Help/guide/tutorial/Step12/tutorial.cxx | 2 +- + Help/guide/tutorial/Step2/tutorial.cxx | 2 +- + Help/guide/tutorial/Step3/tutorial.cxx | 2 +- + Help/guide/tutorial/Step4/tutorial.cxx | 2 +- + Help/guide/tutorial/Step5/tutorial.cxx | 2 +- + Help/guide/tutorial/Step6/tutorial.cxx | 2 +- + Help/guide/tutorial/Step7/tutorial.cxx | 2 +- + Help/guide/tutorial/Step8/tutorial.cxx | 2 +- + Help/guide/tutorial/Step9/tutorial.cxx | 2 +- + 14 files changed, 14 insertions(+), 14 deletions(-) + +diff --git a/Help/guide/importing-exporting/Downstream/main.cc b/Help/guide/importing-exporting/Downstream/main.cc +index 8574373..0956348 100644 +--- a/Help/guide/importing-exporting/Downstream/main.cc ++++ b/Help/guide/importing-exporting/Downstream/main.cc +@@ -12,7 +12,7 @@ int main(int argc, char* argv[]) + } + + // convert input to double +- const double inputValue = std::stod(argv[1]); ++ const double inputValue = strtod(argv[1].c_str(), nullptr); + + // calculate square root + const double sqrt = MathFunctions::sqrt(inputValue); +diff --git a/Help/guide/importing-exporting/DownstreamComponents/main.cc b/Help/guide/importing-exporting/DownstreamComponents/main.cc +index f5e8fa6..9f8be40 100644 +--- a/Help/guide/importing-exporting/DownstreamComponents/main.cc ++++ b/Help/guide/importing-exporting/DownstreamComponents/main.cc +@@ -13,7 +13,7 @@ int main(int argc, char* argv[]) + } + + // convert input to double +- const double inputValue = std::stod(argv[1]); ++ const double inputValue = strtod(argv[1].c_str(), nullptr); + + // calculate square root + const double sqrt = MathFunctions::sqrt(inputValue); +diff --git a/Help/guide/tutorial/Complete/tutorial.cxx b/Help/guide/tutorial/Complete/tutorial.cxx +index a4f44d5..06627a9 100644 +--- a/Help/guide/tutorial/Complete/tutorial.cxx ++++ b/Help/guide/tutorial/Complete/tutorial.cxx +@@ -16,7 +16,7 @@ int main(int argc, char* argv[]) + } + + // convert input to double +- const double inputValue = std::stod(argv[1]); ++ const double inputValue = strtod(argv[1].c_str(), nullptr); + + const double outputValue = mathfunctions::sqrt(inputValue); + +diff --git a/Help/guide/tutorial/Step10/tutorial.cxx b/Help/guide/tutorial/Step10/tutorial.cxx +index 37a0333..553f35a 100644 +--- a/Help/guide/tutorial/Step10/tutorial.cxx ++++ b/Help/guide/tutorial/Step10/tutorial.cxx +@@ -17,7 +17,7 @@ int main(int argc, char* argv[]) + } + + // convert input to double +- const double inputValue = std::stod(argv[1]); ++ const double inputValue = strtod(argv[1].c_str(), nullptr); + + const double outputValue = mathfunctions::sqrt(inputValue); + +diff --git a/Help/guide/tutorial/Step11/tutorial.cxx b/Help/guide/tutorial/Step11/tutorial.cxx +index a4f44d5..06627a9 100644 +--- a/Help/guide/tutorial/Step11/tutorial.cxx ++++ b/Help/guide/tutorial/Step11/tutorial.cxx +@@ -16,7 +16,7 @@ int main(int argc, char* argv[]) + } + + // convert input to double +- const double inputValue = std::stod(argv[1]); ++ const double inputValue = strtod(argv[1].c_str(), nullptr); + + const double outputValue = mathfunctions::sqrt(inputValue); + +diff --git a/Help/guide/tutorial/Step12/tutorial.cxx b/Help/guide/tutorial/Step12/tutorial.cxx +index a4f44d5..06627a9 100644 +--- a/Help/guide/tutorial/Step12/tutorial.cxx ++++ b/Help/guide/tutorial/Step12/tutorial.cxx +@@ -16,7 +16,7 @@ int main(int argc, char* argv[]) + } + + // convert input to double +- const double inputValue = std::stod(argv[1]); ++ const double inputValue = strtod(argv[1].c_str(), nullptr); + + const double outputValue = mathfunctions::sqrt(inputValue); + +diff --git a/Help/guide/tutorial/Step2/tutorial.cxx b/Help/guide/tutorial/Step2/tutorial.cxx +index 53b0810..7ab6adb 100644 +--- a/Help/guide/tutorial/Step2/tutorial.cxx ++++ b/Help/guide/tutorial/Step2/tutorial.cxx +@@ -16,7 +16,7 @@ int main(int argc, char* argv[]) + } + + // convert input to double +- const double inputValue = std::stod(argv[1]); ++ const double inputValue = strtod(argv[1].c_str(), nullptr); + + // calculate square root + const double outputValue = sqrt(inputValue); +diff --git a/Help/guide/tutorial/Step3/tutorial.cxx b/Help/guide/tutorial/Step3/tutorial.cxx +index b3c6a4f..7bfb60b 100644 +--- a/Help/guide/tutorial/Step3/tutorial.cxx ++++ b/Help/guide/tutorial/Step3/tutorial.cxx +@@ -21,7 +21,7 @@ int main(int argc, char* argv[]) + } + + // convert input to double +- const double inputValue = std::stod(argv[1]); ++ const double inputValue = strtod(argv[1].c_str(), nullptr); + + // which square root function should we use? + #ifdef USE_MYMATH +diff --git a/Help/guide/tutorial/Step4/tutorial.cxx b/Help/guide/tutorial/Step4/tutorial.cxx +index b3c6a4f..7bfb60b 100644 +--- a/Help/guide/tutorial/Step4/tutorial.cxx ++++ b/Help/guide/tutorial/Step4/tutorial.cxx +@@ -21,7 +21,7 @@ int main(int argc, char* argv[]) + } + + // convert input to double +- const double inputValue = std::stod(argv[1]); ++ const double inputValue = strtod(argv[1].c_str(), nullptr); + + // which square root function should we use? + #ifdef USE_MYMATH +diff --git a/Help/guide/tutorial/Step5/tutorial.cxx b/Help/guide/tutorial/Step5/tutorial.cxx +index b3c6a4f..7bfb60b 100644 +--- a/Help/guide/tutorial/Step5/tutorial.cxx ++++ b/Help/guide/tutorial/Step5/tutorial.cxx +@@ -21,7 +21,7 @@ int main(int argc, char* argv[]) + } + + // convert input to double +- const double inputValue = std::stod(argv[1]); ++ const double inputValue = strtod(argv[1].c_str(), nullptr); + + // which square root function should we use? + #ifdef USE_MYMATH +diff --git a/Help/guide/tutorial/Step6/tutorial.cxx b/Help/guide/tutorial/Step6/tutorial.cxx +index b3c6a4f..7bfb60b 100644 +--- a/Help/guide/tutorial/Step6/tutorial.cxx ++++ b/Help/guide/tutorial/Step6/tutorial.cxx +@@ -21,7 +21,7 @@ int main(int argc, char* argv[]) + } + + // convert input to double +- const double inputValue = std::stod(argv[1]); ++ const double inputValue = strtod(argv[1].c_str(), nullptr); + + // which square root function should we use? + #ifdef USE_MYMATH +diff --git a/Help/guide/tutorial/Step7/tutorial.cxx b/Help/guide/tutorial/Step7/tutorial.cxx +index b3c6a4f..7bfb60b 100644 +--- a/Help/guide/tutorial/Step7/tutorial.cxx ++++ b/Help/guide/tutorial/Step7/tutorial.cxx +@@ -21,7 +21,7 @@ int main(int argc, char* argv[]) + } + + // convert input to double +- const double inputValue = std::stod(argv[1]); ++ const double inputValue = strtod(argv[1].c_str(), nullptr); + + // which square root function should we use? + #ifdef USE_MYMATH +diff --git a/Help/guide/tutorial/Step8/tutorial.cxx b/Help/guide/tutorial/Step8/tutorial.cxx +index b3c6a4f..7bfb60b 100644 +--- a/Help/guide/tutorial/Step8/tutorial.cxx ++++ b/Help/guide/tutorial/Step8/tutorial.cxx +@@ -21,7 +21,7 @@ int main(int argc, char* argv[]) + } + + // convert input to double +- const double inputValue = std::stod(argv[1]); ++ const double inputValue = strtod(argv[1].c_str(), nullptr); + + // which square root function should we use? + #ifdef USE_MYMATH +diff --git a/Help/guide/tutorial/Step9/tutorial.cxx b/Help/guide/tutorial/Step9/tutorial.cxx +index b3c6a4f..7bfb60b 100644 +--- a/Help/guide/tutorial/Step9/tutorial.cxx ++++ b/Help/guide/tutorial/Step9/tutorial.cxx +@@ -21,7 +21,7 @@ int main(int argc, char* argv[]) + } + + // convert input to double +- const double inputValue = std::stod(argv[1]); ++ const double inputValue = strtod(argv[1].c_str(), nullptr); + + // which square root function should we use? + #ifdef USE_MYMATH +-- +2.30.1 + diff --git a/Ports/cmake/patches/0006-stoll.patch b/Ports/cmake/patches/0006-stoll.patch new file mode 100644 index 0000000000..7e41a99fc7 --- /dev/null +++ b/Ports/cmake/patches/0006-stoll.patch @@ -0,0 +1,93 @@ +From fbb008a5185a002c89c2ce3c3b1cf15042635d91 Mon Sep 17 00:00:00 2001 +From: AnotherTest <ali.mpfard@gmail.com> +Date: Thu, 11 Feb 2021 21:24:11 +0330 +Subject: [PATCH 06/11] stoll + +--- + Source/LexerParser/cmCTestResourceGroupsLexer.cxx | 4 ++-- + Source/LexerParser/cmCTestResourceGroupsLexer.in.l | 4 ++-- + Source/LexerParser/cmExprLexer.cxx | 4 ++-- + Source/LexerParser/cmExprLexer.in.l | 4 ++-- + 4 files changed, 8 insertions(+), 8 deletions(-) + +diff --git a/Source/LexerParser/cmCTestResourceGroupsLexer.cxx b/Source/LexerParser/cmCTestResourceGroupsLexer.cxx +index de07c46..3f59b61 100644 +--- a/Source/LexerParser/cmCTestResourceGroupsLexer.cxx ++++ b/Source/LexerParser/cmCTestResourceGroupsLexer.cxx +@@ -992,14 +992,14 @@ YY_RULE_SETUP + { + BEGIN(RESOURCE_GROUPS_END); +- std::size_t len = yyleng; +- yyextra->SetProcessCount(std::stoll(yytext, &len, 10)); ++ char* end = nullptr; ++ yyextra->SetProcessCount(strtoll(yytext, &end, 10)); + } + YY_BREAK + case 3: + YY_RULE_SETUP + { + BEGIN(RESOURCE_END); +- std::size_t len = yyleng; +- yyextra->SetNeededSlots(std::stoll(yytext, &len, 10)); ++ char* end = nullptr; ++ yyextra->SetNeededSlots(strtoll(yytext, &end, 10)); + yyextra->WriteRequirement(); + } +diff --git a/Source/LexerParser/cmCTestResourceGroupsLexer.in.l b/Source/LexerParser/cmCTestResourceGroupsLexer.in.l +index 2aabea4..ca5f3e5 100644 +--- a/Source/LexerParser/cmCTestResourceGroupsLexer.in.l ++++ b/Source/LexerParser/cmCTestResourceGroupsLexer.in.l +@@ -55,13 +55,13 @@ IDENTIFIER [a-z_][a-z0-9_]* + <INITIAL,RESOURCE_GROUPS_START>{NUMBER} { + BEGIN(RESOURCE_GROUPS_END); +- std::size_t len = yyleng; +- yyextra->SetProcessCount(std::stoll(yytext, &len, 10)); ++ char* end = nullptr; ++ yyextra->SetNeededSlots(strtoll(yytext, &end, 10)); + } + + <RESOURCE_COUNT>{NUMBER} { + BEGIN(RESOURCE_END); +- std::size_t len = yyleng; +- yyextra->SetNeededSlots(std::stoll(yytext, &len, 10)); ++ char* end = nullptr; ++ yyextra->SetNeededSlots(strtoll(yytext, &end, 10)); + yyextra->WriteRequirement(); + } + +diff --git a/Source/LexerParser/cmExprLexer.cxx b/Source/LexerParser/cmExprLexer.cxx +index 72e59b6..6b743e0 100644 +--- a/Source/LexerParser/cmExprLexer.cxx ++++ b/Source/LexerParser/cmExprLexer.cxx +@@ -992,11 +992,11 @@ YY_RULE_SETUP + YY_BREAK + case 2: + YY_RULE_SETUP +-{ yylvalp->Number = std::stoll(yytext, nullptr, 10); return exp_NUMBER; } ++{ yylvalp->Number = strtoll(yytext, nullptr, 10); return exp_NUMBER; } + YY_BREAK + case 3: + YY_RULE_SETUP +-{ yylvalp->Number = std::stoll(yytext, nullptr, 16); return exp_NUMBER; } ++{ yylvalp->Number = strtoll(yytext, nullptr, 16); return exp_NUMBER; } + YY_BREAK + case 4: + YY_RULE_SETUP +diff --git a/Source/LexerParser/cmExprLexer.in.l b/Source/LexerParser/cmExprLexer.in.l +index f8a4224..822aaf5 100644 +--- a/Source/LexerParser/cmExprLexer.in.l ++++ b/Source/LexerParser/cmExprLexer.in.l +@@ -44,8 +44,8 @@ Modify cmExprLexer.cxx: + %% + [ \t] {} + +-[0-9][0-9]* { yylvalp->Number = std::stoll(yytext, nullptr, 10); return exp_NUMBER; } +-0[xX][0-9a-fA-F][0-9a-fA-F]* { yylvalp->Number = std::stoll(yytext, nullptr, 16); return exp_NUMBER; } ++[0-9][0-9]* { yylvalp->Number = strtoll(yytext, nullptr, 10); return exp_NUMBER; } ++0[xX][0-9a-fA-F][0-9a-fA-F]* { yylvalp->Number = strtoll(yytext, nullptr, 16); return exp_NUMBER; } + + "+" { return exp_PLUS; } + "-" { return exp_MINUS; } +-- +2.30.1 + diff --git a/Ports/cmake/patches/0007-utimes-utime.patch b/Ports/cmake/patches/0007-utimes-utime.patch new file mode 100644 index 0000000000..632b1cf07b --- /dev/null +++ b/Ports/cmake/patches/0007-utimes-utime.patch @@ -0,0 +1,145 @@ +From dc70b3830887eea5f28e3e626b4c4ef492d77ce0 Mon Sep 17 00:00:00 2001 +From: AnotherTest <ali.mpfard@gmail.com> +Date: Thu, 11 Feb 2021 21:40:57 +0330 +Subject: [PATCH 07/11] utimes->utime + +--- + Source/kwsys/CMakeLists.txt | 2 +- + Source/kwsys/SystemTools.cxx | 4 ++-- + Source/kwsys/kwsysPlatformTestsCXX.cxx | 2 +- + Utilities/cmlibarchive/CMakeLists.txt | 2 +- + Utilities/cmlibarchive/build/cmake/config.h.in | 2 +- + .../cmlibarchive/libarchive/archive_read_disk_posix.c | 2 +- + .../cmlibarchive/libarchive/archive_write_disk_posix.c | 8 ++++---- + Utilities/cmlibuv/src/unix/fs.c | 2 +- + 8 files changed, 12 insertions(+), 12 deletions(-) + +diff --git a/Source/kwsys/CMakeLists.txt b/Source/kwsys/CMakeLists.txt +index 77adae2..52bc809 100644 +--- a/Source/kwsys/CMakeLists.txt ++++ b/Source/kwsys/CMakeLists.txt +@@ -431,7 +431,7 @@ if(KWSYS_USE_SystemTools) + KWSYS_PLATFORM_CXX_TEST(KWSYS_CXX_HAS_ENVIRON_IN_STDLIB_H + "Checking whether CXX compiler has environ in stdlib.h" DIRECT) + KWSYS_PLATFORM_CXX_TEST(KWSYS_CXX_HAS_UTIMES +- "Checking whether CXX compiler has utimes" DIRECT) ++ "Checking whether CXX compiler has utime" DIRECT) + KWSYS_PLATFORM_CXX_TEST(KWSYS_CXX_HAS_UTIMENSAT + "Checking whether CXX compiler has utimensat" DIRECT) + KWSYS_PLATFORM_CXX_TEST(KWSYS_CXX_STAT_HAS_ST_MTIM +diff --git a/Source/kwsys/SystemTools.cxx b/Source/kwsys/SystemTools.cxx +index fbe7ed9..b0c6d5c 100644 +--- a/Source/kwsys/SystemTools.cxx ++++ b/Source/kwsys/SystemTools.cxx +@@ -1445,8 +1445,8 @@ bool SystemTools::Touch(const std::string& filename, bool create) + return false; + } + #else +- // fall back to utimes +- if (utimes(filename.c_str(), nullptr) < 0) { ++ // fall back to utime ++ if (utime(filename.c_str(), nullptr) < 0) { + return false; + } + #endif +diff --git a/Source/kwsys/kwsysPlatformTestsCXX.cxx b/Source/kwsys/kwsysPlatformTestsCXX.cxx +index 195a461..f5f50b4 100644 +--- a/Source/kwsys/kwsysPlatformTestsCXX.cxx ++++ b/Source/kwsys/kwsysPlatformTestsCXX.cxx +@@ -82,7 +82,7 @@ int main() + int main() + { + struct timeval* current_time = 0; +- return utimes("/example", current_time); ++ return utime("/example", current_time); + } + #endif + +diff --git a/Utilities/cmlibarchive/CMakeLists.txt b/Utilities/cmlibarchive/CMakeLists.txt +index 9d6f9a2..c49043a 100644 +--- a/Utilities/cmlibarchive/CMakeLists.txt ++++ b/Utilities/cmlibarchive/CMakeLists.txt +@@ -1411,7 +1411,7 @@ CHECK_FUNCTION_EXISTS_GLIBC(tzset HAVE_TZSET) + CHECK_FUNCTION_EXISTS_GLIBC(unlinkat HAVE_UNLINKAT) + CHECK_FUNCTION_EXISTS_GLIBC(unsetenv HAVE_UNSETENV) + CHECK_FUNCTION_EXISTS_GLIBC(utime HAVE_UTIME) +-CHECK_FUNCTION_EXISTS_GLIBC(utimes HAVE_UTIMES) ++CHECK_FUNCTION_EXISTS_GLIBC(utime HAVE_UTIMES) + CHECK_FUNCTION_EXISTS_GLIBC(utimensat HAVE_UTIMENSAT) + CHECK_FUNCTION_EXISTS_GLIBC(vfork HAVE_VFORK) + CHECK_FUNCTION_EXISTS_GLIBC(wcrtomb HAVE_WCRTOMB) +diff --git a/Utilities/cmlibarchive/build/cmake/config.h.in b/Utilities/cmlibarchive/build/cmake/config.h.in +index 4c746b7..2407b94 100644 +--- a/Utilities/cmlibarchive/build/cmake/config.h.in ++++ b/Utilities/cmlibarchive/build/cmake/config.h.in +@@ -916,7 +916,7 @@ + /* Define to 1 if you have the `utimensat' function. */ + #cmakedefine HAVE_UTIMENSAT 1 + +-/* Define to 1 if you have the `utimes' function. */ ++/* Define to 1 if you have the `utime' function. */ + #cmakedefine HAVE_UTIMES 1 + + /* Define to 1 if you have the <utime.h> header file. */ +diff --git a/Utilities/cmlibarchive/libarchive/archive_read_disk_posix.c b/Utilities/cmlibarchive/libarchive/archive_read_disk_posix.c +index 6dd1fd9..2fa08d4 100644 +--- a/Utilities/cmlibarchive/libarchive/archive_read_disk_posix.c ++++ b/Utilities/cmlibarchive/libarchive/archive_read_disk_posix.c +@@ -2043,7 +2043,7 @@ close_and_restore_time(int fd, struct tree *t, struct restore_time *rt) + #ifdef HAVE_LUTIMES + if (lutimes(rt->name, times) != 0) + #else +- if (AE_IFLNK != rt->filetype && utimes(rt->name, times) != 0) ++ if (AE_IFLNK != rt->filetype && utime(rt->name, times) != 0) + #endif + return (-1); + #endif +diff --git a/Utilities/cmlibarchive/libarchive/archive_write_disk_posix.c b/Utilities/cmlibarchive/libarchive/archive_write_disk_posix.c +index 67da3e1..157e27a 100644 +--- a/Utilities/cmlibarchive/libarchive/archive_write_disk_posix.c ++++ b/Utilities/cmlibarchive/libarchive/archive_write_disk_posix.c +@@ -3365,8 +3365,8 @@ set_time(int fd, int mode, const char *name, + + #elif HAVE_UTIMES + /* +- * The utimes()-family functions support µs-resolution and +- * setting times fds and symlinks. utimes() is documented as ++ * The utime()-family functions support µs-resolution and ++ * setting times fds and symlinks. utime() is documented as + * LEGACY by POSIX, futimes() and lutimes() are not described + * in POSIX. + */ +@@ -3389,7 +3389,7 @@ set_time(int fd, int mode, const char *name, + #else + if (S_ISLNK(mode)) + return (0); +- return (utimes(name, times)); ++ return (utime(name, times)); + #endif + + #elif defined(HAVE_UTIME) +@@ -3477,7 +3477,7 @@ set_times(struct archive_write_disk *a, + #ifdef HAVE_STRUCT_STAT_ST_BIRTHTIME + /* + * If you have struct stat.st_birthtime, we assume BSD +- * birthtime semantics, in which {f,l,}utimes() updates ++ * birthtime semantics, in which {f,l,}utime() updates + * birthtime to earliest mtime. So we set the time twice, + * first using the birthtime, then using the mtime. If + * birthtime == mtime, this isn't necessary, so we skip it. +diff --git a/Utilities/cmlibuv/src/unix/fs.c b/Utilities/cmlibuv/src/unix/fs.c +index 6d57cee..48c0123 100644 +--- a/Utilities/cmlibuv/src/unix/fs.c ++++ b/Utilities/cmlibuv/src/unix/fs.c +@@ -1036,7 +1036,7 @@ static ssize_t uv__fs_utime(uv_fs_t* req) { + struct timeval tv[2]; + tv[0] = uv__fs_to_timeval(req->atime); + tv[1] = uv__fs_to_timeval(req->mtime); +- return utimes(req->path, tv); ++ return utime(req->path, tv); + #elif defined(_AIX) \ + && !defined(_AIX71) + struct utimbuf buf; +-- +2.30.1 + diff --git a/Ports/cmake/patches/0008-unix-stuff.patch b/Ports/cmake/patches/0008-unix-stuff.patch new file mode 100644 index 0000000000..5c49fe2a65 --- /dev/null +++ b/Ports/cmake/patches/0008-unix-stuff.patch @@ -0,0 +1,76 @@ +From d8b3a1a970d92d5e66a7caa3805a56c186027f44 Mon Sep 17 00:00:00 2001 +From: AnotherTest <ali.mpfard@gmail.com> +Date: Fri, 12 Feb 2021 03:12:38 +0330 +Subject: [PATCH 08/11] unix stuff + +--- + Utilities/cmlibuv/src/unix/core.c | 26 +++++++++++++++++++++++++- + 1 file changed, 25 insertions(+), 1 deletion(-) + +diff --git a/Utilities/cmlibuv/src/unix/core.c b/Utilities/cmlibuv/src/unix/core.c +index e6d61ee..f90d9a3 100644 +--- a/Utilities/cmlibuv/src/unix/core.c ++++ b/Utilities/cmlibuv/src/unix/core.c +@@ -578,6 +578,14 @@ int uv__close(int fd) { + } + + ++#if defined(_AIX) || \ ++ defined(__APPLE__) || \ ++ defined(__DragonFly__) || \ ++ defined(__FreeBSD__) || \ ++ defined(__FreeBSD_kernel__) || \ ++ defined(__linux__) || \ ++ defined(__OpenBSD__) || \ ++ defined(__NetBSD__) + int uv__nonblock_ioctl(int fd, int set) { + int r; + +@@ -590,9 +598,18 @@ int uv__nonblock_ioctl(int fd, int set) { + + return 0; + } ++#endif + + +-#if !defined(__hpux) && !defined(__CYGWIN__) && !defined(__MSYS__) && !defined(__HAIKU__) ++#if defined(_AIX) || \ ++ defined(__APPLE__) || \ ++ defined(__DragonFly__) || \ ++ defined(__FreeBSD__) || \ ++ defined(__FreeBSD_kernel__) || \ ++ defined(__linux__) || \ ++ defined(__OpenBSD__) || \ ++ defined(__NetBSD__) ++ + int uv__cloexec_ioctl(int fd, int set) { + int r; + +@@ -1422,8 +1439,13 @@ int uv_os_getpriority(uv_pid_t pid, int* priority) { + if (priority == NULL) + return UV_EINVAL; + ++ /* + errno = 0; + r = getpriority(PRIO_PROCESS, (int) pid); ++ */ ++ ++ errno = 0; ++ r = 1; + + if (r == -1 && errno != 0) + return UV__ERR(errno); +@@ -1437,8 +1459,10 @@ int uv_os_setpriority(uv_pid_t pid, int priority) { + if (priority < UV_PRIORITY_HIGHEST || priority > UV_PRIORITY_LOW) + return UV_EINVAL; + ++ /* + if (setpriority(PRIO_PROCESS, (int) pid, priority) != 0) + return UV__ERR(errno); ++ */ + + return 0; + } +-- +2.30.1 + diff --git a/Ports/cmake/patches/0009-purge-non-serenity-syscalls.patch b/Ports/cmake/patches/0009-purge-non-serenity-syscalls.patch new file mode 100644 index 0000000000..e0c8e4e66e --- /dev/null +++ b/Ports/cmake/patches/0009-purge-non-serenity-syscalls.patch @@ -0,0 +1,199 @@ +From 6939797ada5dbf5545d857cc60cfd5a8ceddb0ae Mon Sep 17 00:00:00 2001 +From: AnotherTest <ali.mpfard@gmail.com> +Date: Fri, 12 Feb 2021 04:49:01 +0330 +Subject: [PATCH 09/11] purge non-serenity syscalls + +very breaky! +--- + Utilities/cmlibuv/src/unix/fs.c | 31 ++++++++++++++++++++++++++++ + Utilities/cmlibuv/src/unix/poll.c | 2 ++ + Utilities/cmlibuv/src/unix/process.c | 2 ++ + Utilities/cmlibuv/src/unix/stream.c | 3 +-- + 4 files changed, 36 insertions(+), 2 deletions(-) + +diff --git a/Utilities/cmlibuv/src/unix/fs.c b/Utilities/cmlibuv/src/unix/fs.c +index 48c0123..fd102a8 100644 +--- a/Utilities/cmlibuv/src/unix/fs.c ++++ b/Utilities/cmlibuv/src/unix/fs.c +@@ -85,6 +85,8 @@ + defined(__HAIKU__) || \ + defined(__QNX__) + # include <sys/statvfs.h> ++#elif defined(__serenity__) ++// No statfs + #else + # include <sys/statfs.h> + #endif +@@ -540,7 +542,11 @@ static ssize_t uv__fs_scandir(uv_fs_t* req) { + int n; + + dents = NULL; ++#ifndef __serenity__ + n = scandir(req->path, &dents, uv__fs_scandir_filter, uv__fs_scandir_sort); ++#else ++ n = 0; ++#endif + + /* NOTE: We will use nbufs as an index field */ + req->nbufs = 0; +@@ -651,6 +657,9 @@ static int uv__fs_statfs(uv_fs_t* req) { + struct statvfs buf; + + if (0 != statvfs(req->path, &buf)) ++#elif defined(__serenity__) ++ char buf = 0; ++ if (1) + #else + struct statfs buf; + +@@ -658,6 +667,7 @@ static int uv__fs_statfs(uv_fs_t* req) { + #endif /* defined(__sun) */ + return -1; + ++#if !defined(__serenity__) + stat_fs = uv__malloc(sizeof(*stat_fs)); + if (stat_fs == NULL) { + errno = ENOMEM; +@@ -681,6 +691,7 @@ static int uv__fs_statfs(uv_fs_t* req) { + stat_fs->f_files = buf.f_files; + stat_fs->f_ffree = buf.f_ffree; + req->ptr = stat_fs; ++#endif // !defined(__serenity__) + return 0; + } + +@@ -1107,7 +1118,11 @@ static ssize_t uv__fs_write(uv_fs_t* req) { + r = writev(req->file, (struct iovec*) req->bufs, req->nbufs); + } else { + if (req->nbufs == 1) { ++# if defined(__serenity__) ++ r = -1; ++# else + r = pwrite(req->file, req->bufs[0].base, req->bufs[0].len, req->off); ++# endif + goto done; + } + #if HAVE_PREADV +@@ -1117,7 +1132,11 @@ static ssize_t uv__fs_write(uv_fs_t* req) { + if (no_pwritev) retry: + # endif + { ++# if defined(__serenity__) ++ r = -1; ++# else + r = pwrite(req->file, req->bufs[0].base, req->bufs[0].len, req->off); ++# endif + } + # if defined(__linux__) + else { +@@ -1604,7 +1623,9 @@ static void uv__fs_work(struct uv__work* w) { + X(COPYFILE, uv__fs_copyfile(req)); + X(FCHMOD, fchmod(req->file, req->mode)); + X(FCHOWN, fchown(req->file, req->uid, req->gid)); ++#ifndef __serenity__ + X(LCHOWN, lchown(req->path, req->uid, req->gid)); ++#endif + X(FDATASYNC, uv__fs_fdatasync(req)); + X(FSTAT, uv__fs_fstat(req->file, &req->statbuf)); + X(FSYNC, uv__fs_fsync(req)); +@@ -1618,7 +1639,9 @@ static void uv__fs_work(struct uv__work* w) { + X(MKSTEMP, uv__fs_mkstemp(req)); + X(OPEN, uv__fs_open(req)); + X(READ, uv__fs_read(req)); ++#ifndef __serenity__ + X(SCANDIR, uv__fs_scandir(req)); ++#endif + X(OPENDIR, uv__fs_opendir(req)); + X(READDIR, uv__fs_readdir(req)); + X(CLOSEDIR, uv__fs_closedir(req)); +@@ -1628,7 +1651,9 @@ static void uv__fs_work(struct uv__work* w) { + X(RMDIR, rmdir(req->path)); + X(SENDFILE, uv__fs_sendfile(req)); + X(STAT, uv__fs_stat(req->path, &req->statbuf)); ++#ifndef __serenity__ + X(STATFS, uv__fs_statfs(req)); ++#endif + X(SYMLINK, symlink(req->path, req->new_path)); + X(UNLINK, unlink(req->path)); + X(UTIME, uv__fs_utime(req)); +@@ -1743,7 +1768,9 @@ int uv_fs_lchown(uv_loop_t* loop, + uv_uid_t uid, + uv_gid_t gid, + uv_fs_cb cb) { ++#ifndef __serenity__ + INIT(LCHOWN); ++#endif + PATH; + req->uid = uid; + req->gid = gid; +@@ -1912,7 +1939,9 @@ int uv_fs_scandir(uv_loop_t* loop, + const char* path, + int flags, + uv_fs_cb cb) { ++#ifndef __serenity__ + INIT(SCANDIR); ++#endif + PATH; + req->flags = flags; + POST; +@@ -2134,7 +2163,9 @@ int uv_fs_statfs(uv_loop_t* loop, + uv_fs_t* req, + const char* path, + uv_fs_cb cb) { ++#ifndef __serenity__ + INIT(STATFS); ++#endif + PATH; + POST; + } +diff --git a/Utilities/cmlibuv/src/unix/poll.c b/Utilities/cmlibuv/src/unix/poll.c +index 3d5022b..721423f 100644 +--- a/Utilities/cmlibuv/src/unix/poll.c ++++ b/Utilities/cmlibuv/src/unix/poll.c +@@ -79,9 +79,11 @@ int uv_poll_init(uv_loop_t* loop, uv_poll_t* handle, int fd) { + * Workaround for e.g. kqueue fds not supporting ioctls. + */ + err = uv__nonblock(fd, 1); ++#ifndef __serenity__ + if (err == UV_ENOTTY) + if (uv__nonblock == uv__nonblock_ioctl) + err = uv__nonblock_fcntl(fd, 1); ++#endif + + if (err) + return err; +diff --git a/Utilities/cmlibuv/src/unix/process.c b/Utilities/cmlibuv/src/unix/process.c +index 08aa2f3..135260f 100644 +--- a/Utilities/cmlibuv/src/unix/process.c ++++ b/Utilities/cmlibuv/src/unix/process.c +@@ -129,6 +129,8 @@ static int uv__make_socketpair(int fds[2]) { + return UV__ERR(errno); + + return 0; ++#elif defined(__serenity__) ++ return UV__ERR(ENOTSUP); + #else + int err; + +diff --git a/Utilities/cmlibuv/src/unix/stream.c b/Utilities/cmlibuv/src/unix/stream.c +index 3b6da8d..3e2ed5e 100644 +--- a/Utilities/cmlibuv/src/unix/stream.c ++++ b/Utilities/cmlibuv/src/unix/stream.c +@@ -985,13 +985,12 @@ uv_handle_type uv__handle_type(int fd) { + case AF_UNIX: + return UV_NAMED_PIPE; + case AF_INET: +- case AF_INET6: + return UV_TCP; + } + } + + if (type == SOCK_DGRAM && +- (ss.ss_family == AF_INET || ss.ss_family == AF_INET6)) ++ (ss.ss_family == AF_INET)) + return UV_UDP; + + return UV_UNKNOWN_HANDLE; +-- +2.30.1 + diff --git a/Ports/cmake/patches/0010-don-t-use-siginfo.patch b/Ports/cmake/patches/0010-don-t-use-siginfo.patch new file mode 100644 index 0000000000..e70e42aeb1 --- /dev/null +++ b/Ports/cmake/patches/0010-don-t-use-siginfo.patch @@ -0,0 +1,48 @@ +From 6db96fa8e9a0519894326d0a64b72313a5879fd9 Mon Sep 17 00:00:00 2001 +From: AnotherTest <ali.mpfard@gmail.com> +Date: Fri, 12 Feb 2021 13:42:50 +0330 +Subject: [PATCH 10/11] don't use siginfo + +--- + Source/kwsys/ProcessUNIX.c | 2 +- + Source/kwsys/SystemInformation.cxx | 4 ++-- + 2 files changed, 3 insertions(+), 3 deletions(-) + +diff --git a/Source/kwsys/ProcessUNIX.c b/Source/kwsys/ProcessUNIX.c +index a24b773..cbf137b 100644 +--- a/Source/kwsys/ProcessUNIX.c ++++ b/Source/kwsys/ProcessUNIX.c +@@ -105,7 +105,7 @@ static inline void kwsysProcess_usleep(unsigned int msec) + #endif + + /* Some platforms do not have siginfo on their signal handlers. */ +-#if defined(SA_SIGINFO) && !defined(__BEOS__) ++#if defined(SA_SIGINFO) && !defined(__BEOS__) && !defined(__serenity__) + # define KWSYSPE_USE_SIGINFO 1 + #endif + +diff --git a/Source/kwsys/SystemInformation.cxx b/Source/kwsys/SystemInformation.cxx +index 1384dbe..18f03fb 100644 +--- a/Source/kwsys/SystemInformation.cxx ++++ b/Source/kwsys/SystemInformation.cxx +@@ -990,7 +990,7 @@ int GetFieldsFromCommand(const char* command, const char** fieldNames, + #endif + + // **************************************************************************** +-#if !defined(_WIN32) && !defined(__MINGW32__) && !defined(__CYGWIN__) ++#if !defined(_WIN32) && !defined(__MINGW32__) && !defined(__CYGWIN__) && !defined(__serenity__) + void StacktraceSignalHandler(int sigNo, siginfo_t* sigInfo, + void* /*sigContext*/) + { +@@ -3965,7 +3965,7 @@ when set print stack trace in response to common signals. + */ + void SystemInformationImplementation::SetStackTraceOnError(int enable) + { +-#if !defined(_WIN32) && !defined(__MINGW32__) && !defined(__CYGWIN__) ++#if !defined(_WIN32) && !defined(__MINGW32__) && !defined(__CYGWIN__) && !defined(__serenity__) + static int saOrigValid = 0; + static struct sigaction saABRTOrig; + static struct sigaction saSEGVOrig; +-- +2.30.1 + diff --git a/Ports/cmake/patches/0011-Fixed-your-code-rot-cmake.patch b/Ports/cmake/patches/0011-Fixed-your-code-rot-cmake.patch new file mode 100644 index 0000000000..be9787ed1e --- /dev/null +++ b/Ports/cmake/patches/0011-Fixed-your-code-rot-cmake.patch @@ -0,0 +1,39 @@ +From fd44bfe91d4b17c20c8028d60fe73e016879e73b Mon Sep 17 00:00:00 2001 +From: AnotherTest <ali.mpfard@gmail.com> +Date: Fri, 12 Feb 2021 13:59:50 +0330 +Subject: [PATCH 11/11] Fixed your code rot, cmake + +--- + Source/kwsys/ProcessUNIX.c | 8 ++++---- + 1 file changed, 4 insertions(+), 4 deletions(-) + +diff --git a/Source/kwsys/ProcessUNIX.c b/Source/kwsys/ProcessUNIX.c +index cbf137b..65bf129 100644 +--- a/Source/kwsys/ProcessUNIX.c ++++ b/Source/kwsys/ProcessUNIX.c +@@ -2890,10 +2890,10 @@ static void kwsysProcessesSignalHandler(int signum + /* Re-Install our handler. Repeat call until it is not interrupted. */ + { + struct sigaction newSigAction; +- struct sigaction& oldSigAction; ++ struct sigaction* oldSigAction; + memset(&newSigAction, 0, sizeof(struct sigaction)); +- newSigChldAction.sa_handler = kwsysProcessesSignalHandler; +- newSigChldAction.sa_flags = SA_NOCLDSTOP; ++ newSigAction.sa_handler = kwsysProcessesSignalHandler; ++ newSigAction.sa_flags = SA_NOCLDSTOP; + sigemptyset(&newSigAction.sa_mask); + switch (signum) { + case SIGCHLD: +@@ -2908,7 +2908,7 @@ static void kwsysProcessesSignalHandler(int signum + oldSigAction = &kwsysProcessesOldSigTermAction; + break; + default: +- return 0; ++ return; + } + while ((sigaction(signum, &newSigAction, oldSigAction) < 0) && + (errno == EINTR)) +-- +2.30.1 + diff --git a/Ports/cmake/patches/0012-bin-bash.patch b/Ports/cmake/patches/0012-bin-bash.patch new file mode 100644 index 0000000000..9db6b52051 --- /dev/null +++ b/Ports/cmake/patches/0012-bin-bash.patch @@ -0,0 +1,17 @@ +diff -urp a/bootstrap b/bootstrap +--- a/bootstrap 2021-02-12 16:01:09.075367557 +0330 ++++ b/bootstrap 2021-02-12 15:59:27.811749370 +0330 +@@ -1,4 +1,4 @@ +-#!/bin/sh ++#!/bin/bash + # Distributed under the OSI-approved BSD 3-Clause License. See accompanying + # file Copyright.txt or https://cmake.org/licensing for details. + +diff -urp a/configure b/configure +--- a/configure 2021-02-12 16:02:00.042148704 +0330 ++++ b/configure 2021-02-12 16:02:07.035496388 +0330 +@@ -1,3 +1,3 @@ +-#!/bin/sh ++#!/bin/bash + cmake_source_dir=`cd "\`dirname \"$0\"\`";pwd` + exec "${cmake_source_dir}/bootstrap" "$@" diff --git a/Ports/cmake/patches/0013-platform-serenityos.patch b/Ports/cmake/patches/0013-platform-serenityos.patch new file mode 100644 index 0000000000..4b680831e0 --- /dev/null +++ b/Ports/cmake/patches/0013-platform-serenityos.patch @@ -0,0 +1,29 @@ +diff -urp /dev/null a/Modules/Platform/SerenityOS.cmake +--- /dev/null 2021-02-11 00:46:13.390326124 +0330 ++++ a/Modules/Platform/SerenityOS.cmake 2021-02-12 16:31:38.421786222 +0330 +@@ -0,0 +1,25 @@ ++set(CMAKE_DL_LIBS "") ++set(CMAKE_SHARED_LIBRARY_RUNTIME_C_FLAG "-Wl,-rpath,") ++set(CMAKE_SHARED_LIBRARY_RUNTIME_C_FLAG_SEP ":") ++set(CMAKE_SHARED_LIBRARY_RPATH_ORIGIN_TOKEN "\$ORIGIN") ++set(CMAKE_SHARED_LIBRARY_RPATH_LINK_C_FLAG "-Wl,-rpath-link,") ++set(CMAKE_SHARED_LIBRARY_SONAME_C_FLAG "-Wl,-soname,") ++set(CMAKE_EXE_EXPORTS_C_FLAG "-Wl,--export-dynamic") ++ ++# Shared libraries with no builtin soname may not be linked safely by ++# specifying the file path. ++set(CMAKE_PLATFORM_USES_PATH_WHEN_NO_SONAME 1) ++ ++# Initialize C link type selection flags. These flags are used when ++# building a shared library, shared module, or executable that links ++# to other libraries to select whether to use the static or shared ++# versions of the libraries. ++foreach(type SHARED_LIBRARY SHARED_MODULE EXE) ++ set(CMAKE_${type}_LINK_STATIC_C_FLAGS "-Wl,-Bstatic") ++ set(CMAKE_${type}_LINK_DYNAMIC_C_FLAGS "-Wl,-Bdynamic") ++endforeach() ++ ++# No multi-arch here (yet?) ++unset(CMAKE_LIBRARY_ARCHITECTURE_REGEX) ++ ++include(Platform/UnixPaths) diff --git a/Ports/cmake/patches/0014-cmcurl-include-unistd.patch b/Ports/cmake/patches/0014-cmcurl-include-unistd.patch new file mode 100644 index 0000000000..dc9db7e5ab --- /dev/null +++ b/Ports/cmake/patches/0014-cmcurl-include-unistd.patch @@ -0,0 +1,10 @@ +--- a/Utilities/cmcurl/include/curl/multi.h 2021-02-12 21:03:08.726002327 +0330 ++++ b/Utilities/cmcurl/include/curl/multi.h 2021-02-12 21:03:12.015764990 +0330 +@@ -47,6 +47,7 @@ + * but with this warning attached. + */ + #include "curl.h" ++#include <unistd.h> + + #ifdef __cplusplus + extern "C" { diff --git a/Ports/cmake/patches/0015-atoll.patch b/Ports/cmake/patches/0015-atoll.patch new file mode 100644 index 0000000000..1aafb80596 --- /dev/null +++ b/Ports/cmake/patches/0015-atoll.patch @@ -0,0 +1,20 @@ +--- a/Source/kwsys/SystemInformation.cxx 2021-02-12 21:49:51.581563656 +0330 ++++ b/Source/kwsys/SystemInformation.cxx 2021-02-12 21:49:54.454669016 +0330 +@@ -3635,7 +3635,7 @@ long long SystemInformationImplementatio + if (hostLimitEnvVarName) { + const char* hostLimitEnvVarValue = getenv(hostLimitEnvVarName); + if (hostLimitEnvVarValue) { +- long long hostLimit = std::atoll(hostLimitEnvVarValue); ++ long long hostLimit = atoll(hostLimitEnvVarValue); + if (hostLimit > 0) { + memTotal = min(hostLimit, memTotal); + } +@@ -3659,7 +3659,7 @@ long long SystemInformationImplementatio + if (procLimitEnvVarName) { + const char* procLimitEnvVarValue = getenv(procLimitEnvVarName); + if (procLimitEnvVarValue) { +- long long procLimit = std::atoll(procLimitEnvVarValue); ++ long long procLimit = atoll(procLimitEnvVarValue); + if (procLimit > 0) { + memAvail = min(procLimit, memAvail); + } diff --git a/Ports/cmake/patches/0016-conflicting-0.patch b/Ports/cmake/patches/0016-conflicting-0.patch new file mode 100644 index 0000000000..09c1cb9b1e --- /dev/null +++ b/Ports/cmake/patches/0016-conflicting-0.patch @@ -0,0 +1,12 @@ +--- a/Utilities/cmnghttp2/cmakeconfig.h.in 2021-02-12 22:10:29.813759193 +0330 ++++ b/Utilities/cmnghttp2/cmakeconfig.h.in 2021-02-12 22:10:35.577912239 +0330 +@@ -5,9 +5,6 @@ + #include <cm3p/kwiml/abi.h> + #include <cm3p/kwiml/int.h> + +-/* Define to `int' if <sys/types.h> does not define. */ +-#cmakedefine ssize_t @ssize_t@ +- + /* sizeof(int *) */ + #define SIZEOF_INT_P KWIML_ABI_SIZEOF_DATA_PTR + diff --git a/Ports/cmake/patches/0017-conflicting-1.patch b/Ports/cmake/patches/0017-conflicting-1.patch new file mode 100644 index 0000000000..0f09327a00 --- /dev/null +++ b/Ports/cmake/patches/0017-conflicting-1.patch @@ -0,0 +1,12 @@ +--- a/Utilities/cmcurl/lib/curl_config.h.cmake 2021-02-12 22:12:54.848790862 +0330 ++++ b/Utilities/cmcurl/lib/curl_config.h.cmake 2021-02-12 22:12:57.841458768 +0330 +@@ -1052,9 +1052,6 @@ ${SIZEOF_TIME_T_CODE} + /* Define to empty if `const' does not conform to ANSI C. */ + #cmakedefine const ${const} + +-/* Type to use in place of in_addr_t when system does not provide it. */ +-#cmakedefine in_addr_t ${in_addr_t} +- + /* Define to `__inline__' or `__inline' if that's what the C compiler + calls it, or to nothing if 'inline' is not supported under any name. */ + #ifndef __cplusplus diff --git a/Ports/cmake/patches/0018-isfinite.patch b/Ports/cmake/patches/0018-isfinite.patch new file mode 100644 index 0000000000..c41c81b8b2 --- /dev/null +++ b/Ports/cmake/patches/0018-isfinite.patch @@ -0,0 +1,13 @@ +--- a/Utilities/cmjsoncpp/src/lib_json/json_writer.cpp 2021-02-12 22:35:57.078226288 +0330 ++++ b/Utilities/cmjsoncpp/src/lib_json/json_writer.cpp 2021-02-12 22:36:02.937764094 +0330 +@@ -41,7 +41,9 @@ + #endif + #else + #include <cmath> +-#if !(defined(__QNXNTO__)) // QNX already defines isfinite ++#if defined(__serenity__) // isfinite is already defined in math.h ++#include <math.h> ++#elif !(defined(__QNXNTO__)) // QNX already defines isfinite + #define isfinite std::isfinite + #endif + #endif diff --git a/Ports/cmake/patches/0019-libuv-so_linger.patch b/Ports/cmake/patches/0019-libuv-so_linger.patch new file mode 100644 index 0000000000..b41f8aaac4 --- /dev/null +++ b/Ports/cmake/patches/0019-libuv-so_linger.patch @@ -0,0 +1,22 @@ +--- a/Utilities/cmlibuv/src/unix/tcp.c 2021-02-12 22:52:26.980780866 +0330 ++++ b/Utilities/cmlibuv/src/unix/tcp.c 2021-02-12 22:54:10.670863712 +0330 +@@ -310,15 +310,19 @@ int uv_tcp_getpeername(const uv_tcp_t* h + + int uv_tcp_close_reset(uv_tcp_t* handle, uv_close_cb close_cb) { + int fd; ++#ifndef __serenity__ + struct linger l = { 1, 0 }; ++#endif + + /* Disallow setting SO_LINGER to zero due to some platform inconsistencies */ + if (handle->flags & UV_HANDLE_SHUTTING) + return UV_EINVAL; + + fd = uv__stream_fd(handle); ++#ifndef __serenity__ + if (0 != setsockopt(fd, SOL_SOCKET, SO_LINGER, &l, sizeof(l))) + return UV__ERR(errno); ++#endif + + uv_close((uv_handle_t*) handle, close_cb); + return 0; diff --git a/Ports/cmake/patches/0020-libuv-ipv6.patch b/Ports/cmake/patches/0020-libuv-ipv6.patch new file mode 100644 index 0000000000..1262690392 --- /dev/null +++ b/Ports/cmake/patches/0020-libuv-ipv6.patch @@ -0,0 +1,489 @@ +--- a/Utilities/cmlibuv/src/unix/udp.c 2021-02-12 22:54:39.835381661 +0330 ++++ b/Utilities/cmlibuv/src/unix/udp.c 2021-02-12 23:06:41.699978199 +0330 +@@ -585,6 +585,7 @@ static int uv__udp_maybe_deferred_bind(u + addrlen = sizeof *addr; + break; + } ++#ifndef __serenity__ + case AF_INET6: + { + struct sockaddr_in6* addr = &taddr.in6; +@@ -594,6 +595,7 @@ static int uv__udp_maybe_deferred_bind(u + addrlen = sizeof *addr; + break; + } ++#endif + default: + assert(0 && "unsupported address family"); + abort(); +@@ -761,6 +763,9 @@ static int uv__udp_set_membership4(uv_ud + const struct sockaddr_in* multicast_addr, + const char* interface_addr, + uv_membership membership) { ++#ifdef __serenity__ ++ return UV_EINVAL; ++#else + struct ip_mreq mreq; + int optname; + int err; +@@ -801,6 +806,7 @@ static int uv__udp_set_membership4(uv_ud + } + + return 0; ++#endif + } + + +@@ -808,6 +814,9 @@ static int uv__udp_set_membership6(uv_ud + const struct sockaddr_in6* multicast_addr, + const char* interface_addr, + uv_membership membership) { ++#ifdef __serenity__ ++ return UV_EINVAL; ++#else + int optname; + struct ipv6_mreq mreq; + struct sockaddr_in6 addr6; +@@ -848,14 +857,16 @@ static int uv__udp_set_membership6(uv_ud + } + + return 0; ++#endif + } + + + #if !defined(__OpenBSD__) && \ + !defined(__NetBSD__) && \ + !defined(__ANDROID__) && \ +- !defined(__DragonFly__) & \ +- !defined(__QNX__) ++ !defined(__DragonFly__) && \ ++ !defined(__QNX__) && \ ++ !defined(__serenity__) + static int uv__udp_set_source_membership4(uv_udp_t* handle, + const struct sockaddr_in* multicast_addr, + const char* interface_addr, +@@ -1089,11 +1100,15 @@ static int uv__setsockopt(uv_udp_t* hand + int r; + + if (handle->flags & UV_HANDLE_IPV6) ++#ifndef __serenity__ + r = setsockopt(handle->io_watcher.fd, + IPPROTO_IPV6, + option6, + val, + size); ++#else ++ r = -1; ++#endif + else + r = setsockopt(handle->io_watcher.fd, + IPPROTO_IP, +@@ -1162,20 +1177,24 @@ int uv_udp_set_ttl(uv_udp_t* handle, int + &ttl, + sizeof(ttl)); + +-#else /* !(defined(__sun) || defined(_AIX) || defined (__OpenBSD__) || ++#elif !defined(__serenity__) /* !(defined(__sun) || defined(_AIX) || defined (__OpenBSD__) || + defined(__MVS__) || defined(__QNX__)) */ + + return uv__setsockopt_maybe_char(handle, + IP_TTL, + IPV6_UNICAST_HOPS, + ttl); +- ++#else ++ return -1; + #endif /* defined(__sun) || defined(_AIX) || defined (__OpenBSD__) || + defined(__MVS__) || defined(__QNX__) */ + } + + + int uv_udp_set_multicast_ttl(uv_udp_t* handle, int ttl) { ++#if defined(__serenity__) ++ return -1; ++#else + /* + * On Solaris and derivatives such as SmartOS, the length of socket options + * is sizeof(int) for IPV6_MULTICAST_HOPS and sizeof(char) for +@@ -1197,10 +1216,14 @@ int uv_udp_set_multicast_ttl(uv_udp_t* h + IP_MULTICAST_TTL, + IPV6_MULTICAST_HOPS, + ttl); ++#endif + } + + + int uv_udp_set_multicast_loop(uv_udp_t* handle, int on) { ++#if defined(__serenity__) ++ return -1; ++#else + /* + * On Solaris and derivatives such as SmartOS, the length of socket options + * is sizeof(int) for IPV6_MULTICAST_LOOP and sizeof(char) for +@@ -1222,9 +1245,13 @@ int uv_udp_set_multicast_loop(uv_udp_t* + IP_MULTICAST_LOOP, + IPV6_MULTICAST_LOOP, + on); ++#endif + } + + int uv_udp_set_multicast_interface(uv_udp_t* handle, const char* interface_addr) { ++#if defined(__serenity__) ++ return -1; ++#else + struct sockaddr_storage addr_st; + struct sockaddr_in* addr4; + struct sockaddr_in6* addr6; +@@ -1271,6 +1298,7 @@ int uv_udp_set_multicast_interface(uv_ud + } + + return 0; ++#endif + } + + int uv_udp_getpeername(const uv_udp_t* handle, +diff --git a/Utilities/cmlibuv/src/unix/udp.c b/Utilities/cmlibuv/src/unix/udp.c +index 0b83652..77468f9 100644 +--- a/Utilities/cmlibuv/src/unix/udp.c ++++ b/Utilities/cmlibuv/src/unix/udp.c +@@ -1058,7 +1058,8 @@ int uv_udp_set_source_membership(uv_udp_t* handle, + !defined(__NetBSD__) && \ + !defined(__ANDROID__) && \ + !defined(__DragonFly__) && \ +- !defined(__QNX__) ++ !defined(__QNX__) \ ++ !defined(__serenity__) + int err; + union uv__sockaddr mcast_addr; + union uv__sockaddr src_addr; +diff --git a/Utilities/cmlibuv/src/inet.c b/Utilities/cmlibuv/src/inet.c +index 58238dc..5b880b0 100644 +--- a/Utilities/cmlibuv/src/inet.c ++++ b/Utilities/cmlibuv/src/inet.c +@@ -41,8 +41,10 @@ int uv_inet_ntop(int af, const void* src, char* dst, size_t size) { + switch (af) { + case AF_INET: + return (inet_ntop4(src, dst, size)); ++#ifndef __serenity__ + case AF_INET6: + return (inet_ntop6(src, dst, size)); ++#endif + default: + return UV_EAFNOSUPPORT; + } +@@ -154,6 +156,7 @@ int uv_inet_pton(int af, const char* src, void* dst) { + switch (af) { + case AF_INET: + return (inet_pton4(src, dst)); ++#ifndef __serenity__ + case AF_INET6: { + int len; + char tmp[UV__INET6_ADDRSTRLEN], *s, *p; +@@ -169,6 +172,7 @@ int uv_inet_pton(int af, const char* src, void* dst) { + } + return inet_pton6(s, dst); + } ++#endif + default: + return UV_EAFNOSUPPORT; + } +diff --git a/Utilities/cmlibuv/src/unix/getnameinfo.c b/Utilities/cmlibuv/src/unix/getnameinfo.c +index b695081..939db31 100644 +--- a/Utilities/cmlibuv/src/unix/getnameinfo.c ++++ b/Utilities/cmlibuv/src/unix/getnameinfo.c +@@ -37,8 +37,10 @@ static void uv__getnameinfo_work(struct uv__work* w) { + + if (req->storage.ss_family == AF_INET) + salen = sizeof(struct sockaddr_in); ++#ifndef __serenity__ + else if (req->storage.ss_family == AF_INET6) + salen = sizeof(struct sockaddr_in6); ++#endif + else + abort(); + +@@ -90,10 +92,12 @@ int uv_getnameinfo(uv_loop_t* loop, + memcpy(&req->storage, + addr, + sizeof(struct sockaddr_in)); ++#ifndef __serenity__ + } else if (addr->sa_family == AF_INET6) { + memcpy(&req->storage, + addr, + sizeof(struct sockaddr_in6)); ++#endif + } else { + return UV_EINVAL; + } +diff --git a/Utilities/cmlibuv/src/unix/tcp.c b/Utilities/cmlibuv/src/unix/tcp.c +index 748d6ff..ff88f3b 100644 +--- a/Utilities/cmlibuv/src/unix/tcp.c ++++ b/Utilities/cmlibuv/src/unix/tcp.c +@@ -89,8 +89,11 @@ static int maybe_new_socket(uv_tcp_t* handle, int domain, unsigned long flags) { + if (getsockname(uv__stream_fd(handle), (struct sockaddr*) &saddr, &slen)) + return UV__ERR(errno); + +- if ((saddr.ss_family == AF_INET6 && ++ if ( ++#ifndef __serenity__ ++ (saddr.ss_family == AF_INET6 && + ((struct sockaddr_in6*) &saddr)->sin6_port != 0) || ++#endif + (saddr.ss_family == AF_INET && + ((struct sockaddr_in*) &saddr)->sin_port != 0)) { + /* Handle is already bound to a port. */ +@@ -116,7 +119,11 @@ int uv_tcp_init_ex(uv_loop_t* loop, uv_tcp_t* tcp, unsigned int flags) { + + /* Use the lower 8 bits for the domain */ + domain = flags & 0xFF; +- if (domain != AF_INET && domain != AF_INET6 && domain != AF_UNSPEC) ++ if (domain != AF_INET ++#ifndef __serenity__ ++ && domain != AF_INET6 ++#endif ++ && domain != AF_UNSPEC) + return UV_EINVAL; + + if (flags & ~0xFF) +@@ -152,9 +159,11 @@ int uv__tcp_bind(uv_tcp_t* tcp, + int err; + int on; + ++#ifndef __serenity__ + /* Cannot set IPv6-only mode on non-IPv6 socket. */ + if ((flags & UV_TCP_IPV6ONLY) && addr->sa_family != AF_INET6) + return UV_EINVAL; ++#endif + + err = maybe_new_socket(tcp, addr->sa_family, 0); + if (err) +@@ -164,7 +173,7 @@ int uv__tcp_bind(uv_tcp_t* tcp, + if (setsockopt(tcp->io_watcher.fd, SOL_SOCKET, SO_REUSEADDR, &on, sizeof(on))) + return UV__ERR(errno); + +-#ifndef __OpenBSD__ ++#if !defined(__OpenBSD__) && !defined(__serenity__) + #ifdef IPV6_V6ONLY + if (addr->sa_family == AF_INET6) { + on = (flags & UV_TCP_IPV6ONLY) != 0; +@@ -194,8 +203,10 @@ int uv__tcp_bind(uv_tcp_t* tcp, + tcp->delayed_error = UV__ERR(errno); + + tcp->flags |= UV_HANDLE_BOUND; ++#ifndef __serenity__ + if (addr->sa_family == AF_INET6) + tcp->flags |= UV_HANDLE_IPV6; ++#endif + + return 0; + } +diff --git a/Utilities/cmlibuv/src/unix/tty.c b/Utilities/cmlibuv/src/unix/tty.c +index 82cd723..1d6f7f2 100644 +--- a/Utilities/cmlibuv/src/unix/tty.c ++++ b/Utilities/cmlibuv/src/unix/tty.c +@@ -345,7 +345,11 @@ uv_handle_type uv_guess_handle(uv_file file) { + return UV_UNKNOWN_HANDLE; + + if (type == SOCK_DGRAM) +- if (sa.sa_family == AF_INET || sa.sa_family == AF_INET6) ++ if (sa.sa_family == AF_INET ++#ifndef __serenity__ ++ || sa.sa_family == AF_INET6 ++#endif ++ ) + return UV_UDP; + + if (type == SOCK_STREAM) { +@@ -358,7 +362,11 @@ uv_handle_type uv_guess_handle(uv_file file) { + return UV_NAMED_PIPE; + #endif /* defined(_AIX) || defined(__DragonFly__) */ + +- if (sa.sa_family == AF_INET || sa.sa_family == AF_INET6) ++ if (sa.sa_family == AF_INET ++#ifndef __serenity__ ++ || sa.sa_family == AF_INET6 ++#endif ++ ) + return UV_TCP; + if (sa.sa_family == AF_UNIX) + return UV_NAMED_PIPE; +diff --git a/Utilities/cmlibuv/src/unix/udp.c b/Utilities/cmlibuv/src/unix/udp.c +index 77468f9..2db3dd2 100644 +--- a/Utilities/cmlibuv/src/unix/udp.c ++++ b/Utilities/cmlibuv/src/unix/udp.c +@@ -340,9 +340,12 @@ write_queue_drain: + p->msg_hdr.msg_namelen = 0; + } else { + p->msg_hdr.msg_name = &req->addr; ++#ifndef __serenity__ + if (req->addr.ss_family == AF_INET6) + p->msg_hdr.msg_namelen = sizeof(struct sockaddr_in6); +- else if (req->addr.ss_family == AF_INET) ++ else ++#endif ++ if (req->addr.ss_family == AF_INET) + p->msg_hdr.msg_namelen = sizeof(struct sockaddr_in); + else if (req->addr.ss_family == AF_UNIX) + p->msg_hdr.msg_namelen = sizeof(struct sockaddr_un); +@@ -430,9 +433,12 @@ static void uv__udp_sendmsg(uv_udp_t* handle) { + h.msg_namelen = 0; + } else { + h.msg_name = &req->addr; ++#ifndef __serenity__ + if (req->addr.ss_family == AF_INET6) + h.msg_namelen = sizeof(struct sockaddr_in6); +- else if (req->addr.ss_family == AF_INET) ++ else ++#endif ++ if (req->addr.ss_family == AF_INET) + h.msg_namelen = sizeof(struct sockaddr_in); + else if (req->addr.ss_family == AF_UNIX) + h.msg_namelen = sizeof(struct sockaddr_un); +@@ -518,8 +524,10 @@ int uv__udp_bind(uv_udp_t* handle, + return UV_EINVAL; + + /* Cannot set IPv6-only mode on non-IPv6 socket. */ ++#ifndef __serenity__ + if ((flags & UV_UDP_IPV6ONLY) && addr->sa_family != AF_INET6) + return UV_EINVAL; ++#endif + + fd = handle->io_watcher.fd; + if (fd == -1) { +@@ -558,8 +566,10 @@ int uv__udp_bind(uv_udp_t* handle, + return err; + } + ++#ifndef __serenity__ + if (addr->sa_family == AF_INET6) + handle->flags |= UV_HANDLE_IPV6; ++#endif + + handle->flags |= UV_HANDLE_BOUND; + return 0; +@@ -1038,11 +1048,13 @@ int uv_udp_set_membership(uv_udp_t* handle, + if (err) + return err; + return uv__udp_set_membership4(handle, &addr4, interface_addr, membership); ++#ifndef __serenity__ + } else if (uv_ip6_addr(multicast_addr, 0, &addr6) == 0) { + err = uv__udp_maybe_deferred_bind(handle, AF_INET6, UV_UDP_REUSEADDR); + if (err) + return err; + return uv__udp_set_membership6(handle, &addr6, interface_addr, membership); ++#endif + } else { + return UV_EINVAL; + } +@@ -1058,7 +1070,7 @@ int uv_udp_set_source_membership(uv_udp_t* handle, + !defined(__NetBSD__) && \ + !defined(__ANDROID__) && \ + !defined(__DragonFly__) && \ +- !defined(__QNX__) \ ++ !defined(__QNX__) && \ + !defined(__serenity__) + int err; + union uv__sockaddr mcast_addr; +diff --git a/Utilities/cmlibuv/src/uv-common.c b/Utilities/cmlibuv/src/uv-common.c +index f986d75..f73840e 100644 +--- a/Utilities/cmlibuv/src/uv-common.c ++++ b/Utilities/cmlibuv/src/uv-common.c +@@ -231,6 +231,9 @@ int uv_ip4_addr(const char* ip, int port, struct sockaddr_in* addr) { + + + int uv_ip6_addr(const char* ip, int port, struct sockaddr_in6* addr) { ++#ifdef __serenity__ ++ return -1; ++#else + char address_part[40]; + size_t address_part_size; + const char* zone_index; +@@ -262,6 +265,7 @@ int uv_ip6_addr(const char* ip, int port, struct sockaddr_in6* addr) { + } + + return uv_inet_pton(AF_INET6, ip, &addr->sin6_addr); ++#endif + } + + +@@ -271,7 +275,11 @@ int uv_ip4_name(const struct sockaddr_in* src, char* dst, size_t size) { + + + int uv_ip6_name(const struct sockaddr_in6* src, char* dst, size_t size) { ++#ifdef __serenity__ ++ return -1; ++#else + return uv_inet_ntop(AF_INET6, &src->sin6_addr, dst, size); ++#endif + } + + +@@ -285,8 +293,10 @@ int uv_tcp_bind(uv_tcp_t* handle, + + if (addr->sa_family == AF_INET) + addrlen = sizeof(struct sockaddr_in); ++#ifndef __serenity__ + else if (addr->sa_family == AF_INET6) + addrlen = sizeof(struct sockaddr_in6); ++#endif + else + return UV_EINVAL; + +@@ -301,7 +311,11 @@ int uv_udp_init_ex(uv_loop_t* loop, uv_udp_t* handle, unsigned flags) { + + /* Use the lower 8 bits for the domain. */ + domain = flags & 0xFF; +- if (domain != AF_INET && domain != AF_INET6 && domain != AF_UNSPEC) ++ if (domain != AF_INET ++#ifndef __serenity__ ++ && domain != AF_INET6 ++#endif ++ && domain != AF_UNSPEC) + return UV_EINVAL; + + /* Use the higher bits for extra flags. */ +@@ -334,8 +348,10 @@ int uv_udp_bind(uv_udp_t* handle, + + if (addr->sa_family == AF_INET) + addrlen = sizeof(struct sockaddr_in); ++#ifndef __serenity__ + else if (addr->sa_family == AF_INET6) + addrlen = sizeof(struct sockaddr_in6); ++#endif + else + return UV_EINVAL; + +@@ -354,8 +370,10 @@ int uv_tcp_connect(uv_connect_t* req, + + if (addr->sa_family == AF_INET) + addrlen = sizeof(struct sockaddr_in); ++#ifndef __serenity__ + else if (addr->sa_family == AF_INET6) + addrlen = sizeof(struct sockaddr_in6); ++#endif + else + return UV_EINVAL; + +@@ -379,8 +397,10 @@ int uv_udp_connect(uv_udp_t* handle, const struct sockaddr* addr) { + + if (addr->sa_family == AF_INET) + addrlen = sizeof(struct sockaddr_in); ++#ifndef __serenity__ + else if (addr->sa_family == AF_INET6) + addrlen = sizeof(struct sockaddr_in6); ++#endif + else + return UV_EINVAL; + +@@ -420,8 +440,10 @@ int uv__udp_check_before_send(uv_udp_t* handle, const struct sockaddr* addr) { + if (addr != NULL) { + if (addr->sa_family == AF_INET) + addrlen = sizeof(struct sockaddr_in); ++#ifndef __serenity__ + else if (addr->sa_family == AF_INET6) + addrlen = sizeof(struct sockaddr_in6); ++#endif + #if defined(AF_UNIX) && !defined(_WIN32) + else if (addr->sa_family == AF_UNIX) + addrlen = sizeof(struct sockaddr_un); diff --git a/Ports/cmake/patches/0021-libcurl-no-ipv6.patch b/Ports/cmake/patches/0021-libcurl-no-ipv6.patch new file mode 100644 index 0000000000..0a1fe87de7 --- /dev/null +++ b/Ports/cmake/patches/0021-libcurl-no-ipv6.patch @@ -0,0 +1,28 @@ +diff --git a/Utilities/cmcurl/lib/curl_config.h.cmake b/Utilities/cmcurl/lib/curl_config.h.cmake +index c321f4e..7e20d2c 100644 +--- a/Utilities/cmcurl/lib/curl_config.h.cmake ++++ b/Utilities/cmcurl/lib/curl_config.h.cmake +@@ -103,7 +103,7 @@ + #cmakedefine EGD_SOCKET ${EGD_SOCKET} + + /* Define if you want to enable IPv6 support */ +-#cmakedefine ENABLE_IPV6 1 ++/* #cmakedefine ENABLE_IPV6 1 */ + + /* Define to the type qualifier of arg 1 for getnameinfo. */ + #cmakedefine GETNAMEINFO_QUAL_ARG1 ${GETNAMEINFO_QUAL_ARG1} +diff --git a/Utilities/cmcurl/lib/connect.c b/Utilities/cmcurl/lib/connect.c +index b000b1b..e373e02 100644 +--- a/Utilities/cmcurl/lib/connect.c ++++ b/Utilities/cmcurl/lib/connect.c +@@ -1336,8 +1336,10 @@ CURLcode Curl_connecthost(struct connectdata *conn, /* context */ + + conn->tempfamily[0] = conn->tempaddr[0]? + conn->tempaddr[0]->ai_family:0; ++#ifdef ENABLE_IPV6 + conn->tempfamily[1] = conn->tempfamily[0] == AF_INET6 ? + AF_INET : AF_INET6; ++#endif + ainext(conn, 1, FALSE); /* assigns conn->tempaddr[1] accordingly */ + + DEBUGF(infof(data, "family0 == %s, family1 == %s\n", diff --git a/Ports/cmake/patches/0022-remove-mutex.patch b/Ports/cmake/patches/0022-remove-mutex.patch new file mode 100644 index 0000000000..844dc7ab97 --- /dev/null +++ b/Ports/cmake/patches/0022-remove-mutex.patch @@ -0,0 +1,370 @@ +diff --git a/Source/cmQtAutoGenerator.cxx b/Source/cmQtAutoGenerator.cxx +index ee2bc09..a1c5821 100644 +--- a/Source/cmQtAutoGenerator.cxx ++++ b/Source/cmQtAutoGenerator.cxx +@@ -61,7 +61,9 @@ void cmQtAutoGenerator::Logger::Info(GenT genType, + std::string msg = cmStrCat(GeneratorName(genType), ": ", message, + cmHasSuffix(message, '\n') ? "" : "\n"); + { ++#ifndef __serenity__ + std::lock_guard<std::mutex> lock(Mutex_); ++#endif + cmSystemTools::Stdout(msg); + } + } +@@ -80,7 +82,9 @@ void cmQtAutoGenerator::Logger::Warning(GenT genType, + message, cmHasSuffix(message, '\n') ? "\n" : "\n\n"); + } + { ++#ifndef __serenity__ + std::lock_guard<std::mutex> lock(Mutex_); ++#endif + cmSystemTools::Stdout(msg); + } + } +@@ -92,7 +96,9 @@ void cmQtAutoGenerator::Logger::Error(GenT genType, + cmStrCat('\n', HeadLine(cmStrCat(GeneratorName(genType), " error")), + message, cmHasSuffix(message, '\n') ? "\n" : "\n\n"); + { ++#ifndef __serenity__ + std::lock_guard<std::mutex> lock(Mutex_); ++#endif + cmSystemTools::Stderr(msg); + } + } +@@ -108,7 +114,9 @@ void cmQtAutoGenerator::Logger::ErrorCommand( + msg += cmStrCat(HeadLine("Output"), output, + cmHasSuffix(output, '\n') ? "\n" : "\n\n"); + { ++#ifndef __serenity__ + std::lock_guard<std::mutex> lock(Mutex_); ++#endif + cmSystemTools::Stderr(msg); + } + } +diff --git a/Source/cmQtAutoGenerator.h b/Source/cmQtAutoGenerator.h +index b4f057d..e0970f6 100644 +--- a/Source/cmQtAutoGenerator.h ++++ b/Source/cmQtAutoGenerator.h +@@ -55,7 +55,9 @@ public: + static std::string HeadLine(cm::string_view title); + + private: ++#ifndef __serenity__ + mutable std::mutex Mutex_; ++#endif + unsigned int Verbosity_ = 0; + bool ColorOutput_ = false; + }; +diff --git a/Source/cmQtAutoMocUic.cxx b/Source/cmQtAutoMocUic.cxx +index 9cb172b..a365c96 100644 +--- a/Source/cmQtAutoMocUic.cxx ++++ b/Source/cmQtAutoMocUic.cxx +@@ -586,8 +586,10 @@ private: + // -- Worker thread pool + std::atomic<bool> JobError_ = ATOMIC_VAR_INIT(false); + cmWorkerPool WorkerPool_; ++#ifndef __serenity__ + // -- Concurrent processing + mutable std::mutex CMakeLibMutex_; ++#endif + }; + + cmQtAutoMocUicT::IncludeKeyT::IncludeKeyT(std::string const& key, +@@ -2612,7 +2614,9 @@ void cmQtAutoMocUicT::CreateParseJobs(SourceFileMapT const& sourceMap) + /** Concurrently callable implementation of cmSystemTools::CollapseFullPath */ + std::string cmQtAutoMocUicT::CollapseFullPathTS(std::string const& path) const + { ++#ifndef __serenity__ + std::lock_guard<std::mutex> guard(CMakeLibMutex_); ++#endif + return cmSystemTools::CollapseFullPath(path, ProjectDirs().CurrentSource); + } + +diff --git a/Source/cmUVHandlePtr.cxx b/Source/cmUVHandlePtr.cxx +index df2f64e..154b816 100644 +--- a/Source/cmUVHandlePtr.cxx ++++ b/Source/cmUVHandlePtr.cxx +@@ -137,16 +137,22 @@ struct uv_handle_deleter<uv_async_t> + * which is mandated by the standard for Deleter on + * shared_ptrs. + */ ++#ifndef __serenity__ + std::shared_ptr<std::mutex> handleMutex; ++#endif + + uv_handle_deleter() ++#ifndef __serenity__ + : handleMutex(std::make_shared<std::mutex>()) ++#endif + { + } + + void operator()(uv_async_t* handle) + { ++#ifndef __serenity__ + std::lock_guard<std::mutex> lock(*handleMutex); ++#endif + handle_default_delete(handle); + } + }; +@@ -156,7 +162,9 @@ void uv_async_ptr::send() + auto deleter = std::get_deleter<uv_handle_deleter<uv_async_t>>(this->handle); + assert(deleter); + ++#ifndef __serenity__ + std::lock_guard<std::mutex> lock(*deleter->handleMutex); ++#endif + if (this->handle) { + uv_async_send(*this); + } +diff --git a/Source/cmWorkerPool.cxx b/Source/cmWorkerPool.cxx +index 12aba4f..a3f3897 100644 +--- a/Source/cmWorkerPool.cxx ++++ b/Source/cmWorkerPool.cxx +@@ -382,10 +382,12 @@ public: + cmWorkerPoolWorker(cmWorkerPoolWorker const&) = delete; + cmWorkerPoolWorker& operator=(cmWorkerPoolWorker const&) = delete; + ++#ifndef __serenity__ + /** + * Set the internal thread + */ + void SetThread(std::thread&& aThread) { Thread_ = std::move(aThread); } ++#endif + + /** + * Run an external process +@@ -403,13 +405,19 @@ private: + // -- Process management + struct + { ++#ifndef __serenity__ + std::mutex Mutex; ++#endif + cm::uv_async_ptr Request; ++#ifndef __serenity__ + std::condition_variable Condition; ++#endif + std::unique_ptr<cmUVReadOnlyProcess> ROP; + } Proc_; + // -- System thread ++#ifndef __serenity__ + std::thread Thread_; ++#endif + }; + + cmWorkerPoolWorker::cmWorkerPoolWorker(uv_loop_t& uvLoop) +@@ -419,9 +427,11 @@ cmWorkerPoolWorker::cmWorkerPoolWorker(uv_loop_t& uvLoop) + + cmWorkerPoolWorker::~cmWorkerPoolWorker() + { ++#ifndef __serenity__ + if (Thread_.joinable()) { + Thread_.join(); + } ++#endif + } + + bool cmWorkerPoolWorker::RunProcess(cmWorkerPool::ProcessResultT& result, +@@ -433,7 +443,9 @@ bool cmWorkerPoolWorker::RunProcess(cmWorkerPool::ProcessResultT& result, + } + // Create process instance + { ++#ifndef __serenity__ + std::lock_guard<std::mutex> lock(Proc_.Mutex); ++#endif + Proc_.ROP = cm::make_unique<cmUVReadOnlyProcess>(); + Proc_.ROP->setup(&result, true, command, workingDirectory); + } +@@ -441,10 +453,12 @@ bool cmWorkerPoolWorker::RunProcess(cmWorkerPool::ProcessResultT& result, + Proc_.Request.send(); + // Wait until the process has been finished and destroyed + { ++#ifndef __serenity__ + std::unique_lock<std::mutex> ulock(Proc_.Mutex); + while (Proc_.ROP) { + Proc_.Condition.wait(ulock); + } ++#endif + } + return !result.error(); + } +@@ -455,7 +469,9 @@ void cmWorkerPoolWorker::UVProcessStart(uv_async_t* handle) + bool startFailed = false; + { + auto& Proc = wrk->Proc_; ++#ifndef __serenity__ + std::lock_guard<std::mutex> lock(Proc.Mutex); ++#endif + if (Proc.ROP && !Proc.ROP->IsStarted()) { + startFailed = + !Proc.ROP->start(handle->loop, [wrk] { wrk->UVProcessFinished(); }); +@@ -469,12 +485,14 @@ void cmWorkerPoolWorker::UVProcessStart(uv_async_t* handle) + + void cmWorkerPoolWorker::UVProcessFinished() + { ++#ifndef __serenity__ + std::lock_guard<std::mutex> lock(Proc_.Mutex); + if (Proc_.ROP && (Proc_.ROP->IsFinished() || !Proc_.ROP->IsStarted())) { + Proc_.ROP.reset(); + } + // Notify idling thread + Proc_.Condition.notify_one(); ++#endif + } + + /** +@@ -521,7 +539,9 @@ public: + cm::uv_async_ptr UVRequestEnd; + + // -- Thread pool and job queue ++#ifndef __serenity__ + std::mutex Mutex; ++#endif + bool Processing = false; + bool Aborting = false; + bool FenceProcessing = false; +@@ -529,8 +549,10 @@ public: + unsigned int WorkersIdle = 0; + unsigned int JobsProcessing = 0; + std::deque<cmWorkerPool::JobHandleT> Queue; ++#ifndef __serenity__ + std::condition_variable Condition; + std::condition_variable ConditionFence; ++#endif + std::vector<std::unique_ptr<cmWorkerPoolWorker>> Workers; + + // -- References +@@ -593,18 +615,24 @@ bool cmWorkerPoolInternal::Process() + void cmWorkerPoolInternal::Abort() + { + // Clear all jobs and set abort flag ++#ifndef __serenity__ + std::lock_guard<std::mutex> guard(Mutex); ++#endif + if (!Aborting) { + // Register abort and clear queue + Aborting = true; + Queue.clear(); ++#ifndef __serenity__ + Condition.notify_all(); ++#endif + } + } + + inline bool cmWorkerPoolInternal::PushJob(cmWorkerPool::JobHandleT&& jobHandle) + { ++#ifndef __serenity__ + std::lock_guard<std::mutex> guard(Mutex); ++#endif + if (Aborting) { + return false; + } +@@ -612,7 +640,9 @@ inline bool cmWorkerPoolInternal::PushJob(cmWorkerPool::JobHandleT&& jobHandle) + Queue.emplace_back(std::move(jobHandle)); + // Notify an idle worker if there's one + if (WorkersIdle != 0) { ++#ifndef __serenity__ + Condition.notify_one(); ++#endif + } + // Return success + return true; +@@ -630,11 +660,17 @@ void cmWorkerPoolInternal::UVSlotBegin(uv_async_t* handle) + gint.Workers.emplace_back( + cm::make_unique<cmWorkerPoolWorker>(*gint.UVLoop)); + } ++#ifndef __serenity__ + // Start worker threads + for (unsigned int ii = 0; ii != num; ++ii) { + gint.Workers[ii]->SetThread( + std::thread(&cmWorkerPoolInternal::Work, &gint, ii)); + } ++#else ++ for (unsigned int ii = 0; ii != num; ++ii) { ++ gint.Work(ii); ++ } ++#endif + } + // Destroy begin request + gint.UVRequestBegin.reset(); +@@ -652,7 +688,9 @@ void cmWorkerPoolInternal::UVSlotEnd(uv_async_t* handle) + void cmWorkerPoolInternal::Work(unsigned int workerIndex) + { + cmWorkerPool::JobHandleT jobHandle; ++#ifndef __serenity__ + std::unique_lock<std::mutex> uLock(Mutex); ++#endif + // Increment running workers count + ++WorkersRunning; + // Enter worker main loop +@@ -664,7 +702,9 @@ void cmWorkerPoolInternal::Work(unsigned int workerIndex) + // Wait for new jobs on the main CV + if (Queue.empty()) { + ++WorkersIdle; ++#ifndef __serenity__ + Condition.wait(uLock); ++#endif + --WorkersIdle; + continue; + } +@@ -672,7 +712,9 @@ void cmWorkerPoolInternal::Work(unsigned int workerIndex) + // If there is a fence currently active or waiting, + // sleep on the main CV and try again. + if (FenceProcessing) { ++#ifndef __serenity__ + Condition.wait(uLock); ++#endif + continue; + } + +@@ -687,12 +729,16 @@ void cmWorkerPoolInternal::Work(unsigned int workerIndex) + raisedFence = true; + // Wait on the Fence CV until all pending jobs are done. + while (JobsProcessing != 0 && !Aborting) { ++#ifndef __serenity__ + ConditionFence.wait(uLock); ++#endif + } + // When aborting, explicitly kick all threads alive once more. + if (Aborting) { + FenceProcessing = false; ++#ifndef __serenity__ + Condition.notify_all(); ++#endif + break; + } + } +@@ -700,10 +746,14 @@ void cmWorkerPoolInternal::Work(unsigned int workerIndex) + // Unlocked scope for job processing + ++JobsProcessing; + { ++#ifndef __serenity__ + uLock.unlock(); ++#endif + jobHandle->Work(Pool, workerIndex); // Process job + jobHandle.reset(); // Destroy job ++#ifndef __serenity__ + uLock.lock(); ++#endif + } + --JobsProcessing; + +@@ -712,12 +762,16 @@ void cmWorkerPoolInternal::Work(unsigned int workerIndex) + // is done. + if (raisedFence) { + FenceProcessing = false; ++#ifndef __serenity__ + Condition.notify_all(); ++#endif + } + // If fence processing is still not done, notify the + // the fencing worker when all active jobs are done. + if (FenceProcessing && JobsProcessing == 0) { ++#ifndef __serenity__ + ConditionFence.notify_all(); ++#endif + } + } + diff --git a/Ports/cmake/patches/0023-lround.patch b/Ports/cmake/patches/0023-lround.patch new file mode 100644 index 0000000000..93b255ba94 --- /dev/null +++ b/Ports/cmake/patches/0023-lround.patch @@ -0,0 +1,26 @@ +diff --git a/Source/cmFileCommand.cxx b/Source/cmFileCommand.cxx +index 5e40712..972927b 100644 +--- a/Source/cmFileCommand.cxx ++++ b/Source/cmFileCommand.cxx +@@ -1500,7 +1500,7 @@ public: + long OldPercentage = this->CurrentPercentage; + + if (total > 0.0) { +- this->CurrentPercentage = std::lround(value / total * 100.0); ++ this->CurrentPercentage = trunc(round(value / total * 100.0)); + if (this->CurrentPercentage > 100) { + // Avoid extra progress reports for unexpected data beyond total. + this->CurrentPercentage = 100; +diff --git a/Source/CTest/cmCTestTestHandler.cxx b/Source/CTest/cmCTestTestHandler.cxx +index 4d1a589..0209bec 100644 +--- a/Source/CTest/cmCTestTestHandler.cxx ++++ b/Source/CTest/cmCTestTestHandler.cxx +@@ -581,7 +581,7 @@ void cmCTestTestHandler::LogTestSummary(const std::vector<std::string>& passed, + } + cmCTestLog(this->CTest, HANDLER_OUTPUT, + std::endl +- << passColorCode << std::lround(percent) << "% tests passed" ++ << passColorCode << trunc(round(percent)) << "% tests passed" + << this->CTest->GetColorCode(cmCTest::Color::CLEAR_COLOR) + << ", " << failedColorCode << failed.size() << " tests failed" + << this->CTest->GetColorCode(cmCTest::Color::CLEAR_COLOR) diff --git a/Ports/cmake/patches/0024-shared-mutex.patch b/Ports/cmake/patches/0024-shared-mutex.patch new file mode 100644 index 0000000000..a765af2d8e --- /dev/null +++ b/Ports/cmake/patches/0024-shared-mutex.patch @@ -0,0 +1,85 @@ +diff --git a/Source/cmServer.cxx b/Source/cmServer.cxx +index 7f97406..bebb100 100644 +--- a/Source/cmServer.cxx ++++ b/Source/cmServer.cxx +@@ -251,7 +251,9 @@ cmFileMonitor* cmServer::FileMonitor() const + void cmServer::WriteJsonObject(const Json::Value& jsonValue, + const DebugInfo* debug) const + { ++#if 0 + cm::shared_lock<cm::shared_mutex> lock(ConnectionsMutex); ++#endif + for (auto& connection : this->Connections) { + WriteJsonObject(connection.get(), jsonValue, debug); + } +@@ -458,7 +460,9 @@ bool cmServerBase::Serve(std::string* errorMessage) + OnServeStart(); + + { ++#if 0 + cm::shared_lock<cm::shared_mutex> lock(ConnectionsMutex); ++#endif + for (auto& connection : Connections) { + if (!connection->OnServeStart(errorMessage)) { + return false; +@@ -494,7 +498,9 @@ void cmServerBase::StartShutDown() + SIGHUPHandler.reset(); + + { ++#if 0 + std::unique_lock<cm::shared_mutex> lock(ConnectionsMutex); ++#endif + for (auto& connection : Connections) { + connection->OnConnectionShuttingDown(); + } +@@ -541,7 +547,9 @@ cmServerBase::~cmServerBase() + void cmServerBase::AddNewConnection(cmConnection* ownedConnection) + { + { ++#if 0 + std::unique_lock<cm::shared_mutex> lock(ConnectionsMutex); ++#endif + Connections.emplace_back(ownedConnection); + } + ownedConnection->SetServer(this); +@@ -558,7 +566,9 @@ void cmServerBase::OnDisconnect(cmConnection* pConnection) + return m.get() == pConnection; + }; + { ++#if 0 + std::unique_lock<cm::shared_mutex> lock(ConnectionsMutex); ++#endif + Connections.erase( + std::remove_if(Connections.begin(), Connections.end(), pred), + Connections.end()); +diff --git a/Source/cmServer.h b/Source/cmServer.h +index 9543329..6a19be7 100644 +--- a/Source/cmServer.h ++++ b/Source/cmServer.h +@@ -65,7 +65,9 @@ public: + void OnDisconnect(cmConnection* pConnection); + + protected: ++#if 0 + mutable cm::shared_mutex ConnectionsMutex; ++#endif + std::vector<std::unique_ptr<cmConnection>> Connections; + + bool ServeThreadRunning = false; +diff --git a/Utilities/std/cm/shared_mutex b/Utilities/std/cm/shared_mutex +index a1204fa..d4812c8 100644 +--- a/Utilities/std/cm/shared_mutex ++++ b/Utilities/std/cm/shared_mutex +@@ -5,6 +5,7 @@ + file Copyright.txt or https://cmake.org/licensing for details. */ + #pragma once + ++#if 0 + #if __cplusplus >= 201402L || defined(_MSVC_LANG) && _MSVC_LANG >= 201402L + # define CMake_HAVE_CXX_SHARED_LOCK + #endif +@@ -71,3 +72,4 @@ public: + }; + #endif + } ++#endif diff --git a/Ports/cmake/patches/0025-uv-platform.patch b/Ports/cmake/patches/0025-uv-platform.patch new file mode 100644 index 0000000000..95a7258fa4 --- /dev/null +++ b/Ports/cmake/patches/0025-uv-platform.patch @@ -0,0 +1,23 @@ +diff --git a/Utilities/cmlibuv/CMakeLists.txt b/Utilities/cmlibuv/CMakeLists.txt +index 92d2411..e6bf241 100644 +--- a/Utilities/cmlibuv/CMakeLists.txt ++++ b/Utilities/cmlibuv/CMakeLists.txt +@@ -354,6 +354,18 @@ if(CMAKE_SYSTEM_NAME STREQUAL "QNX") + ) + endif() + ++if (CMAKE_SYSTEM_NAME STREQUAL "SerenityOS") ++ list(APPEND uv_headers ++ include/uv/posix.h ++ ) ++ list(APPEND uv_sources ++ src/unix/posix-hrtime.c ++ src/unix/posix-poll.c ++ src/unix/no-fsevents.c ++ src/unix/no-proctitle.c ++ ) ++endif() ++ + include_directories( + ${uv_includes} + ${KWSYS_HEADER_ROOT} diff --git a/Ports/cmake/patches/0026-curl-struct-stat.patch b/Ports/cmake/patches/0026-curl-struct-stat.patch new file mode 100644 index 0000000000..c506b8a4c5 --- /dev/null +++ b/Ports/cmake/patches/0026-curl-struct-stat.patch @@ -0,0 +1,12 @@ +diff --git a/Utilities/cmcurl/lib/curl_setup.h b/Utilities/cmcurl/lib/curl_setup.h +index 45a093f..e621db3 100644 +--- a/Utilities/cmcurl/lib/curl_setup.h ++++ b/Utilities/cmcurl/lib/curl_setup.h +@@ -380,6 +380,7 @@ + #endif + + #ifndef struct_stat ++# include <sys/stat.h> + # define struct_stat struct stat + #endif + diff --git a/Ports/cmake/patches/0027-libuv-platform-serenity.patch b/Ports/cmake/patches/0027-libuv-platform-serenity.patch new file mode 100644 index 0000000000..471b830f54 --- /dev/null +++ b/Ports/cmake/patches/0027-libuv-platform-serenity.patch @@ -0,0 +1,13 @@ +diff --git a/Utilities/cmlibuv/include/uv/unix.h b/Utilities/cmlibuv/include/uv/unix.h +index fb3e97d..a59192f 100644 +--- a/Utilities/cmlibuv/include/uv/unix.h ++++ b/Utilities/cmlibuv/include/uv/unix.h +@@ -78,6 +78,8 @@ + # include "posix.h" + #elif defined(__QNX__) + # include "posix.h" ++#elif defined(__serenity__) ++# include "posix.h" + #endif + + #ifndef NI_MAXHOST diff --git a/Ports/cmake/patches/0028-cmake-disable-tests.patch b/Ports/cmake/patches/0028-cmake-disable-tests.patch new file mode 100644 index 0000000000..35a7bd0255 --- /dev/null +++ b/Ports/cmake/patches/0028-cmake-disable-tests.patch @@ -0,0 +1,14 @@ +diff --git a/CMakeLists.txt b/CMakeLists.txt +index 2d860d4..343db6e 100644 +--- a/CMakeLists.txt ++++ b/CMakeLists.txt +@@ -710,7 +710,8 @@ endif() + include(Source/CMakeVersion.cmake) + + # Include the standard Dart testing module +-enable_testing() ++# enable_testing() ++set(BUILD_TESTING 0) + include (${CMAKE_ROOT}/Modules/Dart.cmake) + + # Set up test-time configuration. diff --git a/Ports/cmake/patches/ReadMe.md b/Ports/cmake/patches/ReadMe.md new file mode 100644 index 0000000000..8ed638e7b4 --- /dev/null +++ b/Ports/cmake/patches/ReadMe.md @@ -0,0 +1,244 @@ +# Patches for CMake (and submodules) on SerenityOS + +## `0000-no_wide_string.patch` + +We don't support wide strings, and our libstdc++ doesn't have `std::wstring`. +This patch is a big hack to wipe wide strings out of the codebase; naturally, it very likely breaks unicode. + +### Status +- [ ] Local? +- [ ] Should be merged to upstream? +- [X] Resolves issue(s) with our side of things +- [X] Hack + +## `0002-stoi-atoi.patch` and `0003-stoi-atoi-2.patch` + +For some reason, our libstdc++ does not define `std::stoi`, these two patches change different overloads of this function to the equivalent C functions. + +### Status +- [X] Local? +- [ ] Should be merged to upstream? +- [X] Resolves issue(s) with our side of things +- [ ] Hack + +## `0004-snprintf.patch` + +Our libstdc++ does not define `std::printf` and `std::snprintf`, this patch simply removes the `std` namespace. + +### Status +- [X] Local? +- [ ] Should be merged to upstream? +- [X] Resolves issue(s) with our side of things +- [ ] Hack + +## `0005-stod.patch` and `0006-stoll.patch` + +Our libstdc++ does not define `std::stod` and `std::stoll`, this patch swaps them with the equivalent C functions. + +### Status +- [X] Local? +- [ ] Should be merged to upstream? +- [X] Resolves issue(s) with our side of things +- [ ] Hack + +## `0007-utimes-utime.patch` + +`utimes` is a deprecated POSIX API, and we do not support it, this patch uses the equivalent `utime` function instead. + +### Status +- [ ] Local? +- [X] Should be merged to upstream? (Once cleaned up) +- [ ] Resolves issue(s) with our side of things +- [ ] Hack + +## `0008-unix-stuff.patch` + +This patch removes the use of `{get,set}priority()` as we do not support it. +it also removes two functions with the correct conditions (the same conditions as their dependents are removed with). + +### Status +- [X] Local? +- [X] Should be merged to upstream? Partially. +- [X] Resolves issue(s) with our side of things +- [X] Hack + +## `0009-purge-non-serenity-syscalls.patch` + +This patch removes syscalls and options not defined in serenity. + +### Status +- [X] Local? +- [ ] Should be merged to upstream? +- [X] Resolves issue(s) with our side of things +- [X] Hack + +## `0010-don-t-use-siginfo.patch` + +We don't support SIGINFO. This patch removes uses of SIGINFO. + +### Status +- [X] Local? +- [ ] Should be merged to upstream? +- [X] Resolves issue(s) with our side of things +- [ ] Hack + +## `0011-Fixed-your-code-rot-cmake.patch` + +This purely fixes code issues with cmake. very funny patch. + +### Status +- [ ] Local? +- [X] Should be merged to upstream? +- [ ] Resolves issue(s) with our side of things +- [ ] Hack + +## `0012-bin-bash.patch` + +This patch swaps out `/bin/sh` for `/bin/bash` in two scripts that need it. + +### Status +- [X] Local? +- [ ] Should be merged to upstream? +- [ ] Resolves issue(s) with our side of things +- [ ] Hack + +## `0013-platform-serenityos.patch` +This patch adds the SerenityOS platform config file to CMake. + +### Status +- [ ] Local? +- [X] Should be merged to upstream? If we want to have cmake support serenity out of the box. +- [ ] Resolves issue(s) with our side of things +- [ ] Hack + +## `0014-cmcurl-include-unistd.patch` + +Everyone gets this wrong. most platforms are very lax with these includes, but we're not one of them. + +### Status +- [X] Local? +- [ ] Should be merged to upstream? +- [ ] Resolves issue(s) with our side of things +- [ ] Hack + +## `0015-atoll.patch` + +Our libstdc++ does not define `std::atoll`, this patch uses the equivalent C function instead. + +### Status +- [ ] Local? +- [ ] Should be merged to upstream? +- [X] Resolves issue(s) with our side of things +- [ ] Hack + +## `0016-conflicting-0.patch` and `0017-conflicting-1.patch` + +These two defines make GCC very sad. reasons are unknown at this time. + +### Status +- [ ] Local? +- [ ] Should be merged to upstream? +- [X] Resolves issue(s) with our side of things +- [X] Hack + +## `0018-isfinite.patch` + +Our `math.h` already defines `isfinite`. + +### Status +- [ ] Local? +- [X] Should be merged to upstream? If we want to have cmake support serenity out of the box. +- [ ] Resolves issue(s) with our side of things +- [ ] Hack + +## `0019-libuv-so_linger.patch` + +We don't have `SO_LINGER` or its associated struct. This patch removes them. + +### Status +- [X] Local? +- [ ] Should be merged to upstream? +- [X] Resolves issue(s) with our side of things +- [X] Hack + +## `0020-libuv-ipv6.patch` + +cmlibuv assumes the platform has definitions for (and supports) IPv6; this patch removes IPv6-specific things from libuv. + +### Status +- [X] Local? +- [ ] Should be merged to upstream? +- [X] Resolves issue(s) with our side of things +- [ ] Hack + +## `0021-libcurl-no-ipv6.patch` + +libcurl has a IPV6 switch, but uses `AF_INET6` unconditionally in one place. this patch disables IPV6 and makes that one use conditional. + +### Status +- [X] Local? Partially. +- [X] Should be merged to upstream? Partially. +- [X] Resolves issue(s) with our side of things +- [ ] Hack + +## `0022-remove-mutex.patch` and `0024-shared-mutex.patch` + +We don't have mutexes, and out libstdc++ does not define `std::mutex`. +This patch removes all uses of `std::mutex`, `std::condition_variable`, and anything that depends on them; and replaces them with single-threaded equivalents. +This will break horribly with smp. + +### Status +- [X] Local? +- [ ] Should be merged to upstream? +- [X] Resolves issue(s) with our side of things +- [X] Hack + +## `0023-lround.patch` + +Our libstdc++ (and stdlib) does not have `lround`, this patch replaces that with somewhat equivalent C stdlib functions. + +### Status +- [X] Local? +- [ ] Should be merged to upstream? +- [X] Resolves issue(s) with our side of things +- [X] Hack + +## `0025-uv-platform.patch` + +This patch adds the definitions necessary to compile libuv on Serenity. + +### Status +- [ ] Local? +- [X] Should be merged to upstream? If we want to have cmake support serenity out of the box. +- [ ] Resolves issue(s) with our side of things +- [ ] Hack + +## `0026-curl-struct-stat.patch` + +For unknown reasons, `curl_setup_once.h` does not include `sys/stat.h`. this patch includes `sys/stat.h`. + +### Status +- [ ] Local? +- [ ] Should be merged to upstream? +- [X] Resolves issue(s) with our side of things +- [X] Hack + +## `0027-libuv-platform-serenity.patch` + +This patch adds a platform-specific conditional include to `uv/unix.h`. + +### Status +- [ ] Local? +- [X] Should be merged to upstream? +- [ ] Resolves issue(s) with our side of things +- [ ] Hack + +## `0028-cmake-disable-tests.patch` + +We don't care about building tests for now, and it makes the compilation much faster. + +### Status +- [ ] Local? +- [ ] Should be merged to upstream? +- [ ] Resolves issue(s) with our side of things +- [ ] Hack |