@@ -2,22 +2,40 @@
 Legacy Python.NET loader for backwards compatibility
 """
 
-def _load():
+def _get_netfx_path():
     import os, sys
-    import importlib.util as util
 
     if sys.maxsize > 2 ** 32:
         arch = "amd64"
     else:
         arch = "x86"
 
-    path = os.path.join(os.path.dirname(__file__), "pythonnet", "dlls", arch, "clr.pyd")
-    del sys.modules["clr"]
+    return os.path.join(os.path.dirname(__file__), "pythonnet", "netfx", arch, "clr.pyd")
+
+
+def _get_mono_path():
+    import os, glob
+
+    paths = glob.glob(os.path.join(os.path.dirname(__file__), "pythonnet", "mono", "clr.*so"))
+    return paths[0]
+
+
+def _load_clr():
+    import sys
+    from importlib import util
+
+    if sys.platform == "win32":
+        path = _get_netfx_path()
+    else:
+        path = _get_mono_path()
+
+    del sys.modules[__name__]
 
     spec = util.spec_from_file_location("clr", path)
     clr = util.module_from_spec(spec)
     spec.loader.exec_module(clr)
 
-    sys.modules["clr"] = clr
+    sys.modules[__name__] = clr
+
 
-_load()
+_load_clr()
@@ -0,0 +1,3 @@
+mono/
+netfx/
+runtime/
@@ -0,0 +1,3 @@
+def get_assembly_path():
+    import os
+    return os.path.dirname(__file__) + "/runtime/Python.Runtime.dll"
@@ -1,6 +1,6 @@
 #!/usr/bin/env python
 
-from setuptools import setup, find_packages, Command, Extension
+from setuptools import setup, Command, Extension
 from wheel.bdist_wheel import bdist_wheel
 from setuptools.command.build_ext import build_ext
 import distutils
@@ -164,18 +164,23 @@ def finalize_options(self):
 
 
 ext_modules = [
+    DotnetLib(
+        "python-runtime",
+        "src/runtime/Python.Runtime.csproj",
+        output="pythonnet/runtime"
+    ),
     DotnetLib(
         "clrmodule-amd64",
         "src/clrmodule/",
         runtime="win-x64",
-        output="pythonnet/dlls/amd64",
+        output="pythonnet/netfx/amd64",
         rename={"clr.dll": "clr.pyd"},
     ),
     DotnetLib(
         "clrmodule-x86",
         "src/clrmodule/",
         runtime="win-x86",
-        output="pythonnet/dlls/x86",
+        output="pythonnet/netfx/x86",
         rename={"clr.dll": "clr.pyd"},
     ),
 ]
@@ -192,7 +197,7 @@ def finalize_options(self):
     clr_ext = Extension(
         "clr",
         language="c++",
-        sources=["src/monoclr/pynetinit.c", "src/monoclr/clrmod.c"],
+        sources=["src/monoclr/clrmod.c"],
         extra_compile_args=cflags.split(" "),
         extra_link_args=libs.split(" "),
     )
@@ -209,6 +214,7 @@ def finalize_options(self):
     license="MIT",
     author="The Contributors of the Python.NET Project",
     author_email="pythonnet@python.org",
+    packages=["pythonnet"],
     setup_requires=["setuptools_scm"],
     install_requires=["pycparser"],
     long_description=long_description,
 
@@ -1,70 +1,223 @@
-#include "pynetclr.h"
+// #define Py_LIMITED_API 0x03050000
+#include <Python.h>
 
-/* List of functions defined in the module */
-static PyMethodDef clr_methods[] = {
-    {NULL, NULL, 0, NULL} /* Sentinel */
-};
+#include "stdlib.h"
 
-PyDoc_STRVAR(clr_module_doc,
-             "clr facade module to initialize the CLR. It's later "
-             "replaced by the real clr module. This module has a facade "
-             "attribute to make it distinguishable from the real clr module."
-);
+#define MONO_VERSION "v4.0.30319.1"
+#define MONO_DOMAIN "Python"
 
-static PyNet_Args *pn_args;
-char **environ = NULL;
-
-#if PY_MAJOR_VERSION >= 3
-static struct PyModuleDef clrdef = {
-    PyModuleDef_HEAD_INIT,
-    "clr",               /* m_name */
-    clr_module_doc,      /* m_doc */
-    -1,                  /* m_size */
-    clr_methods,         /* m_methods */
-    NULL,                /* m_reload */
-    NULL,                /* m_traverse */
-    NULL,                /* m_clear */
-    NULL,                /* m_free */
-};
+#include <mono/jit/jit.h>
+#include <mono/metadata/environment.h>
+#include <mono/metadata/mono-config.h>
+#include <mono/metadata/debug-helpers.h>
+#include <mono/metadata/assembly.h>
+
+#ifndef _WIN32
+#include "dirent.h"
+#include "dlfcn.h"
+#include "libgen.h"
+#include "alloca.h"
 #endif
 
-static PyObject *_initclr()
+typedef struct
 {
-    PyObject *m;
+    MonoDomain *domain;
+    MonoAssembly *pr_assm;
+    MonoMethod *shutdown;
+    const char *pr_file;
+    char *error;
+    char *init_name;
+    char *shutdown_name;
+    PyObject *module;
+} PyNet_Args;
 
-    /* Create the module and add the functions */
-#if PY_MAJOR_VERSION >= 3
-    m = PyModule_Create(&clrdef);
-#else
-    m = Py_InitModule3("clr", clr_methods, clr_module_doc);
-#endif
-    if (m == NULL)
-        return NULL;
-    PyModule_AddObject(m, "facade", Py_True);
-    Py_INCREF(Py_True);
+PyNet_Args *PyNet_Init(void);
+static PyNet_Args *pn_args;
 
-    pn_args = PyNet_Init(1);
+PyMODINIT_FUNC
+PyInit_clr(void)
+{
+    pn_args = PyNet_Init();
     if (pn_args->error)
     {
         return NULL;
     }
 
-    if (NULL != pn_args->module)
-        return pn_args->module;
+    return pn_args->module;
+}
+
+void PyNet_Finalize(PyNet_Args *);
+void main_thread_handler(PyNet_Args *user_data);
+
+// initialize Mono and PythonNet
+PyNet_Args *PyNet_Init()
+{
+    PyObject *pn_module;
+    PyObject *pn_path;
+    PyNet_Args *pn_args;
+    pn_args = (PyNet_Args *)malloc(sizeof(PyNet_Args));
+
+    pn_module = PyImport_ImportModule("pythonnet");
+    if (pn_module == NULL)
+    {
+        pn_args->error = "Failed to import pythonnet";
+        return pn_args;
+    }
+
+    pn_path = PyObject_CallMethod(pn_module, "get_assembly_path", NULL);
+    if (pn_path == NULL)
+    {
+        Py_DecRef(pn_module);
+        pn_args->error = "Failed to get assembly path";
+        return pn_args;
+    }
 
-    return m;
+    pn_args->pr_file = PyUnicode_AsUTF8(pn_path);
+    pn_args->error = NULL;
+    pn_args->shutdown = NULL;
+    pn_args->module = NULL;
+
+#ifdef __linux__
+    // Force preload libmono-2.0 as global. Without this, on some systems
+    // symbols from libmono are not found by libmononative (which implements
+    // some of the System.* namespaces). Since the only happened on Linux so
+    // far, we hardcode the library name, load the symbols into the global
+    // namespace and leak the handle.
+    dlopen("libmono-2.0.so", RTLD_LAZY | RTLD_GLOBAL);
+#endif
+
+    pn_args->init_name = "Python.Runtime:InitExt()";
+    pn_args->shutdown_name = "Python.Runtime:Shutdown()";
+
+    pn_args->domain = mono_jit_init_version(MONO_DOMAIN, MONO_VERSION);
+
+    // XXX: Skip setting config for now, should be derived from pr_file
+    // mono_domain_set_config(pn_args->domain, ".", "Python.Runtime.dll.config");
+
+    /*
+     * Load the default Mono configuration file, this is needed
+     * if you are planning on using the dllmaps defined on the
+     * system configuration
+     */
+    mono_config_parse(NULL);
+
+    /* I can't use this call to run the main_thread_handler. The function
+     * runs it in another thread but *this* thread holds the Python
+     * import lock -> DEAD LOCK.
+     *
+     * mono_runtime_exec_managed_code(pn_args->domain, main_thread_handler,
+     *                                pn_args);
+     */
+
+    main_thread_handler(pn_args);
+
+    if (pn_args->error != NULL)
+    {
+        PyErr_SetString(PyExc_ImportError, pn_args->error);
+    }
+    return pn_args;
 }
 
-#if PY_MAJOR_VERSION >= 3
-PyMODINIT_FUNC
-PyInit_clr(void)
+char *PyNet_ExceptionToString(MonoObject *e);
+
+// Shuts down PythonNet and cleans up Mono
+void PyNet_Finalize(PyNet_Args *pn_args)
 {
-    return _initclr();
+    MonoObject *exception = NULL;
+
+    if (pn_args->shutdown)
+    {
+        mono_runtime_invoke(pn_args->shutdown, NULL, NULL, &exception);
+        if (exception)
+        {
+            pn_args->error = PyNet_ExceptionToString(exception);
+        }
+        pn_args->shutdown = NULL;
+    }
+
+    if (pn_args->domain)
+    {
+        mono_jit_cleanup(pn_args->domain);
+        pn_args->domain = NULL;
+    }
+    free(pn_args);
 }
-#else
-PyMODINIT_FUNC
-initclr(void)
+
+MonoMethod *getMethodFromClass(MonoClass *cls, char *name)
 {
-    _initclr();
+    MonoMethodDesc *mdesc;
+    MonoMethod *method;
+
+    mdesc = mono_method_desc_new(name, 1);
+    method = mono_method_desc_search_in_class(mdesc, cls);
+    mono_method_desc_free(mdesc);
+
+    return method;
+}
+
+void main_thread_handler(PyNet_Args *user_data)
+{
+    PyNet_Args *pn_args = user_data;
+    MonoMethod *init;
+    MonoImage *pr_image;
+    MonoClass *pythonengine;
+    MonoObject *exception = NULL;
+    MonoObject *init_result;
+
+    pn_args->pr_assm = mono_domain_assembly_open(pn_args->domain, pn_args->pr_file);
+    if (!pn_args->pr_assm)
+    {
+        pn_args->error = "Unable to load assembly";
+        return;
+    }
+
+    pr_image = mono_assembly_get_image(pn_args->pr_assm);
+    if (!pr_image)
+    {
+        pn_args->error = "Unable to get image";
+        return;
+    }
+
+    pythonengine = mono_class_from_name(pr_image, "Python.Runtime", "PythonEngine");
+    if (!pythonengine)
+    {
+        pn_args->error = "Unable to load class PythonEngine from Python.Runtime";
+        return;
+    }
+
+    init = getMethodFromClass(pythonengine, pn_args->init_name);
+    if (!init)
+    {
+        pn_args->error = "Unable to fetch Init method from PythonEngine";
+        return;
+    }
+
+    pn_args->shutdown = getMethodFromClass(pythonengine, pn_args->shutdown_name);
+    if (!pn_args->shutdown)
+    {
+        pn_args->error = "Unable to fetch shutdown method from PythonEngine";
+        return;
+    }
+
+    init_result = mono_runtime_invoke(init, NULL, NULL, &exception);
+    if (exception)
+    {
+        pn_args->error = PyNet_ExceptionToString(exception);
+        return;
+    }
+
+    pn_args->module = *(PyObject**)mono_object_unbox(init_result);
+}
+
+// Get string from a Mono exception
+char *PyNet_ExceptionToString(MonoObject *e)
+{
+    MonoMethodDesc *mdesc = mono_method_desc_new(":ToString()", 0 /*FALSE*/);
+    MonoMethod *mmethod = mono_method_desc_search_in_class(mdesc, mono_get_object_class());
+    mono_method_desc_free(mdesc);
+
+    mmethod = mono_object_get_virtual_method(e, mmethod);
+    MonoString *monoString = (MonoString*) mono_runtime_invoke(mmethod, e, NULL, NULL);
+    mono_runtime_invoke(mmethod, e, NULL, NULL);
+    return mono_string_to_utf8(monoString);
 }
-#endif
Original file line number	Diff line number	Diff line change
@@ -0,0 +1,3 @@
	1	+ def get_assembly_path():
	2	+ import os
	3	+ return os.path.dirname(__file__) + "/runtime/Python.Runtime.dll"