Merge pull request #227 from x-santiaga-x/patch-1

Closes klemens-morgenstern/boost-process#218

.travis.yml

@@ -133,5 +133,4 @@ after_success:
 after_script:
   - bash <(curl -s https://codecov.io/bash)
   - cd $BOOST/libs/$PROJECT_TO_TEST/test
-  - curl -s https://report.ci/upload.py | python - --name="$BADGE test run" --root_dir $BOOST
-
+  - curl -s https://report.ci/report.py | python - --name="$BADGE test run"

CMakeLists.txt

@@ -0,0 +1,37 @@
+# Generated by `boostdep --cmake process`
+# Copyright 2020 Peter Dimov
+# Distributed under the Boost Software License, Version 1.0.
+# https://www.boost.org/LICENSE_1_0.txt
+
+cmake_minimum_required(VERSION 3.5...3.16)
+
+project(boost_process VERSION "${BOOST_SUPERPROJECT_VERSION}" LANGUAGES CXX)
+
+add_library(boost_process INTERFACE)
+add_library(Boost::process ALIAS boost_process)
+
+target_include_directories(boost_process INTERFACE include)
+
+target_link_libraries(boost_process
+  INTERFACE
+    Boost::algorithm
+    Boost::asio
+    Boost::config
+    Boost::core
+    Boost::filesystem
+    Boost::fusion
+    Boost::iterator
+    Boost::move
+    Boost::optional
+    Boost::system
+    Boost::tokenizer
+    Boost::type_index
+    Boost::winapi
+)
+
+if(BUILD_TESTING AND EXISTS "${CMAKE_CURRENT_SOURCE_DIR}/test/CMakeLists.txt")
+
+  add_subdirectory(test)
+
+endif()
+

doc/concepts.qbk

@@ -16,11 +16,11 @@ In that it is different than other facilities (like sockets) and provides anothe
 Pipes are typically used for interprocess communication. The main reason is, that pipes can be directly assigned to the process stdio, i.e. stderr, stdin and stdout.
 Additionally, half of the pipe can be inherited to the child process and closed in the father process. This will cause the pipe to be broken when the child process exits.
 
-Though please note, that if the the same thread reads and write to a pipe, it will only talk to itself.
+Though please note, that if the same thread reads and writes to a pipe, it will only talk to itself.
 
 [section:anonymous Anonymous Pipes]
 
-The most common pipes are anonymous. Since the have no name,
+The most common pipes are anonymous. Since they have no name,
 a handle to them can only be obtained from duplicating either handle.
 
 In this library the following functions are used for the creation of unnamed pipes:
@@ -57,12 +57,12 @@ Every process is identified by a unique number[footnote it is unique as long as
 
 [section:exit_code Exit code]
 A process will return an integer value indicating whether it was successful. On posix
-there are more codes associated with that, but not so on windows. Therefore there is not such encoding currently in the library.
+there are more codes associated with that, but not so on windows. Therefore there is no such encoding currently in the library.
 However an exit code of zero means the process was successful, while one different than zero indicates an error. 
 [endsect]
 
 [section:termination Termination]
-Processes can also be forced to exit. There are two ways to do this, signal the process to so and wait, and just terminate the process without conditions.
+Processes can also be forced to exit. There are two ways to do this, signal the process to do so and wait, and just terminate the process without conditions.
 
 Usually the first approach is to signal an exit request, but windows - unlike posix - does not provide a consistent way to do this. Hence this is not part of the
 library and only the hard terminate is. 
@@ -79,4 +79,4 @@ The environment is a map of variables local to every process. The most significa
 
 [endsect]
 
-[endsect]
+[endsect]

doc/design.qbk

@@ -1,12 +1,12 @@
 [section:design Design Rationale]
 [section Scope]
-This library is meant to give an wrapper around the different OS-specific methods
+This library is meant to give a wrapper around the different OS-specific methods
 to launch processes. Its aim is to provide all functionality that is available on 
 those systems and allow the user to do all related things, which require using the OS APIs.
 
-[*This library does not try to provide a full library for everything process related] 
+[*This library does not try to provide a full library for everything process related.] 
 In many discussions the proposal was made to build boost.process into a DSEL [footnote Domain Specific Embedded Language] of some sort. 
-This is not the goal, it rather provides the facilities to build such a DSEL-Library on top of it. 
+This is not the goal, it rather provides the facilities to build such a DSEL-library on top of it. 
 Therefore the library also does [*not] force any particular use (such as only asynchronous communication) on its user. 
 It rather could be integrated with such a library.  
 
@@ -33,7 +33,7 @@ Both styles can also be mixed in some cases.
 system("gcc", "-c", args+={"main.cpp"});
 ```
 
-In the following section the avaible styles will be described. Note that the
+In the following section the available styles will be described. Note that the
 overload style is implemented via type traits, so the types will be listed. 
 
 [caution There is no guarantee in which order the arguments will be applied! 
@@ -54,7 +54,7 @@ interpret each string as an argument.
 ] 
 
 When using the overloading variant, a single string will result in a cmd interpretation, 
-several strings will yield a exe-args interpretation. Both version can be set explicitly:
+several strings will yield a exe-args interpretation. Both versions can be set explicitly:
 
 ```
 system("grep -c false /etc/passwd"); //cmd style
@@ -65,7 +65,7 @@ system(exe="grep", args={"-c", "false", "/etc/passwd"}); //exe-/args-
 ```
 
 [note If a '"' sign is used in the argument style, it will be passed as part of the argument.
-If the same effect it wanted with the cmd syntax, it ought to be escaped, i.e. '\\\"'. ]
+If the same effect is wanted with the cmd syntax, it ought to be escaped, i.e. '\\\"'. ]
 [note The `PATH` variable will automatically be searched in the command style, 
 but the one of the launching process, not the one passed to the child process.]
 [endsect]

doc/extend.qbk

@@ -15,14 +15,14 @@ To extend the library, the header [headerref boost/process/extend.hpp extend] is
 
 It only provides the explicit style for custom properties, but no implicit style.
 
-What this means is, that a custom initializer can be implemented, a reference to which can be passed to one of the launching functions.
-If a class inherits [classref boost::process::extend::handler] it will be regarded as a initializer and thus directly put into the sequence 
+What this means is, that a custom initializer can be implemented, a reference which can be passed to one of the launching functions.
+If a class inherits [classref boost::process::extend::handler] it will be regarded as an initializer and thus directly put into the sequence 
 the executor gets passed.
 
 [section:structure Structure]
 
 The executor calls different handlers of the initializers during the process launch. 
-The basic structure is consists of three functions, as given below:
+The basic structure consists of three functions, as given below:
 
 * [globalref boost::process::extend::on_setup on_setup]
 * [globalref boost::process::extend::on_error on_error]
@@ -53,7 +53,7 @@ namespace ex = bp::extend;
 __child__ c("foo", __on_success__=[](auto & exec) {std::cout << "hello world" << std::endl;});
 ```
 
-Considering that lambda can also capture values, data can easily be shared between handlers. 
+Considering that lambdas can also capture values, data can easily be shared between handlers. 
 
 To see which members the executor has, refer to [classref boost::process::extend::windows_executor windows_executor]
 and [classref boost::process::extend::posix_executor posix_executor].
@@ -86,7 +86,7 @@ __child__ c("foo", hello_world());
 
 [note The implementation is done via overloading, not overriding.]
 
-Every handler not implemented dafaults to [classref boost::process::extend::handler handler], where an empty handler is defined for each event.
+Every handler not implemented defaults to [classref boost::process::extend::handler handler], where an empty handler is defined for each event.
 
 [endsect]
 
@@ -100,7 +100,7 @@ this functionality is also available for extensions. If the class needs the __io
 ```
 struct async_foo : __handler__, __require_io_context__
 {
-    tempalte<typename Executor>
+    template<typename Executor>
     void on_setup(Executor & exec)
     {
         __io_context__ & ios = __get_io_context__(exec.seq); //gives us a reference and a compiler error if not present.
@@ -139,10 +139,10 @@ struct async_bar : __handler, __async_handler__
 
 [section:error Error handling]
 
-If an error occurs in the initializers it shall be told to the executor and not handles directly. This is because
-the behaviour can be changed through arguments passed to the launching function. Hence the the executor
+If an error occurs in the initializers it shall be told to the executor and not handled directly. This is because
+the behaviour can be changed through arguments passed to the launching function. Hence the executor
 has the function `set_error`, which takes an [@http://en.cppreference.com/w/cpp/error/error_code std::error_code] and a string.
-Depending on the cofiguration of the executor, this may either throw, set an internal `error_code`, or do nothing.
+Depending on the configuration of the executor, this may either throw, set an internal `error_code`, or do nothing.
 
 So let's take a simple example, where we set a randomly chosen `error_code`.
 
@@ -202,8 +202,8 @@ struct hello_exe : __handler__
 };
 ```
 
-So given our example, the definitions with the non-native exectur are still a template so that they will not be evaluated if not used. Hence this provides a
-way to implement systems-specific code without using the preprocessor.
+So given our example, the definitions with the non-native executor are still a template so that they will not be evaluated if not used. Hence this provides a
+way to implement system-specific code without using the preprocessor.
 
 [note If you only write a partial implementation, e.g. only for __posix_executor__, the other variants will default to __handler__].
 

doc/faq.qbk

@@ -47,7 +47,7 @@ while (is >> file)
 This will also deadlock, because the pipe does not close when the subprocess exits.
 So the `ipstream` will still look for data even though the process has ended.
 
-[note It is not possible to use automatically pipe-closing in this library, because 
+[note It is not possible to use automatic pipe-closing in this library, because 
 a pipe might be a file-handle (as for async pipes on windows).]
 
 But, since pipes are buffered, you might get incomplete data if you do this:
@@ -64,7 +64,7 @@ while (c.running())
 }
 ```
 
-It is therefore highly recommended that you use the asynchronous api if you are
+It is therefore highly recommended that you use the asynchronous API if you are
 not absolutely sure how the output will look.
 
 [endsect]

doc/tutorial.qbk

@@ -30,7 +30,7 @@
 [def asio_async_read [@http://www.boost.org/doc/libs/release/doc/html/boost_asio/reference/async_read.html boost::asio::async_read]]
 [def bp::environment  [classref boost::process::basic_environment bp::environment]]
 [def bp::native_environment  [classref boost::process::basic_native_environment bp::native_environment]]
-[def boost::this_process::environment [funcref boost::this_process::environment boost::this_process:deadlock :environment]]
+[def boost::this_process::environment [funcref boost::this_process::environment boost::this_process::environment]]
 [def std::chrono::seconds [@http://en.cppreference.com/w/cpp/chrono/duration std::chrono::seconds]]
 [def std::vector [@http://en.cppreference.com/w/cpp/container/vector std::vector]]
 
@@ -68,12 +68,12 @@ namespace bp = boost::process; //we will assume this for all further examples
 int result = bp::system("g++ main.cpp");
 ```
 
-If a single string (or the explicit form bp::cmd), it will be interpreted as a command line. 
+If a single string is given (or the explicit form bp::cmd), it will be interpreted as a command line. 
 That will cause the execution function to search the `PATH` variable to find the executable. 
 The alternative is the `exe-args` style, where the first string will be interpreted as a filename (including the path),
 and the rest as arguments passed to said function.   
 
-[note For more details on the `cmd`/`exe-args` style look [link boost_process.design.arg_cmd_style here]]
+[note For more details on the `cmd`/`exe-args` style look [link boost_process.design.arg_cmd_style here].]
 
 So as a first step, we'll use the `exe-args` style.
 
@@ -141,7 +141,7 @@ things while the process is running and afterwards get the exit code. The call
 to child_wait is necessary, to obtain it and tell the operating system, that no
 one is waiting for the process anymore.
 
-[note You can also wait for a time span or a until a time point with __wait_for__ and __wait_until__]
+[note You can also wait for a time span or until a time point with __wait_for__ and __wait_until__.]
 
 [warning If you don't call wait on a child object, it will be terminated on destruction.
 This can be avoided by calling __detach__ beforehand]  
@@ -217,7 +217,7 @@ std::vector<std::string> read_outline(std::string & file)
 What this does is redirect the `stdout` of the process into a pipe and we read this
 synchronously.
 
-[note You can do the same thing with [globalref boost::process::std_err std_err]]
+[note You can do the same thing with [globalref boost::process::std_err std_err].]
 
 Now we get the name from `nm` and we might want to demangle it, so we use input and output.
 `nm` has a demangle option, but for the sake of the example, we'll use 
@@ -246,7 +246,7 @@ std::vector<std::string> read_demangled_outline(const std::string & file)
     
     std::vector<std::string> outline;
     
-    //we just use the same pipe, so the 
+    //we just use the same pipe, so the output of nm is directly passed as input to c++filt
     bp::child nm(bp::search_path("nm"), file,  bp::std_out > p); 
     bp::child filt(bp::search_path("c++filt"), bp::std_in < p, bp::std_out > is);
     
@@ -270,7 +270,7 @@ If you are familiar with [@http://www.boost.org/doc/libs/release/libs/asio/ boos
 you can use [classref boost::process::async_pipe async_pipe] which is implemented 
 as an I/O-Object and can be used like [classref boost::process::pipe pipe] as shown above.
 
-Now we get back to our compiling example. `nm` we might analyze it line by line,
+Now we get back to our compiling example. For `nm` we might analyze the output line by line,
 but the compiler output will just be put into one large buffer.
 
 With [@http://www.boost.org/doc/libs/release/libs/asio/ boost.asio] this is what it looks like.
@@ -290,7 +290,7 @@ ios.run();
 int result = c.exit_code();
 ```
 
-To make it easier, boost.process provides simpler interface for that, so that the buffer can be passed directly, 
+To make it easier, boost.process provides a simpler interface for that, so that the buffer can be passed directly, 
 provided we also pass a reference to an io_service. 
 
 ```
@@ -304,7 +304,7 @@ int result = c.exit_code();
 ```
 
 [note Passing an instance of io_service to the launching function automatically cause it to wait asynchronously for the exit, so no call of 
-[memberref boost::process::child::wait wait] is needed]
+[memberref boost::process::child::wait wait] is needed.]
  
 To make it even easier, you can use [@http://en.cppreference.com/w/cpp/thread/future std::future] for asynchronous operations
 (you will still need to pass a reference to a io_service) to the launching function, unless you use bp::system or bp::async_system.
@@ -331,7 +331,7 @@ auto err =  data.get();
 [endsect]
 [section:group Groups]
 
-When launching several processes, processes can be grouped together. 
+When launching several processes, they can be grouped together. 
 This will also apply for a child process, that launches other processes, 
 if they do not modify the group membership. E.g. if you call `make` which 
 launches other processes and call terminate on it, 
@@ -342,7 +342,7 @@ The two main reasons to use groups are:
 # Being able to terminate child processes of the child process
 # Grouping several processes into one, just so they can be terminated at once
 
-If we have program like `make`, which does launch its own child processes, 
+If we have a program like `make`, which does launch its own child processes, 
 a call of child_terminate might not suffice. I.e. if we have a makefile launching `gcc` 
 and use the following code, the `gcc` process will still run afterwards:
 
@@ -412,14 +412,14 @@ bp::system("stuff", env_);
 ```
 
 A more convenient way to modify the environment for the child is the 
-[globalref boost::process::env env] property, which the example as following:
+[globalref boost::process::env env] property, which can be used in the example as following:
 
 ```
 bp::system("stuff", bp::env["VALUE_1"]="foo", bp::env["VALUE_2"]+={"bar1", "bar2"});
 
 ```
 
-Please see to the [headerref boost/process/environment.hpp reference] for more information.
+Please see the [headerref boost/process/environment.hpp reference] for more information.
 
 [endsect]
 [endsect]

example/intro.cpp

@@ -10,6 +10,9 @@
 //[intro
 #include <boost/process.hpp>
 
+#include <string>
+#include <iostream>
+
 using namespace boost::process;
 
 int main()

include/boost/process/args.hpp

@@ -138,7 +138,7 @@ struct args_
 
     arg_setter_<char, true> operator()(std::initializer_list<const char*> &&range) const
     {
-        return arg_setter_<char>(range.begin(), range.end());
+        return arg_setter_<char, true>(range.begin(), range.end());
     }
     arg_setter_<char, true> operator+=(std::initializer_list<const char*> &&range) const
     {
@@ -146,11 +146,11 @@ struct args_
     }
     arg_setter_<char, false> operator= (std::initializer_list<const char*> &&range) const
     {
-        return arg_setter_<char, true>(range.begin(), range.end());
+        return arg_setter_<char, false>(range.begin(), range.end());
     }
     arg_setter_<char, true> operator()(std::initializer_list<std::string> &&range) const
     {
-        return arg_setter_<char>(range.begin(), range.end());
+        return arg_setter_<char, true>(range.begin(), range.end());
     }
     arg_setter_<char, true> operator+=(std::initializer_list<std::string> &&range) const
     {
@@ -158,12 +158,12 @@ struct args_
     }
     arg_setter_<char, false> operator= (std::initializer_list<std::string> &&range) const
     {
-        return arg_setter_<char, true>(range.begin(), range.end());
+        return arg_setter_<char, false>(range.begin(), range.end());
     }
 
     arg_setter_<wchar_t, true> operator()(std::initializer_list<const wchar_t*> &&range) const
     {
-        return arg_setter_<wchar_t>(range.begin(), range.end());
+        return arg_setter_<wchar_t, true>(range.begin(), range.end());
     }
     arg_setter_<wchar_t, true> operator+=(std::initializer_list<const wchar_t*> &&range) const
     {
@@ -171,11 +171,11 @@ struct args_
     }
     arg_setter_<wchar_t, false> operator= (std::initializer_list<const wchar_t*> &&range) const
     {
-        return arg_setter_<wchar_t, true>(range.begin(), range.end());
+        return arg_setter_<wchar_t, false>(range.begin(), range.end());
     }
     arg_setter_<wchar_t, true> operator()(std::initializer_list<std::wstring> &&range) const
     {
-        return arg_setter_<wchar_t>(range.begin(), range.end());
+        return arg_setter_<wchar_t, true>(range.begin(), range.end());
     }
     arg_setter_<wchar_t, true> operator+=(std::initializer_list<std::wstring> &&range) const
     {
@@ -183,7 +183,7 @@ struct args_
     }
     arg_setter_<wchar_t, false> operator= (std::initializer_list<std::wstring> &&range) const
     {
-        return arg_setter_<wchar_t, true>(range.begin(), range.end());
+        return arg_setter_<wchar_t, false>(range.begin(), range.end());
     }
 };
 

include/boost/process/async.hpp

@@ -109,10 +109,10 @@ with `function` being a callable object with the signature `(int, const std::err
 \code{.cpp}
 io_context ios;
 
-child c("ls", on_exit=[](int exit, const std::error_code& ec_in){});
+child c("ls", ios, on_exit=[](int exit, const std::error_code& ec_in){});
 
 std::future<int> exit_code;
-chlid c2("ls", on_exit=exit_code);
+chlid c2("ls", ios, on_exit=exit_code);
 
 \endcode
 

include/boost/process/cmd.hpp

@@ -43,7 +43,7 @@ namespace boost { namespace process { namespace detail {
 
 struct cmd_
 {
-    constexpr cmd_() {}
+    constexpr cmd_() = default;
 
     template<typename Char>
     inline api::cmd_setter_<Char> operator()(const Char *s) const

include/boost/process/detail/child_decl.hpp

@@ -60,7 +60,7 @@ public:
     explicit child(child_handle &&ch, const std::shared_ptr<std::atomic<int>> &ptr) : _child_handle(std::move(ch)), _exit_status(ptr) {}
     explicit child(child_handle &&ch) : _child_handle(std::move(ch)) {}
 
-    explicit child(pid_t & pid) : _child_handle(pid), _attached(false) {};
+    explicit child(pid_t pid) : _child_handle(pid), _attached(false) {};
     child(const child&) = delete;
     child(child && lhs) noexcept
         : _child_handle(std::move(lhs._child_handle)),
@@ -73,7 +73,7 @@ public:
 
     template<typename ...Args>
     explicit child(Args&&...args);
-    child() {}
+    child() { } // Must be kept non defaulted for MSVC 14.1 & 14.2 #113
     child& operator=(const child&) = delete;
     child& operator=(child && lhs)
     {

include/boost/process/detail/posix/asio_fwd.hpp

@@ -7,6 +7,7 @@
 #define BOOST_PROCESS_DETAIL_POSIX_ASIO_FWD_HPP_
 
 #include <memory>
+#include <boost/asio/ts/netfwd.hpp>
 
 namespace boost { namespace asio {
 
@@ -20,39 +21,19 @@ template<typename Allocator>
 class basic_streambuf;
 
 typedef basic_streambuf<std::allocator<char>> streambuf;
-class io_context;
 
-class executor;
-
-
-#if defined(BOOST_ASIO_ENABLE_OLD_SERVICES)
-class signal_set_service;
-template <typename SignalSetService>
-
-class basic_signal_set;
-typedef basic_signal_set<signal_set_service> signal_set;
-#else /* defined(BOOST_ASIO_ENABLE_OLD_SERVICES) */
 template <typename Executor>
 class basic_signal_set;
-typedef basic_signal_set<executor> signal_set;
-#endif /* defined(BOOST_ASIO_ENABLE_OLD_SERVICES) */
+typedef basic_signal_set<any_io_executor> signal_set;
 
 template <typename Handler>
 class basic_yield_context;
 
 namespace posix {
 
-#if defined(BOOST_ASIO_ENABLE_OLD_SERVICES)
-class stream_descriptor_service;
-
-template <typename StreamDesscriptorService>
-class basic_stream_descriptor;
-typedef basic_stream_descriptor<stream_descriptor_service> stream_descriptor;
-#else /* defined(BOOST_ASIO_ENABLE_OLD_SERVICES) */
 template <typename Executor>
 class basic_stream_descriptor;
-typedef basic_stream_descriptor<executor> stream_descriptor;
-#endif /* defined(BOOST_ASIO_ENABLE_OLD_SERVICES) */
+typedef basic_stream_descriptor<any_io_executor> stream_descriptor;
 
 } //posix
 } //asio

include/boost/process/detail/posix/async_pipe.hpp

@@ -25,6 +25,11 @@ public:
     typedef ::boost::asio::posix::stream_descriptor handle_type;
     typedef typename handle_type::executor_type executor_type;
 
+    executor_type get_executor()
+    {
+        return _source.get_executor();
+    }
+
     inline async_pipe(boost::asio::io_context & ios) : async_pipe(ios, ios) {}
 
     inline async_pipe(boost::asio::io_context & ios_source,
@@ -45,8 +50,8 @@ public:
     inline async_pipe(const async_pipe& lhs);
     async_pipe(async_pipe&& lhs)  : _source(std::move(lhs._source)), _sink(std::move(lhs._sink))
     {
-        lhs._source.assign (-1);
-        lhs._sink  .assign (-1);
+        lhs._source = ::boost::asio::posix::stream_descriptor{lhs._source.get_executor()};
+        lhs._sink   = ::boost::asio::posix::stream_descriptor{lhs._sink.  get_executor()};
     }
 
     template<class CharT, class Traits = std::char_traits<CharT>>
@@ -71,10 +76,8 @@ public:
 
     ~async_pipe()
     {
-        if (_sink .native_handle()  != -1)
-            ::close(_sink.native_handle());
-        if (_source.native_handle() != -1)
-            ::close(_source.native_handle());
+        boost::system::error_code ec;
+        close(ec);
     }
 
     template<class CharT, class Traits = std::char_traits<CharT>>

include/boost/process/detail/posix/close_out.hpp

@@ -22,7 +22,7 @@ struct close_out : handler_base_ext
     template <class Executor>
     inline void on_exec_setup(Executor &e) const;
 
-    std::array<int, 2> get_used_handles() {return {p1 != -1 ? p1 : p2, p2 != -1 ? p2 : p1};}
+    std::array<int, 2> get_used_handles() {return {{p1 != -1 ? p1 : p2, p2 != -1 ? p2 : p1}};}
 };
 
 template<>

include/boost/process/detail/posix/environment.hpp

@@ -56,6 +56,7 @@ public:
     {
         _buffer = _load();
         _impl = _load_var(_buffer);
+        _env_impl = _impl.data();
     }
 
     string_type get(const pointer_type id) { return get(string_type(id)); }
@@ -230,7 +231,7 @@ template<typename Char>
 inline auto basic_environment_impl<Char>::get(const string_type &id) -> string_type
 {
     auto itr = std::find_if(_data.begin(), _data.end(), 
-            [&](const string_type & st)
+            [&](const string_type & st) -> bool
             {
                 if (st.size() <= id.size())
                     return false;
@@ -250,7 +251,7 @@ template<typename Char>
 inline void basic_environment_impl<Char>::set(const string_type &id, const string_type &value)
 {
     auto itr = std::find_if(_data.begin(), _data.end(), 
-        [&](const string_type & st)
+        [&](const string_type & st) -> bool
         {
             if (st.size() <= id.size())
                 return false;
@@ -270,7 +271,7 @@ template<typename Char>
 inline void  basic_environment_impl<Char>::reset(const string_type &id)
 {
     auto itr = std::find_if(_data.begin(), _data.end(), 
-        [&](const string_type & st)
+        [&](const string_type & st) -> bool
         {
             if (st.size() <= id.size())
                 return false;

include/boost/process/detail/posix/executor.hpp

@@ -152,11 +152,10 @@ class executor
     void write_error(const std::error_code & ec, const char * msg)
     {
         //I am the child
-        int len = ec.value();
-        ::write(_pipe_sink, &len, sizeof(int));
+        const auto len = std::strlen(msg);
+        int data[2] = {ec.value(), len + 1};
 
-        len = std::strlen(msg) + 1;
-        ::write(_pipe_sink, &len, sizeof(int));
+        ::write(_pipe_sink, &data[0], sizeof(int) * 2);
         ::write(_pipe_sink, msg, len);
     }
 
@@ -273,14 +272,15 @@ class executor
         prepare_cmd_style_fn = exe;
         if ((prepare_cmd_style_fn.find('/') == std::string::npos) && ::access(prepare_cmd_style_fn.c_str(), X_OK))
         {
-            auto e = ::environ;
-            while ((*e != nullptr) && !boost::starts_with(*e, "PATH="))
+            const auto * e = ::environ;
+            while ((e != nullptr) && (*e != nullptr) && !boost::starts_with(*e, "PATH="))
                 e++;
 
-            if (e != nullptr)
+            if ((e != nullptr) && (*e != nullptr))
             {
                 std::vector<std::string> path;
-                boost::split(path, *e, boost::is_any_of(":"));
+                //the beginning of the string contains "PATH="
+                boost::split(path, (*e) + 5, boost::is_any_of(":"));
 
                 for (const std::string & pp : path)
                 {

include/boost/process/detail/posix/file_in.hpp

@@ -26,7 +26,7 @@ struct file_in : handler_base_ext, ::boost::process::detail::uses_handles
 
     std::array<int, 2> get_used_handles()
     {
-        return {STDIN_FILENO, handle};
+        return {{STDIN_FILENO, handle}};
     }
 
     template<typename T>

include/boost/process/detail/posix/group_handle.hpp

@@ -42,7 +42,7 @@ struct group_handle
     }
 
     void add(handle_t proc)
-    {   
+    {
         if (::setpgid(proc, grp))
             throw_last_error();
     }

include/boost/process/detail/posix/is_running.hpp

@@ -1,4 +1,4 @@
-// Copyright (c) 2106 Klemens D. Morgenstern
+// Copyright (c) 2016 Klemens D. Morgenstern
 //
 // Distributed under the Boost Software License, Version 1.0. (See accompanying
 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)

include/boost/process/detail/posix/null_in.hpp

@@ -25,7 +25,7 @@ struct null_in : handler_base_ext, ::boost::process::detail::uses_handles
 
     std::array<int, 2> get_used_handles()
     {
-        return {STDIN_FILENO, source.handle()};
+        return {{STDIN_FILENO, source.handle()}};
     }
 
 

include/boost/process/detail/posix/on_exit.hpp

@@ -6,26 +6,39 @@
 #ifndef BOOST_PROCESS_POSIX_ON_EXIT_HPP_
 #define BOOST_PROCESS_POSIX_ON_EXIT_HPP_
 
+#include <boost/asio/execution.hpp>
+#include <boost/process/async.hpp>
 #include <boost/process/detail/config.hpp>
 #include <boost/process/detail/handler_base.hpp>
 #include <boost/process/detail/posix/async_handler.hpp>
 #include <system_error>
 #include <functional>
 
-namespace boost { namespace process { namespace detail { namespace posix {
+namespace boost { namespace process { namespace detail {
+
+template<typename Tuple>
+inline asio::io_context& get_io_context(const Tuple & tup);
+
+namespace posix {
 
 struct on_exit_ : boost::process::detail::posix::async_handler
 {
     std::function<void(int, const std::error_code&)> handler;
     on_exit_(const std::function<void(int, const std::error_code&)> & handler) : handler(handler)
     {
-
     }
 
     template<typename Executor>
-    std::function<void(int, const std::error_code&)> on_exit_handler(Executor&) 
+    std::function<void(int, const std::error_code&)> on_exit_handler(Executor& exec)
     {
-        return handler;
+        auto v = boost::asio::prefer(boost::process::detail::get_io_context(exec.seq).get_executor(),
+                                     boost::asio::execution::outstanding_work.tracked);
+        auto handler_ = this->handler;
+        return
+            [handler_, v](int exit_code, const std::error_code & ec)
+            {
+                handler_(exit_code, ec);
+            };
 
     }
 };

include/boost/process/detail/posix/pipe_in.hpp

@@ -27,7 +27,7 @@ struct pipe_in : handler_base_ext, ::boost::process::detail::uses_handles
 
     std::array<int, 3> get_used_handles()
     {
-        return {STDIN_FILENO, source, sink};
+        return {{STDIN_FILENO, source, sink}};
     }
 
 

include/boost/process/detail/posix/sigchld_service.hpp

@@ -20,7 +20,7 @@ namespace boost { namespace process { namespace detail { namespace posix {
 
 class sigchld_service : public boost::asio::detail::service_base<sigchld_service>
 {
-    boost::asio::io_context::strand _strand{get_io_context()};
+    boost::asio::strand<boost::asio::io_context::executor_type> _strand{get_io_context().get_executor()};
     boost::asio::signal_set _signal_set{get_io_context(), SIGCHLD};
 
     std::vector<std::pair<::pid_t, std::function<void(int, std::error_code)>>> _receivers;
@@ -48,9 +48,22 @@ public:
                     int status;
                     auto pid_res = ::waitpid(pid, &status, WNOHANG);
                     if (pid_res < 0)
-                        h(-1, get_last_error());
+                    {
+                        auto ec = get_last_error();
+                        boost::asio::post(
+                                _strand,
+                                [pid_res, ec, h]
+                                {
+                                    h(pid_res, ec);
+                                });
+                    }
                     else if ((pid_res == pid) && (WIFEXITED(status) || WIFSIGNALED(status)))
-                        h(status, {}); //successfully exited already
+                        boost::asio::post(
+                                _strand,
+                                [status, h]
+                                {
+                                    h(status, {}); //successfully exited already
+                                });
                     else //still running
                     {
                         if (_receivers.empty())

include/boost/process/detail/posix/start_dir.hpp

@@ -21,7 +21,7 @@ struct start_dir_init : handler_base_ext
 {
     typedef Char value_type;
     typedef std::basic_string<value_type> string_type;
-    start_dir_init(const string_type &s) : s_(s) {}
+    start_dir_init(string_type s) : s_(std::move(s)) {}
 
     template <class PosixExecutor>
     void on_exec_setup(PosixExecutor&) const

include/boost/process/detail/posix/terminate.hpp

@@ -27,7 +27,7 @@ inline void terminate(const child_handle &p, std::error_code &ec) noexcept
         ec.clear();
 
     int status;
-    ::waitpid(p.pid, &status, WNOHANG); //just to clean it up
+    ::waitpid(p.pid, &status, 0); //should not be WNOHANG, since that would allow zombies.
 }
 
 inline void terminate(const child_handle &p)

include/boost/process/detail/posix/wait_for_exit.hpp

@@ -158,7 +158,7 @@ inline bool wait_until(
         {
             int res;
             ::kill(pid, SIGKILL);
-            ::waitpid(pid, &res, WNOHANG);
+            ::waitpid(pid, &res, 0);
         }
     };
     child_cleaner_t child_cleaner{timeout_pid};

include/boost/process/detail/traits/wchar_t.hpp

@@ -7,6 +7,8 @@
 #ifndef BOOST_PROCESS_DETAIL_TRAITS_WCHAR_T_HPP_
 #define BOOST_PROCESS_DETAIL_TRAITS_WCHAR_T_HPP_
 
+#include <algorithm>
+
 #include <boost/process/detail/traits/decl.hpp>
 #include <boost/process/detail/traits/cmd_or_exe.hpp>
 #include <boost/process/detail/traits/env.hpp>

include/boost/process/detail/windows/asio_fwd.hpp

@@ -7,6 +7,7 @@
 #define BOOST_PROCESS_DETAIL_WINDOWS_ASIO_FWD_HPP_
 
 #include <memory>
+#include <boost/asio/ts/netfwd.hpp>
 
 namespace boost { namespace asio {
 
@@ -19,43 +20,19 @@ template<typename Allocator>
 class basic_streambuf;
 
 typedef basic_streambuf<std::allocator<char>> streambuf;
-class io_context;
-
-class executor;
-
 
 template <typename Handler>
 class basic_yield_context;
 
 namespace windows {
 
-#if defined(BOOST_ASIO_ENABLE_OLD_SERVICES)
-class stream_handle_service;
-
-template <typename StreamHandleService>
-class basic_stream_handle;
-
-typedef basic_stream_handle<stream_handle_service> stream_handle;
-#else /* defined(BOOST_ASIO_ENABLE_OLD_SERVICES) */
 template <typename Executor>
 class basic_stream_handle;
-typedef basic_stream_handle<executor> stream_handle;
+typedef basic_stream_handle<any_io_executor> stream_handle;
 
-#endif /* defined(BOOST_ASIO_ENABLE_OLD_SERVICES) */
-
-
-#if defined(BOOST_ASIO_ENABLE_OLD_SERVICES)
-class object_handle_service;
-
-template <typename ObjectHandleService>
-class basic_object_handle;
-
-typedef basic_object_handle<object_handle_service> object_handle;
-#else /* defined(BOOST_ASIO_ENABLE_OLD_SERVICES) */
 template <typename Executor>
 class basic_object_handle;
-typedef basic_object_handle<executor> object_handle;
-#endif /* defined(BOOST_ASIO_ENABLE_OLD_SERVICES) */
+typedef basic_object_handle<any_io_executor> object_handle;
 
 } //windows
 } //asio

include/boost/process/detail/windows/basic_cmd.hpp

@@ -30,14 +30,17 @@ inline std::string build_args(const std::string & exe, std::vector<std::string>
 {
     std::string st = exe;
 
-    //put in quotes if it has spaces
+    //put in quotes if it has spaces or double quotes
+    if(!exe.empty())
     {
-        boost::replace_all(st, "\"", "\\\"");
+        auto it = st.find_first_of(" \"");
 
-        auto it = std::find(st.begin(), st.end(), ' ');
-
-        if (it != st.end())//contains spaces.
+        if(it != st.npos)//contains spaces.
         {
+            // double existing quotes
+            boost::replace_all(st, "\"", "\"\"");
+
+            // surround with quotes
             st.insert(st.begin(), '"');
             st += '"';
         }
@@ -45,15 +48,18 @@ inline std::string build_args(const std::string & exe, std::vector<std::string>
 
     for (auto & arg : data)
     {
-        boost::replace_all(arg, "\"", "\\\"");
-
-        auto it = std::find(arg.begin(), arg.end(), ' ');//contains space?
-        if (it != arg.end())//ok, contains spaces.
+        if(!arg.empty())
         {
-            //the first one is put directly onto the output,
-            //because then I don't have to copy the whole string
-            arg.insert(arg.begin(), '"');
-            arg += '"'; //thats the post one.
+            auto it = arg.find_first_of(" \"");//contains space or double quotes?
+            if(it != arg.npos)//yes
+            {
+                // double existing quotes
+                boost::replace_all(arg, "\"", "\"\"");
+
+                // surround with quotes
+                arg.insert(arg.begin(), '"');
+                arg += '"';
+            }
         }
 
         if (!st.empty())//first one does not need a preceeding space
@@ -68,30 +74,36 @@ inline std::wstring build_args(const std::wstring & exe, std::vector<std::wstrin
 {
     std::wstring st = exe;
 
-    //put in quotes if it has spaces
+    //put in quotes if it has spaces or double quotes
+    if(!exe.empty())
     {
-        boost::replace_all(st, L"\"", L"\\\"");
+        auto it = st.find_first_of(L" \"");
 
-        auto it = std::find(st.begin(), st.end(), L' ');
-
-        if (it != st.end())//contains spaces.
+        if(it != st.npos)//contains spaces or double quotes.
         {
+            // double existing quotes
+            boost::replace_all(st, L"\"", L"\"\"");
+
+            // surround with quotes
             st.insert(st.begin(), L'"');
             st += L'"';
         }
     }
 
-    for (auto & arg : data)
+    for(auto & arg : data)
     {
-        boost::replace_all(arg, L"\"", L"\\\"");
-
-        auto it = std::find(arg.begin(), arg.end(), L' ');//contains space?
-        if (it != arg.end())//ok, contains spaces.
+        if(!arg.empty())
         {
-            //the first one is put directly onto the output,
-            //because then I don't have to copy the whole string
-            arg.insert(arg.begin(), L'"');
-            arg += L'"'; //thats the post one.
+            auto it = arg.find_first_of(L" \"");//contains space or double quotes?
+            if(it != arg.npos)//yes
+            {
+                // double existing quotes
+                boost::replace_all(arg, L"\"", L"\"\"");
+
+                // surround with quotes
+                arg.insert(arg.begin(), L'"');
+                arg += '"';
+            }
         }
 
         if (!st.empty())//first one does not need a preceeding space

include/boost/process/detail/windows/child_handle.hpp

@@ -17,7 +17,7 @@
 
 namespace boost { namespace process { namespace detail { namespace windows {
 
-typedef int pid_t;
+typedef ::boost::winapi::DWORD_ pid_t;
 
 struct child_handle
 {
@@ -66,7 +66,7 @@ struct child_handle
 
     pid_t id() const
     {
-        return static_cast<int>(proc_info.dwProcessId);
+        return static_cast<pid_t>(proc_info.dwProcessId);
     }
 
     typedef ::boost::winapi::HANDLE_ process_handle_t;

include/boost/process/detail/windows/file_descriptor.hpp

@@ -102,6 +102,7 @@ struct file_descriptor
         if (_handle != ::boost::winapi::INVALID_HANDLE_VALUE_)
             ::boost::winapi::CloseHandle(_handle);
         _handle = boost::exchange(other._handle, ::boost::winapi::INVALID_HANDLE_VALUE_);
+        return *this;
     }
 
     ~file_descriptor()

include/boost/process/detail/windows/handle_workaround.hpp

@@ -12,7 +12,7 @@
 //#define BOOST_USE_WINDOWS_H 1
 
 #if defined( BOOST_USE_WINDOWS_H )
-#include <Winternl.h>
+#include <winternl.h>
 #endif
 
 
@@ -198,20 +198,20 @@ typedef struct _OBJECT_TYPE_INFORMATION_ {
 
 
 /*
-__kernel_entry NTSTATUS NtQuerySystemInformation(
+NTSTATUS NtQuerySystemInformation(
   IN SYSTEM_INFORMATION_CLASS SystemInformationClass,
   OUT PVOID                   SystemInformation,
   IN ULONG                    SystemInformationLength,
   OUT PULONG                  ReturnLength
 );
  */
-typedef ::boost::winapi::NTSTATUS_ (__kernel_entry *nt_system_query_information_p )(
+typedef ::boost::winapi::NTSTATUS_ (*nt_system_query_information_p )(
         SYSTEM_INFORMATION_CLASS_,
         void *,
         ::boost::winapi::ULONG_,
         ::boost::winapi::PULONG_);
 /*
-__kernel_entry NTSYSCALLAPI NTSTATUS NtQueryObject(
+NTSYSCALLAPI NTSTATUS NtQueryObject(
   HANDLE                   Handle,
   OBJECT_INFORMATION_CLASS ObjectInformationClass,
   PVOID                    ObjectInformation,
@@ -220,7 +220,7 @@ __kernel_entry NTSYSCALLAPI NTSTATUS NtQueryObject(
 );
  */
 
-typedef ::boost::winapi::NTSTATUS_ (__kernel_entry *nt_query_object_p )(
+typedef ::boost::winapi::NTSTATUS_ (*nt_query_object_p )(
         ::boost::winapi::HANDLE_,
         OBJECT_INFORMATION_CLASS_,
         void *,

include/boost/process/detail/windows/handles.hpp

@@ -136,7 +136,7 @@ struct limit_handles_ : handler_base_ext
                 [&](::boost::winapi::HANDLE_ handle)
                 {
                     auto itr = std::find(all_handles.begin(), all_handles .end(), handle);
-                    DWORD flags = 0u;
+                    ::boost::winapi::DWORD_ flags = 0u;
                     if (itr != all_handles.end())
                         *itr = ::boost::winapi::INVALID_HANDLE_VALUE_;
                     else if ((::boost::winapi::GetHandleInformation(*itr, &flags) != 0)

include/boost/process/detail/windows/io_context_ref.hpp

@@ -8,7 +8,9 @@
 
 #include <boost/process/detail/handler_base.hpp>
 #include <boost/process/detail/windows/async_handler.hpp>
+#include <boost/process/detail/windows/is_running.hpp>
 #include <boost/asio/io_context.hpp>
+#include <boost/asio/post.hpp>
 #include <boost/asio/windows/object_handle.hpp>
 #include <boost/winapi/process.hpp>
 #include <boost/winapi/handles.hpp>
@@ -114,6 +116,15 @@ struct io_context_ref : boost::process::detail::handler_base
 
         wait_handler wh(std::move(funcs), ios, process_handle, exec.exit_status);
 
+        ::boost::winapi::DWORD_ code;
+        if(::boost::winapi::GetExitCodeProcess(process_handle, &code)
+            && code != still_active)
+        {
+            ::boost::asio::post(wh.handle->get_executor(), std::move(wh));
+            return;
+        }
+
+
         auto handle_p = wh.handle.get();
         handle_p->async_wait(std::move(wh));
     }
@@ -130,12 +141,13 @@ struct io_context_ref : boost::process::detail::handler_base
                      boost::asio::io_context & ios, void * handle,
                      const std::shared_ptr<std::atomic<int>> &exit_status)
                 : funcs(std::move(funcs)),
-                  handle(new boost::asio::windows::object_handle(ios.get_executor(), handle)),
+                  handle(new boost::asio::windows::object_handle(
+                          asio::prefer(ios.get_executor(), asio::execution::outstanding_work.tracked), handle)),
                   exit_status(exit_status)
         {
 
         }
-        void operator()(const boost::system::error_code & ec_in)
+        void operator()(const boost::system::error_code & ec_in = {})
         {
             std::error_code ec;
             if (ec_in)

include/boost/process/detail/windows/is_running.hpp

@@ -1,4 +1,4 @@
-// Copyright (c) 2106 Klemens D. Morgenstern
+// Copyright (c) 2016 Klemens D. Morgenstern
 //
 // Distributed under the Boost Software License, Version 1.0. (See accompanying
 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
@@ -7,6 +7,7 @@
 #define BOOST_PROCESS_WINDOWS_IS_RUNNING_HPP
 
 #include <boost/process/detail/config.hpp>
+#include <boost/process/detail/windows/child_handle.hpp>
 #include <system_error>
 #include <cstdlib>
 #include <boost/winapi/process.hpp>

include/boost/process/detail/windows/on_exit.hpp

@@ -6,13 +6,20 @@
 #ifndef BOOST_PROCESS_WINDOWS_ON_EXIT_HPP_
 #define BOOST_PROCESS_WINDOWS_ON_EXIT_HPP_
 
+#include <boost/process/async.hpp>
 #include <boost/process/detail/config.hpp>
 #include <boost/process/detail/handler_base.hpp>
 #include <boost/process/detail/windows/async_handler.hpp>
+#include <boost/asio/execution.hpp>
 #include <system_error>
 #include <functional>
 
-namespace boost { namespace process { namespace detail { namespace windows {
+namespace boost { namespace process { namespace detail {
+
+template<typename Tuple>
+inline asio::io_context& get_io_context(const Tuple & tup);
+
+namespace windows {
 
 struct on_exit_ : boost::process::detail::windows::async_handler
 {
@@ -23,10 +30,12 @@ struct on_exit_ : boost::process::detail::windows::async_handler
     }
 
     template<typename Executor>
-    std::function<void(int, const std::error_code&)> on_exit_handler(Executor&)
+    std::function<void(int, const std::error_code&)> on_exit_handler(Executor& exec)
     {
+        auto v = boost::asio::prefer(boost::process::detail::get_io_context(exec.seq).get_executor(),
+                                     boost::asio::execution::outstanding_work.tracked);
         auto handler_ = this->handler;
-        return [handler_](int exit_code, const std::error_code & ec)
+        return [v, handler_](int exit_code, const std::error_code & ec)
                {
                     handler_(static_cast<int>(exit_code), ec);
                };

include/boost/process/environment.hpp

@@ -677,11 +677,11 @@ inline std::vector<boost::filesystem::path> path()
 #if defined(BOOST_WINDOWS_API)
     const ::boost::process::wnative_environment ne{};
     typedef typename ::boost::process::wnative_environment::const_entry_type value_type;
-    const auto id = L"PATH";
+    static constexpr auto id = L"PATH";
 #else
     const ::boost::process::native_environment ne{};
     typedef typename ::boost::process::native_environment::const_entry_type value_type;
-    const auto id = "PATH";
+    static constexpr auto id = "PATH";
 #endif
 
     auto itr = std::find_if(ne.cbegin(), ne.cend(),

include/boost/process/error.hpp

@@ -59,7 +59,7 @@ namespace detail {
 
 struct throw_on_error_ : ::boost::process::detail::api::handler_base_ext
 {
-    constexpr throw_on_error_() {};
+    constexpr throw_on_error_() = default;
 
     template <class Executor>
     void on_error(Executor&, const std::error_code & ec) const
@@ -72,7 +72,7 @@ struct throw_on_error_ : ::boost::process::detail::api::handler_base_ext
 
 struct ignore_error_ : ::boost::process::detail::api::handler_base_ext
 {
-    constexpr ignore_error_() {};
+    constexpr ignore_error_() = default;
 };
 
 struct set_on_error : ::boost::process::detail::api::handler_base_ext
@@ -81,7 +81,7 @@ struct set_on_error : ::boost::process::detail::api::handler_base_ext
     explicit set_on_error(std::error_code &ec) : ec_(ec) {}
 
     template <class Executor>
-    void on_error(Executor&, const std::error_code & ec) const
+    void on_error(Executor&, const std::error_code & ec) const noexcept
     {
         ec_ = ec;
     }
@@ -92,7 +92,7 @@ private:
 
 struct error_
 {
-    constexpr error_() {}
+    constexpr error_() = default;
     set_on_error operator()(std::error_code &ec) const {return set_on_error(ec);}
     set_on_error operator= (std::error_code &ec) const {return set_on_error(ec);}
 

include/boost/process/extend.hpp

@@ -8,6 +8,7 @@
 
 #include <boost/process/detail/handler.hpp>
 #include <boost/process/detail/used_handles.hpp>
+#include <memory>
 
 #if defined(BOOST_WINDOWS_API)
 #include <boost/process/detail/windows/executor.hpp>

include/boost/process/io.hpp

@@ -136,13 +136,13 @@ template<typename T> using is_mutable_buffer =
         >;
 
 
-struct null_t  {constexpr null_t() {}};
+struct null_t  {constexpr null_t() = default;};
 struct close_t;
 
 template<class>
 struct std_in_
 {
-    constexpr std_in_() {}
+    constexpr std_in_() = default;
 
     api::close_in close() const {return api::close_in(); }
     api::close_in operator=(const close_t &) const {return api::close_in();}
@@ -199,7 +199,7 @@ struct std_in_
 template<int p1, int p2 = -1>
 struct std_out_
 {
-    constexpr std_out_() {}
+    constexpr std_out_() = default;
 
     api::close_out<p1,p2> close() const {return api::close_out<p1,p2>(); }
     api::close_out<p1,p2> operator=(const close_t &) const {return api::close_out<p1,p2>();}
@@ -260,7 +260,7 @@ struct std_out_
 
 struct close_t
 {
-    constexpr close_t() {}
+    constexpr close_t() = default;
     template<int T, int U>
     api::close_out<T,U> operator()(std_out_<T,U>) {return api::close_out<T,U>();}
 };

include/boost/process/locale.hpp

@@ -28,7 +28,7 @@ namespace detail
 class codecvt_category_t : public std::error_category
 {
 public:
-    codecvt_category_t(){}
+    codecvt_category_t() = default;
     const char* name() const noexcept override {return "codecvt";}
     std::string message(int ev) const override
     {
@@ -76,9 +76,8 @@ inline std::locale default_locale()
     std::locale global_loc = std::locale();
     return std::locale(global_loc, new std::codecvt_utf8<wchar_t>);
 # else  // Other POSIX
-    // ISO C calls std::locale("") "the locale-specific native environment", and this
-    // locale is the default for many POSIX-based operating systems such as Linux.
-    return std::locale("");
+    // Return a default locale object.
+    return std::locale();
 # endif
 }
 

include/boost/process/pipe.hpp

@@ -123,8 +123,8 @@ struct basic_pipebuf : std::basic_streambuf<CharT, Traits>
     ///Destructor -> writes the frest of the data
     ~basic_pipebuf()
     {
-        if (is_open())
-            overflow(Traits::eof());
+        if (basic_pipebuf::is_open())
+            basic_pipebuf::overflow(Traits::eof());
     }
 
     ///Move construct from a pipe.
@@ -167,10 +167,12 @@ struct basic_pipebuf : std::basic_streambuf<CharT, Traits>
             if (this->pptr() == this->epptr())
             {
                 bool wr = this->_write_impl();
-                *this->pptr() = ch;
-                this->pbump(1);
                 if (wr)
+                {
+                    *this->pptr() = ch;
+                    this->pbump(1);
                     return ch;
+                }
             }
             else
             {
@@ -277,7 +279,7 @@ private:
         else if (wrt == 0) //broken pipe
             return false;
 
-        this->pbump(-wrt);
+        this->pbump(static_cast<int>(-wrt));
 
         return true;
     }

meta/libraries.json

@@ -11,5 +11,6 @@
   "description": "Library to create processes in a portable way.",
   "category": [
     "System"
-  ]
+  ],
+  "cxxstd": "11"
 }

test/appveyor.yml

@@ -13,6 +13,7 @@
 init:
     - set BRANCH_TO_TEST=%APPVEYOR_REPO_BRANCH%
     - set BOOST_REMOVE=process
+    - set BOOST_TEST_LOG_LEVEL=success
 
 os: Visual Studio 2015
 configuration: Debug

test/async.cpp

@@ -182,8 +182,8 @@ BOOST_AUTO_TEST_CASE(async_wait_different_contexts, *boost::unit_test::timeout(1
     BOOST_REQUIRE(!ec);
 
     // Regression test for #143: make sure each io_context handles its own children
-    std::thread thr1{[&]{io_context1.run();}};
-    std::thread thr2{[&]{io_context2.run();}};
+    std::thread thr1{[&]() noexcept {io_context1.run();}};
+    std::thread thr2{[&]() noexcept {io_context2.run();}};
 
     thr1.join();
     thr2.join();
@@ -214,7 +214,7 @@ BOOST_AUTO_TEST_CASE(async_wait_abort, *boost::unit_test::timeout(5))
     int exit_code = 0;
     bp::child c(
         master_test_suite().argv[1],
-        "test", "--abort",
+        "test", "exit-code", "42",
         ec,
         io_context,
         bp::on_exit([&](int exit, const std::error_code& ec_in)
@@ -232,7 +232,7 @@ BOOST_AUTO_TEST_CASE(async_wait_abort, *boost::unit_test::timeout(5))
     io_context.run();
 
     BOOST_CHECK(exit_called);
-    BOOST_CHECK_NE(exit_code,  0);
+    BOOST_CHECK_NE(exit_code,  42);
     BOOST_CHECK_EQUAL(c.exit_code(), exit_code);
 }
 
@@ -293,7 +293,7 @@ BOOST_AUTO_TEST_CASE(async_out_stream, *boost::unit_test::timeout(5))
 
     std::string line;
     std::getline(istr, line);
-    BOOST_REQUIRE_GE(line.size(), 3);
+    BOOST_REQUIRE_GE(line.size(), 3u);
     BOOST_CHECK(boost::algorithm::starts_with(line, "abc"));
     c.wait();
 }
@@ -413,4 +413,5 @@ BOOST_AUTO_TEST_CASE(mixed_async, *boost::unit_test::timeout(5))
 
 }*/
 
-BOOST_AUTO_TEST_SUITE_END();
+
+BOOST_AUTO_TEST_SUITE_END();

test/async_system_future.cpp

@@ -57,8 +57,7 @@ BOOST_AUTO_TEST_CASE(future_error, *boost::unit_test::timeout(15))
 
     ios.run();
 
-    int exit_code = 0;
-    BOOST_CHECK_THROW(exit_code = fut.get(), boost::system::system_error);
+    BOOST_CHECK_THROW(fut.get(), boost::system::system_error);
 }
 
-BOOST_AUTO_TEST_SUITE_END();
+BOOST_AUTO_TEST_SUITE_END();

test/async_system_stackful.cpp

@@ -41,9 +41,9 @@ BOOST_AUTO_TEST_CASE(stackful, *boost::unit_test::timeout(15))
                     bp::async_system(
                         ios, yield_,
                         master_test_suite().argv[1],
-                        "test", "--exit-code", "123");
+                        "test", "--wait", "1");
 
-                BOOST_CHECK_EQUAL(ret, 123);
+                BOOST_CHECK_EQUAL(ret, 0);
                 BOOST_CHECK(did_something_else);
             };
 

test/async_system_stackless.cpp

@@ -53,7 +53,7 @@ BOOST_AUTO_TEST_CASE(stackless, *boost::unit_test::timeout(15))
                         master_test_suite().argv[1],
                         "test", "--exit-code", "42");
 
-                BOOST_CHECK_EQUAL(exit_code, 42);
+                BOOST_CHECK_EQUAL(exit_code, 42u);
                 BOOST_CHECK(did_something_else);
             }
         }
@@ -68,4 +68,4 @@ BOOST_AUTO_TEST_CASE(stackless, *boost::unit_test::timeout(15))
 }
 
 
-BOOST_AUTO_TEST_SUITE_END();
+BOOST_AUTO_TEST_SUITE_END();

test/extensions.cpp

@@ -29,7 +29,6 @@ struct run_exe
     {
         e.exe = exe.c_str();
     }
-
 };
 
 struct  set_on_error
@@ -74,13 +73,11 @@ struct overload_handler : ex::handler
     void on_setup(ex::windows_executor<Char, Sequence>& exec) const
     {
         st = "windows";
-        const char* env = exec.env;
     }
     template <class Sequence>
     void on_setup(ex::posix_executor<Sequence>& exec) const
     {
         st = "posix";
-        char** env = exec.env;
     }
 };
 

test/limit_fd.cpp

@@ -57,7 +57,7 @@ BOOST_AUTO_TEST_CASE(leak_test, *boost::unit_test::timeout(5))
     BOOST_CHECK(bt::is_stream_handle(get_handle(stderr), ec));      BOOST_CHECK_MESSAGE(!ec, ec.message());
 
 
-    BOOST_CHECK_GE(fd_list.size(), 3);
+    BOOST_CHECK_GE(fd_list.size(), 3u);
     BOOST_CHECK_GE(bt::get_handles(ec).size(), fd_list.size());
 
     bp::pipe p;
@@ -66,14 +66,14 @@ BOOST_AUTO_TEST_CASE(leak_test, *boost::unit_test::timeout(5))
 
         auto fd_list_new = bt::get_handles(ec);
         BOOST_CHECK_MESSAGE(!ec, ec);
-        BOOST_CHECK_LE(fd_list.size() + 2, fd_list_new.size());
+        BOOST_CHECK_LE(fd_list.size() + 2u, fd_list_new.size());
         fd_list = std::move(fd_list_new);
     }
 
 
 
-    BOOST_CHECK_EQUAL(std::count(fd_list.begin(), fd_list.end(), p.native_source()), 1);
-    BOOST_CHECK_EQUAL(std::count(fd_list.begin(), fd_list.end(), p.native_sink()),   1);
+    BOOST_CHECK_EQUAL(std::count(fd_list.begin(), fd_list.end(), p.native_source()), 1u);
+    BOOST_CHECK_EQUAL(std::count(fd_list.begin(), fd_list.end(), p.native_sink()),   1u);
 
     BOOST_CHECK(bt::is_stream_handle(p.native_source(), ec)); BOOST_CHECK_MESSAGE(!ec, ec.message());
     BOOST_CHECK(bt::is_stream_handle(p.native_sink(),   ec)); BOOST_CHECK_MESSAGE(!ec, ec.message());
@@ -82,8 +82,8 @@ BOOST_AUTO_TEST_CASE(leak_test, *boost::unit_test::timeout(5))
     p.close();
     fd_list = bt::get_handles(ec);
 
-    BOOST_CHECK_EQUAL(std::count(fd_list.begin(), fd_list.end(), p.native_source()), 0);
-    BOOST_CHECK_EQUAL(std::count(fd_list.begin(), fd_list.end(), p.native_sink()),   0);
+    BOOST_CHECK_EQUAL(std::count(fd_list.begin(), fd_list.end(), p.native_source()), 0u);
+    BOOST_CHECK_EQUAL(std::count(fd_list.begin(), fd_list.end(), p.native_sink()),   0u);
 
 #if defined( BOOST_WINDOWS_API )
     std::thread thr([]{});
@@ -128,7 +128,6 @@ struct on_setup_t
         bp::extend::foreach_used_handle(e, [this](bt::native_handle_type handle)
         {
             res.push_back(handle);
-            std::cout << "Pushing " << handle << std::endl;
         });
     }
 };
@@ -155,9 +154,9 @@ BOOST_AUTO_TEST_CASE(iterate_handles, *boost::unit_test::timeout(5))
 
     BOOST_CHECK_MESSAGE(!ec, ec.message());
 
-    BOOST_CHECK_EQUAL(ret, 42);
-    BOOST_CHECK_EQUAL(std::count(res.begin(), res.end(), p_in. native_sink()), 0);
-    BOOST_CHECK_EQUAL(std::count(res.begin(), res.end(), p_out.native_source()), 0);
+    BOOST_CHECK_EQUAL(ret, 42u);
+    BOOST_CHECK_EQUAL(std::count(res.begin(), res.end(), p_in. native_sink()), 0u);
+    BOOST_CHECK_EQUAL(std::count(res.begin(), res.end(), p_out.native_source()), 0u);
 }
 
 BOOST_AUTO_TEST_CASE(limit_fd, *boost::unit_test::timeout(5))
@@ -168,12 +167,14 @@ BOOST_AUTO_TEST_CASE(limit_fd, *boost::unit_test::timeout(5))
     const auto get_handle = [](FILE * f){return std::to_string(fileno(f));};
 #endif
 
+    auto p = fopen("./test-file", "w");
+
     using boost::unit_test::framework::master_test_suite;
-    BOOST_CHECK_EQUAL(bp::system(master_test_suite().argv[1], "--has-handle",  get_handle(stdout), bp::std_err > stderr), EXIT_SUCCESS);
-    BOOST_CHECK_EQUAL(bp::system(master_test_suite().argv[1], "--has-handle",  get_handle(stderr), bp::std_err > stderr), EXIT_SUCCESS);
 
+    BOOST_CHECK_EQUAL(bp::system(master_test_suite().argv[1], "--has-handle", bp::limit_handles, get_handle(p),  bp::std_in  < p), EXIT_SUCCESS);
+    BOOST_CHECK_EQUAL(bp::system(master_test_suite().argv[1], "--has-handle", bp::limit_handles, get_handle(p),  bp::std_err > p), EXIT_SUCCESS);
+    BOOST_CHECK_EQUAL(bp::system(master_test_suite().argv[1], "--has-handle", bp::limit_handles, get_handle(p),  bp::std_out > p), EXIT_SUCCESS);
+    BOOST_CHECK_EQUAL(bp::system(master_test_suite().argv[1], "--has-handle", bp::limit_handles, get_handle(p)), EXIT_FAILURE);
 
-    BOOST_CHECK_EQUAL(bp::system(master_test_suite().argv[1], "--has-handle", get_handle(stdout), bp::std_err > stderr, bp::limit_handles), EXIT_FAILURE);
-    BOOST_CHECK_EQUAL(bp::system(master_test_suite().argv[1], "--has-handle", get_handle(stderr), bp::std_err > stderr, bp::limit_handles), EXIT_SUCCESS);
-
-}
+    fclose(p);
+}

test/wargs_cmd.cpp

@@ -33,7 +33,7 @@ BOOST_AUTO_TEST_CASE(wargs, *boost::unit_test::timeout(2))
     std::error_code ec;
     bp::child c(
         master_test_suite().argv[1],
-        L"test", "--echo-argv", L"hello thingy", "\"stuff\"", static_cast<const wchar_t*>(L"  spa ce  "),
+        L"test", "--echo-argv", L"hello thingy", "\"stuff\"", static_cast<const wchar_t*>(L"  spa\" ce  "),
         bp::std_out>is,
         ec
     );
@@ -62,9 +62,9 @@ BOOST_AUTO_TEST_CASE(wargs, *boost::unit_test::timeout(2))
     BOOST_CHECK_EQUAL(s, "\"stuff\"");
 
     std::getline(is, s);
-    s.resize(10);
+    s.resize(11);
 
-    BOOST_CHECK_EQUAL(s, "  spa ce  ");
+    BOOST_CHECK_EQUAL(s, "  spa\" ce  ");
 
 }