pythonnet · filmor · Nov 9, 2019 · Apr 10, 2020 · Apr 11, 2020 · Apr 11, 2020
diff --git a/.gitignore b/.gitignore
@@ -2,6 +2,7 @@
 *.dll
 *.exe
 *.pdb
+pythonnet/dlls/
 
 ### JetBrains ###
 .idea/

diff --git a/NuGet.config b/NuGet.config
diff --git a/Python.Loader/InternalDllImportResolver.cs b/Python.Loader/InternalDllImportResolver.cs
@@ -0,0 +1,16 @@
+using System;
+using System.Reflection;
+using System.Runtime.InteropServices;
+
+namespace Python.Loader
+{
+    public static class InternalDllImportResolver
+    {
+        public static IntPtr Resolve(string libraryName, Assembly assembly, int? flags) {
+            if (libraryName == "__Internal") {
+
+            }
+        }
+
+    }
+}
diff --git a/Python.Loader/Loader.cs b/Python.Loader/Loader.cs
@@ -0,0 +1,109 @@
+using System.Runtime.InteropServices;
+using System.Text;
+using System;
+using System.IO;
+using System.Reflection;
+using Mono.Cecil;
+
+namespace Python.Loader
+{
+    public class RuntimeLoader
+    {
+        AssemblyDefinition assembly;
+
+        static public RuntimeLoader FromFile(string filename)
+        {
+            return new RuntimeLoader(File.OpenRead(filename));
+        }
+
+        public RuntimeLoader(Stream stream)
+        {
+            assembly = AssemblyDefinition.ReadAssembly(stream, new ReaderParameters
+            {
+                InMemory = true,
+            });
+        }
+
+        public void Remap(string pythonDll)
+        {
+            var moduleRef = new ModuleReference(pythonDll);
+
+            var module = assembly.MainModule;
+            module.ModuleReferences.Add(moduleRef);
+
+            foreach (var type in module.Types)
+            {
+                foreach (var func in type.Methods)
+                {
+                    if (func.HasPInvokeInfo)
+                    {
+                        var info = func.PInvokeInfo;
+                        if (info.Module.Name == "__Internal")
+                        {
+                            info.Module = moduleRef;
+                        }
+                    }
+                }
+            }
+        }
+
+        public Assembly LoadAssembly()
+        {
+            using (var stream = new MemoryStream())
+            {
+                assembly.Write(stream);
+                return Assembly.Load(stream.ToArray());
+            }
+        }
+    }
+
+    static class Internal
+    {
+        static Type PythonEngine = null;
+
+        public static int Initialize(IntPtr data, int size)
+        {
+            try
+            {
+                var buf = new byte[size];
+                Marshal.Copy(data, buf, 0, size);
+                var str = UTF8Encoding.Default.GetString(buf);
+
+                var splitted = str.Split(';');
+
+                var dllPath = splitted[0];
+                var pythonDll = splitted[1];
+
+                var loader = RuntimeLoader.FromFile(dllPath);
+                loader.Remap(pythonDll);
+                var assembly = loader.LoadAssembly();
+
+                PythonEngine = assembly.GetType("Python.Runtime.PythonEngine");
+                var method = PythonEngine.GetMethod("InternalInitialize");
+                return (int)method.Invoke(null, new object[] { data, size });
+            }
+            catch (Exception exc)
+            {
+                Console.WriteLine($"{exc}\n{exc.StackTrace}");
+                return -1;
+            }
+        }
+
+        public static int Shutdown(IntPtr data, int size)
+        {
+            if (PythonEngine == null)
+                return -2;
+
+            try
+            {
+                var method = PythonEngine.GetMethod("InternalShutdown");
+                return (int)method.Invoke(null, new object[] { data, size });
+            }
+            catch (Exception exc)
+            {
+                Console.WriteLine($"{exc}\n{exc.StackTrace}");
+                return -1;
+            }
+        }
+    }
+}
diff --git a/Python.Loader/Python.Loader.csproj b/Python.Loader/Python.Loader.csproj
@@ -0,0 +1,13 @@
+<Project Sdk="Microsoft.NET.Sdk">
+
+  <PropertyGroup>
+    <TargetFramework>netcoreapp3.1</TargetFramework>
+    <AllowUnsafeBlocks>true</AllowUnsafeBlocks>
+  </PropertyGroup>
+
+  <ItemGroup>
+    <PackageReference Include="Mono.Cecil" Version="0.11.2" />
+    <PackageReference Include="System.Runtime.InteropServices" Version="4.3.0" />
+  </ItemGroup>
+
+</Project>
diff --git a/Python.Runtime/AssemblyInfo.cs b/Python.Runtime/AssemblyInfo.cs
@@ -0,0 +1,5 @@
+using System;
+using System.Runtime.CompilerServices;
+
+[assembly: CLSCompliant(true)]
+[assembly: InternalsVisibleTo("Python.Test.Embed")]
diff --git a/src/runtime/BorrowedReference.cs → Python.Runtime/BorrowedReference.cs b/src/runtime/BorrowedReference.cs → Python.Runtime/BorrowedReference.cs
diff --git a/src/runtime/Codecs/TupleCodecs.cs → Python.Runtime/Codecs/TupleCodecs.cs b/src/runtime/Codecs/TupleCodecs.cs → Python.Runtime/Codecs/TupleCodecs.cs
diff --git a/src/runtime/CustomMarshaler.cs → Python.Runtime/CustomMarshaler.cs b/src/runtime/CustomMarshaler.cs → Python.Runtime/CustomMarshaler.cs
@@ -91,9 +91,11 @@ public static int GetUnicodeByteLength(IntPtr p)
             var len = 0;
             while (true)
             {
-                int c = Runtime._UCS == 2
-                    ? Marshal.ReadInt16(p, len * 2)
-                    : Marshal.ReadInt32(p, len * 4);
+#if UCS2
+                int c = Marshal.ReadInt16(p, len * 2);
+#else
+                int c = Marshal.ReadInt32(p, len * 4);
+#endif
 
                 if (c == 0)
                 {
@@ -120,9 +122,11 @@ public static int GetUnicodeByteLength(IntPtr p)
         /// </remarks>
         public static IntPtr Py3UnicodePy2StringtoPtr(string s)
         {
-            return Runtime.IsPython3
-                ? Instance.MarshalManagedToNative(s)
-                : Marshal.StringToHGlobalAnsi(s);
+#if PYTHON2
+            return Marshal.StringToHGlobalAnsi(s);
+#else
+            return Instance.MarshalManagedToNative(s);
+#endif
         }
 
         /// <summary>
@@ -137,9 +141,11 @@ public static IntPtr Py3UnicodePy2StringtoPtr(string s)
         /// </returns>
         public static string PtrToPy3UnicodePy2String(IntPtr p)
         {
-            return Runtime.IsPython3
-                ? PtrToStringUni(p)
-                : Marshal.PtrToStringAnsi(p);
+#if PYTHON2
+            return Marshal.PtrToStringAnsi(p);
+#else
+            return PtrToStringUni(p);
+#endif
         }
     }
 

diff --git a/src/runtime/NewReference.cs → Python.Runtime/NewReference.cs b/src/runtime/NewReference.cs → Python.Runtime/NewReference.cs
diff --git a/src/runtime/NonCopyableAttribute.cs → Python.Runtime/NonCopyableAttribute.cs b/src/runtime/NonCopyableAttribute.cs → Python.Runtime/NonCopyableAttribute.cs
diff --git a/Python.Runtime/Python.Runtime.csproj b/Python.Runtime/Python.Runtime.csproj
@@ -0,0 +1,18 @@
+<Project Sdk="Microsoft.NET.Sdk">
+
+  <PropertyGroup>
+    <TargetFramework>netstandard2.0</TargetFramework>
+    <AllowUnsafeBlocks>true</AllowUnsafeBlocks>
+  </PropertyGroup>
+
+  <ItemGroup>
+    <EmbeddedResource Include="resources\clr.py">
+      <LogicalName>clr.py</LogicalName>
+    </EmbeddedResource>
+  </ItemGroup>
+
+  <ItemGroup>
+    <PackageReference Include="System.Reflection.Emit" Version="4.6.0" />
+  </ItemGroup>
+
+</Project>
diff --git a/src/runtime/ReferenceExtensions.cs → Python.Runtime/ReferenceExtensions.cs b/src/runtime/ReferenceExtensions.cs → Python.Runtime/ReferenceExtensions.cs
diff --git a/src/runtime/Util.cs → Python.Runtime/Util.cs b/src/runtime/Util.cs → Python.Runtime/Util.cs
diff --git a/src/runtime/arrayobject.cs → Python.Runtime/arrayobject.cs b/src/runtime/arrayobject.cs → Python.Runtime/arrayobject.cs
diff --git a/src/runtime/assemblymanager.cs → Python.Runtime/assemblymanager.cs b/src/runtime/assemblymanager.cs → Python.Runtime/assemblymanager.cs
diff --git a/src/runtime/classbase.cs → Python.Runtime/classbase.cs b/src/runtime/classbase.cs → Python.Runtime/classbase.cs
diff --git a/src/runtime/classderived.cs → Python.Runtime/classderived.cs b/src/runtime/classderived.cs → Python.Runtime/classderived.cs
diff --git a/src/runtime/classmanager.cs → Python.Runtime/classmanager.cs b/src/runtime/classmanager.cs → Python.Runtime/classmanager.cs
diff --git a/src/runtime/classobject.cs → Python.Runtime/classobject.cs b/src/runtime/classobject.cs → Python.Runtime/classobject.cs
diff --git a/src/runtime/clrobject.cs → Python.Runtime/clrobject.cs b/src/runtime/clrobject.cs → Python.Runtime/clrobject.cs
diff --git a/src/runtime/codegenerator.cs → Python.Runtime/codegenerator.cs b/src/runtime/codegenerator.cs → Python.Runtime/codegenerator.cs
@@ -13,16 +13,40 @@ namespace Python.Runtime
     /// </summary>
     internal class CodeGenerator
     {
-        private AssemblyBuilder aBuilder;
-        private ModuleBuilder mBuilder;
+        private AssemblyBuilder _aBuilder = null;
 
-        internal CodeGenerator()
+        private AssemblyBuilder aBuilder
+        {
+            get
+            {
+                if (_aBuilder == null)
+                {
+                    var aname = new AssemblyName { Name = "__CodeGenerator_Assembly" };
+                    var aa = AssemblyBuilderAccess.Run;
+
+                    _aBuilder = Thread.GetDomain().DefineDynamicAssembly(aname, aa);
+                }
+
+                return _aBuilder;
+            }
+        }
+
+        private ModuleBuilder _mBuilder = null;
+        private ModuleBuilder mBuilder
         {
-            var aname = new AssemblyName { Name = "__CodeGenerator_Assembly" };
-            var aa = AssemblyBuilderAccess.Run;
+            get
+            {
+                if (_mBuilder == null)
+                {
+                    _mBuilder = aBuilder.DefineDynamicModule("__CodeGenerator_Module");
+                }
+
+                return _mBuilder;
+            }
+        }
 
-            aBuilder = Thread.GetDomain().DefineDynamicAssembly(aname, aa);
-            mBuilder = aBuilder.DefineDynamicModule("__CodeGenerator_Module");
+        internal CodeGenerator()
+        {
         }
 
         /// <summary>

diff --git a/src/runtime/constructorbinder.cs → Python.Runtime/constructorbinder.cs b/src/runtime/constructorbinder.cs → Python.Runtime/constructorbinder.cs
diff --git a/src/runtime/constructorbinding.cs → Python.Runtime/constructorbinding.cs b/src/runtime/constructorbinding.cs → Python.Runtime/constructorbinding.cs
-Original file line number
+Diff line change
@@ Expand Up / @@ -2,6 +2,7 @@ @@
     *.dll
     *.exe
     *.pdb
+    pythonnet/dlls/
     ### JetBrains ###
     .idea/
@@ Expand Down @@