Add ICustomMarshaler StrMarshaler

vmuriart · vmuriart · commit 6667669e71bf · 2017-02-27T18:57:53.000-07:00
Useful resources https://msdn.microsoft.com/en-us/library/system.runtime.interopservices.icustommarshaler(v=vs.110).aspx https://limbioliong.wordpress.com/2013/11/03/understanding-custom-marshaling-part-1/ https://github.com/mono/mono/blob/master/mcs/class/Mono.Posix/Mono.Unix/UnixMarshal.cs http://stackoverflow.com/a/33514037/5208670
diff --git a/src/runtime/CustomMarshaler.cs b/src/runtime/CustomMarshaler.cs
@@ -0,0 +1,80 @@
+using System;
+using System.Runtime.InteropServices;
+using System.Text;
+
+namespace Python.Runtime
+{
+    /// <summary>
+    /// Abstract class defining boiler plate methods that
+    /// Custom Marshalers will use.
+    /// </summary>
+    public abstract class MarshalerBase : ICustomMarshaler
+    {
+        public object MarshalNativeToManaged(IntPtr pNativeData)
+        {
+            throw new NotImplementedException();
+        }
+
+        public abstract IntPtr MarshalManagedToNative(object managedObj);
+
+        public void CleanUpNativeData(IntPtr pNativeData)
+        {
+            Marshal.FreeHGlobal(pNativeData);
+        }
+
+        public void CleanUpManagedData(object managedObj)
+        {
+            // Let GC deal with it
+        }
+
+        public int GetNativeDataSize()
+        {
+            return IntPtr.Size;
+        }
+    }
+
+
+    /// <summary>
+    /// Custom Marshaler to deal with Managed String to Native
+    /// conversion differences on UCS2/UCS4.
+    /// </summary>
+    public class StrMarshaler : MarshalerBase
+    {
+        private static readonly MarshalerBase Instance = new StrMarshaler();
+
+        public override IntPtr MarshalManagedToNative(object managedObj)
+        {
+            Encoding encoding = Runtime.UCS == 2 ? Encoding.Unicode : Encoding.UTF32;
+            var s = managedObj as string;
+
+            if (s == null)
+            {
+                return IntPtr.Zero;
+            }
+
+            int minByteCount = encoding.GetMaxByteCount(1);
+            char[] cStr = s.ToCharArray(0, s.Length);
+            byte[] bStr = new byte[encoding.GetByteCount(cStr) + minByteCount];
+            encoding.GetBytes(cStr, 0, cStr.Length, bStr, 0);
+            DebugUtil.PrintHexBytes(bStr);
+
+            IntPtr mem = Marshal.AllocHGlobal(bStr.Length);
+            try
+            {
+                Marshal.Copy(bStr, 0, mem, bStr.Length);
+            }
+            catch (Exception)
+            {
+                Marshal.FreeHGlobal(mem);
+                throw;
+            }
+
+            return mem;
+        }
+
+        public static ICustomMarshaler GetInstance(string cookie)
+        {
+            return Instance;
+        }
+    }
+}
diff --git a/src/runtime/Python.Runtime.csproj b/src/runtime/Python.Runtime.csproj
@@ -89,6 +89,7 @@
     <Compile Include="constructorbinder.cs" />
     <Compile Include="constructorbinding.cs" />
     <Compile Include="converter.cs" />
+    <Compile Include="CustomMarshaler.cs" />
     <Compile Include="debughelper.cs" />
     <Compile Include="delegatemanager.cs" />
     <Compile Include="delegateobject.cs" />
diff --git a/src/runtime/debughelper.cs b/src/runtime/debughelper.cs
@@ -115,5 +115,27 @@ internal static void debug(string msg)
             Console.WriteLine("thread {0} : {1}", tid, caller);
             Console.WriteLine("  {0}", msg);
         }
+
+        /// <summary>
+        /// Helper function to inspect/compare managed to native conversions.
+        /// Especially useful when debugging CustomMarshaler.
+        /// </summary>
+        /// <param name="bytes"></param>
+        [Conditional("DEBUG")]
+        public static void PrintHexBytes(byte[] bytes)
+        {
+            if ((bytes == null) || (bytes.Length == 0))
+            {
+                Console.WriteLine("<none>");
+            }
+            else
+            {
+                foreach (byte t in bytes)
+                {
+                    Console.Write("{0:X2} ", t);
+                }
+                Console.WriteLine();
+            }
+        }
     }
 }
diff --git a/src/runtime/runtime.cs b/src/runtime/runtime.cs
@@ -1688,34 +1688,10 @@ internal unsafe static extern IntPtr
         internal unsafe static extern IntPtr
             PyUnicode_FromKindAndString(
                 int kind,
-                IntPtr s,
+                [MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof(StrMarshaler))] string s,
                 int size
             );
 
-        internal static unsafe IntPtr PyUnicode_FromKindAndString(
-            int kind,
-            string s,
-            int size)
-        {
-            var bufLength = Math.Max(s.Length, size) * 4;
-
-            IntPtr mem = Marshal.AllocHGlobal(bufLength);
-            try
-            {
-                fixed (char* ps = s)
-                {
-                    Encoding.UTF32.GetBytes(ps, s.Length, (byte*)mem, bufLength);
-                }
-
-                var result = PyUnicode_FromKindAndString(kind, mem, size);
-                return result;
-            }
-            finally
-            {
-                Marshal.FreeHGlobal(mem);
-            }
-        }
-
         internal static IntPtr PyUnicode_FromUnicode(string s, int size)
         {
             return PyUnicode_FromKindAndString(4, s, size);
@@ -1758,28 +1734,10 @@ internal unsafe static extern IntPtr
             EntryPoint = "PyUnicodeUCS4_FromUnicode",
             ExactSpelling = true)]
         internal unsafe static extern IntPtr
-            PyUnicode_FromUnicode(IntPtr s, int size);
-
-        internal static unsafe IntPtr PyUnicode_FromUnicode(string s, int size)
-        {
-            var bufLength = Math.Max(s.Length, size) * 4;
-
-            IntPtr mem = Marshal.AllocHGlobal(bufLength);
-            try
-            {
-                fixed (char* ps = s)
-                {
-                    Encoding.UTF32.GetBytes(ps, s.Length, (byte*)mem, bufLength);
-                }
-
-                var result = PyUnicode_FromUnicode(mem, size);
-                return result;
-            }
-            finally
-            {
-                Marshal.FreeHGlobal(mem);
-            }
-        }
+            PyUnicode_FromUnicode(
+                [MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof(StrMarshaler))] string s,
+                int size
+            );
 
         [DllImport(Runtime.dll, CallingConvention = CallingConvention.Cdecl,
             EntryPoint = "PyUnicodeUCS4_GetSize",
