Ports: Add a cmake port

Yes, you build this *inside* serenity.

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,
+                     &registry_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