Moved third party libs in a dedicated directory

third-party/boost/process/windows/child.hpp

@@ -0,0 +1,55 @@
+// Copyright (c) 2006, 2007 Julio M. Merino Vidal
+// Copyright (c) 2008 Ilya Sokolov, Boris Schaeling
+// Copyright (c) 2009 Boris Schaeling
+// Copyright (c) 2010 Felipe Tanus, Boris Schaeling
+// Copyright (c) 2011, 2012 Jeff Flinn, Boris Schaeling
+//
+// 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)
+
+#ifndef BOOST_PROCESS_WINDOWS_CHILD_HPP
+#define BOOST_PROCESS_WINDOWS_CHILD_HPP
+
+#include <boost/move/move.hpp>
+#include <Windows.h>
+
+namespace boost { namespace process { namespace windows {
+
+class child
+{
+public:
+    PROCESS_INFORMATION proc_info;
+
+    explicit child(const PROCESS_INFORMATION &pi) : proc_info(pi) {}
+
+    ~child()
+    {
+        ::CloseHandle(proc_info.hProcess);
+        ::CloseHandle(proc_info.hThread);
+    }
+
+    child(BOOST_RV_REF(child) c) : proc_info(c.proc_info)
+    {
+        c.proc_info.hProcess = INVALID_HANDLE_VALUE;
+        c.proc_info.hThread = INVALID_HANDLE_VALUE;
+    }
+
+    child &operator=(BOOST_RV_REF(child) c)
+    {
+        ::CloseHandle(proc_info.hProcess);
+        ::CloseHandle(proc_info.hThread);
+        proc_info = c.proc_info;
+        c.proc_info.hProcess = INVALID_HANDLE_VALUE;
+        c.proc_info.hThread = INVALID_HANDLE_VALUE;
+        return *this;
+    }
+
+    HANDLE process_handle() const { return proc_info.hProcess; }
+
+private:
+    BOOST_MOVABLE_BUT_NOT_COPYABLE(child);
+};
+
+}}}
+
+#endif

third-party/boost/process/windows/create_pipe.hpp

@@ -0,0 +1,40 @@
+// Copyright (c) 2006, 2007 Julio M. Merino Vidal
+// Copyright (c) 2008 Ilya Sokolov, Boris Schaeling
+// Copyright (c) 2009 Boris Schaeling
+// Copyright (c) 2010 Felipe Tanus, Boris Schaeling
+// Copyright (c) 2011, 2012 Jeff Flinn, Boris Schaeling
+//
+// 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)
+
+#ifndef BOOST_PROCESS_WINDOWS_CREATE_PIPE_HPP
+#define BOOST_PROCESS_WINDOWS_CREATE_PIPE_HPP
+
+#include <boost/process/config.hpp>
+#include <boost/process/windows/pipe.hpp>
+#include <boost/system/error_code.hpp>
+#include <Windows.h>
+
+namespace boost { namespace process { namespace windows {
+
+inline pipe create_pipe()
+{
+    HANDLE handles[2];
+    if (!::CreatePipe(&handles[0], &handles[1], NULL, 0))
+        BOOST_PROCESS_THROW_LAST_SYSTEM_ERROR("CreatePipe() failed");
+    return make_pipe(handles[0], handles[1]);
+}
+
+inline pipe create_pipe(boost::system::error_code &ec)
+{
+    HANDLE handles[2];
+    if (!::CreatePipe(&handles[0], &handles[1], NULL, 0))
+        BOOST_PROCESS_RETURN_LAST_SYSTEM_ERROR(ec);
+    else
+        ec.clear();
+    return make_pipe(handles[0], handles[1]);
+}
+
+}}}
+
+#endif

third-party/boost/process/windows/execute.hpp

@@ -0,0 +1,82 @@
+// Copyright (c) 2006, 2007 Julio M. Merino Vidal
+// Copyright (c) 2008 Ilya Sokolov, Boris Schaeling
+// Copyright (c) 2009 Boris Schaeling
+// Copyright (c) 2010 Felipe Tanus, Boris Schaeling
+// Copyright (c) 2011, 2012 Jeff Flinn, Boris Schaeling
+//
+// 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)
+
+#ifndef BOOST_PROCESS_WINDOWS_EXECUTE_HPP
+#define BOOST_PROCESS_WINDOWS_EXECUTE_HPP
+
+#include <boost/process/windows/executor.hpp>
+#include <boost/process/windows/child.hpp>
+#include <boost/fusion/tuple/make_tuple.hpp>
+#include <boost/ref.hpp>
+
+namespace boost { namespace process { namespace windows {
+
+template <class I0>
+child execute(const I0 &i0)
+{
+    return executor()(boost::fusion::make_tuple(boost::cref(i0)));
+}
+
+template <class I0, class I1>
+child execute(const I0 &i0, const I1 &i1)
+{
+    return executor()(boost::fusion::make_tuple(boost::cref(i0), boost::cref(i1)));
+}
+
+template <class I0, class I1, class I2>
+child execute(const I0 &i0, const I1 &i1, const I2 &i2)
+{
+    return executor()(boost::fusion::make_tuple(boost::cref(i0), boost::cref(i1), boost::cref(i2)));
+}
+
+template <class I0, class I1, class I2, class I3>
+child execute(const I0 &i0, const I1 &i1, const I2 &i2, const I3 &i3)
+{
+    return executor()(boost::fusion::make_tuple(boost::cref(i0), boost::cref(i1), boost::cref(i2), boost::cref(i3)));
+}
+
+template <class I0, class I1, class I2, class I3, class I4>
+child execute(const I0 &i0, const I1 &i1, const I2 &i2, const I3 &i3, const I4 &i4)
+{
+    return executor()(boost::fusion::make_tuple(boost::cref(i0), boost::cref(i1), boost::cref(i2), boost::cref(i3), boost::cref(i4)));
+}
+
+template <class I0, class I1, class I2, class I3, class I4, class I5>
+child execute(const I0 &i0, const I1 &i1, const I2 &i2, const I3 &i3, const I4 &i4, const I5 &i5)
+{
+    return executor()(boost::fusion::make_tuple(boost::cref(i0), boost::cref(i1), boost::cref(i2), boost::cref(i3), boost::cref(i4), boost::cref(i5)));
+}
+
+template <class I0, class I1, class I2, class I3, class I4, class I5, class I6>
+child execute(const I0 &i0, const I1 &i1, const I2 &i2, const I3 &i3, const I4 &i4, const I5 &i5, const I6 &i6)
+{
+    return executor()(boost::fusion::make_tuple(boost::cref(i0), boost::cref(i1), boost::cref(i2), boost::cref(i3), boost::cref(i4), boost::cref(i5), boost::cref(i6)));
+}
+
+template <class I0, class I1, class I2, class I3, class I4, class I5, class I6, class I7>
+child execute(const I0 &i0, const I1 &i1, const I2 &i2, const I3 &i3, const I4 &i4, const I5 &i5, const I6 &i6, const I7 &i7)
+{
+    return executor()(boost::fusion::make_tuple(boost::cref(i0), boost::cref(i1), boost::cref(i2), boost::cref(i3), boost::cref(i4), boost::cref(i5), boost::cref(i6), boost::cref(i7)));
+}
+
+template <class I0, class I1, class I2, class I3, class I4, class I5, class I6, class I7, class I8>
+child execute(const I0 &i0, const I1 &i1, const I2 &i2, const I3 &i3, const I4 &i4, const I5 &i5, const I6 &i6, const I7 &i7, const I8 &i8)
+{
+    return executor()(boost::fusion::make_tuple(boost::cref(i0), boost::cref(i1), boost::cref(i2), boost::cref(i3), boost::cref(i4), boost::cref(i5), boost::cref(i6), boost::cref(i7), boost::cref(i8)));
+}
+
+template <class I0, class I1, class I2, class I3, class I4, class I5, class I6, class I7, class I8, class I9>
+child execute(const I0 &i0, const I1 &i1, const I2 &i2, const I3 &i3, const I4 &i4, const I5 &i5, const I6 &i6, const I7 &i7, const I8 &i8, const I9 &i9)
+{
+    return executor()(boost::fusion::make_tuple(boost::cref(i0), boost::cref(i1), boost::cref(i2), boost::cref(i3), boost::cref(i4), boost::cref(i5), boost::cref(i6), boost::cref(i7), boost::cref(i8), boost::cref(i9)));
+}
+
+}}}
+
+#endif

third-party/boost/process/windows/executor.hpp

@@ -0,0 +1,130 @@
+// Copyright (c) 2006, 2007 Julio M. Merino Vidal
+// Copyright (c) 2008 Ilya Sokolov, Boris Schaeling
+// Copyright (c) 2009 Boris Schaeling
+// Copyright (c) 2010 Felipe Tanus, Boris Schaeling
+// Copyright (c) 2011, 2012 Jeff Flinn, Boris Schaeling
+//
+// 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)
+
+#ifndef BOOST_PROCESS_WINDOWS_EXECUTOR_HPP
+#define BOOST_PROCESS_WINDOWS_EXECUTOR_HPP
+
+#include <boost/process/windows/child.hpp>
+#include <boost/fusion/algorithm/iteration/for_each.hpp>
+#include <Windows.h>
+
+namespace boost { namespace process { namespace windows {
+
+struct executor
+{
+    executor() : exe(0), cmd_line(0), proc_attrs(0), thread_attrs(0),
+        inherit_handles(FALSE),
+#if (_WIN32_WINNT >= 0x0600)
+        creation_flags(EXTENDED_STARTUPINFO_PRESENT),
+#else
+        creation_flags(0),
+#endif
+        env(0), work_dir(0)
+#if (_WIN32_WINNT >= 0x0600)
+        ,startup_info(startup_info_ex.StartupInfo)
+#endif
+    {
+#if (_WIN32_WINNT >= 0x0600)
+        ZeroMemory(&startup_info_ex, sizeof(STARTUPINFOEX));
+        startup_info.cb = sizeof(STARTUPINFOEX);
+#else
+        ZeroMemory(&startup_info, sizeof(STARTUPINFO));
+        startup_info.cb = sizeof(STARTUPINFO);
+#endif
+        startup_info.hStdInput = INVALID_HANDLE_VALUE;
+        startup_info.hStdOutput = INVALID_HANDLE_VALUE;
+        startup_info.hStdError = INVALID_HANDLE_VALUE;
+    }
+
+    struct call_on_CreateProcess_setup
+    {
+        executor &e_;
+
+        call_on_CreateProcess_setup(executor &e) : e_(e) {}
+
+        template <class Arg>
+        void operator()(Arg &arg) const
+        {
+            arg.on_CreateProcess_setup(e_);
+        }
+    };
+
+    struct call_on_CreateProcess_error
+    {
+        executor &e_;
+
+        call_on_CreateProcess_error(executor &e) : e_(e) {}
+
+        template <class Arg>
+        void operator()(Arg &arg) const
+        {
+            arg.on_CreateProcess_error(e_);
+        }
+    };
+
+    struct call_on_CreateProcess_success
+    {
+        executor &e_;
+
+        call_on_CreateProcess_success(executor &e) : e_(e) {}
+
+        template <class Arg>
+        void operator()(Arg &arg) const
+        {
+            arg.on_CreateProcess_success(e_);
+        }
+    };
+
+    template <class InitializerSequence>
+    child operator()(const InitializerSequence &seq)
+    {
+        boost::fusion::for_each(seq, call_on_CreateProcess_setup(*this));
+
+        if (!::CreateProcess(
+            exe,
+            cmd_line,
+            proc_attrs,
+            thread_attrs,
+            inherit_handles,
+            creation_flags,
+            env,
+            work_dir,
+            &startup_info,
+            &proc_info))
+        {
+            boost::fusion::for_each(seq, call_on_CreateProcess_error(*this));
+        }
+        else
+        {
+            boost::fusion::for_each(seq, call_on_CreateProcess_success(*this));
+        }
+
+        return child(proc_info);
+    }
+
+    LPCTSTR exe;
+    LPTSTR cmd_line;
+    LPSECURITY_ATTRIBUTES proc_attrs;
+    LPSECURITY_ATTRIBUTES thread_attrs;
+    BOOL inherit_handles;
+    DWORD creation_flags;
+    LPVOID env;
+    LPCTSTR work_dir;
+#if (_WIN32_WINNT >= 0x0600)
+    STARTUPINFOEX startup_info_ex;
+    STARTUPINFO &startup_info;
+#else
+    STARTUPINFO startup_info;
+#endif
+    PROCESS_INFORMATION proc_info;
+};
+
+}}}
+
+#endif

third-party/boost/process/windows/initializers.hpp

@@ -0,0 +1,33 @@
+// Copyright (c) 2006, 2007 Julio M. Merino Vidal
+// Copyright (c) 2008 Ilya Sokolov, Boris Schaeling
+// Copyright (c) 2009 Boris Schaeling
+// Copyright (c) 2010 Felipe Tanus, Boris Schaeling
+// Copyright (c) 2011, 2012 Jeff Flinn, Boris Schaeling
+//
+// 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)
+
+#ifndef BOOST_PROCESS_WINDOWS_INITIALIZERS_HPP
+#define BOOST_PROCESS_WINDOWS_INITIALIZERS_HPP
+
+#include <boost/process/windows/initializers/bind_stderr.hpp>
+#include <boost/process/windows/initializers/bind_stdin.hpp>
+#include <boost/process/windows/initializers/bind_stdout.hpp>
+#include <boost/process/windows/initializers/close_stderr.hpp>
+#include <boost/process/windows/initializers/close_stdin.hpp>
+#include <boost/process/windows/initializers/close_stdout.hpp>
+#include <boost/process/windows/initializers/hide_console.hpp>
+#include <boost/process/windows/initializers/inherit_env.hpp>
+#include <boost/process/windows/initializers/on_CreateProcess_error.hpp>
+#include <boost/process/windows/initializers/on_CreateProcess_setup.hpp>
+#include <boost/process/windows/initializers/on_CreateProcess_success.hpp>
+#include <boost/process/windows/initializers/run_exe.hpp>
+#include <boost/process/windows/initializers/set_args.hpp>
+#include <boost/process/windows/initializers/set_cmd_line.hpp>
+#include <boost/process/windows/initializers/set_env.hpp>
+#include <boost/process/windows/initializers/set_on_error.hpp>
+#include <boost/process/windows/initializers/show_window.hpp>
+#include <boost/process/windows/initializers/start_in_dir.hpp>
+#include <boost/process/windows/initializers/throw_on_error.hpp>
+
+#endif

third-party/boost/process/windows/initializers/bind_stderr.hpp

@@ -0,0 +1,39 @@
+// Copyright (c) 2006, 2007 Julio M. Merino Vidal
+// Copyright (c) 2008 Ilya Sokolov, Boris Schaeling
+// Copyright (c) 2009 Boris Schaeling
+// Copyright (c) 2010 Felipe Tanus, Boris Schaeling
+// Copyright (c) 2011, 2012 Jeff Flinn, Boris Schaeling
+//
+// 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)
+
+#ifndef BOOST_PROCESS_WINDOWS_INITIALIZERS_BIND_STDERR_HPP
+#define BOOST_PROCESS_WINDOWS_INITIALIZERS_BIND_STDERR_HPP
+
+#include <boost/process/windows/initializers/initializer_base.hpp>
+#include <boost/iostreams/device/file_descriptor.hpp>
+#include <Windows.h>
+
+namespace boost { namespace process { namespace windows { namespace initializers {
+
+class bind_stderr : public initializer_base
+{
+public:
+    explicit bind_stderr(const boost::iostreams::file_descriptor_sink &sink) : sink_(sink) {}
+
+    template <class WindowsExecutor>
+    void on_CreateProcess_setup(WindowsExecutor &e) const
+    {
+        ::SetHandleInformation(sink_.handle(), HANDLE_FLAG_INHERIT, HANDLE_FLAG_INHERIT);
+        e.startup_info.hStdError = sink_.handle();
+        e.startup_info.dwFlags |= STARTF_USESTDHANDLES;
+        e.inherit_handles = true;
+    }
+
+private:
+    boost::iostreams::file_descriptor_sink sink_;
+};
+
+}}}}
+
+#endif

third-party/boost/process/windows/initializers/bind_stdin.hpp

@@ -0,0 +1,39 @@
+// Copyright (c) 2006, 2007 Julio M. Merino Vidal
+// Copyright (c) 2008 Ilya Sokolov, Boris Schaeling
+// Copyright (c) 2009 Boris Schaeling
+// Copyright (c) 2010 Felipe Tanus, Boris Schaeling
+// Copyright (c) 2011, 2012 Jeff Flinn, Boris Schaeling
+//
+// 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)
+
+#ifndef BOOST_PROCESS_WINDOWS_INITIALIZERS_BIND_STDIN_HPP
+#define BOOST_PROCESS_WINDOWS_INITIALIZERS_BIND_STDIN_HPP
+
+#include <boost/process/windows/initializers/initializer_base.hpp>
+#include <boost/iostreams/device/file_descriptor.hpp>
+#include <Windows.h>
+
+namespace boost { namespace process { namespace windows { namespace initializers {
+
+class bind_stdin : public initializer_base
+{
+public:
+    explicit bind_stdin(const boost::iostreams::file_descriptor_source &source) : source_(source) {}
+
+    template <class WindowsExecutor>
+    void on_CreateProcess_setup(WindowsExecutor &e) const
+    {
+        ::SetHandleInformation(source_.handle(), HANDLE_FLAG_INHERIT, HANDLE_FLAG_INHERIT);
+        e.startup_info.hStdInput = source_.handle();
+        e.startup_info.dwFlags |= STARTF_USESTDHANDLES;
+        e.inherit_handles = true;
+    }
+
+private:
+    boost::iostreams::file_descriptor_source source_;
+};
+
+}}}}
+
+#endif

third-party/boost/process/windows/initializers/bind_stdout.hpp

@@ -0,0 +1,39 @@
+// Copyright (c) 2006, 2007 Julio M. Merino Vidal
+// Copyright (c) 2008 Ilya Sokolov, Boris Schaeling
+// Copyright (c) 2009 Boris Schaeling
+// Copyright (c) 2010 Felipe Tanus, Boris Schaeling
+// Copyright (c) 2011, 2012 Jeff Flinn, Boris Schaeling
+//
+// 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)
+
+#ifndef BOOST_PROCESS_WINDOWS_INITIALIZERS_BIND_STDOUT_HPP
+#define BOOST_PROCESS_WINDOWS_INITIALIZERS_BIND_STDOUT_HPP
+
+#include <boost/process/windows/initializers/initializer_base.hpp>
+#include <boost/iostreams/device/file_descriptor.hpp>
+#include <Windows.h>
+
+namespace boost { namespace process { namespace windows { namespace initializers {
+
+class bind_stdout : public initializer_base
+{
+public:
+    explicit bind_stdout(const boost::iostreams::file_descriptor_sink &sink) : sink_(sink) {}
+
+    template <class WindowsExecutor>
+    void on_CreateProcess_setup(WindowsExecutor &e) const
+    {
+        ::SetHandleInformation(sink_.handle(), HANDLE_FLAG_INHERIT, HANDLE_FLAG_INHERIT);
+        e.startup_info.hStdOutput = sink_.handle();
+        e.startup_info.dwFlags |= STARTF_USESTDHANDLES;
+        e.inherit_handles = true;
+    }
+
+private:
+    boost::iostreams::file_descriptor_sink sink_;
+};
+
+}}}}
+
+#endif

third-party/boost/process/windows/initializers/close_stderr.hpp

@@ -0,0 +1,31 @@
+// Copyright (c) 2006, 2007 Julio M. Merino Vidal
+// Copyright (c) 2008 Ilya Sokolov, Boris Schaeling
+// Copyright (c) 2009 Boris Schaeling
+// Copyright (c) 2010 Felipe Tanus, Boris Schaeling
+// Copyright (c) 2011, 2012 Jeff Flinn, Boris Schaeling
+//
+// 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)
+
+#ifndef BOOST_PROCESS_WINDOWS_INITIALIZERS_CLOSE_STDERR_HPP
+#define BOOST_PROCESS_WINDOWS_INITIALIZERS_CLOSE_STDERR_HPP
+
+#include <boost/process/windows/initializers/initializer_base.hpp>
+#include <Windows.h>
+
+namespace boost { namespace process { namespace windows { namespace initializers {
+
+class close_stderr : public initializer_base
+{
+public:
+    template <class WindowsExecutor>
+    void on_CreateProcess_setup(WindowsExecutor &e) const
+    {
+        e.startup_info.hStdError = INVALID_HANDLE_VALUE;
+        e.startup_info.dwFlags |= STARTF_USESTDHANDLES;
+    }
+};
+
+}}}}
+
+#endif

third-party/boost/process/windows/initializers/close_stdin.hpp

@@ -0,0 +1,31 @@
+// Copyright (c) 2006, 2007 Julio M. Merino Vidal
+// Copyright (c) 2008 Ilya Sokolov, Boris Schaeling
+// Copyright (c) 2009 Boris Schaeling
+// Copyright (c) 2010 Felipe Tanus, Boris Schaeling
+// Copyright (c) 2011, 2012 Jeff Flinn, Boris Schaeling
+//
+// 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)
+
+#ifndef BOOST_PROCESS_WINDOWS_INITIALIZERS_CLOSE_STDIN_HPP
+#define BOOST_PROCESS_WINDOWS_INITIALIZERS_CLOSE_STDIN_HPP
+
+#include <boost/process/windows/initializers/initializer_base.hpp>
+#include <Windows.h>
+
+namespace boost { namespace process { namespace windows { namespace initializers {
+
+class close_stdin : public initializer_base
+{
+public:
+    template <class WindowsExecutor>
+    void on_CreateProcess_setup(WindowsExecutor &e) const
+    {
+        e.startup_info.hStdInput = INVALID_HANDLE_VALUE;
+        e.startup_info.dwFlags |= STARTF_USESTDHANDLES;
+    }
+};
+
+}}}}
+
+#endif

third-party/boost/process/windows/initializers/close_stdout.hpp

@@ -0,0 +1,31 @@
+// Copyright (c) 2006, 2007 Julio M. Merino Vidal
+// Copyright (c) 2008 Ilya Sokolov, Boris Schaeling
+// Copyright (c) 2009 Boris Schaeling
+// Copyright (c) 2010 Felipe Tanus, Boris Schaeling
+// Copyright (c) 2011, 2012 Jeff Flinn, Boris Schaeling
+//
+// 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)
+
+#ifndef BOOST_PROCESS_WINDOWS_INITIALIZERS_CLOSE_STDOUT_HPP
+#define BOOST_PROCESS_WINDOWS_INITIALIZERS_CLOSE_STDOUT_HPP
+
+#include <boost/process/windows/initializers/initializer_base.hpp>
+#include <Windows.h>
+
+namespace boost { namespace process { namespace windows { namespace initializers {
+
+class close_stdout : public initializer_base
+{
+public:
+    template <class WindowsExecutor>
+    void on_CreateProcess_setup(WindowsExecutor &e) const
+    {
+        e.startup_info.hStdOutput = INVALID_HANDLE_VALUE;
+        e.startup_info.dwFlags |= STARTF_USESTDHANDLES;
+    }
+};
+
+}}}}
+
+#endif

third-party/boost/process/windows/initializers/hide_console.hpp

@@ -0,0 +1,31 @@
+// Copyright (c) 2006, 2007 Julio M. Merino Vidal
+// Copyright (c) 2008 Ilya Sokolov, Boris Schaeling
+// Copyright (c) 2009 Boris Schaeling
+// Copyright (c) 2010 Felipe Tanus, Boris Schaeling
+// Copyright (c) 2011, 2012 Jeff Flinn, Boris Schaeling
+//
+// 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)
+
+#ifndef BOOST_PROCESS_WINDOWS_INITIALIZERS_HIDE_CONSOLE_HPP
+#define BOOST_PROCESS_WINDOWS_INITIALIZERS_HIDE_CONSOLE_HPP
+
+#include <boost/process/windows/initializers/initializer_base.hpp>
+#include <Windows.h>
+
+namespace boost { namespace process { namespace windows { namespace initializers {
+
+class hide_console : public initializer_base
+{
+public:
+    template <class WindowsExecutor>
+    void on_CreateProcess_setup(WindowsExecutor &e) const
+    {
+        e.startup_info.dwFlags |= STARTF_USESHOWWINDOW;
+        e.startup_info.wShowWindow |= SW_HIDE;
+    }
+};
+
+}}}}
+
+#endif

third-party/boost/process/windows/initializers/inherit_env.hpp

@@ -0,0 +1,24 @@
+// Copyright (c) 2006, 2007 Julio M. Merino Vidal
+// Copyright (c) 2008 Ilya Sokolov, Boris Schaeling
+// Copyright (c) 2009 Boris Schaeling
+// Copyright (c) 2010 Felipe Tanus, Boris Schaeling
+// Copyright (c) 2011, 2012 Jeff Flinn, Boris Schaeling
+//
+// 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)
+
+#ifndef BOOST_PROCESS_WINDOWS_INITIALIZERS_INHERIT_ENV_HPP
+#define BOOST_PROCESS_WINDOWS_INITIALIZERS_INHERIT_ENV_HPP
+
+#include <boost/process/windows/initializers/initializer_base.hpp>
+
+namespace boost { namespace process { namespace windows { namespace initializers {
+
+class inherit_env : public initializer_base
+{
+public:
+};
+
+}}}}
+
+#endif

third-party/boost/process/windows/initializers/initializer_base.hpp

@@ -0,0 +1,29 @@
+// Copyright (c) 2006, 2007 Julio M. Merino Vidal
+// Copyright (c) 2008 Ilya Sokolov, Boris Schaeling
+// Copyright (c) 2009 Boris Schaeling
+// Copyright (c) 2010 Felipe Tanus, Boris Schaeling
+// Copyright (c) 2011, 2012 Jeff Flinn, Boris Schaeling
+//
+// 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)
+
+#ifndef BOOST_PROCESS_WINDOWS_INITIALIZERS_INITIALIZER_BASE_HPP
+#define BOOST_PROCESS_WINDOWS_INITIALIZERS_INITIALIZER_BASE_HPP
+
+namespace boost { namespace process { namespace windows { namespace initializers {
+
+struct initializer_base
+{
+    template <class WindowsExecutor>
+    void on_CreateProcess_setup(WindowsExecutor&) const {}
+
+    template <class WindowsExecutor>
+    void on_CreateProcess_error(WindowsExecutor&) const {}
+
+    template <class WindowsExecutor>
+    void on_CreateProcess_success(WindowsExecutor&) const {}
+};
+
+}}}}
+
+#endif

third-party/boost/process/windows/initializers/on_CreateProcess_error.hpp

@@ -0,0 +1,42 @@
+// Copyright (c) 2006, 2007 Julio M. Merino Vidal
+// Copyright (c) 2008 Ilya Sokolov, Boris Schaeling
+// Copyright (c) 2009 Boris Schaeling
+// Copyright (c) 2010 Felipe Tanus, Boris Schaeling
+// Copyright (c) 2011, 2012 Jeff Flinn, Boris Schaeling
+//
+// 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)
+
+#ifndef BOOST_PROCESS_WINDOWS_INITIALIZERS_ON_CREATEPROCESS_ERROR_HPP
+#define BOOST_PROCESS_WINDOWS_INITIALIZERS_ON_CREATEPROCESS_ERROR_HPP
+
+#include <boost/process/config.hpp>
+#include <boost/process/windows/initializers/initializer_base.hpp>
+
+namespace boost { namespace process { namespace windows { namespace initializers {
+
+template <class Handler>
+class on_CreateProcess_error_ : public initializer_base
+{
+public:
+    explicit on_CreateProcess_error_(Handler handler) : handler_(handler) {}
+
+    template <class WindowsExecutor>
+    void on_CreateProcess_error(WindowsExecutor &e) const
+    {
+        handler_(e);
+    }
+
+private:
+    Handler handler_;
+};
+
+template <class Handler>
+on_CreateProcess_error_<Handler> on_CreateProcess_error(Handler handler)
+{
+    return on_CreateProcess_error_<Handler>(handler);
+}
+
+}}}}
+
+#endif

third-party/boost/process/windows/initializers/on_CreateProcess_setup.hpp

@@ -0,0 +1,42 @@
+// Copyright (c) 2006, 2007 Julio M. Merino Vidal
+// Copyright (c) 2008 Ilya Sokolov, Boris Schaeling
+// Copyright (c) 2009 Boris Schaeling
+// Copyright (c) 2010 Felipe Tanus, Boris Schaeling
+// Copyright (c) 2011, 2012 Jeff Flinn, Boris Schaeling
+//
+// 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)
+
+#ifndef BOOST_PROCESS_WINDOWS_INITIALIZERS_ON_CREATEPROCESS_SETUP_HPP
+#define BOOST_PROCESS_WINDOWS_INITIALIZERS_ON_CREATEPROCESS_SETUP_HPP
+
+#include <boost/process/config.hpp>
+#include <boost/process/windows/initializers/initializer_base.hpp>
+
+namespace boost { namespace process { namespace windows { namespace initializers {
+
+template <class Handler>
+class on_CreateProcess_setup_ : public initializer_base
+{
+public:
+    explicit on_CreateProcess_setup_(Handler handler) : handler_(handler) {}
+
+    template <class WindowsExecutor>
+    void on_CreateProcess_setup(WindowsExecutor &e) const
+    {
+        handler_(e);
+    }
+
+private:
+    Handler handler_;
+};
+
+template <class Handler>
+on_CreateProcess_setup_<Handler> on_CreateProcess_setup(Handler handler)
+{
+    return on_CreateProcess_setup_<Handler>(handler);
+}
+
+}}}}
+
+#endif

third-party/boost/process/windows/initializers/on_CreateProcess_success.hpp

@@ -0,0 +1,42 @@
+// Copyright (c) 2006, 2007 Julio M. Merino Vidal
+// Copyright (c) 2008 Ilya Sokolov, Boris Schaeling
+// Copyright (c) 2009 Boris Schaeling
+// Copyright (c) 2010 Felipe Tanus, Boris Schaeling
+// Copyright (c) 2011, 2012 Jeff Flinn, Boris Schaeling
+//
+// 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)
+
+#ifndef BOOST_PROCESS_WINDOWS_INITIALIZERS_ON_CREATEPROCESS_SUCCESS_HPP
+#define BOOST_PROCESS_WINDOWS_INITIALIZERS_ON_CREATEPROCESS_SUCCESS_HPP
+
+#include <boost/process/config.hpp>
+#include <boost/process/windows/initializers/initializer_base.hpp>
+
+namespace boost { namespace process { namespace windows { namespace initializers {
+
+template <class Handler>
+class on_CreateProcess_success_ : public initializer_base
+{
+public:
+    explicit on_CreateProcess_success_(Handler handler) : handler_(handler) {}
+
+    template <class WindowsExecutor>
+    void on_CreateProcess_sucess(WindowsExecutor &e) const
+    {
+        handler_(e);
+    }
+
+private:
+    Handler handler_;
+};
+
+template <class Handler>
+on_CreateProcess_success_<Handler> on_CreateProcess_success(Handler handler)
+{
+    return on_CreateProcess_success_<Handler>(handler);
+}
+
+}}}}
+
+#endif

third-party/boost/process/windows/initializers/run_exe.hpp

@@ -0,0 +1,69 @@
+// Copyright (c) 2006, 2007 Julio M. Merino Vidal
+// Copyright (c) 2008 Ilya Sokolov, Boris Schaeling
+// Copyright (c) 2009 Boris Schaeling
+// Copyright (c) 2010 Felipe Tanus, Boris Schaeling
+// Copyright (c) 2011, 2012 Jeff Flinn, Boris Schaeling
+//
+// 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)
+
+#ifndef BOOST_PROCESS_WINDOWS_INITIALIZERS_RUN_EXE_HPP
+#define BOOST_PROCESS_WINDOWS_INITIALIZERS_RUN_EXE_HPP
+
+#include <boost/process/windows/initializers/initializer_base.hpp>
+#include <boost/filesystem.hpp>
+#include <string>
+
+namespace boost { namespace process { namespace windows { namespace initializers {
+
+template <class String>
+class run_exe_ : public initializer_base
+{
+public:
+    explicit run_exe_(const String &s) : s_(s) {}
+
+    template <class WindowsExecutor>
+    void on_CreateProcess_setup(WindowsExecutor &e) const
+    {
+        e.exe = s_.c_str();
+    }
+
+private:
+    String s_;
+};
+
+#if defined(_UNICODE) || defined(UNICODE)
+inline run_exe_<std::wstring> run_exe(const wchar_t *ws)
+{
+    return run_exe_<std::wstring>(ws);
+}
+
+inline run_exe_<std::wstring> run_exe(const std::wstring &ws)
+{
+    return run_exe_<std::wstring>(ws);
+}
+
+inline run_exe_<std::wstring> run_exe(const boost::filesystem::path &p)
+{
+    return run_exe_<std::wstring>(p.wstring());
+}
+#else
+inline run_exe_<std::string> run_exe(const char *s)
+{
+    return run_exe_<std::string>(s);
+}
+
+inline run_exe_<std::string> run_exe(const std::string &s)
+{
+    return run_exe_<std::string>(s);
+}
+
+inline run_exe_<std::string> run_exe(const boost::filesystem::path &p)
+{
+    return run_exe_<std::string>(p.string());
+}
+#endif
+
+}}}}
+
+#endif

third-party/boost/process/windows/initializers/set_args.hpp

@@ -0,0 +1,87 @@
+// Copyright (c) 2006, 2007 Julio M. Merino Vidal
+// Copyright (c) 2008 Ilya Sokolov, Boris Schaeling
+// Copyright (c) 2009 Boris Schaeling
+// Copyright (c) 2010 Felipe Tanus, Boris Schaeling
+// Copyright (c) 2011, 2012 Jeff Flinn, Boris Schaeling
+//
+// 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)
+
+#ifndef BOOST_PROCESS_WINDOWS_INITIALIZERS_SET_ARGS_HPP
+#define BOOST_PROCESS_WINDOWS_INITIALIZERS_SET_ARGS_HPP
+
+#include <boost/process/windows/initializers/initializer_base.hpp>
+#include <boost/range/begin.hpp>
+#include <boost/range/end.hpp>
+#include <boost/range/algorithm/copy.hpp>
+#include <boost/algorithm/string/predicate.hpp>
+#include <boost/shared_array.hpp>
+#include <sstream>
+
+namespace boost { namespace process { namespace windows { namespace initializers {
+
+template <class Range>
+class set_args_ : public initializer_base
+{
+private:
+    typedef typename Range::const_iterator ConstIterator;
+    typedef typename Range::value_type String;
+    typedef typename String::value_type Char;
+    typedef std::basic_ostringstream<Char> OStringStream;
+
+public:
+    explicit set_args_(const Range &args)
+    {
+        ConstIterator it = boost::const_begin(args);
+        ConstIterator end = boost::const_end(args);
+        if (it != end)
+        {
+            exe_ = *it;
+            OStringStream os;
+            for (; it != end; ++it)
+            {
+                if (boost::algorithm::contains(*it,
+                    String(1, static_cast<Char>(' '))))
+                {
+                    os << static_cast<Char>('"') << *it <<
+                        static_cast<Char>('"');
+                }
+                else
+                {
+                    os << *it;
+                }
+                os << static_cast<Char>(' ');
+            }
+            String s = os.str();
+            cmd_line_.reset(new Char[s.size() + 1]);
+            boost::copy(s, cmd_line_.get());
+            cmd_line_[s.size()] = 0;
+        }
+        else
+        {
+            cmd_line_.reset(new Char[1]());
+        }
+    }
+
+    template <class WindowsExecutor>
+    void on_CreateProcess_setup(WindowsExecutor &e) const
+    {
+        e.cmd_line = cmd_line_.get();
+        if (!e.exe && !exe_.empty())
+            e.exe = exe_.c_str();
+    }
+
+private:
+    boost::shared_array<Char> cmd_line_;
+    String exe_;
+};
+
+template <class Range>
+set_args_<Range> set_args(const Range &range)
+{
+    return set_args_<Range>(range);
+}
+
+}}}}
+
+#endif

third-party/boost/process/windows/initializers/set_cmd_line.hpp

@@ -0,0 +1,68 @@
+// Copyright (c) 2006, 2007 Julio M. Merino Vidal
+// Copyright (c) 2008 Ilya Sokolov, Boris Schaeling
+// Copyright (c) 2009 Boris Schaeling
+// Copyright (c) 2010 Felipe Tanus, Boris Schaeling
+// Copyright (c) 2011, 2012 Jeff Flinn, Boris Schaeling
+//
+// 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)
+
+#ifndef BOOST_PROCESS_WINDOWS_INITIALIZERS_SET_CMD_LINE_HPP
+#define BOOST_PROCESS_WINDOWS_INITIALIZERS_SET_CMD_LINE_HPP
+
+#include <boost/process/windows/initializers/initializer_base.hpp>
+#include <boost/range/algorithm/copy.hpp>
+#include <boost/shared_array.hpp>
+#include <memory>
+
+namespace boost { namespace process { namespace windows { namespace initializers {
+
+template <class String>
+class set_cmd_line_ : public initializer_base
+{
+private:
+    typedef typename String::value_type Char;
+
+public:
+    explicit set_cmd_line_(const String &s)
+        : cmd_line_(new Char[s.size() + 1])
+    {
+        boost::copy(s, cmd_line_.get());
+        cmd_line_[s.size()] = 0;
+    }
+
+    template <class WindowsExecutor>
+    void on_CreateProcess_setup(WindowsExecutor &e) const
+    {
+        e.cmd_line = cmd_line_.get();
+    }
+
+private:
+    boost::shared_array<Char> cmd_line_;
+};
+
+#if defined(_UNICODE) || defined(UNICODE)
+inline set_cmd_line_<std::wstring> set_cmd_line(const wchar_t *ws)
+{
+    return set_cmd_line_<std::wstring>(ws);
+}
+
+inline set_cmd_line_<std::wstring> set_cmd_line(const std::wstring &ws)
+{
+    return set_cmd_line_<std::wstring>(ws);
+}
+#else
+inline set_cmd_line_<std::string> set_cmd_line(const char *s)
+{
+    return set_cmd_line_<std::string>(s);
+}
+
+inline set_cmd_line_<std::string> set_cmd_line(const std::string &s)
+{
+    return set_cmd_line_<std::string>(s);
+}
+#endif
+
+}}}}
+
+#endif

third-party/boost/process/windows/initializers/set_env.hpp

@@ -0,0 +1,88 @@
+// Copyright (c) 2006, 2007 Julio M. Merino Vidal
+// Copyright (c) 2008 Ilya Sokolov, Boris Schaeling
+// Copyright (c) 2009 Boris Schaeling
+// Copyright (c) 2010 Felipe Tanus, Boris Schaeling
+// Copyright (c) 2011, 2012 Jeff Flinn, Boris Schaeling
+//
+// 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)
+
+#ifndef BOOST_PROCESS_WINDOWS_INITIALIZERS_SET_ENV_HPP
+#define BOOST_PROCESS_WINDOWS_INITIALIZERS_SET_ENV_HPP
+
+#include <Windows.h>
+#include <boost/process/windows/initializers/initializer_base.hpp>
+#include <boost/range/numeric.hpp>
+#include <boost/range/algorithm/copy.hpp>
+#include <boost/range/algorithm/for_each.hpp>
+#include <boost/shared_array.hpp>
+#include <iterator>
+#include <cstddef>
+
+namespace boost { namespace process { namespace windows { namespace initializers {
+
+template <class Range, bool Unicode>
+class set_env_ : public initializer_base
+{
+private:
+    typedef typename Range::value_type String;
+    typedef typename String::value_type Char;
+
+    static std::size_t add_size(std::size_t size, const String &s)
+    {
+        return size + s.size() + 1u;
+    }
+
+    struct copy
+    {
+        Char *it_;
+
+        copy(Char *it) : it_(it) {}
+
+        void operator()(const String &s)
+        {
+            it_ = boost::copy(s, it_);
+            *it_ = 0;
+            ++it_;
+        }
+    };
+
+public:
+    set_env_(const Range &envs)
+        : size_(boost::accumulate(envs, 0, add_size) + 1),
+        env_(new Char[size_])
+    {
+        boost::for_each(envs, copy(env_.get()));
+        env_[size_ - 1] = 0;
+    }
+
+    template <class WindowsExecutor>
+    void on_CreateProcess_setup(WindowsExecutor &e) const
+    {
+        e.env = env_.get();
+        if (Unicode)
+            e.creation_flags |= CREATE_UNICODE_ENVIRONMENT;
+    }
+
+private:
+    std::size_t size_;
+    boost::shared_array<Char> env_;
+};
+
+#if defined(_UNICODE) || defined(UNICODE)
+template <class Range>
+set_env_<Range, true> set_env(const Range &envs)
+{
+    return set_env_<Range, true>(envs);
+}
+#else
+template <class Range>
+set_env_<Range, false> set_env(const Range &envs)
+{
+    return set_env_<Range, false>(envs);
+}
+#endif
+
+}}}}
+
+#endif

third-party/boost/process/windows/initializers/set_on_error.hpp

@@ -0,0 +1,36 @@
+// Copyright (c) 2006, 2007 Julio M. Merino Vidal
+// Copyright (c) 2008 Ilya Sokolov, Boris Schaeling
+// Copyright (c) 2009 Boris Schaeling
+// Copyright (c) 2010 Felipe Tanus, Boris Schaeling
+// Copyright (c) 2011, 2012 Jeff Flinn, Boris Schaeling
+//
+// 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)
+
+#ifndef BOOST_PROCESS_WINDOWS_INITIALIZERS_SET_ON_ERROR_HPP
+#define BOOST_PROCESS_WINDOWS_INITIALIZERS_SET_ON_ERROR_HPP
+
+#include <boost/process/config.hpp>
+#include <boost/process/windows/initializers/initializer_base.hpp>
+#include <boost/system/error_code.hpp>
+
+namespace boost { namespace process { namespace windows { namespace initializers {
+
+class set_on_error : public initializer_base
+{
+public:
+    explicit set_on_error(boost::system::error_code &ec) : ec_(ec) {}
+
+    template <class WindowsExecutor>
+    void on_CreateProcess_error(WindowsExecutor&) const
+    {
+        BOOST_PROCESS_RETURN_LAST_SYSTEM_ERROR(ec_);
+    }
+
+private:
+    boost::system::error_code &ec_;
+};
+
+}}}}
+
+#endif

third-party/boost/process/windows/initializers/show_window.hpp

@@ -0,0 +1,36 @@
+// Copyright (c) 2006, 2007 Julio M. Merino Vidal
+// Copyright (c) 2008 Ilya Sokolov, Boris Schaeling
+// Copyright (c) 2009 Boris Schaeling
+// Copyright (c) 2010 Felipe Tanus, Boris Schaeling
+// Copyright (c) 2011, 2012 Jeff Flinn, Boris Schaeling
+//
+// 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)
+
+#ifndef BOOST_PROCESS_WINDOWS_INITIALIZERS_SHOW_WINDOW_HPP
+#define BOOST_PROCESS_WINDOWS_INITIALIZERS_SHOW_WINDOW_HPP
+
+#include <boost/process/windows/initializers/initializer_base.hpp>
+#include <Windows.h>
+
+namespace boost { namespace process { namespace windows { namespace initializers {
+
+class show_window : public initializer_base
+{
+public:
+    explicit show_window(WORD flags) : flags_(flags) {}
+
+    template <class WindowsExecutor>
+    void on_CreateProcess_setup(WindowsExecutor &e) const
+    {
+        e.startup_info.dwFlags |= STARTF_USESHOWWINDOW;
+        e.startup_info.wShowWindow |= flags_;
+    }
+
+private:
+    WORD flags_;
+};
+
+}}}}
+
+#endif

third-party/boost/process/windows/initializers/start_in_dir.hpp

@@ -0,0 +1,69 @@
+// Copyright (c) 2006, 2007 Julio M. Merino Vidal
+// Copyright (c) 2008 Ilya Sokolov, Boris Schaeling
+// Copyright (c) 2009 Boris Schaeling
+// Copyright (c) 2010 Felipe Tanus, Boris Schaeling
+// Copyright (c) 2011, 2012 Jeff Flinn, Boris Schaeling
+//
+// 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)
+
+#ifndef BOOST_PROCESS_WINDOWS_INITIALIZERS_START_IN_DIR_HPP
+#define BOOST_PROCESS_WINDOWS_INITIALIZERS_START_IN_DIR_HPP
+
+#include <boost/process/windows/initializers/initializer_base.hpp>
+#include <boost/filesystem/path.hpp>
+#include <string>
+
+namespace boost { namespace process { namespace windows { namespace initializers {
+
+template <class String>
+class start_in_dir_ : public initializer_base
+{
+public:
+    explicit start_in_dir_(const String &s) : s_(s) {}
+
+    template <class WindowsExecutor>
+    void on_CreateProcess_setup(WindowsExecutor &e) const
+    {
+        e.work_dir = s_.c_str();
+    }
+
+private:
+    String s_;
+};
+
+#if defined(_UNICODE) || defined(UNICODE)
+inline start_in_dir_<std::wstring> start_in_dir(const wchar_t *ws)
+{
+    return start_in_dir_<std::wstring>(ws);
+}
+
+inline start_in_dir_<std::wstring> start_in_dir(const std::wstring &ws)
+{
+    return start_in_dir_<std::wstring>(ws);
+}
+
+inline start_in_dir_<std::wstring> start_in_dir(const boost::filesystem::path &p)
+{
+    return start_in_dir_<std::wstring>(p.wstring());
+}
+#else
+inline start_in_dir_<std::string> start_in_dir(const char *s)
+{
+    return start_in_dir_<std::string>(s);
+}
+
+inline start_in_dir_<std::string> start_in_dir(const std::string &s)
+{
+    return start_in_dir_<std::string>(s);
+}
+
+inline start_in_dir_<std::string> start_in_dir(const boost::filesystem::path &p)
+{
+    return start_in_dir_<std::string>(p.string());
+}
+#endif
+
+}}}}
+
+#endif

third-party/boost/process/windows/initializers/throw_on_error.hpp

@@ -0,0 +1,30 @@
+// Copyright (c) 2006, 2007 Julio M. Merino Vidal
+// Copyright (c) 2008 Ilya Sokolov, Boris Schaeling
+// Copyright (c) 2009 Boris Schaeling
+// Copyright (c) 2010 Felipe Tanus, Boris Schaeling
+// Copyright (c) 2011, 2012 Jeff Flinn, Boris Schaeling
+//
+// 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)
+
+#ifndef BOOST_PROCESS_WINDOWS_INITIALIZERS_THROW_ON_ERROR_HPP
+#define BOOST_PROCESS_WINDOWS_INITIALIZERS_THROW_ON_ERROR_HPP
+
+#include <boost/process/config.hpp>
+#include <boost/process/windows/initializers/initializer_base.hpp>
+
+namespace boost { namespace process { namespace windows { namespace initializers {
+
+class throw_on_error : public initializer_base
+{
+public:
+    template <class WindowsExecutor>
+    void on_CreateProcess_error(WindowsExecutor&) const
+    {
+        BOOST_PROCESS_THROW_LAST_SYSTEM_ERROR("CreateProcess() failed");
+    }
+};
+
+}}}}
+
+#endif

third-party/boost/process/windows/pipe.hpp

@@ -0,0 +1,32 @@
+// Copyright (c) 2006, 2007 Julio M. Merino Vidal
+// Copyright (c) 2008 Ilya Sokolov, Boris Schaeling
+// Copyright (c) 2009 Boris Schaeling
+// Copyright (c) 2010 Felipe Tanus, Boris Schaeling
+// Copyright (c) 2011, 2012 Jeff Flinn, Boris Schaeling
+//
+// 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)
+
+#ifndef BOOST_PROCESS_WINDOWS_PIPE_HPP
+#define BOOST_PROCESS_WINDOWS_PIPE_HPP
+
+#include <Windows.h>
+
+namespace boost { namespace process { namespace windows {
+
+struct pipe
+{
+    HANDLE source;
+    HANDLE sink;
+
+    pipe(HANDLE source, HANDLE sink) : source(source), sink(sink) {}
+};
+
+inline pipe make_pipe(HANDLE source, HANDLE sink)
+{
+    return pipe(source, sink);
+}
+
+}}}
+
+#endif

third-party/boost/process/windows/search_path.hpp

@@ -0,0 +1,104 @@
+// Copyright (c) 2006, 2007 Julio M. Merino Vidal
+// Copyright (c) 2008 Ilya Sokolov, Boris Schaeling
+// Copyright (c) 2009 Boris Schaeling
+// Copyright (c) 2010 Felipe Tanus, Boris Schaeling
+// Copyright (c) 2011, 2012 Jeff Flinn, Boris Schaeling
+//
+// 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)
+
+#ifndef BOOST_PROCESS_WINDOWS_SEARCH_PATH_HPP
+#define BOOST_PROCESS_WINDOWS_SEARCH_PATH_HPP
+
+#include <boost/process/config.hpp>
+#include <boost/filesystem.hpp>
+#include <boost/tokenizer.hpp>
+#include <boost/array.hpp>
+#include <boost/system/error_code.hpp>
+#include <string>
+#include <stdexcept>
+#include <stdlib.h>
+#include <Shellapi.h>
+
+namespace boost { namespace process { namespace windows {
+
+#if defined(_UNICODE) || defined(UNICODE)
+inline std::wstring search_path(const std::wstring &filename,
+    std::wstring path = L"")
+{
+    if (path.empty())
+    {
+        path = ::_wgetenv(L"PATH");
+        if (path.empty())
+            BOOST_PROCESS_THROW(std::runtime_error(
+                "Environment variable PATH not found"));
+    }
+
+    typedef boost::tokenizer<boost::char_separator<wchar_t>,
+        std::wstring::const_iterator, std::wstring> tokenizer;
+    boost::char_separator<wchar_t> sep(L";");
+    tokenizer tok(path, sep);
+    for (tokenizer::iterator it = tok.begin(); it != tok.end(); ++it)
+    {
+        boost::filesystem::path p = *it;
+        p /= filename;
+        boost::array<std::wstring, 4> extensions =
+            { L"", L".exe", L".com", L".bat" };
+        for (boost::array<std::wstring, 4>::iterator it2 = extensions.begin();
+            it2 != extensions.end(); ++it2)
+        {
+            boost::filesystem::path p2 = p;
+            p2 += *it2;
+            boost::system::error_code ec;
+            bool file = boost::filesystem::is_regular_file(p2, ec);
+            if (!ec && file &&
+                SHGetFileInfoW(p2.c_str(), 0, 0, 0, SHGFI_EXETYPE))
+            {
+                return p2.wstring();
+            }
+        }
+    }
+    return L"";
+}
+#else
+inline std::string search_path(const std::string &filename,
+    std::string path = "")
+{
+    if (path.empty())
+    {
+        path = ::getenv("PATH");
+        if (path.empty())
+            BOOST_PROCESS_THROW(std::runtime_error(
+                "Environment variable PATH not found"));
+    }
+
+    typedef boost::tokenizer<boost::char_separator<char> > tokenizer;
+    boost::char_separator<char> sep(";");
+    tokenizer tok(path, sep);
+    for (tokenizer::iterator it = tok.begin(); it != tok.end(); ++it)
+    {
+        boost::filesystem::path p = *it;
+        p /= filename;
+        boost::array<std::string, 4> extensions =
+            { "", ".exe", ".com", ".bat" };
+        for (boost::array<std::string, 4>::iterator it2 = extensions.begin();
+            it2 != extensions.end(); ++it2)
+        {
+            boost::filesystem::path p2 = p;
+            p2 += *it2;
+            boost::system::error_code ec;
+            bool file = boost::filesystem::is_regular_file(p2, ec);
+            if (!ec && file &&
+                SHGetFileInfoA(p2.string().c_str(), 0, 0, 0, SHGFI_EXETYPE))
+            {
+                return p2.string();
+            }
+        }
+    }
+    return "";
+}
+#endif
+
+}}}
+
+#endif

third-party/boost/process/windows/shell_path.hpp

@@ -0,0 +1,50 @@
+// Copyright (c) 2006, 2007 Julio M. Merino Vidal
+// Copyright (c) 2008 Ilya Sokolov, Boris Schaeling
+// Copyright (c) 2009 Boris Schaeling
+// Copyright (c) 2010 Felipe Tanus, Boris Schaeling
+// Copyright (c) 2011, 2012 Jeff Flinn, Boris Schaeling
+//
+// 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)
+
+#ifndef BOOST_PROCESS_WINDOWS_SHELL_PATH_HPP
+#define BOOST_PROCESS_WINDOWS_SHELL_PATH_HPP
+
+#include <boost/process/config.hpp>
+#include <boost/system/error_code.hpp>
+#include <boost/filesystem/path.hpp>
+#include <Windows.h>
+
+namespace boost { namespace process { namespace windows {
+
+inline boost::filesystem::path shell_path()
+{
+    TCHAR sysdir[MAX_PATH];
+    UINT size = ::GetSystemDirectory(sysdir, sizeof(sysdir));
+    if (!size)
+        BOOST_PROCESS_THROW_LAST_SYSTEM_ERROR("GetSystemDirectory() failed");
+    boost::filesystem::path p = sysdir;
+    return p / "cmd.exe";
+}
+
+inline boost::filesystem::path shell_path(boost::system::error_code &ec)
+{
+    TCHAR sysdir[MAX_PATH];
+    UINT size = ::GetSystemDirectory(sysdir, sizeof(sysdir));
+    boost::filesystem::path p;
+    if (!size)
+    {
+        BOOST_PROCESS_RETURN_LAST_SYSTEM_ERROR(ec);
+    }
+    else
+    {
+        ec.clear();
+        p = sysdir;
+        p /= "cmd.exe";
+    }
+    return p;
+}
+
+}}}
+
+#endif

third-party/boost/process/windows/terminate.hpp

@@ -0,0 +1,38 @@
+// Copyright (c) 2006, 2007 Julio M. Merino Vidal
+// Copyright (c) 2008 Ilya Sokolov, Boris Schaeling
+// Copyright (c) 2009 Boris Schaeling
+// Copyright (c) 2010 Felipe Tanus, Boris Schaeling
+// Copyright (c) 2011, 2012 Jeff Flinn, Boris Schaeling
+//
+// 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)
+
+#ifndef BOOST_PROCESS_WINDOWS_TERMINATE_HPP
+#define BOOST_PROCESS_WINDOWS_TERMINATE_HPP
+
+#include <boost/process/config.hpp>
+#include <boost/system/error_code.hpp>
+#include <cstdlib>
+#include <Windows.h>
+
+namespace boost { namespace process { namespace windows {
+
+template <class Process>
+void terminate(const Process &p)
+{
+    if (!::TerminateProcess(p.process_handle(), EXIT_FAILURE))
+        BOOST_PROCESS_THROW_LAST_SYSTEM_ERROR("TerminateProcess() failed");
+}
+
+template <class Process>
+void terminate(const Process &p, boost::system::error_code &ec)
+{
+    if (!::TerminateProcess(p.process_handle(), EXIT_FAILURE))
+        BOOST_PROCESS_RETURN_LAST_SYSTEM_ERROR(ec);
+    else
+        ec.clear();
+}
+
+}}}
+
+#endif

third-party/boost/process/windows/wait_for_exit.hpp

@@ -0,0 +1,49 @@
+// Copyright (c) 2006, 2007 Julio M. Merino Vidal
+// Copyright (c) 2008 Ilya Sokolov, Boris Schaeling
+// Copyright (c) 2009 Boris Schaeling
+// Copyright (c) 2010 Felipe Tanus, Boris Schaeling
+// Copyright (c) 2011, 2012 Jeff Flinn, Boris Schaeling
+//
+// 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)
+
+#ifndef BOOST_PROCESS_WINDOWS_WAIT_FOR_EXIT_HPP
+#define BOOST_PROCESS_WINDOWS_WAIT_FOR_EXIT_HPP
+
+#include <boost/process/config.hpp>
+#include <boost/system/error_code.hpp>
+#include <Windows.h>
+
+namespace boost { namespace process { namespace windows {
+
+template <class Process>
+inline DWORD wait_for_exit(const Process &p)
+{
+    if (::WaitForSingleObject(p.process_handle(), INFINITE) == WAIT_FAILED)
+        BOOST_PROCESS_THROW_LAST_SYSTEM_ERROR("WaitForSingleObject() failed");
+
+    DWORD exit_code;
+    if (!::GetExitCodeProcess(p.process_handle(), &exit_code))
+        BOOST_PROCESS_THROW_LAST_SYSTEM_ERROR("GetExitCodeProcess() failed");
+
+    return exit_code;
+}
+
+template <class Process>
+inline DWORD wait_for_exit(const Process &p, boost::system::error_code &ec)
+{
+    DWORD exit_code = 1;
+
+    if (::WaitForSingleObject(p.process_handle(), INFINITE) == WAIT_FAILED)
+        BOOST_PROCESS_RETURN_LAST_SYSTEM_ERROR(ec);
+    else if (!::GetExitCodeProcess(p.process_handle(), &exit_code))
+        BOOST_PROCESS_RETURN_LAST_SYSTEM_ERROR(ec);
+    else
+        ec.clear();
+
+    return exit_code;
+}
+
+}}}
+
+#endif