Merge branch 'master' into use-BUILD_TESTING

Author: benman64

CMakeLists.txt

@@ -4,6 +4,7 @@ if(NOT CMAKE_BUILD_TYPE)
     set(CMAKE_BUILD_TYPE Release CACHE STRING "Release/Debug")
 endif()
 
+message(STATUS "build type ${CMAKE_BUILD_TYPE}")
 set(CMAKE_EXPORT_COMPILE_COMMANDS ON)
 include(CheckCXXCompilerFlag)
 
@@ -28,6 +29,7 @@ set(CMAKE_CXX_STANDARD_REQUIRED ON)
 set(CMAKE_CXX_EXTENSIONS OFF)
 
 enable_cxx_compiler_flag_if_supported(-pedantic)
+enable_cxx_compiler_flag_if_supported(-ggdb)
 
 if(MSVC)
     add_compile_options(-Zc:__cplusplus)
@@ -38,8 +40,8 @@ endif()
 
 add_subdirectory(src/cpp subprocess)
 
-# TODO testing
 if (BUILD_TESTING)
     enable_testing()
     add_subdirectory(test)
 endif(BUILD_TESTING)
+

README.md

@@ -175,7 +175,18 @@ All tests pass on linux & mac. Most pass under mingw & MSVC.
 - breaking: RunOptions which is used in subprocess::run order is changed to be
   identical to python subprocess::run. This effects users using c++20 designated
   initializers. Prior versions of compilers didn't seem to care about order.
-- fixed #5 cin double closed. Thanks [GerHobbelt](https://github.com/GerHobbelt)
+- Thanks to [urs-muff](https://github.com/urs-muff) for windows 64bit support
+
+Thanks [GerHobbelt](https://github.com/GerHobbelt) for the following
+
+- fixed #5 cin double closed.
+- `_DCRTIMP` for environ
+- order of [check](https://github.com/benman64/subprocess/pull/8/commits/cbf1a7aff1a627c961f93fb39de94601a52ceb0a) fixed, done so to match python ordering
+  rather than changing example.
+
+- [yurivict](https://github.com/yurivict) Thanks for FREEBSD compatibility (I have no way of testing this)
+- [StableAgOH](https://github.com/StableAgOH) thanks for pointing out WC_ERR_INVALID_CHARS macro exists and std::string nullptr fix
+
 
 # 0.4.0
 

src/cpp/subprocess/ProcessBuilder.cpp

@@ -4,7 +4,7 @@
 
 #else
 #include <spawn.h>
-#ifdef __APPLE__
+#if defined(__APPLE__) || defined(__FreeBSD__)
 #include <sys/wait.h>
 #else
 #include <wait.h>
@@ -160,7 +160,7 @@ namespace subprocess {
         case PipeVarIndex::handle:
         case PipeVarIndex::option: break;
         case PipeVarIndex::string: // doesn't make sense
-        case PipeVarIndex::istream: // dousn't make sense
+        case PipeVarIndex::istream: // doesn't make sense
             throw std::domain_error("expected something to output to");
         case PipeVarIndex::ostream:
             pipe_thread(input, std::get<std::ostream*>(output));
@@ -341,7 +341,7 @@ namespace subprocess {
     int Popen::wait(double timeout) {
         if (returncode != kBadReturnCode)
             return returncode;
-        DWORD ms = timeout < 0? INFINITE : timeout*1000.0;
+        DWORD ms = timeout < 0 ? INFINITE : (DWORD)(timeout*1000.0);
         DWORD result = WaitForSingleObject(process_info.hProcess, ms);
         if (result == WAIT_TIMEOUT) {
             throw TimeoutExpired("timeout of " + std::to_string(ms) + " expired");
@@ -583,4 +583,4 @@ namespace subprocess {
         return completed;
     }
 
-}
+}

src/cpp/subprocess/ProcessBuilder.hpp

@@ -100,6 +100,7 @@ namespace subprocess {
         pid_t       pid         = 0;
         /** The exit value of the process. Valid once process is completed */
         int         returncode  = kBadReturnCode;
+        std::string cwd;
         CommandLine args;
 
         /** calls pipe_ignore_and_close on cout */

src/cpp/subprocess/ProcessBuilder_windows.cpp

@@ -9,6 +9,7 @@
 
 #include "shell_utils.hpp"
 #include "environ.hpp"
+#include "utf8_to_utf16.hpp"
 
 static STARTUPINFO g_startupInfo;
 static bool g_startupInfoInit = false;
@@ -48,7 +49,6 @@ namespace subprocess {
         saAttr.lpSecurityDescriptor = NULL;
 
 
-        PROCESS_INFORMATION piProcInfo  = {0};
         STARTUPINFO siStartInfo         = {0};
         BOOL bSuccess = FALSE;
 
@@ -72,7 +72,6 @@ namespace subprocess {
             disable_inherit(cin_pair.output);
         }
 
-
         if (cout_option == PipeOption::close) {
             cout_pair = pipe_create();
             siStartInfo.hStdOutput = cout_pair.output;
@@ -83,7 +82,7 @@ namespace subprocess {
             process.cout = cout_pair.input;
             disable_inherit(cout_pair.input);
         } else if (cout_option == PipeOption::cerr) {
-            // Do this when stderr is setup bellow
+            // Do this when stderr is setup below
         } else if (cout_option == PipeOption::specific) {
             pipe_set_inheritable(cout_pipe, true);
             siStartInfo.hStdOutput = cout_pipe;
@@ -109,7 +108,6 @@ namespace subprocess {
         if (cout_option == PipeOption::cerr) {
             siStartInfo.hStdOutput = siStartInfo.hStdError;
         }
-        const char* cwd = this->cwd.empty()? nullptr : this->cwd.c_str();
         std::string args = windows_args(command);
 
         void* env = nullptr;
@@ -130,19 +128,42 @@ namespace subprocess {
         if (this->new_process_group) {
             process_flags |= CREATE_NEW_PROCESS_GROUP;
         }
+        
+        process.cwd = this->cwd;
         // Create the child process.
-        bSuccess = CreateProcess(program.c_str(),
-            (char*)args.c_str(),            // command line
-            NULL,                           // process security attributes
-            NULL,                           // primary thread security attributes
-            TRUE,                           // handles are inherited
-            process_flags,                  // creation flags
-            env,                            // environment
-            cwd,                            // use parent's current directory
-            &siStartInfo,                   // STARTUPINFO pointer
-            &piProcInfo);                   // receives PROCESS_INFORMATION
-        process.process_info = piProcInfo;
-        process.pid = piProcInfo.dwProcessId;
+#if _WIN64
+        std::u16string cmd_args{ utf8_to_utf16(args) };
+        bSuccess = CreateProcess(
+          (LPCWSTR)utf8_to_utf16(program).c_str(),
+          (LPWSTR)cmd_args.data(),                                                      // command line
+          NULL,                                                                         // process security attributes
+          NULL,                                                                         // primary thread security attributes
+          TRUE,                                                                         // handles are inherited
+          process_flags,                                                                // creation flags
+          env,                                                                          // environment
+          (LPCWSTR)(this->cwd.empty() ? nullptr : utf8_to_utf16(this->cwd).c_str()),    // use parent's current directory
+          &siStartInfo,                                                                 // STARTUPINFO pointer
+          &process.process_info);                                                       // receives PROCESS_INFORMATION
+#else
+        std::string cmd_args{ args };
+        bSuccess = CreateProcess(
+          (LPCSTR)program.c_str(),
+          (LPSTR)cmd_args.data(),                                                       // command line
+          NULL,                                                                         // process security attributes
+          NULL,                                                                         // primary thread security attributes
+          TRUE,                                                                         // handles are inherited
+          process_flags,                                                                // creation flags
+          env,                                                                          // environment
+          (LPCSTR)(this->cwd.empty() ? nullptr : this->cwd.c_str()),                    // use parent's current directory
+          &siStartInfo,                                                                 // STARTUPINFO pointer
+          &process.process_info);                                                       // receives PROCESS_INFORMATION
+
+
+        LPCSTR cwd = this->cwd.empty() ? nullptr : (LPCSTR)this->cwd.c_str();
+        LPCSTR program_arg = (LPCSTR)program.c_str();
+        LPSTR cmd_args = (LPSTR)args.c_str();            // command line
+#endif
+        process.pid = process.process_info.dwProcessId;
         if (cin_pair)
             cin_pair.close_input();
         if (cout_pair)

src/cpp/subprocess/basic_types.hpp

@@ -1,5 +1,6 @@
 #pragma once
 #ifdef _WIN32
+#define NOMINMAX
 #include <windows.h>
 #else
 #include <unistd.h>

src/cpp/subprocess/environ.cpp

@@ -6,7 +6,11 @@
 #include "utf8_to_utf16.hpp"
 using std::to_string;
 
-extern "C" char **environ;
+#if !defined(_DCRTIMP)     // Windows-specific RTL DLL import macro
+#define _DCRTIMP
+#endif
+
+extern "C" _DCRTIMP char **environ;
 
 namespace subprocess {
     Environ cenv;
@@ -131,4 +135,4 @@ namespace subprocess {
         result += (char16_t)'\0';
         return result;
     }
-}
+}

src/cpp/subprocess/pipe.cpp

@@ -63,15 +63,15 @@ namespace subprocess {
     }
     ssize_t pipe_read(PipeHandle handle, void* buffer, std::size_t size) {
         DWORD bread = 0;
-        bool result = ReadFile(handle, buffer, size, &bread, nullptr);
+        bool result = ReadFile(handle, buffer, (DWORD)size, &bread, nullptr);
         if (result)
             return bread;
         return -1;
     }
 
     ssize_t pipe_write(PipeHandle handle, const void* buffer, size_t size) {
         DWORD written = 0;
-        bool result = WriteFile(handle, buffer, size, &written, nullptr);
+        bool result = WriteFile(handle, buffer, (DWORD)size, &written, nullptr);
         if (result)
             return written;
         return -1;

src/cpp/subprocess/shell_utils.cpp

@@ -7,7 +7,7 @@
 #else
 #include <unistd.h>
 #include <spawn.h>
-#ifdef __APPLE__
+#if defined(__APPLE__) || defined(__FreeBSD__)
 #include <sys/wait.h>
 #else
 #include <wait.h>
@@ -42,7 +42,7 @@ namespace {
             if (path.empty())
                 return false;
             return std::filesystem::is_regular_file(path);
-        } catch (std::filesystem::filesystem_error& e) {
+        } catch (std::filesystem::filesystem_error&) {
             return false;
         }
     }
@@ -302,4 +302,4 @@ namespace subprocess {
         return result;
     }
 
-}
+}

src/cpp/subprocess/utf8_to_utf16.cpp

@@ -112,13 +112,13 @@ namespace subprocess {
     std::u16string utf8_to_utf16(const std::string& string) {
         static_assert(sizeof(wchar_t) == 2, "wchar_t must be of size 2");
         static_assert(sizeof(wchar_t) == sizeof(char16_t), "wchar_t must be of size 2");
-        int size = string.size()+1;
+        int size = (int)string.size()+1;
         // Determine wstring size (`MultiByteToWideChar` returns the required size if
         // its last two arguments are `NULL` and 0).
         int r = MultiByteToWideChar(CP_UTF8, MB_ERR_INVALID_CHARS,
             string.c_str(), size, NULL, 0);
         if (r == 0) {
-            return std::u16string();
+            return {};
         }
         assert(r > 0);
 
@@ -127,7 +127,7 @@ namespace subprocess {
         wchar_t *wstring = new wchar_t[r];
         if (wstring == NULL) {
             SetLastError(ERROR_NOT_ENOUGH_MEMORY);
-            return NULL;
+            return {};
         }
 
         // Now we pass our allocated string and its size as the last two arguments
@@ -137,27 +137,27 @@ namespace subprocess {
             wstring, r);
         if (r == 0) {
             delete [] wstring;
-            return NULL;
+            return {};
         }
         std::u16string result((char16_t*)wstring, r-1);
         delete [] wstring;
         return result;
     }
 
-#ifdef __MINGW32__
+#ifndef WC_ERR_INVALID_CHARS
     // mingw doesn't define this
     constexpr int WC_ERR_INVALID_CHARS = 0;
 #endif
 
     std::string utf16_to_utf8(const std::u16string& wstring) {
-        int size = wstring.size()+1;
+        int size = (int)wstring.size()+1;
         // Determine wstring size (`MultiByteToWideChar` returns the required size if
         // its last two arguments are `NULL` and 0).
         int r = WideCharToMultiByte(CP_UTF8, WC_ERR_INVALID_CHARS,
             (wchar_t*)wstring.c_str(), size, NULL, 0, NULL, NULL);
 
         if (r == 0) {
-            return "";
+            return {};
         }
         assert(r > 0);
 
@@ -166,7 +166,7 @@ namespace subprocess {
         char *string = new char[r];
         if (string == nullptr) {
             SetLastError(ERROR_NOT_ENOUGH_MEMORY);
-            return NULL;
+            return {};
         }
 
         // Now we pass our allocated string and its size as the last two arguments
@@ -176,22 +176,22 @@ namespace subprocess {
             string, r, NULL, NULL);
         if (r == 0) {
             delete [] string;
-            return NULL;
+            return {};
         }
         std::string result(string, r-1);
         delete [] string;
         return result;
     }
 
     std::string utf16_to_utf8(const std::wstring& wstring) {
-        int size = wstring.size()+1;
+        int size = (int)wstring.size()+1;
         // Determine wstring size (`MultiByteToWideChar` returns the required size if
         // its last two arguments are `NULL` and 0).
         int r = WideCharToMultiByte(CP_UTF8, WC_ERR_INVALID_CHARS,
             (wchar_t*)wstring.c_str(), size, NULL, 0, NULL, NULL);
 
         if (r == 0) {
-            return "";
+            return {};
         }
         assert(r > 0);
 
@@ -200,7 +200,7 @@ namespace subprocess {
         char *string = new char[r];
         if (string == nullptr) {
             SetLastError(ERROR_NOT_ENOUGH_MEMORY);
-            return NULL;
+            return {};
         }
 
         // Now we pass our allocated string and its size as the last two arguments
@@ -210,7 +210,7 @@ namespace subprocess {
             string, r, NULL, NULL);
         if (r == 0) {
             delete [] string;
-            return NULL;
+            return {};
         }
         std::string result(string, r-1);
         delete [] string;