comparison third_party/boost/process/detail/posix_helpers.hpp @ 0:add35537fdbb tip

Initial import

+//
+// Boost.Process
+// ~~~~~~~~~~~~~
+//
+// 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
+//
+// 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/detail/posix_helpers.hpp
+ *
+ * Includes the declaration of helper functions for POSIX systems.
+ */
+
+#ifndef BOOST_PROCESS_POSIX_HELPERS_HPP
+#define BOOST_PROCESS_POSIX_HELPERS_HPP
+
+#include <boost/process/config.hpp>
+#include <boost/process/environment.hpp>
+#include <string>
+#include <utility>
+#include <cstring>
+#include <cstddef>
+
+namespace boost {
+namespace process {
+namespace detail {
+
+/**
+ * Converts an environment to a char** table as used by execve().
+ *
+ * Converts the environment's contents to the format used by the
+ * execve() system call. The returned char** array is allocated
+ * in dynamic memory; the caller must free it when not used any
+ * more. Each entry is also allocated in dynamic memory and is a
+ * NULL-terminated string of the form var=value; these must also be
+ * released by the caller.
+ *
+ * This operation is only available on POSIX systems.
+ *
+ * \return The first argument of the pair is an integer that indicates
+ *         how many strings are stored in the second argument. The
+ *         second argument is a NULL-terminated, dynamically allocated
+ *         array of dynamically allocated strings representing the
+ *         enviroment's content. Each array entry is a NULL-terminated
+ *         string of the form var=value. The caller is responsible for
+ *         freeing them.
+ */
+inline std::pair<std::size_t, char**> environment_to_envp(const environment
+    &env)
+{
+    std::size_t nargs = env.size();
+    char **envp = new char*[nargs + 1];
+    environment::size_type i = 0;
+    for (environment::const_iterator it = env.begin(); it != env.end(); ++it)
+    {
+        std::string s = it->first + "=" + it->second;
+        envp[i] = new char[s.size() + 1];
+        std::strncpy(envp[i], s.c_str(), s.size() + 1);
+        ++i;
+    }
+    envp[i] = 0;
+    return std::pair<std::size_t, char**>(nargs, envp);
+}
+
+/**
+ * Converts the command line to an array of C strings.
+ *
+ * Converts the command line's list of arguments to the format expected
+ * by the \a argv parameter in the POSIX execve() system call.
+ *
+ * This operation is only available on POSIX systems.
+ *
+ * \return The first argument of the pair is an integer that indicates
+ *         how many strings are stored in the second argument. The
+ *         second argument is a NULL-terminated, dynamically allocated
+ *         array of dynamically allocated strings holding the arguments
+ *         to the executable. The caller is responsible for freeing them.
+ */
+template <class Arguments>
+inline std::pair<std::size_t, char**> collection_to_argv(const Arguments &args)
+{
+    std::size_t nargs = args.size();
+    char **argv = new char*[nargs + 1];
+    typename Arguments::size_type i = 0;
+    for (typename Arguments::const_iterator it = args.begin(); it != args.end();
+        ++it)
+    {
+        argv[i] = new char[it->size() + 1];
+        std::strncpy(argv[i], it->c_str(), it->size() + 1);
+        ++i;
+    }
+    argv[nargs] = 0;
+    return std::pair<std::size_t, char**>(nargs, argv);
+}
+
+}
+}
+}
+
+#endif