Call PySys_SetArgv when initializing interpreter.

include/pybind11/embed.h

@@ -87,29 +87,126 @@ struct embedded_module {
     }
 };
 
+/// Python 2.x/3.x-compatible version of `PySys_SetArgv`
+inline void set_interpreter_argv(int argc, char** argv, bool add_current_dir_to_path) {
+    // Before it was special-cased in python 3.8, passing an empty or null argv
+    // caused a segfault, so we have to reimplement the special case ourselves.
+    char** safe_argv = argv;
+    if (nullptr == argv || argc <= 0) {
+        safe_argv = new char*[1];
+        if (nullptr == safe_argv) return;
+        safe_argv[0] = new char[1];
+        if (nullptr == safe_argv[0]) {
+            delete[] safe_argv;
+            return;
+        }
+        safe_argv[0][0] = '\0';
+        argc = 1;
+    }
+#if PY_MAJOR_VERSION >= 3
+    // SetArgv* on python 3 takes wchar_t, so we have to convert.
+    wchar_t** widened_argv = new wchar_t*[static_cast<unsigned>(argc)];
+    for (int ii = 0; ii < argc; ++ii) {
+#  if PY_MINOR_VERSION >= 5
+        // From Python 3.5 onwards, we're supposed to use Py_DecodeLocale to
+        // generate the wchar_t version of argv.
+        widened_argv[ii] = Py_DecodeLocale(safe_argv[ii], nullptr);
+#    define FREE_WIDENED_ARG(X) PyMem_RawFree(X)
+#  else
+        // Before Python 3.5, we're stuck with mbstowcs, which may or may not
+        // actually work. Mercifully, pyconfig.h provides this define:
+#    ifdef HAVE_BROKEN_MBSTOWCS
+        size_t count = strlen(safe_argv[ii]);
+#    else
+        size_t count = mbstowcs(nullptr, safe_argv[ii], 0);
+#    endif
+        widened_argv[ii] = nullptr;
+        if (count != static_cast<size_t>(-1)) {
+            widened_argv[ii] = new wchar_t[count + 1];
+            mbstowcs(widened_argv[ii], safe_argv[ii], count + 1);
+        }
+#    define FREE_WIDENED_ARG(X) delete[] X
+#  endif
+        if (nullptr == widened_argv[ii]) {
+            // Either we ran out of memory or had a unicode encoding issue.
+            // Free what we've encoded so far and bail.
+            for (--ii; ii >= 0; --ii)
+                FREE_WIDENED_ARG(widened_argv[ii]);
+            return;
+        }
+    }
+
+#  if PY_MINOR_VERSION < 1 || (PY_MINOR_VERSION == 1 && PY_MICRO_VERSION < 3)
+#    define NEED_PYRUN_TO_SANITIZE_PATH 1
+    // don't have SetArgvEx yet
+    PySys_SetArgv(argc, widened_argv);
+#  else
+    PySys_SetArgvEx(argc, widened_argv, add_current_dir_to_path ? 1 : 0);
+#  endif
+
+    // PySys_SetArgv makes new PyUnicode objects so we can clean up this memory
+    if (nullptr != widened_argv) {
+        for (int ii = 0; ii < argc; ++ii)
+            if (nullptr != widened_argv[ii])
+                FREE_WIDENED_ARG(widened_argv[ii]);
+        delete[] widened_argv;
+    }
+#  undef FREE_WIDENED_ARG
+#else
+    // python 2.x
+#  if PY_MINOR_VERSION < 6 || (PY_MINOR_VERSION == 6 && PY_MICRO_VERSION < 6)
+#    define NEED_PYRUN_TO_SANITIZE_PATH 1
+    // don't have SetArgvEx yet
+    PySys_SetArgv(argc, safe_argv);
+#  else
+    PySys_SetArgvEx(argc, safe_argv, add_current_dir_to_path ? 1 : 0);
+#  endif
+#endif
+
+#ifdef NEED_PYRUN_TO_SANITIZE_PATH
+#  undef NEED_PYRUN_TO_SANITIZE_PATH
+    if (!add_current_dir_to_path)
+        PyRun_SimpleString("import sys; sys.path.pop(0)\n");
+#endif
+
+    // if we allocated new memory to make safe_argv, we need to free it
+    if (safe_argv != argv) {
+        delete[] safe_argv[0];
+        delete[] safe_argv;
+    }
+}
+
 PYBIND11_NAMESPACE_END(detail)
 
 /** \rst
     Initialize the Python interpreter. No other pybind11 or CPython API functions can be
     called before this is done; with the exception of `PYBIND11_EMBEDDED_MODULE`. The
-    optional parameter can be used to skip the registration of signal handlers (see the
-    `Python documentation`_ for details). Calling this function again after the interpreter
-    has already been initialized is a fatal error.
+    optional `init_signal_handlers` parameter can be used to skip the registration of
+    signal handlers (see the `Python documentation`_ for details). Calling this function
+    again after the interpreter has already been initialized is a fatal error.
 
     If initializing the Python interpreter fails, then the program is terminated.  (This
     is controlled by the CPython runtime and is an exception to pybind11's normal behavior
     of throwing exceptions on errors.)
 
+    The remaining optional parameters, `argc`, `argv`, and `add_current_dir_to_path` are
+    used to populate ``sys.argv`` and ``sys.path``.
+    See the |PySys_SetArgvEx documentation|_ for details.
+
     .. _Python documentation: https://docs.python.org/3/c-api/init.html#c.Py_InitializeEx
+    .. |PySys_SetArgvEx documentation| replace:: ``PySys_SetArgvEx`` documentation
+    .. _PySys_SetArgvEx documentation: https://docs.python.org/3/c-api/init.html#c.PySys_SetArgvEx
  \endrst */
-inline void initialize_interpreter(bool init_signal_handlers = true) {
+inline void initialize_interpreter(bool init_signal_handlers = true,
+                                   int argc = 0,
+                                   char** argv = nullptr,
+                                   bool add_current_dir_to_path = true) {
     if (Py_IsInitialized())
         pybind11_fail("The interpreter is already running");
 
     Py_InitializeEx(init_signal_handlers ? 1 : 0);
 
-    // Make .py files in the working directory available by default
-    module::import("sys").attr("path").cast<list>().append(".");
+    detail::set_interpreter_argv(argc, argv, add_current_dir_to_path);
 }
 
 /** \rst
@@ -171,6 +268,8 @@ inline void finalize_interpreter() {
     Scope guard version of `initialize_interpreter` and `finalize_interpreter`.
     This a move-only guard and only a single instance can exist.
 
+    See `initialize_interpreter` for a discussion of its constructor arguments.
+
     .. code-block:: cpp
 
         #include <pybind11/embed.h>
@@ -182,8 +281,11 @@ inline void finalize_interpreter() {
  \endrst */
 class scoped_interpreter {
 public:
-    scoped_interpreter(bool init_signal_handlers = true) {
-        initialize_interpreter(init_signal_handlers);
+    scoped_interpreter(bool init_signal_handlers = true,
+                       int argc = 0,
+                       char** argv = nullptr,
+                       bool add_current_dir_to_path = true) {
+        initialize_interpreter(init_signal_handlers, argc, argv, add_current_dir_to_path);
     }
 
     scoped_interpreter(const scoped_interpreter &) = delete;

tests/test_embed/test_interpreter.cpp

@@ -22,6 +22,7 @@ class Widget {
 
     std::string the_message() const { return message; }
     virtual int the_answer() const = 0;
+    virtual std::string argv0() const = 0;
 
 private:
     std::string message;
@@ -31,6 +32,7 @@ class PyWidget final : public Widget {
     using Widget::Widget;
 
     int the_answer() const override { PYBIND11_OVERLOAD_PURE(int, Widget, the_answer); }
+    std::string argv0() const override { PYBIND11_OVERLOAD_PURE(std::string, Widget, argv0); }
 };
 
 PYBIND11_EMBEDDED_MODULE(widget_module, m) {
@@ -282,3 +284,25 @@ TEST_CASE("Reload module from file") {
     result = module.attr("test")().cast<int>();
     REQUIRE(result == 2);
 }
+
+TEST_CASE("sys.argv gets initialized properly") {
+    py::finalize_interpreter();
+    {
+        py::scoped_interpreter default_scope;
+        auto module = py::module::import("test_interpreter");
+        auto py_widget = module.attr("DerivedWidget")("The question");
+        const auto &cpp_widget = py_widget.cast<const Widget &>();
+        REQUIRE(cpp_widget.argv0() == "");
+    }
+
+    {
+        char* argv[] = { strdup("a.out") };
+        py::scoped_interpreter argv_scope(true, 1, argv);
+        free(argv[0]);
+        auto module = py::module::import("test_interpreter");
+        auto py_widget = module.attr("DerivedWidget")("The question");
+        const auto &cpp_widget = py_widget.cast<const Widget &>();
+        REQUIRE(cpp_widget.argv0() == "a.out");
+    }
+    py::initialize_interpreter();
+}

tests/test_embed/test_interpreter.py

@@ -1,5 +1,6 @@
 # -*- coding: utf-8 -*-
 from widget_module import Widget
+import sys
 
 
 class DerivedWidget(Widget):
@@ -8,3 +9,6 @@ def __init__(self, message):
 
     def the_answer(self):
         return 42
+
+    def argv0(self):
+        return sys.argv[0]