Core/Updates: Add an automatic database update system. Automatically detects new and edited sql updates through file lists and hashing. Detects renames, deletes and is able to create and auto import full databases. * cleanups in main.cpp of world & bnetserver * refactoring in DatabaseWorkerPool.h & MySQLConnection.cpp

Make sure you re-run cmake, because boost::iostreams was added as dependency.
Maybe you need to install libboost-iostreams1.55-dev on unix as well.

Import every update manual until (included) those INSERT IGNORE updates for each database.

Thanks DDuarte and Shauren for your amazing ideas, help and advises.

In hope that nobody gets a "Your database structure is not up to date..." anymore ,-)

Signed-off-by: Naios <naios-dev@live.de>
Signed-off-by: Nayd <dnpd.dd@gmail.com>

82 files changed, 4605 insertions, 0 deletions

diff --git a/dep/process/License.txt b/dep/process/License.txt
new file mode 100644
index 00000000000..36b7cd93cdf
--- /dev/null
+++ b/dep/process/License.txt
@@ -0,0 +1,23 @@
+Boost Software License - Version 1.0 - August 17th, 2003
+
+Permission is hereby granted, free of charge, to any person or organization
+obtaining a copy of the software and accompanying documentation covered by
+this license (the "Software") to use, reproduce, display, distribute,
+execute, and transmit the Software, and to prepare derivative works of the
+Software, and to permit third-parties to whom the Software is furnished to
+do so, all subject to the following:
+
+The copyright notices in the Software and this entire statement, including
+the above license grant, this restriction and the following disclaimer,
+must be included in all copies of the Software, in whole or in part, and
+all derivative works of the Software, unless such copies or derivative
+works are solely in the form of machine-executable object code generated by
+a source language processor.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE, TITLE AND NON-INFRINGEMENT. IN NO EVENT
+SHALL THE COPYRIGHT HOLDERS OR ANYONE DISTRIBUTING THE SOFTWARE BE LIABLE
+FOR ANY DAMAGES OR OTHER LIABILITY, WHETHER IN CONTRACT, TORT OR OTHERWISE,
+ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
+DEALINGS IN THE SOFTWARE.
diff --git a/dep/process/Readme.txt b/dep/process/Readme.txt
new file mode 100644
index 00000000000..ada7cf74974
--- /dev/null
+++ b/dep/process/Readme.txt
@@ -0,0 +1,6 @@
+Boost.Process (Not part of the official boost libraries yet)
+================================================================
+Its used to start child processes within the application.
+
+Website: http://www.highscore.de/boost/process0.5/
+Downloaded from: http://www.highscore.de/boost/process0.5/process.zip
diff --git a/dep/process/boost/process.hpp b/dep/process/boost/process.hpp
new file mode 100644
index 00000000000..2271e9b49e7
--- /dev/null
+++ b/dep/process/boost/process.hpp
@@ -0,0 +1,22 @@
+// 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 Jeff Flinn, Boris Schaeling
+// Copyright (c) 2012 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)
+
+/**
+ * \file boost/process.hpp
+ *
+ * Convenience header which includes all public Boost.Process header files.
+ */
+
+#ifndef BOOST_PROCESS_HPP
+#define BOOST_PROCESS_HPP
+
+#include <boost/process/all.hpp>
+
+#endif
diff --git a/dep/process/boost/process/all.hpp b/dep/process/boost/process/all.hpp
new file mode 100644
index 00000000000..234dd05d4c1
--- /dev/null
+++ b/dep/process/boost/process/all.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)
+
+/**
+ * \file boost/process/all.hpp
+ *
+ * Convenience header which includes all public Boost.Process header files.
+ */
+
+#ifndef BOOST_PROCESS_ALL_HPP
+#define BOOST_PROCESS_ALL_HPP
+
+#include <boost/process/child.hpp>
+#include <boost/process/create_pipe.hpp>
+#include <boost/process/execute.hpp>
+#include <boost/process/executor.hpp>
+#include <boost/process/initializers.hpp>
+#include <boost/process/pipe.hpp>
+#include <boost/process/search_path.hpp>
+#include <boost/process/shell_path.hpp>
+#include <boost/process/terminate.hpp>
+#include <boost/process/wait_for_exit.hpp>
+
+#endif
diff --git a/dep/process/boost/process/child.hpp b/dep/process/boost/process/child.hpp
new file mode 100644
index 00000000000..ec129fc9367
--- /dev/null
+++ b/dep/process/boost/process/child.hpp
@@ -0,0 +1,74 @@
+// 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)
+
+/**
+ * \file boost/process/child.hpp
+ *
+ * Defines a child process class.
+ */
+
+#ifndef BOOST_PROCESS_CHILD_HPP
+#define BOOST_PROCESS_CHILD_HPP
+
+#include <boost/process/config.hpp>
+
+#include BOOST_PROCESS_PLATFORM_PROMOTE_PATH(child)
+BOOST_PROCESS_PLATFORM_PROMOTE_NAMESPACE(child)
+
+#if defined(BOOST_PROCESS_DOXYGEN)
+namespace boost { namespace process {
+
+/**
+ * Represents a child process.
+ *
+ * On Windows child is movable but non-copyable. The destructor
+ * automatically closes handles to the child process.
+ */
+struct child
+{
+    /**
+     * Process information.
+     *
+     * \remark <em>Windows only.</em>
+     */
+    PROCESS_INFORMATION proc_info;
+
+    /**
+     * Constructor.
+     *
+     * \remark <em>Windows only.<em/>
+     */
+    explicit child(const PROCESS_INFORMATION &pi) : proc_info(pi) {}
+
+    /**
+     * Returns the process handle.
+     *
+     * \remark <em>Windows only.</em>
+     */
+    HANDLE process_handle() const { return proc_info.hProcess; }
+
+    /**
+     * Process identifier.
+     *
+     * \remark <em>POSIX only.</em>
+     */
+    pid_t pid;
+
+    /**
+     * Constructor.
+     *
+     * \remark <em>POSIX only.</em>
+     */
+    explicit child(pid_t p) : pid(p) {}
+};
+
+}}
+#endif
+
+#endif
diff --git a/dep/process/boost/process/config.hpp b/dep/process/boost/process/config.hpp
new file mode 100644
index 00000000000..7aae4d3ca4f
--- /dev/null
+++ b/dep/process/boost/process/config.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)
+
+/**
+ * \file boost/process/config.hpp
+ *
+ * Defines various macros.
+ */
+
+#ifndef BOOST_PROCESS_CONFIG_HPP
+#define BOOST_PROCESS_CONFIG_HPP
+
+#include <boost/config.hpp>
+#include <boost/system/config.hpp>
+#include <boost/system/error_code.hpp>
+#include <boost/system/system_error.hpp>
+
+#if defined(BOOST_POSIX_API)
+#   include <errno.h>
+#   define BOOST_PROCESS_LAST_ERROR errno
+#   define BOOST_PROCESS_PLATFORM posix
+#elif defined(BOOST_WINDOWS_API)
+#   include <Windows.h>
+#   define BOOST_PROCESS_LAST_ERROR GetLastError()
+#   define BOOST_PROCESS_PLATFORM windows
+#endif
+
+/** \cond */
+#define BOOST_PROCESS_PLATFORM_PROMOTE_PATH(COMPONENT) \
+    <boost/process/BOOST_PROCESS_PLATFORM/COMPONENT.hpp>
+#define BOOST_PROCESS_PLATFORM_PROMOTE_NAMESPACE(COMPONENT) \
+    namespace boost { namespace process { using BOOST_PROCESS_PLATFORM::COMPONENT; }}
+#define BOOST_PROCESS_PLATFORM_PROMOTE_INITIALIZERS_NAMESPACE \
+    namespace boost { namespace process { namespace initializers { \
+    using namespace boost::process::BOOST_PROCESS_PLATFORM::initializers; }}}
+/** \endcond */
+
+#if defined(BOOST_PROCESS_DOXYGEN)
+/**
+ * \def BOOST_POSIX_API
+ *
+ * This macro is defined on POSIX.
+ */
+#define BOOST_POSIX_API
+/**
+ * \def BOOST_WINDOWS_API
+ *
+ * This macro is defined on Windows.
+ */
+#define BOOST_WINDOWS_API
+#endif
+
+/**
+ * \def BOOST_PROCESS_THROW(EX)
+ *
+ * Defines how exceptions are thrown. Set this macro for example
+ * to \c BOOST_THROW_EXCEPTION if you like to use Boost.Exception.
+ */
+#define BOOST_PROCESS_THROW(EX) throw EX
+
+/** \cond */
+#define BOOST_PROCESS_SOURCE_LOCATION \
+    "in file '" __FILE__ "', line " BOOST_STRINGIZE(__LINE__) ": "
+
+#define BOOST_PROCESS_THROW_LAST_SYSTEM_ERROR(what) \
+    BOOST_PROCESS_THROW(boost::system::system_error( \
+        boost::system::error_code(BOOST_PROCESS_LAST_ERROR, \
+            boost::system::system_category()), \
+        BOOST_PROCESS_SOURCE_LOCATION what))
+
+#define BOOST_PROCESS_RETURN_LAST_SYSTEM_ERROR(ec) \
+    ec = boost::system::error_code(BOOST_PROCESS_LAST_ERROR, \
+        boost::system::system_category())
+/** \endcond */
+
+#endif
diff --git a/dep/process/boost/process/create_pipe.hpp b/dep/process/boost/process/create_pipe.hpp
new file mode 100644
index 00000000000..6c34ecf44b1
--- /dev/null
+++ b/dep/process/boost/process/create_pipe.hpp
@@ -0,0 +1,48 @@
+// 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)
+
+/**
+ * \file boost/process/create_pipe.hpp
+ *
+ * Defines a function to create a pipe.
+ */
+
+#ifndef BOOST_PROCESS_CREATE_PIPE_HPP
+#define BOOST_PROCESS_CREATE_PIPE_HPP
+
+#include <boost/process/config.hpp>
+
+#include BOOST_PROCESS_PLATFORM_PROMOTE_PATH(create_pipe)
+BOOST_PROCESS_PLATFORM_PROMOTE_NAMESPACE(create_pipe)
+
+#if defined(BOOST_PROCESS_DOXYGEN)
+namespace boost { namespace process {
+
+/**
+ * Creates an anonymous pipe.
+ *
+ * \note On Windows anonymous pipes don't support
+ *       asynchronous I/O.
+ *
+ * \throws boost::system::system_error in case of an error
+ */
+pipe create_pipe();
+
+/**
+ * Creates an anonymous pipe.
+ *
+ * \note On Windows anonymous pipes don't support
+ *       asynchronous I/O.
+ */
+pipe create_pipe(boost::system::error_code &ec);
+
+}}
+#endif
+
+#endif
diff --git a/dep/process/boost/process/execute.hpp b/dep/process/boost/process/execute.hpp
new file mode 100644
index 00000000000..608831171e9
--- /dev/null
+++ b/dep/process/boost/process/execute.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)
+
+/**
+ * \file boost/process/execute.hpp
+ *
+ * Defines a function to execute a program.
+ */
+
+#ifndef BOOST_PROCESS_EXECUTE_HPP
+#define BOOST_PROCESS_EXECUTE_HPP
+
+#include <boost/process/config.hpp>
+
+#include BOOST_PROCESS_PLATFORM_PROMOTE_PATH(execute)
+BOOST_PROCESS_PLATFORM_PROMOTE_NAMESPACE(execute)
+
+#if defined(BOOST_PROCESS_DOXYGEN)
+namespace boost { namespace process {
+
+/**
+ * Starts a program.
+ *
+ * \tparam initializers define what and how the program is started
+ */
+template <class Initializer, class... Initializers>
+child execute(const Initializer &initializer, const Initializers... &initializers);
+
+}}
+#endif
+
+#endif
diff --git a/dep/process/boost/process/executor.hpp b/dep/process/boost/process/executor.hpp
new file mode 100644
index 00000000000..905d7f84cc7
--- /dev/null
+++ b/dep/process/boost/process/executor.hpp
@@ -0,0 +1,176 @@
+// 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)
+
+/**
+ * \file boost/process/executor.hpp
+ *
+ * Defines an executor which can create child processes.
+ */
+
+#ifndef BOOST_PROCESS_EXECUTOR_HPP
+#define BOOST_PROCESS_EXECUTOR_HPP
+
+#include <boost/process/config.hpp>
+
+#include BOOST_PROCESS_PLATFORM_PROMOTE_PATH(executor)
+BOOST_PROCESS_PLATFORM_PROMOTE_NAMESPACE(executor)
+
+#if defined(BOOST_PROCESS_DOXYGEN)
+namespace boost { namespace process {
+
+/**
+ * Starts a program.
+ *
+ * boost::process::executor is a functor which calls the system functions
+ * to start a program. Before system functions are called it iterates
+ * over initializers and calls a member function passing a reference
+ * to itself as a parameter. Initializers get then a chance to setup
+ * the executor. If system functions fail boost::process::executor again
+ * iterates over initializers and calls another member function passing a
+ * reference to itself as a parameter. This gives initializers a
+ * chance to handle the error.
+ *
+ * \note Library users shouldn't need to use boost::process::executor.
+ *       It is recommended to call boost::process::execute which uses
+ *       boost::pocess::executor internally.
+ */
+struct executor
+{
+    /**
+     * Default constructor.
+     */
+    executor();
+
+    /**
+     * Starts a program.
+     *
+     * \tparam initializers define what and how the program is started
+     */
+    template <class Initializer, class... Initializers>
+    child operator()(const Initializer &initializer, const Initializers... &initializers);
+
+    ///\defgroup WindowsOnly Windows only.
+    ///@{
+
+    /**
+     * Program name.
+     *
+     * \remark <em>Windows only.</em>
+     */
+    LPCTSTR exe;
+
+    /**
+     * Command line.
+     *
+     * \remark <em>Windows only.</em>
+     */
+    LPTSTR cmd_line;
+
+    /**
+     * Process attributes.
+     *
+     * \remark <em>Windows only.</em>
+     */
+    LPSECURITY_ATTRIBUTES proc_attrs;
+
+    /**
+     * Thread attributes.
+     *
+     * \remark <em>Windows only.</em>
+     */
+    LPSECURITY_ATTRIBUTES thread_attrs;
+
+    /**
+     * Flag to inherit handles.
+     *
+     * \remark <em>Windows only.</em>
+     */
+    BOOL inherit_handles;
+
+    /**
+     * Creation flags.
+     *
+     * \remark <em>Windows only.</em>
+     */
+    DWORD creation_flags;
+
+    /**
+     * Environment variables.
+     *
+     * \remark <em>Windows only.</em>
+     */
+    LPVOID env;
+
+    /**
+     * Work directory.
+     *
+     * \remark <em>Windows only.</em>
+     */
+    LPCTSTR work_dir;
+
+    /**
+     * Startupinfo structure.
+     *
+     * \remark <em>Windows only.</em>
+     */
+    STARTUPINFO startup_info;
+
+    /**
+     * Startupinfoex structure.
+     *
+     * If this member variable is available, \c startup_info is a reference
+     * to \c StartupInfo in STARTUPINFOEX.
+     *
+     * \remark <em>Windows Vista, Windows Server 2008 or better.</em>
+     */
+    STARTUPINFOEX startup_info_ex;
+
+    /**
+     * Process information.
+     *
+     * \c proc_info contains the result after a child process
+     * could be started successfully.
+     *
+     * \remark <em>Windows only.</em>
+     */
+    PROCESS_INFORMATION proc_info;
+
+    ///@}
+
+    ///\defgroup POSIXOnly POSIX only.
+    ///@{
+
+    /**
+     * Program name.
+     *
+     * \remark <em>POSIX only.</em>
+     */
+    const char *exe;
+
+    /**
+     * Command line arguments.
+     *
+     * \remark <em>POSIX only.</em>
+     */
+    char **cmd_line;
+
+    /**
+     * Environment variables.
+     *
+     * \remark <em>POSIX only.</em>
+     */
+    char **env;
+
+    ///@}
+};
+
+}}
+#endif
+
+#endif
diff --git a/dep/process/boost/process/initializers.hpp b/dep/process/boost/process/initializers.hpp
new file mode 100644
index 00000000000..c7175d1425d
--- /dev/null
+++ b/dep/process/boost/process/initializers.hpp
@@ -0,0 +1,497 @@
+// 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)
+
+/**
+ * \file boost/process/initializers.hpp
+ *
+ * Defines initializers.
+ */
+
+#ifndef BOOST_PROCESS_INITIALIZERS_HPP
+#define BOOST_PROCESS_INITIALIZERS_HPP
+
+#include <boost/process/config.hpp>
+
+#include BOOST_PROCESS_PLATFORM_PROMOTE_PATH(initializers)
+BOOST_PROCESS_PLATFORM_PROMOTE_INITIALIZERS_NAMESPACE
+
+#if defined(BOOST_PROCESS_DOXYGEN)
+namespace boost { namespace process { namespace initializers {
+
+/**
+ * Binds the standard error stream.
+ */
+class bind_stderr : public initializer_base
+{
+public:
+    /**
+     * Constructor.
+     */
+    explicit bind_stderr(const boost::iostreams::file_descriptor_sink &sink);
+};
+
+/**
+ * Binds the standard input stream.
+ */
+class bind_stdin : public initializer_base
+{
+public:
+    /**
+     * Constructor.
+     */
+    explicit bind_stdin(const boost::iostreams::file_descriptor_source &source);
+};
+
+/**
+ * Binds the standard output stream.
+ */
+class bind_stdout : public initializer_base
+{
+public:
+    /**
+     * Constructor.
+     */
+    explicit bind_stdout(const boost::iostreams::file_descriptor_sink &sink);
+};
+
+/**
+ * Binds a file descriptor.
+ *
+ * \remark <em>POSIX only.</em>
+ */
+class bind_fd : public initializer_base
+{
+public:
+    /**
+     * Constructor.
+     */
+    bind_fd(int id, const boost::iostreams::file_descriptor &fd);
+};
+
+/**
+ * Closes a file descriptor.
+ *
+ * \remark <em>POSIX only.</em>
+ */
+class close_fd : public initializer_base
+{
+    /**
+     * Constructor.
+     */
+    explicit close_fd(int fd);
+};
+
+/**
+ * Closes file descriptors.
+ *
+ * \remark <em>POSIX only.</em>
+ */
+class close_fds : public initializer_base
+{
+public:
+    /**
+     * Constructor.
+     *
+     * \c range_type must be an <tt>int</tt>-range.
+     */
+    explicit close_fds(const range_type &fds);
+};
+
+/**
+ * Closes all file descriptors a predicate returns
+ * true for.
+ *
+ * This initializer doesn't close file descriptors
+ * immediately. Instead it sets the \c FD_CLOEXEC
+ * flag. File descriptors are closed when \c execve
+ * is called and the call succeeds.
+ *
+ * \remark <em>POSIX only.</em>
+ */
+class close_fds_if : public initializer_base
+{
+public:
+    /**
+     * Constructor.
+     *
+     * \c predicate_type must be a function or functor with
+     * this signature: <tt>bool(int)</tt>
+     */
+    explicit close_fds_if(const predicate_type &pred);
+};
+
+/**
+ * Closes the standard error stream.
+ */
+class close_stderr : public initializer_base
+{
+    /**
+     * Constructor.
+     */
+    close_stderr();
+};
+
+/**
+ * Closes the standard input stream.
+ */
+class close_stdin : public initializer_base
+{
+    /**
+     * Constructor.
+     */
+    close_stdin();
+};
+
+/**
+ * Closes the standard output stream.
+ */
+class close_stdout : public initializer_base
+{
+    /**
+     * Constructor.
+     */
+    close_stdout();
+};
+
+/**
+ * Hides the console.
+ */
+class hide_console : public initializer_base
+{
+public:
+    /**
+     * Constructor.
+     */
+    hide_console();
+};
+
+/**
+ * Inherits environment variables.
+ */
+class inherit_env : public initializer_base
+{
+public:
+    /**
+     * Constructor.
+     */
+    inherit_env();
+};
+
+/**
+ * Notifies an I/O service object of fork-related events.
+ *
+ * \see boost::asio::io_service::notify_fork
+ *
+ * \remark <em>POSIX only.</em>
+ */
+class notify_io_service : public initializer_base
+{
+public:
+    /**
+     * Constructor.
+     */
+    explicit notify_io_service(boost::asio::io_service &io_service);
+};
+
+/**
+ * Generic initializer to execute any code if \c execve
+ * failed.
+ *
+ * \remark <em>POSIX only.</em>
+ */
+class on_exec_error : public initializer_base
+{
+public:
+    /**
+     * Constructor.
+     *
+     * \c handler_type must be a function or functor with
+     * this signature: <tt>void(executor&)</tt>
+     */
+    explicit on_exec_error(handler_type handler);
+};
+
+/**
+ * Generic initializer to execute any code before \c execve
+ * is called.
+ *
+ * \remark <em>POSIX only.</em>
+ */
+class on_exec_setup : public initializer_base
+{
+public:
+    /**
+     * Constructor.
+     *
+     * \c handler_type must be a function or functor with
+     * this signature: <tt>void(executor&)</tt>
+     */
+    explicit on_exec_setup(handler_type handler);
+};
+
+/**
+ * Generic initializer to execute any code if \c fork
+ * failed.
+ *
+ * \remark <em>POSIX only.</em>
+ */
+class on_fork_error : public initializer_base
+{
+public:
+    /**
+     * Constructor.
+     *
+     * \c handler_type must be a function or functor with
+     * this signature: <tt>void(executor&)</tt>
+     */
+    explicit on_fork_error(handler_type handler);
+};
+
+/**
+ * Generic initializer to execute any code before \c fork
+ * is called.
+ *
+ * \remark <em>POSIX only.</em>
+ */
+class on_fork_setup : public initializer_base
+{
+public:
+    /**
+     * Constructor.
+     *
+     * \c handler_type must be a function or functor with
+     * this signature: <tt>void(executor&)</tt>
+     */
+    explicit on_fork_setup(handler_type handler);
+};
+
+/**
+ * Generic initializer to execute any code in the parent
+ * process after \c fork has been called successfully.
+ *
+ * \remark <em>POSIX only.</em>
+ */
+class on_fork_success : public initializer_base
+{
+public:
+    /**
+     * Constructor.
+     *
+     * \c handler_type must be a function or functor with
+     * this signature: <tt>void(executor&)</tt>
+     */
+    explicit on_fork_success(handler_type handler);
+};
+
+/**
+ * Generic initializer to execute any code if \c CreateProcess
+ * failed.
+ *
+ * \remark <em>Windows only.</em>
+ */
+class on_CreateProcess_error : public initializer_base
+{
+public:
+    /**
+     * Constructor.
+     *
+     * \c handler_type must be a function or functor with
+     * this signature: <tt>void(executor&)</tt>
+     */
+    explicit on_CreateProcess_error(handler_type handler);
+};
+
+/**
+ * Generic initializer to execute any code before \c CreateProcess
+ * is called.
+ *
+ * \remark <em>Windows only.</em>
+ */
+class on_CreateProcess_setup : public initializer_base
+{
+public:
+    /**
+     * Constructor.
+     *
+     * \c handler_type must be a function or functor with
+     * this signature: <tt>void(executor&)</tt>
+     */
+    explicit on_CreateProcess_setup(handler_type handler);
+};
+
+/**
+ * Generic initializer to execute any code after \c CreateProcess
+ * has been called successfully.
+ *
+ * \remark <em>Windows only.</em>
+ */
+class on_CreateProcess_success : public initializer_base
+{
+public:
+    /**
+     * Constructor.
+     *
+     * \c handler_type must be a function or functor with
+     * this signature: <tt>void(executor&)</tt>
+     */
+    explicit on_CreateProcess_success(handler_type handler);
+};
+
+/**
+ * Specifies the executable to start.
+ *
+ * This initializer must always be used. The only exception is
+ * if you use \c set_args or a generic initializer which
+ * specifies the executable.
+ */
+class run_exe : public initializer_base
+{
+public:
+    /**
+     * Constructor.
+     *
+     * On Windows \c string_type must be <tt>const char*</tt>,
+     * <tt>std::string</tt> or <tt>boost::filesystem::path</tt>.
+     * If Unicode is used, \c string_type must be
+     * <tt>const wchar_t*</tt>, <tt>std::wstring</tt> or
+     * <tt>boost::filesystem::path</tt>.
+     *
+     * On POSIX \c string_type must be <tt>const char*</tt>,
+     * <tt>std::string</tt> or <tt>boost::filesystem::path</tt>.
+     */
+    explicit run_exe(const string_type &s);
+};
+
+/**
+ * Sets the command line arguments.
+ *
+ * The first argument specifies the executable to start unless
+ * \c run_exe is used.
+ *
+ * Use \c set_cmd_line if you don't want to pass a collection of
+ * command line arguments but set the command line as one string.
+ */
+class set_args : public initializer_base
+{
+public:
+    /**
+     * Constructor.
+     *
+     * On Windows \c range_type must be a <tt>std::string</tt>-range.
+     * If Unicode is used, \c range_type must be a
+     * <tt>std::wstring</tt>-range.
+     *
+     * On POSIX \c range_type must be a <tt>std::string</tt>-range.
+     */
+    explicit set_args(const range_type &r);
+};
+
+/**
+ * Sets the command line.
+ *
+ * Use \c set_args if you don't want to set the command line as
+ * one string but pass a collection of command line arguments.
+ */
+class set_cmd_line : public initializer_base
+{
+public:
+    /**
+     * Constructor.
+     *
+     * On Windows \c string_type must be <tt>const char*</tt>,
+     * <tt>std::string</tt> or <tt>boost::filesystem::path</tt>.
+     * If Unicode is used, \c string_type must be
+     * <tt>const wchar_t*</tt>, <tt>std::wstring</tt> or
+     * <tt>boost::filesystem::path</tt>.
+     *
+     * On POSIX \c string_type must be <tt>const char*</tt>,
+     * <tt>std::string</tt> or <tt>boost::filesystem::path</tt>.
+     */
+    explicit set_cmd_line(const string_type &s);
+};
+
+/**
+ * Sets the environment.
+ */
+class set_env : public initializer_base
+{
+public:
+    /**
+     * Constructor.
+     *
+     * On Windows \c range_type must be a <tt>std::string</tt>-range.
+     * If Unicode is used, \c range_type must be a
+     * <tt>std::wstring</tt>-range.
+     *
+     * On POSIX \c range_type must be a <tt>std::string</tt>-range.
+     */
+    explicit set_env(const range_type &r);
+};
+
+/**
+ * Sets an error if a child process can't be created.
+ */
+class set_on_error : public initializer_base
+{
+public:
+    /**
+     * Constructor.
+     */
+    explicit set_on_error(boost::system::error_code &ec);
+};
+
+/**
+ * Sets the flag \c wShowWindow in \c STARTUPINFO.
+ *
+ * \remark <em>Windows only.</em>
+ */
+class show_window : public initializer_base
+{
+public:
+    /**
+     * Constructor.
+     */
+    explicit show_window(WORD flags);
+};
+
+/**
+ * Sets the work directory.
+ */
+class start_in_dir : public initializer_base
+{
+public:
+    /**
+     * Constructor.
+     *
+     * On Windows \c string_type must be <tt>const char*</tt>,
+     * <tt>std::string</tt> or <tt>boost::filesystem::path</tt>.
+     * If Unicode is used, \c string_type must be
+     * <tt>const wchar_t*</tt>, <tt>std::wstring</tt> or
+     * <tt>boost::filesystem::path</tt>.
+     *
+     * On POSIX \c string_type must be <tt>const char*</tt>,
+     * <tt>std::string</tt> or <tt>boost::filesystem::path</tt>.
+     */
+    explicit start_in_dir(const string_type &s);
+};
+
+/**
+ * Throws an error if a child process can't be created.
+ *
+ * The type of the error thrown is \c boost::system::system_error.
+ */
+class throw_on_error : public initializer_base
+{
+public:
+};
+
+}}}
+#endif
+
+#endif
diff --git a/dep/process/boost/process/mitigate.hpp b/dep/process/boost/process/mitigate.hpp
new file mode 100644
index 00000000000..6838984aa1a
--- /dev/null
+++ b/dep/process/boost/process/mitigate.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)
+
+/**
+ * \file boost/process/mitigate.hpp
+ *
+ * Helpers to mitigate platform differences.
+ */
+
+#ifndef BOOST_PROCESS_MITIGATE_HPP
+#define BOOST_PROCESS_MITIGATE_HPP
+
+#include <boost/asio.hpp>
+#if defined(BOOST_POSIX_API)
+#   include <sys/wait.h>
+#endif
+
+namespace boost { namespace process {
+
+#if defined(BOOST_WINDOWS_API)
+typedef boost::asio::windows::stream_handle pipe_end;
+#elif defined(BOOST_POSIX_API)
+typedef boost::asio::posix::stream_descriptor pipe_end;
+#endif
+
+inline const char *zero_device()
+{
+#if defined(BOOST_WINDOWS_API)
+    return "NUL";
+#elif defined(BOOST_POSIX_API)
+    return "/dev/zero";
+#endif
+}
+
+inline const char *null_device()
+{
+#if defined(BOOST_WINDOWS_API)
+    return "NUL";
+#elif defined(BOOST_POSIX_API)
+    return "/dev/null";
+#endif
+}
+
+#if defined(BOOST_WINDOWS_API)
+#   define BOOST_PROCESS_EXITSTATUS(a) static_cast<int>(a)
+#elif defined(BOOST_POSIX_API)
+#   define BOOST_PROCESS_EXITSTATUS WEXITSTATUS
+#endif
+
+#if defined(BOOST_PROCESS_DOXYGEN)
+/**
+ * Type definition for the end of a pipe.
+ *
+ * On Windows the type is based on boost::asio::windows::stream_handle. On
+ * POSIX it is based on boost::asio::posix::stream_descriptor.
+ *
+ * You can use this type definition for asynchronous I/O with streams of
+ * child processes.
+ */
+typedef boost_asio_type pipe_end;
+
+/**
+ * Gets the name of the zero device.
+ *
+ * You can use zero_device to initialize a
+ * boost::iostreams::file_descriptor_source to read
+ * null characters from.
+ *
+ * \returns NUL on Windows and /dev/zero on POSIX.
+ */
+const char *zero_device();
+
+/**
+ * Gets the name of the null device.
+ *
+ * You can use null_device to initialize a
+ * boost::iostreams::file_descriptor_sink which discards
+ * data written to it.
+ *
+ * \returns NUL on Windows and /dev/null on POSIX.
+ */
+const char *null_device();
+
+/**
+ * \def BOOST_PROCESS_EXITSTATUS
+ *
+ * On Windows \c BOOST_PROCESS_EXITSTATUS is a static cast to \c int.
+ * On POSIX it is set to \c WEXITSTATUS.
+ *
+ * You can use \c BOOST_PROCESS_EXITSTATUS for the return value of
+ * boost::process::wait_for_exit to get the exit status of a process.
+ */
+#define BOOST_PROCESS_EXITSTATUS
+#endif
+
+}}
+
+#endif
diff --git a/dep/process/boost/process/pipe.hpp b/dep/process/boost/process/pipe.hpp
new file mode 100644
index 00000000000..35f2a4470d6
--- /dev/null
+++ b/dep/process/boost/process/pipe.hpp
@@ -0,0 +1,64 @@
+// 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)
+
+/**
+ * \file boost/process/pipe.hpp
+ *
+ * Defines a pipe.
+ */
+
+#ifndef BOOST_PROCESS_PIPE_HPP
+#define BOOST_PROCESS_PIPE_HPP
+
+#include <boost/process/config.hpp>
+
+#include BOOST_PROCESS_PLATFORM_PROMOTE_PATH(pipe)
+BOOST_PROCESS_PLATFORM_PROMOTE_NAMESPACE(pipe)
+BOOST_PROCESS_PLATFORM_PROMOTE_NAMESPACE(make_pipe)
+
+#if defined(BOOST_PROCESS_DOXYGEN)
+namespace boost { namespace process {
+
+/**
+ * Represents a pipe.
+ */
+struct pipe
+{
+    /**
+     * Read-end.
+     */
+    pipe_end_type source;
+
+    /**
+     * Write-end.
+     */
+    pipe_end_type sink;
+
+    /**
+     * Constructor.
+     */
+    pipe(pipe_end_type source, pipe_end_type sink);
+};
+
+/**
+ * Returns a pipe instance.
+ *
+ * This is a helper function to instantiate boost::process::pipe.
+ *
+ * \note boost::process::make_pipe does not create a pipe.
+ *       You must pass existing pipe ends to this function.
+ *       If you want to create an anonymous pipe, call
+ *       boost::process::create_pipe.
+ */
+pipe make_pipe(pipe_end_type source, pipe_end_type sink);
+
+}}
+#endif
+
+#endif
diff --git a/dep/process/boost/process/posix/child.hpp b/dep/process/boost/process/posix/child.hpp
new file mode 100644
index 00000000000..913484529e8
--- /dev/null
+++ b/dep/process/boost/process/posix/child.hpp
@@ -0,0 +1,26 @@
+// 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_POSIX_CHILD_HPP
+#define BOOST_PROCESS_POSIX_CHILD_HPP
+
+#include <sys/types.h>
+
+namespace boost { namespace process { namespace posix {
+
+struct child
+{
+    pid_t pid;
+
+    explicit child(pid_t p) : pid(p) {}
+};
+
+}}}
+
+#endif
diff --git a/dep/process/boost/process/posix/create_pipe.hpp b/dep/process/boost/process/posix/create_pipe.hpp
new file mode 100644
index 00000000000..ecdd523516f
--- /dev/null
+++ b/dep/process/boost/process/posix/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_POSIX_CREATE_PIPE_HPP
+#define BOOST_PROCESS_POSIX_CREATE_PIPE_HPP
+
+#include <boost/process/config.hpp>
+#include <boost/process/posix/pipe.hpp>
+#include <boost/system/error_code.hpp>
+#include <unistd.h>
+
+namespace boost { namespace process { namespace posix {
+
+inline pipe create_pipe()
+{
+    int fds[2];
+    if (::pipe(fds) == -1)
+        BOOST_PROCESS_THROW_LAST_SYSTEM_ERROR("pipe(2) failed");
+    return pipe(fds[0], fds[1]);
+}
+
+inline pipe create_pipe(boost::system::error_code &ec)
+{
+    int fds[2];
+    if (::pipe(fds) == -1)
+        BOOST_PROCESS_RETURN_LAST_SYSTEM_ERROR(ec);
+    else
+        ec.clear();
+    return pipe(fds[0], fds[1]);
+}
+
+}}}
+
+#endif
diff --git a/dep/process/boost/process/posix/execute.hpp b/dep/process/boost/process/posix/execute.hpp
new file mode 100644
index 00000000000..27082196c8a
--- /dev/null
+++ b/dep/process/boost/process/posix/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_POSIX_EXECUTE_HPP
+#define BOOST_PROCESS_POSIX_EXECUTE_HPP
+
+#include <boost/process/posix/executor.hpp>
+#include <boost/process/posix/child.hpp>
+#include <boost/fusion/tuple/make_tuple.hpp>
+#include <boost/ref.hpp>
+
+namespace boost { namespace process { namespace posix {
+
+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
diff --git a/dep/process/boost/process/posix/executor.hpp b/dep/process/boost/process/posix/executor.hpp
new file mode 100644
index 00000000000..a3e81f128f5
--- /dev/null
+++ b/dep/process/boost/process/posix/executor.hpp
@@ -0,0 +1,120 @@
+// 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_POSIX_EXECUTOR_HPP
+#define BOOST_PROCESS_POSIX_EXECUTOR_HPP
+
+#include <boost/process/posix/child.hpp>
+#include <boost/fusion/algorithm/iteration/for_each.hpp>
+#include <cstdlib>
+#include <sys/types.h>
+#include <unistd.h>
+
+namespace boost { namespace process { namespace posix {
+
+struct executor
+{
+    executor() : exe(0), cmd_line(0), env(0) {}
+
+    struct call_on_fork_setup
+    {
+        executor &e_;
+
+        call_on_fork_setup(executor &e) : e_(e) {}
+
+        template <class Arg>
+        void operator()(const Arg &arg) const
+        {
+            arg.on_fork_setup(e_);
+        }
+    };
+
+    struct call_on_fork_error
+    {
+        executor &e_;
+
+        call_on_fork_error(executor &e) : e_(e) {}
+
+        template <class Arg>
+        void operator()(Arg &arg) const
+        {
+            arg.on_fork_error(e_);
+        }
+    };
+
+    struct call_on_fork_success
+    {
+        executor &e_;
+
+        call_on_fork_success(executor &e) : e_(e) {}
+
+        template <class Arg>
+        void operator()(Arg &arg) const
+        {
+            arg.on_fork_success(e_);
+        }
+    };
+
+    struct call_on_exec_setup
+    {
+        executor &e_;
+
+        call_on_exec_setup(executor &e) : e_(e) {}
+
+        template <class Arg>
+        void operator()(Arg &arg) const
+        {
+            arg.on_exec_setup(e_);
+        }
+    };
+
+    struct call_on_exec_error
+    {
+        executor &e_;
+
+        call_on_exec_error(executor &e) : e_(e) {}
+
+        template <class Arg>
+        void operator()(Arg &arg) const
+        {
+            arg.on_exec_error(e_);
+        }
+    };
+
+    template <class InitializerSequence>
+    child operator()(const InitializerSequence &seq)
+    {
+        boost::fusion::for_each(seq, call_on_fork_setup(*this));
+
+        pid_t pid = ::fork();
+        if (pid == -1)
+        {
+            boost::fusion::for_each(seq, call_on_fork_error(*this));
+        }
+        else if (pid == 0)
+        {
+            boost::fusion::for_each(seq, call_on_exec_setup(*this));
+            ::execve(exe, cmd_line, env);
+            boost::fusion::for_each(seq, call_on_exec_error(*this));
+            _exit(EXIT_FAILURE);
+        }
+
+        boost::fusion::for_each(seq, call_on_fork_success(*this));
+
+        return child(pid);
+    }
+
+    const char *exe;
+    char **cmd_line;
+    char **env;
+};
+
+}}}
+
+#endif
diff --git a/dep/process/boost/process/posix/initializers.hpp b/dep/process/boost/process/posix/initializers.hpp
new file mode 100644
index 00000000000..78295c14cb6
--- /dev/null
+++ b/dep/process/boost/process/posix/initializers.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_POSIX_INITIALIZERS_HPP
+#define BOOST_PROCESS_POSIX_INITIALIZERS_HPP
+
+#include <boost/process/posix/initializers/bind_fd.hpp>
+#include <boost/process/posix/initializers/bind_stderr.hpp>
+#include <boost/process/posix/initializers/bind_stdin.hpp>
+#include <boost/process/posix/initializers/bind_stdout.hpp>
+#include <boost/process/posix/initializers/close_fd.hpp>
+#include <boost/process/posix/initializers/close_fds.hpp>
+#include <boost/process/posix/initializers/close_fds_if.hpp>
+#include <boost/process/posix/initializers/close_stderr.hpp>
+#include <boost/process/posix/initializers/close_stdin.hpp>
+#include <boost/process/posix/initializers/close_stdout.hpp>
+#include <boost/process/posix/initializers/hide_console.hpp>
+#include <boost/process/posix/initializers/inherit_env.hpp>
+#include <boost/process/posix/initializers/notify_io_service.hpp>
+#include <boost/process/posix/initializers/on_exec_error.hpp>
+#include <boost/process/posix/initializers/on_exec_setup.hpp>
+#include <boost/process/posix/initializers/on_fork_error.hpp>
+#include <boost/process/posix/initializers/on_fork_setup.hpp>
+#include <boost/process/posix/initializers/on_fork_success.hpp>
+#include <boost/process/posix/initializers/run_exe.hpp>
+#include <boost/process/posix/initializers/set_args.hpp>
+#include <boost/process/posix/initializers/set_cmd_line.hpp>
+#include <boost/process/posix/initializers/set_env.hpp>
+#include <boost/process/posix/initializers/set_on_error.hpp>
+#include <boost/process/posix/initializers/start_in_dir.hpp>
+#include <boost/process/posix/initializers/throw_on_error.hpp>
+
+#endif
diff --git a/dep/process/boost/process/posix/initializers/bind_fd.hpp b/dep/process/boost/process/posix/initializers/bind_fd.hpp
new file mode 100644
index 00000000000..851b7ef3e44
--- /dev/null
+++ b/dep/process/boost/process/posix/initializers/bind_fd.hpp
@@ -0,0 +1,43 @@
+// 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_POSIX_INITIALIZERS_BIND_FD_HPP
+#define BOOST_PROCESS_POSIX_INITIALIZERS_BIND_FD_HPP
+
+#include <boost/process/posix/initializers/initializer_base.hpp>
+#include <unistd.h>
+
+namespace boost { namespace process { namespace posix { namespace initializers {
+
+template <class FileDescriptor>
+class bind_fd_ : public initializer_base
+{
+public:
+    bind_fd_(int id, const FileDescriptor &fd) : id_(id), fd_(fd) {}
+
+    template <class PosixExecutor>
+    void on_exec_setup(PosixExecutor&) const
+    {
+        ::dup2(fd_.handle(), id_);
+    }
+
+private:
+    int id_;
+    FileDescriptor fd_;
+};
+
+template <class FileDescriptor>
+bind_fd_<FileDescriptor> bind_fd(int id, const FileDescriptor &fd)
+{
+    return bind_fd_<FileDescriptor>(id, fd);
+}
+
+}}}}
+
+#endif
diff --git a/dep/process/boost/process/posix/initializers/bind_stderr.hpp b/dep/process/boost/process/posix/initializers/bind_stderr.hpp
new file mode 100644
index 00000000000..be767bf2fe1
--- /dev/null
+++ b/dep/process/boost/process/posix/initializers/bind_stderr.hpp
@@ -0,0 +1,37 @@
+// 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_POSIX_INITIALIZERS_BIND_STDERR_HPP
+#define BOOST_PROCESS_POSIX_INITIALIZERS_BIND_STDERR_HPP
+
+#include <boost/process/posix/initializers/initializer_base.hpp>
+#include <boost/iostreams/device/file_descriptor.hpp>
+#include <unistd.h>
+
+namespace boost { namespace process { namespace posix { namespace initializers {
+
+class bind_stderr : public initializer_base
+{
+public:
+    explicit bind_stderr(const boost::iostreams::file_descriptor_sink &sink)
+        : sink_(sink) {}
+
+    template <class PosixExecutor>
+    void on_exec_setup(PosixExecutor&) const
+    {
+        ::dup2(sink_.handle(), STDERR_FILENO);
+    }
+
+private:
+    boost::iostreams::file_descriptor_sink sink_;
+};
+
+}}}}
+
+#endif
diff --git a/dep/process/boost/process/posix/initializers/bind_stdin.hpp b/dep/process/boost/process/posix/initializers/bind_stdin.hpp
new file mode 100644
index 00000000000..b592d6f8b38
--- /dev/null
+++ b/dep/process/boost/process/posix/initializers/bind_stdin.hpp
@@ -0,0 +1,37 @@
+// 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_POSIX_INITIALIZERS_BIND_STDIN_HPP
+#define BOOST_PROCESS_POSIX_INITIALIZERS_BIND_STDIN_HPP
+
+#include <boost/process/posix/initializers/initializer_base.hpp>
+#include <boost/iostreams/device/file_descriptor.hpp>
+#include <unistd.h>
+
+namespace boost { namespace process { namespace posix { namespace initializers {
+
+class bind_stdin : public initializer_base
+{
+public:
+    explicit bind_stdin(const boost::iostreams::file_descriptor_source &source)
+        : source_(source) {}
+
+    template <class PosixExecutor>
+    void on_exec_setup(PosixExecutor&) const
+    {
+        ::dup2(source_.handle(), STDIN_FILENO);
+    }
+
+private:
+    boost::iostreams::file_descriptor_source source_;
+};
+
+}}}}
+
+#endif
diff --git a/dep/process/boost/process/posix/initializers/bind_stdout.hpp b/dep/process/boost/process/posix/initializers/bind_stdout.hpp
new file mode 100644
index 00000000000..a2c316d9972
--- /dev/null
+++ b/dep/process/boost/process/posix/initializers/bind_stdout.hpp
@@ -0,0 +1,37 @@
+// 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_POSIX_INITIALIZERS_BIND_STDOUT_HPP
+#define BOOST_PROCESS_POSIX_INITIALIZERS_BIND_STDOUT_HPP
+
+#include <boost/process/posix/initializers/initializer_base.hpp>
+#include <boost/iostreams/device/file_descriptor.hpp>
+#include <unistd.h>
+
+namespace boost { namespace process { namespace posix { namespace initializers {
+
+class bind_stdout : public initializer_base
+{
+public:
+    explicit bind_stdout(const boost::iostreams::file_descriptor_sink &sink)
+        : sink_(sink) {}
+
+    template <class PosixExecutor>
+    void on_exec_setup(PosixExecutor&) const
+    {
+        ::dup2(sink_.handle(), STDOUT_FILENO);
+    }
+
+private:
+    boost::iostreams::file_descriptor_sink sink_;
+};
+
+}}}}
+
+#endif
diff --git a/dep/process/boost/process/posix/initializers/close_fd.hpp b/dep/process/boost/process/posix/initializers/close_fd.hpp
new file mode 100644
index 00000000000..fd516e41005
--- /dev/null
+++ b/dep/process/boost/process/posix/initializers/close_fd.hpp
@@ -0,0 +1,35 @@
+// 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_POSIX_INITIALIZERS_CLOSE_FD_HPP
+#define BOOST_PROCESS_POSIX_INITIALIZERS_CLOSE_FD_HPP
+
+#include <boost/process/posix/initializers/initializer_base.hpp>
+#include <unistd.h>
+
+namespace boost { namespace process { namespace posix { namespace initializers {
+
+class close_fd : public initializer_base
+{
+public:
+    explicit close_fd(int fd) : fd_(fd) {}
+
+    template <class PosixExecutor>
+    void on_exec_setup(PosixExecutor&) const
+    {
+        ::close(fd_);
+    }
+
+private:
+    int fd_;
+};
+
+}}}}
+
+#endif
diff --git a/dep/process/boost/process/posix/initializers/close_fds.hpp b/dep/process/boost/process/posix/initializers/close_fds.hpp
new file mode 100644
index 00000000000..2fa338501eb
--- /dev/null
+++ b/dep/process/boost/process/posix/initializers/close_fds.hpp
@@ -0,0 +1,43 @@
+// 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_POSIX_INITIALIZERS_CLOSE_FDS_HPP
+#define BOOST_PROCESS_POSIX_INITIALIZERS_CLOSE_FDS_HPP
+
+#include <boost/process/posix/initializers/initializer_base.hpp>
+#include <boost/range/algorithm/for_each.hpp>
+#include <unistd.h>
+
+namespace boost { namespace process { namespace posix { namespace initializers {
+
+template <class Range>
+class close_fds_ : public initializer_base
+{
+public:
+    explicit close_fds_(const Range &fds) : fds_(fds) {}
+
+    template <class PosixExecutor>
+    void on_exec_setup(PosixExecutor&) const
+    {
+        boost::for_each(fds_, ::close);
+    }
+
+private:
+    Range fds_;
+};
+
+template <class Range>
+close_fds_<Range> close_fds(const Range &fds)
+{
+    return close_fds_<Range>(fds);
+}
+
+}}}}
+
+#endif
diff --git a/dep/process/boost/process/posix/initializers/close_fds_if.hpp b/dep/process/boost/process/posix/initializers/close_fds_if.hpp
new file mode 100644
index 00000000000..fb3a651d628
--- /dev/null
+++ b/dep/process/boost/process/posix/initializers/close_fds_if.hpp
@@ -0,0 +1,80 @@
+// 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_POSIX_INITIALIZERS_CLOSE_FDS_IF_HPP
+#define BOOST_PROCESS_POSIX_INITIALIZERS_CLOSE_FDS_IF_HPP
+
+#include <boost/process/posix/initializers/initializer_base.hpp>
+#include <boost/iterator/counting_iterator.hpp>
+#include <boost/range/counting_range.hpp>
+#include <boost/range/adaptor/filtered.hpp>
+#include <boost/range/algorithm/for_each.hpp>
+#include <unistd.h>
+#include <fcntl.h>
+#include <errno.h>
+
+#ifndef BOOST_PROCESS_POSIX_MAX_FD
+#   define BOOST_PROCESS_POSIX_MAX_FD 32
+#endif
+
+namespace boost { namespace process { namespace posix { namespace initializers {
+
+template <class Predicate>
+class close_fds_if_ : public initializer_base
+{
+private:
+    static void close(int fd)
+    {
+        ::fcntl(fd, F_SETFD, FD_CLOEXEC);
+    }
+
+public:
+    explicit close_fds_if_(const Predicate &pred) : pred_(pred) {}
+
+    template <class PosixExecutor>
+    void on_exec_setup(PosixExecutor&) const
+    {
+        boost::for_each(
+            boost::adaptors::filter(
+                boost::counting_range(0, upper_bound()),
+                pred_
+            ),
+            close
+        );
+    }
+
+private:
+    static int upper_bound()
+    {
+        int up;
+#if defined(F_MAXFD)
+        do
+        {
+            up = ::fcntl(0, F_MAXFD);
+        } while (up == -1 && errno == EINTR);
+        if (up == -1)
+#endif
+            up = ::sysconf(_SC_OPEN_MAX);
+        if (up == -1)
+            up = BOOST_PROCESS_POSIX_MAX_FD;
+        return up;
+    }
+
+    Predicate pred_;
+};
+
+template <class Predicate>
+close_fds_if_<Predicate> close_fds_if(const Predicate &pred)
+{
+    return close_fds_if_<Predicate>(pred);
+}
+
+}}}}
+
+#endif
diff --git a/dep/process/boost/process/posix/initializers/close_stderr.hpp b/dep/process/boost/process/posix/initializers/close_stderr.hpp
new file mode 100644
index 00000000000..1a4c2ad00df
--- /dev/null
+++ b/dep/process/boost/process/posix/initializers/close_stderr.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_POSIX_INITIALIZERS_CLOSE_STDERR_HPP
+#define BOOST_PROCESS_POSIX_INITIALIZERS_CLOSE_STDERR_HPP
+
+#include <boost/process/posix/initializers/initializer_base.hpp>
+#include <unistd.h>
+
+namespace boost { namespace process { namespace posix { namespace initializers {
+
+class close_stderr : public initializer_base
+{
+public:
+    template <class PosixExecutor>
+    void on_exec_setup(PosixExecutor&) const
+    {
+        ::close(STDERR_FILENO);
+    }
+};
+
+}}}}
+
+#endif
diff --git a/dep/process/boost/process/posix/initializers/close_stdin.hpp b/dep/process/boost/process/posix/initializers/close_stdin.hpp
new file mode 100644
index 00000000000..021c3ec54df
--- /dev/null
+++ b/dep/process/boost/process/posix/initializers/close_stdin.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_POSIX_INITIALIZERS_CLOSE_STDIN_HPP
+#define BOOST_PROCESS_POSIX_INITIALIZERS_CLOSE_STDIN_HPP
+
+#include <boost/process/posix/initializers/initializer_base.hpp>
+#include <unistd.h>
+
+namespace boost { namespace process { namespace posix { namespace initializers {
+
+class close_stdin : public initializer_base
+{
+public:
+    template <class PosixExecutor>
+    void on_exec_setup(PosixExecutor&) const
+    {
+        ::close(STDIN_FILENO);
+    }
+};
+
+}}}}
+
+#endif
diff --git a/dep/process/boost/process/posix/initializers/close_stdout.hpp b/dep/process/boost/process/posix/initializers/close_stdout.hpp
new file mode 100644
index 00000000000..cfab7d1d62f
--- /dev/null
+++ b/dep/process/boost/process/posix/initializers/close_stdout.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_POSIX_INITIALIZERS_CLOSE_STDOUT_HPP
+#define BOOST_PROCESS_POSIX_INITIALIZERS_CLOSE_STDOUT_HPP
+
+#include <boost/process/posix/initializers/initializer_base.hpp>
+#include <unistd.h>
+
+namespace boost { namespace process { namespace posix { namespace initializers {
+
+class close_stdout : public initializer_base
+{
+public:
+    template <class PosixExecutor>
+    void on_exec_setup(PosixExecutor&) const
+    {
+        ::close(STDOUT_FILENO);
+    }
+};
+
+}}}}
+
+#endif
diff --git a/dep/process/boost/process/posix/initializers/hide_console.hpp b/dep/process/boost/process/posix/initializers/hide_console.hpp
new file mode 100644
index 00000000000..20d527b457f
--- /dev/null
+++ b/dep/process/boost/process/posix/initializers/hide_console.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_POSIX_INITIALIZERS_HIDE_CONSOLE_HPP
+#define BOOST_PROCESS_POSIX_INITIALIZERS_HIDE_CONSOLE_HPP
+
+#include <boost/process/posix/initializers/initializer_base.hpp>
+
+namespace boost { namespace process { namespace posix { namespace initializers {
+
+class hide_console : public initializer_base
+{
+public:
+};
+
+}}}}
+
+#endif
diff --git a/dep/process/boost/process/posix/initializers/inherit_env.hpp b/dep/process/boost/process/posix/initializers/inherit_env.hpp
new file mode 100644
index 00000000000..bc73c8571f8
--- /dev/null
+++ b/dep/process/boost/process/posix/initializers/inherit_env.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_POSIX_INITIALIZERS_INHERIT_ENV_HPP
+#define BOOST_PROCESS_POSIX_INITIALIZERS_INHERIT_ENV_HPP
+
+#include <boost/process/posix/initializers/initializer_base.hpp>
+// From <https://svn.boost.org/trac/boost/changeset/67768>
+#if defined(__APPLE__) && defined(__DYNAMIC__)
+extern "C" { extern char ***_NSGetEnviron(void); }
+#   define environ (*_NSGetEnviron())
+#else
+#   include <unistd.h>
+#endif
+
+namespace boost { namespace process { namespace posix { namespace initializers {
+
+class inherit_env : public initializer_base
+{
+public:
+    template <class PosixExecutor>
+    void on_fork_setup(PosixExecutor &e) const
+    {
+        e.env = environ;
+    }
+};
+
+}}}}
+
+#endif
diff --git a/dep/process/boost/process/posix/initializers/initializer_base.hpp b/dep/process/boost/process/posix/initializers/initializer_base.hpp
new file mode 100644
index 00000000000..775f00e48ce
--- /dev/null
+++ b/dep/process/boost/process/posix/initializers/initializer_base.hpp
@@ -0,0 +1,35 @@
+// 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_POSIX_INITIALIZERS_INITIALIZER_BASE_HPP
+#define BOOST_PROCESS_POSIX_INITIALIZERS_INITIALIZER_BASE_HPP
+
+namespace boost { namespace process { namespace posix { namespace initializers {
+
+struct initializer_base
+{
+    template <class PosixExecutor>
+    void on_fork_setup(PosixExecutor&) const {}
+
+    template <class PosixExecutor>
+    void on_fork_error(PosixExecutor&) const {}
+
+    template <class PosixExecutor>
+    void on_fork_success(PosixExecutor&) const {}
+
+    template <class PosixExecutor>
+    void on_exec_setup(PosixExecutor&) const {}
+
+    template <class PosixExecutor>
+    void on_exec_error(PosixExecutor&) const {}
+};
+
+}}}}
+
+#endif
diff --git a/dep/process/boost/process/posix/initializers/notify_io_service.hpp b/dep/process/boost/process/posix/initializers/notify_io_service.hpp
new file mode 100644
index 00000000000..d94f674c81a
--- /dev/null
+++ b/dep/process/boost/process/posix/initializers/notify_io_service.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_POSIX_INITIALIZERS_NOTIFY_IO_SERVICE_HPP
+#define BOOST_PROCESS_POSIX_INITIALIZERS_NOTIFY_IO_SERVICE_HPP
+
+#include <boost/process/config.hpp>
+#include <boost/process/posix/initializers/initializer_base.hpp>
+
+namespace boost { namespace process { namespace posix { namespace initializers {
+
+template <class IOService>
+class notify_io_service_ : public initializer_base
+{
+public:
+    explicit notify_io_service_(IOService &io_service) :
+        io_service_(io_service) {}
+
+    template <class PosixExecutor>
+    void on_fork_setup(PosixExecutor&) const
+    {
+        io_service_.notify_fork(IOService::fork_prepare);
+    }
+
+    template <class PosixExecutor>
+    void on_fork_success(PosixExecutor&) const
+    {
+        io_service_.notify_fork(IOService::fork_parent);
+    }
+
+    template <class PosixExecutor>
+    void on_exec_setup(PosixExecutor&) const
+    {
+        io_service_.notify_fork(IOService::fork_child);
+    }
+
+private:
+    IOService &io_service_;
+};
+
+template <class IOService>
+notify_io_service_<IOService> notify_io_service(IOService &io_service)
+{
+    return notify_io_service_<IOService>(io_service);
+}
+
+}}}}
+
+#endif
diff --git a/dep/process/boost/process/posix/initializers/on_exec_error.hpp b/dep/process/boost/process/posix/initializers/on_exec_error.hpp
new file mode 100644
index 00000000000..63b56def4f2
--- /dev/null
+++ b/dep/process/boost/process/posix/initializers/on_exec_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_POSIX_INITIALIZERS_ON_EXEC_ERROR_HPP
+#define BOOST_PROCESS_POSIX_INITIALIZERS_ON_EXEC_ERROR_HPP
+
+#include <boost/process/config.hpp>
+#include <boost/process/posix/initializers/initializer_base.hpp>
+
+namespace boost { namespace process { namespace posix { namespace initializers {
+
+template <class Handler>
+class on_exec_error_ : public initializer_base
+{
+public:
+    explicit on_exec_error_(Handler handler) : handler_(handler) {}
+
+    template <class PosixExecutor>
+    void on_exec_error(PosixExecutor &e) const
+    {
+        handler_(e);
+    }
+
+private:
+    Handler handler_;
+};
+
+template <class Handler>
+on_exec_error_<Handler> on_exec_error(Handler handler)
+{
+    return on_exec_error_<Handler>(handler);
+}
+
+}}}}
+
+#endif
diff --git a/dep/process/boost/process/posix/initializers/on_exec_setup.hpp b/dep/process/boost/process/posix/initializers/on_exec_setup.hpp
new file mode 100644
index 00000000000..50f5f3736b1
--- /dev/null
+++ b/dep/process/boost/process/posix/initializers/on_exec_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_POSIX_INITIALIZERS_ON_EXEC_SETUP_HPP
+#define BOOST_PROCESS_POSIX_INITIALIZERS_ON_EXEC_SETUP_HPP
+
+#include <boost/process/config.hpp>
+#include <boost/process/posix/initializers/initializer_base.hpp>
+
+namespace boost { namespace process { namespace posix { namespace initializers {
+
+template <class Handler>
+class on_exec_setup_ : public initializer_base
+{
+public:
+    explicit on_exec_setup_(Handler handler) : handler_(handler) {}
+
+    template <class PosixExecutor>
+    void on_exec_setup(PosixExecutor &e) const
+    {
+        handler_(e);
+    }
+
+private:
+    Handler handler_;
+};
+
+template <class Handler>
+on_exec_setup_<Handler> on_exec_setup(Handler handler)
+{
+    return on_exec_setup_<Handler>(handler);
+}
+
+}}}}
+
+#endif
diff --git a/dep/process/boost/process/posix/initializers/on_fork_error.hpp b/dep/process/boost/process/posix/initializers/on_fork_error.hpp
new file mode 100644
index 00000000000..42ecf1aac91
--- /dev/null
+++ b/dep/process/boost/process/posix/initializers/on_fork_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_POSIX_INITIALIZERS_ON_FORK_ERROR_HPP
+#define BOOST_PROCESS_POSIX_INITIALIZERS_ON_FORK_ERROR_HPP
+
+#include <boost/process/config.hpp>
+#include <boost/process/posix/initializers/initializer_base.hpp>
+
+namespace boost { namespace process { namespace posix { namespace initializers {
+
+template <class Handler>
+class on_fork_error_ : public initializer_base
+{
+public:
+    explicit on_fork_error_(Handler handler) : handler_(handler) {}
+
+    template <class PosixExecutor>
+    void on_fork_error(PosixExecutor &e) const
+    {
+        handler_(e);
+    }
+
+private:
+    Handler handler_;
+};
+
+template <class Handler>
+on_fork_error_<Handler> on_fork_error(Handler handler)
+{
+    return on_fork_error_<Handler>(handler);
+}
+
+}}}}
+
+#endif
diff --git a/dep/process/boost/process/posix/initializers/on_fork_setup.hpp b/dep/process/boost/process/posix/initializers/on_fork_setup.hpp
new file mode 100644
index 00000000000..c0c5b0682f2
--- /dev/null
+++ b/dep/process/boost/process/posix/initializers/on_fork_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_POSIX_INITIALIZERS_ON_FORK_SETUP_HPP
+#define BOOST_PROCESS_POSIX_INITIALIZERS_ON_FORK_SETUP_HPP
+
+#include <boost/process/config.hpp>
+#include <boost/process/posix/initializers/initializer_base.hpp>
+
+namespace boost { namespace process { namespace posix { namespace initializers {
+
+template <class Handler>
+class on_fork_setup_ : public initializer_base
+{
+public:
+    explicit on_fork_setup_(Handler handler) : handler_(handler) {}
+
+    template <class PosixExecutor>
+    void on_fork_setup(PosixExecutor &e) const
+    {
+        handler_(e);
+    }
+
+private:
+    Handler handler_;
+};
+
+template <class Handler>
+on_fork_setup_<Handler> on_fork_setup(Handler handler)
+{
+    return on_fork_setup_<Handler>(handler);
+}
+
+}}}}
+
+#endif
diff --git a/dep/process/boost/process/posix/initializers/on_fork_success.hpp b/dep/process/boost/process/posix/initializers/on_fork_success.hpp
new file mode 100644
index 00000000000..01c9b12db06
--- /dev/null
+++ b/dep/process/boost/process/posix/initializers/on_fork_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_POSIX_INITIALIZERS_ON_FORK_SUCCESS_HPP
+#define BOOST_PROCESS_POSIX_INITIALIZERS_ON_FORK_SUCCESS_HPP
+
+#include <boost/process/config.hpp>
+#include <boost/process/posix/initializers/initializer_base.hpp>
+
+namespace boost { namespace process { namespace posix { namespace initializers {
+
+template <class Handler>
+class on_fork_success_ : public initializer_base
+{
+public:
+    explicit on_fork_success_(Handler handler) : handler_(handler) {}
+
+    template <class PosixExecutor>
+    void on_fork_success(PosixExecutor &e) const
+    {
+        handler_(e);
+    }
+
+private:
+    Handler handler_;
+};
+
+template <class Handler>
+on_fork_success_<Handler> on_fork_success(Handler handler)
+{
+    return on_fork_success_<Handler>(handler);
+}
+
+}}}}
+
+#endif
diff --git a/dep/process/boost/process/posix/initializers/run_exe.hpp b/dep/process/boost/process/posix/initializers/run_exe.hpp
new file mode 100644
index 00000000000..6cceeea8c15
--- /dev/null
+++ b/dep/process/boost/process/posix/initializers/run_exe.hpp
@@ -0,0 +1,59 @@
+// 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_POSIX_INITIALIZERS_RUN_EXE_HPP
+#define BOOST_PROCESS_POSIX_INITIALIZERS_RUN_EXE_HPP
+
+#include <boost/process/posix/initializers/initializer_base.hpp>
+#include <boost/filesystem.hpp>
+#include <boost/shared_array.hpp>
+#include <string>
+
+namespace boost { namespace process { namespace posix { namespace initializers {
+
+class run_exe_ : public initializer_base
+{
+public:
+    explicit run_exe_(const std::string &s) : s_(s), cmd_line_(new char*[2])
+    {
+        cmd_line_[0] = const_cast<char*>(s_.c_str());
+        cmd_line_[1] = 0;
+    }
+
+    template <class PosixExecutor>
+    void on_exec_setup(PosixExecutor &e) const
+    {
+        e.exe = s_.c_str();
+        if (!e.cmd_line)
+            e.cmd_line = cmd_line_.get();
+    }
+
+private:
+    std::string s_;
+    boost::shared_array<char*> cmd_line_;
+};
+
+inline run_exe_ run_exe(const char *s)
+{
+    return run_exe_(s);
+}
+
+inline run_exe_ run_exe(const std::string &s)
+{
+    return run_exe_(s);
+}
+
+inline run_exe_ run_exe(const boost::filesystem::path &p)
+{
+    return run_exe_(p.string());
+}
+
+}}}}
+
+#endif
diff --git a/dep/process/boost/process/posix/initializers/set_args.hpp b/dep/process/boost/process/posix/initializers/set_args.hpp
new file mode 100644
index 00000000000..294926dc222
--- /dev/null
+++ b/dep/process/boost/process/posix/initializers/set_args.hpp
@@ -0,0 +1,57 @@
+// 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_POSIX_INITIALIZERS_SET_ARGS_HPP
+#define BOOST_PROCESS_POSIX_INITIALIZERS_SET_ARGS_HPP
+
+#include <boost/process/posix/initializers/initializer_base.hpp>
+#include <boost/range/algorithm/transform.hpp>
+#include <boost/shared_array.hpp>
+#include <string>
+
+namespace boost { namespace process { namespace posix { namespace initializers {
+
+template <class Range>
+class set_args_ : public initializer_base
+{
+private:
+    static char *c_str(const std::string &s)
+    {
+        return const_cast<char*>(s.c_str());
+    }
+
+public:
+    explicit set_args_(const Range &args)
+    {
+        args_.reset(new char*[args.size() + 1]);
+        boost::transform(args, args_.get(), c_str);
+        args_[args.size()] = 0;
+    }
+
+    template <class PosixExecutor>
+    void on_exec_setup(PosixExecutor &e) const
+    {
+        e.cmd_line = args_.get();
+        if (!e.exe && *args_[0])
+            e.exe = args_[0];
+    }
+
+private:
+    boost::shared_array<char*> args_;
+};
+
+template <class Range>
+set_args_<Range> set_args(const Range &range)
+{
+    return set_args_<Range>(range);
+}
+
+}}}}
+
+#endif
diff --git a/dep/process/boost/process/posix/initializers/set_cmd_line.hpp b/dep/process/boost/process/posix/initializers/set_cmd_line.hpp
new file mode 100644
index 00000000000..0f59d253594
--- /dev/null
+++ b/dep/process/boost/process/posix/initializers/set_cmd_line.hpp
@@ -0,0 +1,54 @@
+// 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_POSIX_INITIALIZERS_SET_CMD_LINE_HPP
+#define BOOST_PROCESS_POSIX_INITIALIZERS_SET_CMD_LINE_HPP
+
+#include <boost/process/posix/initializers/initializer_base.hpp>
+#include <boost/tokenizer.hpp>
+#include <boost/shared_array.hpp>
+#include <string>
+#include <vector>
+
+namespace boost { namespace process { namespace posix { namespace initializers {
+
+class set_cmd_line : public initializer_base
+{
+private:
+    static char *c_str(const std::string &s)
+    {
+        return const_cast<char*>(s.c_str());
+    }
+
+public:
+    explicit set_cmd_line(const std::string &s)
+    {
+        typedef boost::tokenizer<boost::escaped_list_separator<char> > tokenizer;
+        boost::escaped_list_separator<char> sep('\\', ' ', '\"');
+        tokenizer tok(s, sep);
+        args_.assign(tok.begin(), tok.end());
+        cmd_line_.reset(new char*[args_.size() + 1]);
+        boost::transform(args_, cmd_line_.get(), c_str);
+        cmd_line_[args_.size()] = 0;
+    }
+
+    template <class PosixExecutor>
+    void on_exec_setup(PosixExecutor &e) const
+    {
+        e.cmd_line = cmd_line_.get();
+    }
+
+private:
+    std::vector<std::string> args_;
+    boost::shared_array<char*> cmd_line_;
+};
+
+}}}}
+
+#endif
diff --git a/dep/process/boost/process/posix/initializers/set_env.hpp b/dep/process/boost/process/posix/initializers/set_env.hpp
new file mode 100644
index 00000000000..76649184f34
--- /dev/null
+++ b/dep/process/boost/process/posix/initializers/set_env.hpp
@@ -0,0 +1,54 @@
+// 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_POSIX_INITIALIZERS_SET_ENV_HPP
+#define BOOST_PROCESS_POSIX_INITIALIZERS_SET_ENV_HPP
+
+#include <boost/process/posix/initializers/initializer_base.hpp>
+#include <boost/range/algorithm/transform.hpp>
+#include <boost/shared_array.hpp>
+#include <string>
+
+namespace boost { namespace process { namespace posix { namespace initializers {
+
+template <class Range>
+class set_env_ : public initializer_base
+{
+private:
+    static char *get_ptr(const std::string &s)
+    {
+        return const_cast<char*>(s.c_str());
+    }
+
+public:
+    explicit set_env_(const Range &envs) : env_(new char*[envs.size() + 1])
+    {
+        boost::transform(envs, env_.get(), get_ptr);
+        env_[envs.size()] = 0;
+    }
+
+    template <class PosixExecutor>
+    void on_fork_setup(PosixExecutor &e) const
+    {
+        e.env = env_.get();
+    }
+
+private:
+    boost::shared_array<char*> env_;
+};
+
+template <class Range>
+set_env_<Range> set_env(const Range &envs)
+{
+    return set_env_<Range>(envs);
+}
+
+}}}}
+
+#endif
diff --git a/dep/process/boost/process/posix/initializers/set_on_error.hpp b/dep/process/boost/process/posix/initializers/set_on_error.hpp
new file mode 100644
index 00000000000..c01a816e603
--- /dev/null
+++ b/dep/process/boost/process/posix/initializers/set_on_error.hpp
@@ -0,0 +1,95 @@
+// 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_POSIX_INITIALIZERS_SET_ON_ERROR_HPP
+#define BOOST_PROCESS_POSIX_INITIALIZERS_SET_ON_ERROR_HPP
+
+#include <boost/process/config.hpp>
+#include <boost/process/posix/initializers/initializer_base.hpp>
+#include <boost/system/error_code.hpp>
+#include <unistd.h>
+#include <fcntl.h>
+#include <errno.h>
+
+namespace boost { namespace process { namespace posix { namespace initializers {
+
+class set_on_error : public initializer_base
+{
+public:
+    explicit set_on_error(boost::system::error_code &ec) : ec_(ec) {}
+
+    template <class PosixExecutor>
+    void on_fork_setup(PosixExecutor&) const
+    {
+        if (::pipe(fds_) == -1)
+            BOOST_PROCESS_RETURN_LAST_SYSTEM_ERROR(ec_);
+        if (::fcntl(fds_[1], F_SETFD, FD_CLOEXEC) == -1)
+        {
+            BOOST_PROCESS_RETURN_LAST_SYSTEM_ERROR(ec_);
+            ::close(fds_[0]);
+            ::close(fds_[1]);
+        }
+    }
+
+    template <class PosixExecutor>
+    void on_fork_error(PosixExecutor&) const
+    {
+        if (!ec_)
+        {
+            BOOST_PROCESS_RETURN_LAST_SYSTEM_ERROR(ec_);
+            ::close(fds_[0]);
+            ::close(fds_[1]);
+        }
+    }
+
+    template <class PosixExecutor>
+    void on_fork_success(PosixExecutor&) const
+    {
+        if (!ec_)
+        {
+            ::close(fds_[1]);
+            int code;
+            if (::read(fds_[0], &code, sizeof(int)) > 0)
+            {
+                ec_ = boost::system::error_code(code,
+                    boost::system::system_category());
+            }
+            ::close(fds_[0]);
+        }
+    }
+
+    template <class PosixExecutor>
+    void on_exec_setup(PosixExecutor&) const
+    {
+        if (!ec_)
+        {
+            ::close(fds_[0]);
+        }
+    }
+
+    template <class PosixExecutor>
+    void on_exec_error(PosixExecutor&) const
+    {
+        if (!ec_)
+        {
+            int e = errno;
+            while (::write(fds_[1], &e, sizeof(int)) == -1 && errno == EINTR)
+                ;
+            ::close(fds_[1]);
+        }
+    }
+
+private:
+    boost::system::error_code &ec_;
+    mutable int fds_[2];
+};
+
+}}}}
+
+#endif
diff --git a/dep/process/boost/process/posix/initializers/start_in_dir.hpp b/dep/process/boost/process/posix/initializers/start_in_dir.hpp
new file mode 100644
index 00000000000..187b5a31f44
--- /dev/null
+++ b/dep/process/boost/process/posix/initializers/start_in_dir.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_POSIX_INITIALIZERS_START_IN_DIR_HPP
+#define BOOST_PROCESS_POSIX_INITIALIZERS_START_IN_DIR_HPP
+
+#include <boost/process/posix/initializers/initializer_base.hpp>
+#include <string>
+#include <unistd.h>
+
+namespace boost { namespace process { namespace posix { namespace initializers {
+
+class start_in_dir : public initializer_base
+{
+public:
+    explicit start_in_dir(const std::string &s) : s_(s) {}
+
+    template <class PosixExecutor>
+    void on_exec_setup(PosixExecutor&) const
+    {
+        ::chdir(s_.c_str());
+    }
+
+private:
+    std::string s_;
+};
+
+}}}}
+
+#endif
diff --git a/dep/process/boost/process/posix/initializers/throw_on_error.hpp b/dep/process/boost/process/posix/initializers/throw_on_error.hpp
new file mode 100644
index 00000000000..7734c19e30b
--- /dev/null
+++ b/dep/process/boost/process/posix/initializers/throw_on_error.hpp
@@ -0,0 +1,90 @@
+// 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_POSIX_INITIALIZERS_THROW_ON_ERROR_HPP
+#define BOOST_PROCESS_POSIX_INITIALIZERS_THROW_ON_ERROR_HPP
+
+#include <boost/process/config.hpp>
+#include <boost/process/posix/initializers/initializer_base.hpp>
+#include <boost/system/error_code.hpp>
+#include <boost/system/system_error.hpp>
+#include <unistd.h>
+#include <fcntl.h>
+#include <errno.h>
+
+namespace boost { namespace process { namespace posix { namespace initializers {
+
+class throw_on_error : public initializer_base
+{
+public:
+    template <class PosixExecutor>
+    void on_fork_setup(PosixExecutor&) const
+    {
+        if (::pipe(fds_) == -1)
+            BOOST_PROCESS_THROW_LAST_SYSTEM_ERROR("pipe(2) failed");
+        if (::fcntl(fds_[1], F_SETFD, FD_CLOEXEC) == -1)
+        {
+            int e = errno;
+            ::close(fds_[0]);
+            ::close(fds_[1]);
+            BOOST_PROCESS_THROW(boost::system::system_error(
+                boost::system::error_code(e, boost::system::system_category()),
+                BOOST_PROCESS_SOURCE_LOCATION "fcntl(2) failed"));
+        }
+    }
+
+    template <class PosixExecutor>
+    void on_fork_error(PosixExecutor&) const
+    {
+        int e = errno;
+        ::close(fds_[0]);
+        ::close(fds_[1]);
+        BOOST_PROCESS_THROW(boost::system::system_error(
+            boost::system::error_code(e, boost::system::system_category()),
+            BOOST_PROCESS_SOURCE_LOCATION "fork(2) failed"));
+    }
+
+    template <class PosixExecutor>
+    void on_fork_success(PosixExecutor&) const
+    {
+        ::close(fds_[1]);
+        int code;
+        if (::read(fds_[0], &code, sizeof(int)) > 0)
+        {
+            ::close(fds_[0]);
+            BOOST_PROCESS_THROW(boost::system::system_error(
+                boost::system::error_code(code,
+                boost::system::system_category()),
+                BOOST_PROCESS_SOURCE_LOCATION "execve(2) failed"));
+        }
+        ::close(fds_[0]);
+    }
+
+    template <class PosixExecutor>
+    void on_exec_setup(PosixExecutor&) const
+    {
+        ::close(fds_[0]);
+    }
+
+    template <class PosixExecutor>
+    void on_exec_error(PosixExecutor&) const
+    {
+        int e = errno;
+        while (::write(fds_[1], &e, sizeof(int)) == -1 && errno == EINTR)
+            ;
+        ::close(fds_[1]);
+    }
+
+private:
+    mutable int fds_[2];
+};
+
+}}}}
+
+#endif
diff --git a/dep/process/boost/process/posix/pipe.hpp b/dep/process/boost/process/posix/pipe.hpp
new file mode 100644
index 00000000000..ca5b29447ab
--- /dev/null
+++ b/dep/process/boost/process/posix/pipe.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_POSIX_PIPE_HPP
+#define BOOST_PROCESS_POSIX_PIPE_HPP
+
+namespace boost { namespace process { namespace posix {
+
+struct pipe
+{
+    int source;
+    int sink;
+
+    pipe(int source, int sink) : source(source), sink(sink) {}
+};
+
+inline pipe make_pipe(int source, int sink)
+{
+    return pipe(source, sink);
+}
+
+}}}
+
+#endif
diff --git a/dep/process/boost/process/posix/search_path.hpp b/dep/process/boost/process/posix/search_path.hpp
new file mode 100644
index 00000000000..6dc2bea063d
--- /dev/null
+++ b/dep/process/boost/process/posix/search_path.hpp
@@ -0,0 +1,53 @@
+// 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_POSIX_SEARCH_PATH_HPP
+#define BOOST_PROCESS_POSIX_SEARCH_PATH_HPP
+
+#include <boost/process/config.hpp>
+#include <boost/filesystem.hpp>
+#include <boost/tokenizer.hpp>
+#include <string>
+#include <stdexcept>
+#include <stdlib.h>
+#include <unistd.h>
+
+namespace boost { namespace process { namespace posix {
+
+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"));
+    }
+
+    std::string result;
+    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;
+        if (!::access(p.c_str(), X_OK))
+        {
+            result = p.string();
+            break;
+        }
+    }
+    return result;
+}
+
+}}}
+
+#endif
diff --git a/dep/process/boost/process/posix/shell_path.hpp b/dep/process/boost/process/posix/shell_path.hpp
new file mode 100644
index 00000000000..3e21e757591
--- /dev/null
+++ b/dep/process/boost/process/posix/shell_path.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_POSIX_SHELL_PATH_HPP
+#define BOOST_PROCESS_POSIX_SHELL_PATH_HPP
+
+#include <boost/process/config.hpp>
+#include <boost/system/error_code.hpp>
+#include <boost/filesystem/path.hpp>
+
+namespace boost { namespace process { namespace posix {
+
+inline boost::filesystem::path shell_path()
+{
+    return "/bin/sh";
+}
+
+inline boost::filesystem::path shell_path(boost::system::error_code &ec)
+{
+    ec.clear();
+    return "/bin/sh";
+}
+
+}}}
+
+#endif
diff --git a/dep/process/boost/process/posix/terminate.hpp b/dep/process/boost/process/posix/terminate.hpp
new file mode 100644
index 00000000000..9be087df253
--- /dev/null
+++ b/dep/process/boost/process/posix/terminate.hpp
@@ -0,0 +1,37 @@
+// 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_POSIX_TERMINATE_HPP
+#define BOOST_PROCESS_POSIX_TERMINATE_HPP
+
+#include <boost/process/config.hpp>
+#include <boost/system/error_code.hpp>
+#include <signal.h>
+
+namespace boost { namespace process { namespace posix {
+
+template <class Process>
+void terminate(const Process &p)
+{
+    if (::kill(p.pid, SIGKILL) == -1)
+        BOOST_PROCESS_THROW_LAST_SYSTEM_ERROR("kill(2) failed");
+}
+
+template <class Process>
+void terminate(const Process &p, boost::system::error_code &ec)
+{
+    if (::kill(p.pid, SIGKILL) == -1)
+        BOOST_PROCESS_RETURN_LAST_SYSTEM_ERROR(ec);
+    else
+        ec.clear();
+}
+
+}}}
+
+#endif
diff --git a/dep/process/boost/process/posix/wait_for_exit.hpp b/dep/process/boost/process/posix/wait_for_exit.hpp
new file mode 100644
index 00000000000..d2b946c262a
--- /dev/null
+++ b/dep/process/boost/process/posix/wait_for_exit.hpp
@@ -0,0 +1,52 @@
+// 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_POSIX_WAIT_FOR_EXIT_HPP
+#define BOOST_PROCESS_POSIX_WAIT_FOR_EXIT_HPP
+
+#include <boost/process/config.hpp>
+#include <boost/system/error_code.hpp>
+#include <sys/types.h>
+#include <sys/wait.h>
+
+namespace boost { namespace process { namespace posix {
+
+template <class Process>
+inline int wait_for_exit(const Process &p)
+{
+    pid_t ret;
+    int status;
+    do
+    {
+        ret = ::waitpid(p.pid, &status, 0);
+    } while ((ret == -1 && errno == EINTR) || (ret != -1 && !WIFEXITED(status)));
+    if (ret == -1)
+        BOOST_PROCESS_THROW_LAST_SYSTEM_ERROR("waitpid(2) failed");
+    return status;
+}
+
+template <class Process>
+inline int wait_for_exit(const Process &p, boost::system::error_code &ec)
+{
+    pid_t ret;
+    int status;
+    do
+    {
+        ret = ::waitpid(p.pid, &status, 0);
+    } while ((ret == -1 && errno == EINTR) || (ret != -1 && !WIFEXITED(status)));
+    if (ret == -1)
+        BOOST_PROCESS_RETURN_LAST_SYSTEM_ERROR(ec);
+    else
+        ec.clear();
+    return status;
+}
+
+}}}
+
+#endif
diff --git a/dep/process/boost/process/search_path.hpp b/dep/process/boost/process/search_path.hpp
new file mode 100644
index 00000000000..20bff060b62
--- /dev/null
+++ b/dep/process/boost/process/search_path.hpp
@@ -0,0 +1,51 @@
+// 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)
+
+/**
+ * \file boost/process/search_path.hpp
+ *
+ * Defines a function to search for an executable in path.
+ */
+
+#ifndef BOOST_PROCESS_SEARCH_PATH_HPP
+#define BOOST_PROCESS_SEARCH_PATH_HPP
+
+#include <boost/process/config.hpp>
+
+#include BOOST_PROCESS_PLATFORM_PROMOTE_PATH(search_path)
+BOOST_PROCESS_PLATFORM_PROMOTE_NAMESPACE(search_path)
+
+#if defined(BOOST_PROCESS_DOXYGEN)
+namespace boost { namespace process {
+
+/**
+ * Searches for an executable in path.
+ *
+ * filename must be a basename including the file extension.
+ * It must not include any directory separators (like a slash).
+ * On Windows the file extension may be omitted. The function
+ * will then try the various file extensions for executables on
+ * Windows to find filename.
+ *
+ * path must be a set of directories. Directories must be
+ * separated by colons on POSIX and by semicolons on Windows.
+ * If path is empty, the environment variable PATH is used.
+ *
+ * \returns the absolute path to the executable filename or an
+ *          empty string if filename isn't found
+ *
+ * \throws std::runtime_error if path is empty and no environment
+ *                            variable PATH exists
+ */
+string_type search_path(const string_type &filename, string_type path = "");
+
+}}
+#endif
+
+#endif
diff --git a/dep/process/boost/process/shell_path.hpp b/dep/process/boost/process/shell_path.hpp
new file mode 100644
index 00000000000..92e9f0814b0
--- /dev/null
+++ b/dep/process/boost/process/shell_path.hpp
@@ -0,0 +1,46 @@
+// 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)
+
+/**
+ * \file boost/process/shell_path.hpp
+ *
+ * Defines a function to return the absolute path to a shell executable.
+ */
+
+#ifndef BOOST_PROCESS_SHELL_PATH_HPP
+#define BOOST_PROCESS_SHELL_PATH_HPP
+
+#include <boost/process/config.hpp>
+
+#include BOOST_PROCESS_PLATFORM_PROMOTE_PATH(shell_path)
+BOOST_PROCESS_PLATFORM_PROMOTE_NAMESPACE(shell_path)
+
+#if defined(BOOST_PROCESS_DOXYGEN)
+namespace boost { namespace process {
+
+/**
+ * Returns the absolute path to a shell executable.
+ *
+ * \returns the path to cmd.exe on Windows and /bin/sh on POSIX.
+ *
+ * \throws boost::system::system_error in case of an error
+ */
+boost::filesystem::path shell_path();
+
+/**
+ * Returns the absolute path to a shell executable.
+ *
+ * \returns the path to cmd.exe on Windows and /bin/sh on POSIX.
+ */
+boost::filesystem::path shell_path(boost::system::error_code &ec);
+
+}}
+#endif
+
+#endif
diff --git a/dep/process/boost/process/terminate.hpp b/dep/process/boost/process/terminate.hpp
new file mode 100644
index 00000000000..140eba7e8dd
--- /dev/null
+++ b/dep/process/boost/process/terminate.hpp
@@ -0,0 +1,52 @@
+// 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)
+
+/**
+ * \file boost/process/terminate.hpp
+ *
+ * Defines a function to terminate a process.
+ */
+
+#ifndef BOOST_PROCESS_TERMINATE_HPP
+#define BOOST_PROCESS_TERMINATE_HPP
+
+#include <boost/process/config.hpp>
+
+#include BOOST_PROCESS_PLATFORM_PROMOTE_PATH(terminate)
+BOOST_PROCESS_PLATFORM_PROMOTE_NAMESPACE(terminate)
+
+#if defined(BOOST_PROCESS_DOXYGEN)
+namespace boost { namespace process {
+
+/**
+ * Terminates a process.
+ *
+ * \warning Call this function only as a last resort. The process
+ *          is terminated immediately and forcefully and has no
+ *          chance to close or clean up resources properly.
+ *
+ * \throws boost::system::system_error in case of an error
+ */
+template <class Process>
+void terminate(const Process &p);
+
+/**
+ * Terminates a process.
+ *
+ * \warning Call this function only as a last resort. The process
+ *          is terminated immediately and forcefully and has no
+ *          chance to close or clean up resources properly.
+ */
+template <class Process>
+void terminate(const Process &p, boost::system::error_code &ec);
+
+}}
+#endif
+
+#endif
diff --git a/dep/process/boost/process/wait_for_exit.hpp b/dep/process/boost/process/wait_for_exit.hpp
new file mode 100644
index 00000000000..d9b118695d7
--- /dev/null
+++ b/dep/process/boost/process/wait_for_exit.hpp
@@ -0,0 +1,58 @@
+// 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)
+
+/**
+ * \file boost/process/wait_for_exit.hpp
+ *
+ * Defines a function to wait for a process to exit.
+ */
+
+#ifndef BOOST_PROCESS_WAIT_FOR_EXIT_HPP
+#define BOOST_PROCESS_WAIT_FOR_EXIT_HPP
+
+#include <boost/process/config.hpp>
+
+#include BOOST_PROCESS_PLATFORM_PROMOTE_PATH(wait_for_exit)
+BOOST_PROCESS_PLATFORM_PROMOTE_NAMESPACE(wait_for_exit)
+
+#if defined(BOOST_PROCESS_DOXYGEN)
+namespace boost { namespace process {
+
+/**
+ * Waits for a process to exit.
+ *
+ * On Window boost::process::wait_for_exit returns the exit code
+ * of the process. On POSIX the exit status is returned. You must
+ * use the macro \c WEXITSTATUS (defined in sys/wait.h) to fetch
+ * the exit code from the exit status.
+ *
+ * \note This is a blocking function.
+ *
+ * \throws boost::system::system_error in case of an error
+ */
+template <class Process>
+int_type wait_for_exit(const Process &p);
+
+/**
+ * Waits for a process to exit.
+ *
+ * On Window boost::process::wait_for_exit returns the exit code
+ * of the process. On POSIX the exit status is returned. You must
+ * use the macro \c WEXITSTATUS (defined in sys/wait.h) to fetch
+ * the exit code from the exit status.
+ *
+ * \note This is a blocking function.
+ */
+template <class Process>
+int_type wait_for_exit(const Process &p, boost::system::error_code &ec);
+
+}}
+#endif
+
+#endif
diff --git a/dep/process/boost/process/windows/child.hpp b/dep/process/boost/process/windows/child.hpp
new file mode 100644
index 00000000000..083cd29da0e
--- /dev/null
+++ b/dep/process/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
diff --git a/dep/process/boost/process/windows/create_pipe.hpp b/dep/process/boost/process/windows/create_pipe.hpp
new file mode 100644
index 00000000000..fe1e49751d8
--- /dev/null
+++ b/dep/process/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
diff --git a/dep/process/boost/process/windows/execute.hpp b/dep/process/boost/process/windows/execute.hpp
new file mode 100644
index 00000000000..43067521ead
--- /dev/null
+++ b/dep/process/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
diff --git a/dep/process/boost/process/windows/executor.hpp b/dep/process/boost/process/windows/executor.hpp
new file mode 100644
index 00000000000..1560f30793d
--- /dev/null
+++ b/dep/process/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
diff --git a/dep/process/boost/process/windows/initializers.hpp b/dep/process/boost/process/windows/initializers.hpp
new file mode 100644
index 00000000000..2d7098c034c
--- /dev/null
+++ b/dep/process/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
diff --git a/dep/process/boost/process/windows/initializers/bind_stderr.hpp b/dep/process/boost/process/windows/initializers/bind_stderr.hpp
new file mode 100644
index 00000000000..de3ee30dc53
--- /dev/null
+++ b/dep/process/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
diff --git a/dep/process/boost/process/windows/initializers/bind_stdin.hpp b/dep/process/boost/process/windows/initializers/bind_stdin.hpp
new file mode 100644
index 00000000000..54c942ab639
--- /dev/null
+++ b/dep/process/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
diff --git a/dep/process/boost/process/windows/initializers/bind_stdout.hpp b/dep/process/boost/process/windows/initializers/bind_stdout.hpp
new file mode 100644
index 00000000000..c72c05f1bfb
--- /dev/null
+++ b/dep/process/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
diff --git a/dep/process/boost/process/windows/initializers/close_stderr.hpp b/dep/process/boost/process/windows/initializers/close_stderr.hpp
new file mode 100644
index 00000000000..373c097f3ab
--- /dev/null
+++ b/dep/process/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
diff --git a/dep/process/boost/process/windows/initializers/close_stdin.hpp b/dep/process/boost/process/windows/initializers/close_stdin.hpp
new file mode 100644
index 00000000000..036b0bb4ce9
--- /dev/null
+++ b/dep/process/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
diff --git a/dep/process/boost/process/windows/initializers/close_stdout.hpp b/dep/process/boost/process/windows/initializers/close_stdout.hpp
new file mode 100644
index 00000000000..b58a6000f9c
--- /dev/null
+++ b/dep/process/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
diff --git a/dep/process/boost/process/windows/initializers/hide_console.hpp b/dep/process/boost/process/windows/initializers/hide_console.hpp
new file mode 100644
index 00000000000..b01aa026f0e
--- /dev/null
+++ b/dep/process/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
diff --git a/dep/process/boost/process/windows/initializers/inherit_env.hpp b/dep/process/boost/process/windows/initializers/inherit_env.hpp
new file mode 100644
index 00000000000..a2b2eda00a3
--- /dev/null
+++ b/dep/process/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
diff --git a/dep/process/boost/process/windows/initializers/initializer_base.hpp b/dep/process/boost/process/windows/initializers/initializer_base.hpp
new file mode 100644
index 00000000000..b98da7b21b9
--- /dev/null
+++ b/dep/process/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
diff --git a/dep/process/boost/process/windows/initializers/on_CreateProcess_error.hpp b/dep/process/boost/process/windows/initializers/on_CreateProcess_error.hpp
new file mode 100644
index 00000000000..71eeada0720
--- /dev/null
+++ b/dep/process/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
diff --git a/dep/process/boost/process/windows/initializers/on_CreateProcess_setup.hpp b/dep/process/boost/process/windows/initializers/on_CreateProcess_setup.hpp
new file mode 100644
index 00000000000..671fc9ac5c2
--- /dev/null
+++ b/dep/process/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
diff --git a/dep/process/boost/process/windows/initializers/on_CreateProcess_success.hpp b/dep/process/boost/process/windows/initializers/on_CreateProcess_success.hpp
new file mode 100644
index 00000000000..67b3b2bdcf7
--- /dev/null
+++ b/dep/process/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
diff --git a/dep/process/boost/process/windows/initializers/run_exe.hpp b/dep/process/boost/process/windows/initializers/run_exe.hpp
new file mode 100644
index 00000000000..bfa2b790b17
--- /dev/null
+++ b/dep/process/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
diff --git a/dep/process/boost/process/windows/initializers/set_args.hpp b/dep/process/boost/process/windows/initializers/set_args.hpp
new file mode 100644
index 00000000000..4b3c5b6249e
--- /dev/null
+++ b/dep/process/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
diff --git a/dep/process/boost/process/windows/initializers/set_cmd_line.hpp b/dep/process/boost/process/windows/initializers/set_cmd_line.hpp
new file mode 100644
index 00000000000..a3d9f6f7615
--- /dev/null
+++ b/dep/process/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
diff --git a/dep/process/boost/process/windows/initializers/set_env.hpp b/dep/process/boost/process/windows/initializers/set_env.hpp
new file mode 100644
index 00000000000..6dfdfc58a48
--- /dev/null
+++ b/dep/process/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
diff --git a/dep/process/boost/process/windows/initializers/set_on_error.hpp b/dep/process/boost/process/windows/initializers/set_on_error.hpp
new file mode 100644
index 00000000000..695ea5904d7
--- /dev/null
+++ b/dep/process/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
diff --git a/dep/process/boost/process/windows/initializers/show_window.hpp b/dep/process/boost/process/windows/initializers/show_window.hpp
new file mode 100644
index 00000000000..3046179205a
--- /dev/null
+++ b/dep/process/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
diff --git a/dep/process/boost/process/windows/initializers/start_in_dir.hpp b/dep/process/boost/process/windows/initializers/start_in_dir.hpp
new file mode 100644
index 00000000000..8dc952abcc0
--- /dev/null
+++ b/dep/process/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
diff --git a/dep/process/boost/process/windows/initializers/throw_on_error.hpp b/dep/process/boost/process/windows/initializers/throw_on_error.hpp
new file mode 100644
index 00000000000..044fa004177
--- /dev/null
+++ b/dep/process/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
diff --git a/dep/process/boost/process/windows/pipe.hpp b/dep/process/boost/process/windows/pipe.hpp
new file mode 100644
index 00000000000..fd912afcc9e
--- /dev/null
+++ b/dep/process/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
diff --git a/dep/process/boost/process/windows/search_path.hpp b/dep/process/boost/process/windows/search_path.hpp
new file mode 100644
index 00000000000..62bb5f27454
--- /dev/null
+++ b/dep/process/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
diff --git a/dep/process/boost/process/windows/shell_path.hpp b/dep/process/boost/process/windows/shell_path.hpp
new file mode 100644
index 00000000000..ace15b96e10
--- /dev/null
+++ b/dep/process/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
diff --git a/dep/process/boost/process/windows/terminate.hpp b/dep/process/boost/process/windows/terminate.hpp
new file mode 100644
index 00000000000..43afe250a6a
--- /dev/null
+++ b/dep/process/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
diff --git a/dep/process/boost/process/windows/wait_for_exit.hpp b/dep/process/boost/process/windows/wait_for_exit.hpp
new file mode 100644
index 00000000000..23a8b9a9f18
--- /dev/null
+++ b/dep/process/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