pythonnet · vmuriart · Feb 28, 2017 · Feb 25, 2017 · Feb 25, 2017 · Feb 25, 2017
diff --git a/src/runtime/CustomMarshaler.cs b/src/runtime/CustomMarshaler.cs
@@ -0,0 +1,171 @@
+using System;
+using System.Linq;
+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();
+        private static readonly Encoding PyEncoding = Runtime.PyEncoding;
+
+        public override IntPtr MarshalManagedToNative(object managedObj)
+        {
+            var s = managedObj as string;
+
+            if (s == null)
+            {
+                return IntPtr.Zero;
+            }
+
+            byte[] bStr = PyEncoding.GetBytes(s + "\0");
+            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;
+        }
+    }
+
+
+    /// <summary>
+    /// Custom Marshaler to deal with Managed String Arrays to Native
+    /// conversion differences on UCS2/UCS4.
+    /// </summary>
+    public class StrArrayMarshaler : MarshalerBase
+    {
+        private static readonly MarshalerBase Instance = new StrArrayMarshaler();
+        private static readonly Encoding PyEncoding = Runtime.PyEncoding;
+
+        public override IntPtr MarshalManagedToNative(object managedObj)
+        {
+            var argv = managedObj as string[];
+
+            if (argv == null)
+            {
+                return IntPtr.Zero;
+            }
+
+            int totalStrLength = argv.Sum(arg => arg.Length + 1);
+            int memSize = argv.Length * IntPtr.Size + totalStrLength * Runtime.UCS;
+
+            IntPtr mem = Marshal.AllocHGlobal(memSize);
+            try
+            {
+                // Preparing array of pointers to strings
+                IntPtr curStrPtr = mem + argv.Length * IntPtr.Size;
+                for (var i = 0; i < argv.Length; i++)
+                {
+                    byte[] bStr = PyEncoding.GetBytes(argv[i] + "\0");
+                    Marshal.Copy(bStr, 0, curStrPtr, bStr.Length);
+                    Marshal.WriteIntPtr(mem + i * IntPtr.Size, curStrPtr);
+                    curStrPtr += bStr.Length;
+                }
+            }
+            catch (Exception)
+            {
+                Marshal.FreeHGlobal(mem);
+                throw;
+            }
+
+            return mem;
+        }
+
+        public static ICustomMarshaler GetInstance(string cookie)
+        {
+            return Instance;
+        }
+    }
+
+
+    /// <summary>
+    /// Custom Marshaler to deal with Managed String to Native
+    /// conversion on UTF-8. Use on functions that expect UTF-8 encoded
+    /// strings like `PyUnicode_FromStringAndSize`
+    /// </summary>
+    /// <remarks>
+    /// If instead we used `MarshalAs(UnmanagedType.LPWStr)` the output to
+    /// `foo` would be `f\x00o\x00o\x00`.
+    /// </remarks>
+    public class Utf8Marshaler : MarshalerBase
+    {
+        private static readonly MarshalerBase Instance = new Utf8Marshaler();
+        private static readonly Encoding PyEncoding = Encoding.UTF8;
+
+        public override IntPtr MarshalManagedToNative(object managedObj)
+        {
+            var s = managedObj as string;
+
+            if (s == null)
+            {
+                return IntPtr.Zero;
+            }
+
+            byte[] bStr = PyEncoding.GetBytes(s + "\0");
+            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/converter.cs b/src/runtime/converter.cs
@@ -599,21 +599,10 @@ private static bool ToPrimitive(IntPtr value, Type obType, out object result, bo
                     {
                         if (Runtime.PyUnicode_GetSize(value) == 1)
                         {
-                            op = Runtime.PyUnicode_AS_UNICODE(value);
-                            if (Runtime.UCS == 2) // Don't trust linter, statement not always true.
-                            {
-                                // 2011-01-02: Marshal as character array because the cast
-                                // result = (char)Marshal.ReadInt16(op); throws an OverflowException
-                                // on negative numbers with Check Overflow option set on the project
-                                Char[] buff = new Char[1];
-                                Marshal.Copy(op, buff, 0, 1);
-                                result = buff[0];
-                            }
-                            else // UCS4
-                            {
-                                // XXX this is probably NOT correct?
-                                result = (char)Marshal.ReadInt32(op);
-                            }
+                            op = Runtime.PyUnicode_AsUnicode(value);
+                            Char[] buff = new Char[1];
+                            Marshal.Copy(op, buff, 0, 1);
+                            result = buff[0];
                             return true;
                         }
                         goto type_error;

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();
+            }
+        }
     }
 }