Fixed the marshalling of std::string with GCC 6+ on Linux.

Signed-off-by: Dimitar Dobrev <dpldobrev@protonmail.com>

src/CppParser/Bindings/CLI/CppParser.h

@@ -281,7 +281,7 @@ namespace CppSharp
 
             void ClearSupportedStdTypes();
 
-            protected:
+        protected:
             bool __ownsNativeInstance;
         };
 
@@ -334,7 +334,7 @@ namespace CppSharp
                 void set(int);
             }
 
-            protected:
+        protected:
             bool __ownsNativeInstance;
         };
 
@@ -392,7 +392,7 @@ namespace CppSharp
 
             void ClearDiagnostics();
 
-            protected:
+        protected:
             bool __ownsNativeInstance;
         };
 
@@ -419,7 +419,7 @@ namespace CppSharp
 
             static CppSharp::Parser::ParserResult^ ParseLibrary(CppSharp::Parser::CppParserOptions^ Opts);
 
-            protected:
+        protected:
             bool __ownsNativeInstance;
         };
     }

src/CppParser/Bindings/CLI/Sources.h

@@ -37,7 +37,7 @@ namespace CppSharp
 
             static operator CppSharp::Parser::SourceLocation(unsigned int ID);
 
-            private:
+        private:
             unsigned int __ID;
         };
     }

src/CppParser/Bindings/CLI/Target.h

@@ -302,7 +302,7 @@ namespace CppSharp
                 void set(unsigned int);
             }
 
-            protected:
+        protected:
             bool __ownsNativeInstance;
         };
     }

src/CppParser/Bindings/CSharp/i686-apple-darwin12.4.0/Std-symbols.cpp

@@ -1,7 +1,7 @@
 #include <string>
 
 
-template __attribute__((visibility("default"))) std::allocator<char>::allocator() noexcept;
-template __attribute__((visibility("default"))) std::basic_string<char, std::char_traits<char>, std::allocator<char>>::basic_string(const std::basic_string<char, std::char_traits<char>, std::allocator<char>>::value_type*, const std::basic_string<char, std::char_traits<char>, std::allocator<char>>::allocator_type&);
+template __attribute__((visibility("default"))) std::basic_string<char, std::char_traits<char>, std::allocator<char>>::basic_string();
 template __attribute__((visibility("default"))) std::basic_string<char, std::char_traits<char>, std::allocator<char>>::~basic_string() noexcept;
+template __attribute__((visibility("default"))) std::basic_string<char, std::char_traits<char>, std::allocator<char>>& std::basic_string<char, std::char_traits<char>, std::allocator<char>>::assign(const std::basic_string<char, std::char_traits<char>, std::allocator<char>>::value_type*);
 template __attribute__((visibility("default"))) const std::basic_string<char, std::char_traits<char>, std::allocator<char>>::value_type* std::basic_string<char, std::char_traits<char>, std::allocator<char>>::c_str() const noexcept;

src/CppParser/Bindings/CSharp/i686-apple-darwin12.4.0/Std.cs

@@ -50,10 +50,6 @@ namespace Std
         [StructLayout(LayoutKind.Explicit, Size = 0)]
         public unsafe partial struct __Internal
         {
-            [SuppressUnmanagedCodeSecurity]
-            [DllImport("Std-symbols", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl,
-                EntryPoint="_ZNSt3__19allocatorIcEC2Ev")]
-            internal static extern void ctorc__N_std_N___1_S_allocator__C(global::System.IntPtr instance);
         }
     }
 
@@ -98,20 +94,6 @@ namespace Std
             __Instance = new global::System.IntPtr(native);
         }
 
-        public Allocator()
-        {
-            var ___Tp = typeof(_Tp);
-            if (___Tp.IsAssignableFrom(typeof(sbyte)))
-            {
-                __Instance = Marshal.AllocHGlobal(sizeof(global::Std.Allocator.__Internal));
-                __ownsNativeInstance = true;
-                NativeToManagedMap[__Instance] = this;
-                global::Std.Allocator.__Internal.ctorc__N_std_N___1_S_allocator__C((__Instance + __PointerAdjustment));
-                return;
-            }
-            throw new ArgumentOutOfRangeException("_Tp", string.Join(", ", new[] { typeof(_Tp).FullName }), "global::Std.Allocator<_Tp> maps a C++ template class and therefore it only supports a limited set of types and their subclasses: <sbyte>.");
-        }
-
         public void Dispose()
         {
             Dispose(disposing: true);
@@ -661,47 +643,6 @@ namespace Std
 
 namespace Std
 {
-    public unsafe static partial class BasicStringExtensions
-    {
-        [StructLayout(LayoutKind.Explicit, Size = 0)]
-        public partial struct __Internal
-        {
-            [SuppressUnmanagedCodeSecurity]
-            [DllImport("Std-symbols", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl,
-                EntryPoint="_ZNSt3__112basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEEC2EPKcRKS4_")]
-            internal static extern global::System.IntPtr BasicString(global::System.IntPtr instance, [MarshalAs(UnmanagedType.LPStr)] string __s, global::System.IntPtr __a);
-
-            [SuppressUnmanagedCodeSecurity]
-            [DllImport("Std-symbols", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl,
-                EntryPoint="_ZNKSt3__112basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEE5c_strEv")]
-            internal static extern global::System.IntPtr CStr(global::System.IntPtr instance);
-        }
-
-        public static global::Std.BasicString<sbyte, global::Std.CharTraits<sbyte>, global::Std.Allocator<sbyte>> BasicString(string __s, global::Std.Allocator<sbyte> __a)
-        {
-            if (ReferenceEquals(__a, null))
-                throw new global::System.ArgumentNullException("__a", "Cannot be null because it is a C++ reference (&).");
-            var __arg1 = __a.__Instance;
-            if (ReferenceEquals(__s, null))
-                throw new global::System.ArgumentNullException(__s, "The underlying std::string cannot take null.");
-            var __ret = Marshal.AllocHGlobal(12);
-            __Internal.BasicString(__ret, __s, __arg1);
-            global::Std.BasicString<sbyte, global::Std.CharTraits<sbyte>, global::Std.Allocator<sbyte>> __result0;
-            if (__ret == IntPtr.Zero) __result0 = null;
-            else if (global::Std.BasicString<sbyte, global::Std.CharTraits<sbyte>, global::Std.Allocator<sbyte>>.NativeToManagedMap.ContainsKey(__ret))
-                __result0 = (global::Std.BasicString<sbyte, global::Std.CharTraits<sbyte>, global::Std.Allocator<sbyte>>) global::Std.BasicString<sbyte, global::Std.CharTraits<sbyte>, global::Std.Allocator<sbyte>>.NativeToManagedMap[__ret];
-            else __result0 = global::Std.BasicString<sbyte, global::Std.CharTraits<sbyte>, global::Std.Allocator<sbyte>>.__CreateInstance(__ret);
-            return __result0;
-        }
-
-        public static string CStr(this global::Std.BasicString<sbyte, global::Std.CharTraits<sbyte>, global::Std.Allocator<sbyte>> @this)
-        {
-            var __arg0 = ReferenceEquals(@this, null) ? global::System.IntPtr.Zero : @this.__Instance;
-            var __ret = __Internal.CStr(__arg0);
-            return Marshal.PtrToStringAnsi(__ret);
-        }
-    }
-
     namespace BasicString
     {
         [StructLayout(LayoutKind.Explicit, Size = 12)]
@@ -710,6 +651,11 @@ namespace Std
             [FieldOffset(0)]
             internal global::Std.CompressedPair.__Internal __r_;
 
+            [SuppressUnmanagedCodeSecurity]
+            [DllImport("Std-symbols", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl,
+                EntryPoint="_ZNSt3__112basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEEC2Ev")]
+            internal static extern void ctorc__N_std_N___1_S_basic_string__C___N_std_N___1_S_char_traits__C___N_std_N___1_S_allocator__C(global::System.IntPtr instance);
+
             [SuppressUnmanagedCodeSecurity]
             [DllImport("Std-symbols", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl,
                 EntryPoint="_ZNSt3__112basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEED2Ev")]
@@ -847,6 +793,22 @@ namespace Std
             __Instance = new global::System.IntPtr(native);
         }
 
+        public BasicString()
+        {
+            var ___CharT = typeof(_CharT);
+            var ___Traits = typeof(_Traits);
+            var ___Allocator = typeof(_Allocator);
+            if (___CharT.IsAssignableFrom(typeof(sbyte)) && ___Traits.IsAssignableFrom(typeof(global::Std.CharTraits<sbyte>)) && ___Allocator.IsAssignableFrom(typeof(global::Std.Allocator<sbyte>)))
+            {
+                __Instance = Marshal.AllocHGlobal(sizeof(global::Std.BasicString.__Internalc__N_std_N___1_S_basic_string__C___N_std_N___1_S_char_traits__C___N_std_N___1_S_allocator__C));
+                __ownsNativeInstance = true;
+                NativeToManagedMap[__Instance] = this;
+                global::Std.BasicString.__Internalc__N_std_N___1_S_basic_string__C___N_std_N___1_S_char_traits__C___N_std_N___1_S_allocator__C.ctorc__N_std_N___1_S_basic_string__C___N_std_N___1_S_char_traits__C___N_std_N___1_S_allocator__C((__Instance + __PointerAdjustment));
+                return;
+            }
+            throw new ArgumentOutOfRangeException("_CharT, _Traits, _Allocator", string.Join(", ", new[] { typeof(_CharT).FullName, typeof(_Traits).FullName, typeof(_Allocator).FullName }), "global::Std.BasicString<_CharT, _Traits, _Allocator> maps a C++ template class and therefore it only supports a limited set of types and their subclasses: <sbyte, global::Std.CharTraits<sbyte>, global::Std.Allocator<sbyte>>.");
+        }
+
         public void Dispose()
         {
             Dispose(disposing: true);
@@ -874,6 +836,18 @@ namespace Std
                 Marshal.FreeHGlobal(__Instance);
             __Instance = IntPtr.Zero;
         }
+
+        public global::Std.BasicString<_CharT, _Traits, _Allocator> Assign(global::Std.BasicString<_CharT, _Traits, _Allocator> str)
+        {
+            var ___CharT = typeof(_CharT);
+            var ___Traits = typeof(_Traits);
+            var ___Allocator = typeof(_Allocator);
+            if (___CharT.IsAssignableFrom(typeof(sbyte)) && ___Traits.IsAssignableFrom(typeof(global::Std.CharTraits<sbyte>)) && ___Allocator.IsAssignableFrom(typeof(global::Std.Allocator<sbyte>)))
+            {
+                throw new MissingMethodException("Method Assign ignored in specialization global::Std.BasicString<sbyte, global::Std.CharTraits<sbyte>, global::Std.Allocator<sbyte>>.");
+            }
+            throw new ArgumentOutOfRangeException("_CharT, _Traits, _Allocator", string.Join(", ", new[] { typeof(_CharT).FullName, typeof(_Traits).FullName, typeof(_Allocator).FullName }), "global::Std.BasicString<_CharT, _Traits, _Allocator> maps a C++ template class and therefore it only supports a limited set of types and their subclasses: <sbyte, global::Std.CharTraits<sbyte>, global::Std.Allocator<sbyte>>.");
+        }
     }
 
     namespace CharTraits
@@ -941,4 +915,40 @@ namespace Std
             __Instance = IntPtr.Zero;
         }
     }
+
+    public unsafe static partial class BasicStringExtensions
+    {
+        [StructLayout(LayoutKind.Explicit, Size = 0)]
+        public partial struct __Internal
+        {
+            [SuppressUnmanagedCodeSecurity]
+            [DllImport("Std-symbols", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl,
+                EntryPoint="_ZNSt3__112basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEE6assignEPKc")]
+            internal static extern global::System.IntPtr Assign(global::System.IntPtr instance, [MarshalAs(UnmanagedType.LPStr)] string __s);
+
+            [SuppressUnmanagedCodeSecurity]
+            [DllImport("Std-symbols", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl,
+                EntryPoint="_ZNKSt3__112basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEE5c_strEv")]
+            internal static extern global::System.IntPtr CStr(global::System.IntPtr instance);
+        }
+
+        public static global::Std.BasicString<sbyte, global::Std.CharTraits<sbyte>, global::Std.Allocator<sbyte>> Assign(this global::Std.BasicString<sbyte, global::Std.CharTraits<sbyte>, global::Std.Allocator<sbyte>> @this, string __s)
+        {
+            var __arg0 = ReferenceEquals(@this, null) ? global::System.IntPtr.Zero : @this.__Instance;
+            var __ret = __Internal.Assign(__arg0, __s);
+            global::Std.BasicString<sbyte, global::Std.CharTraits<sbyte>, global::Std.Allocator<sbyte>> __result0;
+            if (__ret == IntPtr.Zero) __result0 = null;
+            else if (global::Std.BasicString<sbyte, global::Std.CharTraits<sbyte>, global::Std.Allocator<sbyte>>.NativeToManagedMap.ContainsKey(__ret))
+                __result0 = (global::Std.BasicString<sbyte, global::Std.CharTraits<sbyte>, global::Std.Allocator<sbyte>>) global::Std.BasicString<sbyte, global::Std.CharTraits<sbyte>, global::Std.Allocator<sbyte>>.NativeToManagedMap[__ret];
+            else __result0 = global::Std.BasicString<sbyte, global::Std.CharTraits<sbyte>, global::Std.Allocator<sbyte>>.__CreateInstance(__ret);
+            return __result0;
+        }
+
+        public static string CStr(this global::Std.BasicString<sbyte, global::Std.CharTraits<sbyte>, global::Std.Allocator<sbyte>> @this)
+        {
+            var __arg0 = ReferenceEquals(@this, null) ? global::System.IntPtr.Zero : @this.__Instance;
+            var __ret = __Internal.CStr(__arg0);
+            return Marshal.PtrToStringAnsi(__ret);
+        }
+    }
 }

src/CppParser/Bindings/CSharp/i686-pc-win32-msvc/Std.cs

@@ -379,10 +379,6 @@ namespace Std
         [StructLayout(LayoutKind.Explicit, Size = 0)]
         public unsafe partial struct __Internal
         {
-            [SuppressUnmanagedCodeSecurity]
-            [DllImport("Std-symbols", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.ThisCall,
-                EntryPoint="??0?$allocator@D@std@@QAE@XZ")]
-            internal static extern global::System.IntPtr ctorc__N_std_S_allocator__C(global::System.IntPtr instance);
         }
     }
 
@@ -427,20 +423,6 @@ namespace Std
             __Instance = new global::System.IntPtr(native);
         }
 
-        public Allocator()
-        {
-            var ___Ty = typeof(_Ty);
-            if (___Ty.IsAssignableFrom(typeof(sbyte)))
-            {
-                __Instance = Marshal.AllocHGlobal(sizeof(global::Std.Allocator.__Internal));
-                __ownsNativeInstance = true;
-                NativeToManagedMap[__Instance] = this;
-                global::Std.Allocator.__Internal.ctorc__N_std_S_allocator__C((__Instance + __PointerAdjustment));
-                return;
-            }
-            throw new ArgumentOutOfRangeException("_Ty", string.Join(", ", new[] { typeof(_Ty).FullName }), "global::Std.Allocator<_Ty> maps a C++ template class and therefore it only supports a limited set of types and their subclasses: <sbyte>.");
-        }
-
         public void Dispose()
         {
             Dispose(disposing: true);
@@ -461,47 +443,6 @@ namespace Std
 
 namespace Std
 {
-    public unsafe static partial class BasicStringExtensions
-    {
-        [StructLayout(LayoutKind.Explicit, Size = 0)]
-        public partial struct __Internal
-        {
-            [SuppressUnmanagedCodeSecurity]
-            [DllImport("Std-symbols", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.ThisCall,
-                EntryPoint="??0?$basic_string@DU?$char_traits@D@std@@V?$allocator@D@2@@std@@QAE@QBDABV?$allocator@D@1@@Z")]
-            internal static extern global::System.IntPtr BasicString(global::System.IntPtr instance, [MarshalAs(UnmanagedType.LPStr)] string _Ptr, global::System.IntPtr _Al);
-
-            [SuppressUnmanagedCodeSecurity]
-            [DllImport("Std-symbols", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.ThisCall,
-                EntryPoint="?c_str@?$basic_string@DU?$char_traits@D@std@@V?$allocator@D@2@@std@@QBEPBDXZ")]
-            internal static extern global::System.IntPtr CStr(global::System.IntPtr instance);
-        }
-
-        public static global::Std.BasicString<sbyte, global::Std.CharTraits<sbyte>, global::Std.Allocator<sbyte>> BasicString(string _Ptr, global::Std.Allocator<sbyte> _Al)
-        {
-            if (ReferenceEquals(_Al, null))
-                throw new global::System.ArgumentNullException("_Al", "Cannot be null because it is a C++ reference (&).");
-            var __arg1 = _Al.__Instance;
-            if (ReferenceEquals(_Ptr, null))
-                throw new global::System.ArgumentNullException(_Ptr, "The underlying std::string cannot take null.");
-            var __ret = Marshal.AllocHGlobal(24);
-            __Internal.BasicString(__ret, _Ptr, __arg1);
-            global::Std.BasicString<sbyte, global::Std.CharTraits<sbyte>, global::Std.Allocator<sbyte>> __result0;
-            if (__ret == IntPtr.Zero) __result0 = null;
-            else if (global::Std.BasicString<sbyte, global::Std.CharTraits<sbyte>, global::Std.Allocator<sbyte>>.NativeToManagedMap.ContainsKey(__ret))
-                __result0 = (global::Std.BasicString<sbyte, global::Std.CharTraits<sbyte>, global::Std.Allocator<sbyte>>) global::Std.BasicString<sbyte, global::Std.CharTraits<sbyte>, global::Std.Allocator<sbyte>>.NativeToManagedMap[__ret];
-            else __result0 = global::Std.BasicString<sbyte, global::Std.CharTraits<sbyte>, global::Std.Allocator<sbyte>>.__CreateInstance(__ret);
-            return __result0;
-        }
-
-        public static string CStr(this global::Std.BasicString<sbyte, global::Std.CharTraits<sbyte>, global::Std.Allocator<sbyte>> @this)
-        {
-            var __arg0 = ReferenceEquals(@this, null) ? global::System.IntPtr.Zero : @this.__Instance;
-            var __ret = __Internal.CStr(__arg0);
-            return Marshal.PtrToStringAnsi(__ret);
-        }
-    }
-
     namespace BasicString
     {
         [StructLayout(LayoutKind.Explicit, Size = 24)]
@@ -510,6 +451,11 @@ namespace Std
             [FieldOffset(0)]
             internal global::Std.CompressedPair.__Internalc__N_std_S__Compressed_pair____N_std_S_allocator__C___N_std_S__String_val____N_std_S__Simple_types__C_Vb1 _Mypair;
 
+            [SuppressUnmanagedCodeSecurity]
+            [DllImport("Std-symbols", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.ThisCall,
+                EntryPoint="??0?$basic_string@DU?$char_traits@D@std@@V?$allocator@D@2@@std@@QAE@XZ")]
+            internal static extern global::System.IntPtr ctorc__N_std_S_basic_string__C___N_std_S_char_traits__C___N_std_S_allocator__C(global::System.IntPtr instance);
+
             [SuppressUnmanagedCodeSecurity]
             [DllImport("Std-symbols", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.ThisCall,
                 EntryPoint="??1?$basic_string@DU?$char_traits@D@std@@V?$allocator@D@2@@std@@QAE@XZ")]
@@ -563,6 +509,22 @@ namespace Std
             __Instance = new global::System.IntPtr(native);
         }
 
+        public BasicString()
+        {
+            var ___Elem = typeof(_Elem);
+            var ___Traits = typeof(_Traits);
+            var ___Alloc = typeof(_Alloc);
+            if (___Elem.IsAssignableFrom(typeof(sbyte)) && ___Traits.IsAssignableFrom(typeof(global::Std.CharTraits<sbyte>)) && ___Alloc.IsAssignableFrom(typeof(global::Std.Allocator<sbyte>)))
+            {
+                __Instance = Marshal.AllocHGlobal(sizeof(global::Std.BasicString.__Internalc__N_std_S_basic_string__C___N_std_S_char_traits__C___N_std_S_allocator__C));
+                __ownsNativeInstance = true;
+                NativeToManagedMap[__Instance] = this;
+                global::Std.BasicString.__Internalc__N_std_S_basic_string__C___N_std_S_char_traits__C___N_std_S_allocator__C.ctorc__N_std_S_basic_string__C___N_std_S_char_traits__C___N_std_S_allocator__C((__Instance + __PointerAdjustment));
+                return;
+            }
+            throw new ArgumentOutOfRangeException("_Elem, _Traits, _Alloc", string.Join(", ", new[] { typeof(_Elem).FullName, typeof(_Traits).FullName, typeof(_Alloc).FullName }), "global::Std.BasicString<_Elem, _Traits, _Alloc> maps a C++ template class and therefore it only supports a limited set of types and their subclasses: <sbyte, global::Std.CharTraits<sbyte>, global::Std.Allocator<sbyte>>.");
+        }
+
         public void Dispose()
         {
             Dispose(disposing: true);
@@ -590,6 +552,18 @@ namespace Std
                 Marshal.FreeHGlobal(__Instance);
             __Instance = IntPtr.Zero;
         }
+
+        public global::Std.BasicString<_Elem, _Traits, _Alloc> Assign(global::Std.BasicString<_Elem, _Traits, _Alloc> _Right)
+        {
+            var ___Elem = typeof(_Elem);
+            var ___Traits = typeof(_Traits);
+            var ___Alloc = typeof(_Alloc);
+            if (___Elem.IsAssignableFrom(typeof(sbyte)) && ___Traits.IsAssignableFrom(typeof(global::Std.CharTraits<sbyte>)) && ___Alloc.IsAssignableFrom(typeof(global::Std.Allocator<sbyte>)))
+            {
+                throw new MissingMethodException("Method Assign ignored in specialization global::Std.BasicString<sbyte, global::Std.CharTraits<sbyte>, global::Std.Allocator<sbyte>>.");
+            }
+            throw new ArgumentOutOfRangeException("_Elem, _Traits, _Alloc", string.Join(", ", new[] { typeof(_Elem).FullName, typeof(_Traits).FullName, typeof(_Alloc).FullName }), "global::Std.BasicString<_Elem, _Traits, _Alloc> maps a C++ template class and therefore it only supports a limited set of types and their subclasses: <sbyte, global::Std.CharTraits<sbyte>, global::Std.Allocator<sbyte>>.");
+        }
     }
 
     namespace StringVal
@@ -624,6 +598,42 @@ namespace Std
         }
 
     }
+
+    public unsafe static partial class BasicStringExtensions
+    {
+        [StructLayout(LayoutKind.Explicit, Size = 0)]
+        public partial struct __Internal
+        {
+            [SuppressUnmanagedCodeSecurity]
+            [DllImport("Std-symbols", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.ThisCall,
+                EntryPoint="?assign@?$basic_string@DU?$char_traits@D@std@@V?$allocator@D@2@@std@@QAEAAV12@QBD@Z")]
+            internal static extern global::System.IntPtr Assign(global::System.IntPtr instance, [MarshalAs(UnmanagedType.LPStr)] string _Ptr);
+
+            [SuppressUnmanagedCodeSecurity]
+            [DllImport("Std-symbols", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.ThisCall,
+                EntryPoint="?c_str@?$basic_string@DU?$char_traits@D@std@@V?$allocator@D@2@@std@@QBEPBDXZ")]
+            internal static extern global::System.IntPtr CStr(global::System.IntPtr instance);
+        }
+
+        public static global::Std.BasicString<sbyte, global::Std.CharTraits<sbyte>, global::Std.Allocator<sbyte>> Assign(this global::Std.BasicString<sbyte, global::Std.CharTraits<sbyte>, global::Std.Allocator<sbyte>> @this, string _Ptr)
+        {
+            var __arg0 = ReferenceEquals(@this, null) ? global::System.IntPtr.Zero : @this.__Instance;
+            var __ret = __Internal.Assign(__arg0, _Ptr);
+            global::Std.BasicString<sbyte, global::Std.CharTraits<sbyte>, global::Std.Allocator<sbyte>> __result0;
+            if (__ret == IntPtr.Zero) __result0 = null;
+            else if (global::Std.BasicString<sbyte, global::Std.CharTraits<sbyte>, global::Std.Allocator<sbyte>>.NativeToManagedMap.ContainsKey(__ret))
+                __result0 = (global::Std.BasicString<sbyte, global::Std.CharTraits<sbyte>, global::Std.Allocator<sbyte>>) global::Std.BasicString<sbyte, global::Std.CharTraits<sbyte>, global::Std.Allocator<sbyte>>.NativeToManagedMap[__ret];
+            else __result0 = global::Std.BasicString<sbyte, global::Std.CharTraits<sbyte>, global::Std.Allocator<sbyte>>.__CreateInstance(__ret);
+            return __result0;
+        }
+
+        public static string CStr(this global::Std.BasicString<sbyte, global::Std.CharTraits<sbyte>, global::Std.Allocator<sbyte>> @this)
+        {
+            var __arg0 = ReferenceEquals(@this, null) ? global::System.IntPtr.Zero : @this.__Instance;
+            var __ret = __Internal.CStr(__arg0);
+            return Marshal.PtrToStringAnsi(__ret);
+        }
+    }
 }
 
 namespace Std

src/CppParser/Bindings/CSharp/x86_64-apple-darwin12.4.0/Std-symbols.cpp

@@ -1,7 +1,7 @@
 #include <string>
 
 
-template __attribute__((visibility("default"))) std::allocator<char>::allocator() noexcept;
-template __attribute__((visibility("default"))) std::basic_string<char, std::char_traits<char>, std::allocator<char>>::basic_string(const std::basic_string<char, std::char_traits<char>, std::allocator<char>>::value_type*, const std::basic_string<char, std::char_traits<char>, std::allocator<char>>::allocator_type&);
+template __attribute__((visibility("default"))) std::basic_string<char, std::char_traits<char>, std::allocator<char>>::basic_string();
 template __attribute__((visibility("default"))) std::basic_string<char, std::char_traits<char>, std::allocator<char>>::~basic_string() noexcept;
+template __attribute__((visibility("default"))) std::basic_string<char, std::char_traits<char>, std::allocator<char>>& std::basic_string<char, std::char_traits<char>, std::allocator<char>>::assign(const std::basic_string<char, std::char_traits<char>, std::allocator<char>>::value_type*);
 template __attribute__((visibility("default"))) const std::basic_string<char, std::char_traits<char>, std::allocator<char>>::value_type* std::basic_string<char, std::char_traits<char>, std::allocator<char>>::c_str() const noexcept;

src/CppParser/Bindings/CSharp/x86_64-apple-darwin12.4.0/Std.cs

@@ -50,10 +50,6 @@ namespace Std
         [StructLayout(LayoutKind.Explicit, Size = 0)]
         public unsafe partial struct __Internal
         {
-            [SuppressUnmanagedCodeSecurity]
-            [DllImport("Std-symbols", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl,
-                EntryPoint="_ZNSt3__19allocatorIcEC2Ev")]
-            internal static extern void ctorc__N_std_N___1_S_allocator__C(global::System.IntPtr instance);
         }
     }
 
@@ -98,20 +94,6 @@ namespace Std
             __Instance = new global::System.IntPtr(native);
         }
 
-        public Allocator()
-        {
-            var ___Tp = typeof(_Tp);
-            if (___Tp.IsAssignableFrom(typeof(sbyte)))
-            {
-                __Instance = Marshal.AllocHGlobal(sizeof(global::Std.Allocator.__Internal));
-                __ownsNativeInstance = true;
-                NativeToManagedMap[__Instance] = this;
-                global::Std.Allocator.__Internal.ctorc__N_std_N___1_S_allocator__C((__Instance + __PointerAdjustment));
-                return;
-            }
-            throw new ArgumentOutOfRangeException("_Tp", string.Join(", ", new[] { typeof(_Tp).FullName }), "global::Std.Allocator<_Tp> maps a C++ template class and therefore it only supports a limited set of types and their subclasses: <sbyte>.");
-        }
-
         public void Dispose()
         {
             Dispose(disposing: true);
@@ -661,47 +643,6 @@ namespace Std
 
 namespace Std
 {
-    public unsafe static partial class BasicStringExtensions
-    {
-        [StructLayout(LayoutKind.Explicit, Size = 0)]
-        public partial struct __Internal
-        {
-            [SuppressUnmanagedCodeSecurity]
-            [DllImport("Std-symbols", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl,
-                EntryPoint="_ZNSt3__112basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEEC2EPKcRKS4_")]
-            internal static extern global::System.IntPtr BasicString(global::System.IntPtr instance, [MarshalAs(UnmanagedType.LPStr)] string __s, global::System.IntPtr __a);
-
-            [SuppressUnmanagedCodeSecurity]
-            [DllImport("Std-symbols", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl,
-                EntryPoint="_ZNKSt3__112basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEE5c_strEv")]
-            internal static extern global::System.IntPtr CStr(global::System.IntPtr instance);
-        }
-
-        public static global::Std.BasicString<sbyte, global::Std.CharTraits<sbyte>, global::Std.Allocator<sbyte>> BasicString(string __s, global::Std.Allocator<sbyte> __a)
-        {
-            if (ReferenceEquals(__a, null))
-                throw new global::System.ArgumentNullException("__a", "Cannot be null because it is a C++ reference (&).");
-            var __arg1 = __a.__Instance;
-            if (ReferenceEquals(__s, null))
-                throw new global::System.ArgumentNullException(__s, "The underlying std::string cannot take null.");
-            var __ret = Marshal.AllocHGlobal(24);
-            __Internal.BasicString(__ret, __s, __arg1);
-            global::Std.BasicString<sbyte, global::Std.CharTraits<sbyte>, global::Std.Allocator<sbyte>> __result0;
-            if (__ret == IntPtr.Zero) __result0 = null;
-            else if (global::Std.BasicString<sbyte, global::Std.CharTraits<sbyte>, global::Std.Allocator<sbyte>>.NativeToManagedMap.ContainsKey(__ret))
-                __result0 = (global::Std.BasicString<sbyte, global::Std.CharTraits<sbyte>, global::Std.Allocator<sbyte>>) global::Std.BasicString<sbyte, global::Std.CharTraits<sbyte>, global::Std.Allocator<sbyte>>.NativeToManagedMap[__ret];
-            else __result0 = global::Std.BasicString<sbyte, global::Std.CharTraits<sbyte>, global::Std.Allocator<sbyte>>.__CreateInstance(__ret);
-            return __result0;
-        }
-
-        public static string CStr(this global::Std.BasicString<sbyte, global::Std.CharTraits<sbyte>, global::Std.Allocator<sbyte>> @this)
-        {
-            var __arg0 = ReferenceEquals(@this, null) ? global::System.IntPtr.Zero : @this.__Instance;
-            var __ret = __Internal.CStr(__arg0);
-            return Marshal.PtrToStringAnsi(__ret);
-        }
-    }
-
     namespace BasicString
     {
         [StructLayout(LayoutKind.Explicit, Size = 24)]
@@ -710,6 +651,11 @@ namespace Std
             [FieldOffset(0)]
             internal global::Std.CompressedPair.__Internal __r_;
 
+            [SuppressUnmanagedCodeSecurity]
+            [DllImport("Std-symbols", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl,
+                EntryPoint="_ZNSt3__112basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEEC2Ev")]
+            internal static extern void ctorc__N_std_N___1_S_basic_string__C___N_std_N___1_S_char_traits__C___N_std_N___1_S_allocator__C(global::System.IntPtr instance);
+
             [SuppressUnmanagedCodeSecurity]
             [DllImport("Std-symbols", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl,
                 EntryPoint="_ZNSt3__112basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEED2Ev")]
@@ -847,6 +793,22 @@ namespace Std
             __Instance = new global::System.IntPtr(native);
         }
 
+        public BasicString()
+        {
+            var ___CharT = typeof(_CharT);
+            var ___Traits = typeof(_Traits);
+            var ___Allocator = typeof(_Allocator);
+            if (___CharT.IsAssignableFrom(typeof(sbyte)) && ___Traits.IsAssignableFrom(typeof(global::Std.CharTraits<sbyte>)) && ___Allocator.IsAssignableFrom(typeof(global::Std.Allocator<sbyte>)))
+            {
+                __Instance = Marshal.AllocHGlobal(sizeof(global::Std.BasicString.__Internalc__N_std_N___1_S_basic_string__C___N_std_N___1_S_char_traits__C___N_std_N___1_S_allocator__C));
+                __ownsNativeInstance = true;
+                NativeToManagedMap[__Instance] = this;
+                global::Std.BasicString.__Internalc__N_std_N___1_S_basic_string__C___N_std_N___1_S_char_traits__C___N_std_N___1_S_allocator__C.ctorc__N_std_N___1_S_basic_string__C___N_std_N___1_S_char_traits__C___N_std_N___1_S_allocator__C((__Instance + __PointerAdjustment));
+                return;
+            }
+            throw new ArgumentOutOfRangeException("_CharT, _Traits, _Allocator", string.Join(", ", new[] { typeof(_CharT).FullName, typeof(_Traits).FullName, typeof(_Allocator).FullName }), "global::Std.BasicString<_CharT, _Traits, _Allocator> maps a C++ template class and therefore it only supports a limited set of types and their subclasses: <sbyte, global::Std.CharTraits<sbyte>, global::Std.Allocator<sbyte>>.");
+        }
+
         public void Dispose()
         {
             Dispose(disposing: true);
@@ -874,6 +836,18 @@ namespace Std
                 Marshal.FreeHGlobal(__Instance);
             __Instance = IntPtr.Zero;
         }
+
+        public global::Std.BasicString<_CharT, _Traits, _Allocator> Assign(global::Std.BasicString<_CharT, _Traits, _Allocator> str)
+        {
+            var ___CharT = typeof(_CharT);
+            var ___Traits = typeof(_Traits);
+            var ___Allocator = typeof(_Allocator);
+            if (___CharT.IsAssignableFrom(typeof(sbyte)) && ___Traits.IsAssignableFrom(typeof(global::Std.CharTraits<sbyte>)) && ___Allocator.IsAssignableFrom(typeof(global::Std.Allocator<sbyte>)))
+            {
+                throw new MissingMethodException("Method Assign ignored in specialization global::Std.BasicString<sbyte, global::Std.CharTraits<sbyte>, global::Std.Allocator<sbyte>>.");
+            }
+            throw new ArgumentOutOfRangeException("_CharT, _Traits, _Allocator", string.Join(", ", new[] { typeof(_CharT).FullName, typeof(_Traits).FullName, typeof(_Allocator).FullName }), "global::Std.BasicString<_CharT, _Traits, _Allocator> maps a C++ template class and therefore it only supports a limited set of types and their subclasses: <sbyte, global::Std.CharTraits<sbyte>, global::Std.Allocator<sbyte>>.");
+        }
     }
 
     namespace CharTraits
@@ -941,4 +915,40 @@ namespace Std
             __Instance = IntPtr.Zero;
         }
     }
+
+    public unsafe static partial class BasicStringExtensions
+    {
+        [StructLayout(LayoutKind.Explicit, Size = 0)]
+        public partial struct __Internal
+        {
+            [SuppressUnmanagedCodeSecurity]
+            [DllImport("Std-symbols", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl,
+                EntryPoint="_ZNSt3__112basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEE6assignEPKc")]
+            internal static extern global::System.IntPtr Assign(global::System.IntPtr instance, [MarshalAs(UnmanagedType.LPStr)] string __s);
+
+            [SuppressUnmanagedCodeSecurity]
+            [DllImport("Std-symbols", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl,
+                EntryPoint="_ZNKSt3__112basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEE5c_strEv")]
+            internal static extern global::System.IntPtr CStr(global::System.IntPtr instance);
+        }
+
+        public static global::Std.BasicString<sbyte, global::Std.CharTraits<sbyte>, global::Std.Allocator<sbyte>> Assign(this global::Std.BasicString<sbyte, global::Std.CharTraits<sbyte>, global::Std.Allocator<sbyte>> @this, string __s)
+        {
+            var __arg0 = ReferenceEquals(@this, null) ? global::System.IntPtr.Zero : @this.__Instance;
+            var __ret = __Internal.Assign(__arg0, __s);
+            global::Std.BasicString<sbyte, global::Std.CharTraits<sbyte>, global::Std.Allocator<sbyte>> __result0;
+            if (__ret == IntPtr.Zero) __result0 = null;
+            else if (global::Std.BasicString<sbyte, global::Std.CharTraits<sbyte>, global::Std.Allocator<sbyte>>.NativeToManagedMap.ContainsKey(__ret))
+                __result0 = (global::Std.BasicString<sbyte, global::Std.CharTraits<sbyte>, global::Std.Allocator<sbyte>>) global::Std.BasicString<sbyte, global::Std.CharTraits<sbyte>, global::Std.Allocator<sbyte>>.NativeToManagedMap[__ret];
+            else __result0 = global::Std.BasicString<sbyte, global::Std.CharTraits<sbyte>, global::Std.Allocator<sbyte>>.__CreateInstance(__ret);
+            return __result0;
+        }
+
+        public static string CStr(this global::Std.BasicString<sbyte, global::Std.CharTraits<sbyte>, global::Std.Allocator<sbyte>> @this)
+        {
+            var __arg0 = ReferenceEquals(@this, null) ? global::System.IntPtr.Zero : @this.__Instance;
+            var __ret = __Internal.CStr(__arg0);
+            return Marshal.PtrToStringAnsi(__ret);
+        }
+    }
 }

src/CppParser/Bindings/CSharp/x86_64-linux-gnu-cxx11abi/Std.cs

@@ -20,11 +20,6 @@ namespace Std
         [StructLayout(LayoutKind.Explicit, Size = 0)]
         public unsafe partial struct __Internal
         {
-            [SuppressUnmanagedCodeSecurity]
-            [DllImport("Std-symbols", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl,
-                EntryPoint="_ZNSaIcEC2Ev")]
-            internal static extern void ctorc__N_std_S_allocator__C(global::System.IntPtr instance);
-
             [SuppressUnmanagedCodeSecurity]
             [DllImport("Std-symbols", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl,
                 EntryPoint="_ZNSaIcED2Ev")]
@@ -73,20 +68,6 @@ namespace Std
             __Instance = new global::System.IntPtr(native);
         }
 
-        public Allocator()
-        {
-            var ___Tp = typeof(_Tp);
-            if (___Tp.IsAssignableFrom(typeof(sbyte)))
-            {
-                __Instance = Marshal.AllocHGlobal(sizeof(global::Std.Allocator.__Internal));
-                __ownsNativeInstance = true;
-                NativeToManagedMap[__Instance] = this;
-                global::Std.Allocator.__Internal.ctorc__N_std_S_allocator__C((__Instance + __PointerAdjustment));
-                return;
-            }
-            throw new ArgumentOutOfRangeException("_Tp", string.Join(", ", new[] { typeof(_Tp).FullName }), "global::Std.Allocator<_Tp> maps a C++ template class and therefore it only supports a limited set of types and their subclasses: <sbyte>.");
-        }
-
         public void Dispose()
         {
             Dispose(disposing: true);
@@ -103,7 +84,7 @@ namespace Std
                 var ___Tp = typeof(_Tp);
                 if (___Tp.IsAssignableFrom(typeof(sbyte)))
                 {
-                    global::Std.Allocator.__Internal.dtorc__N_std_S_allocator__C((__Instance + __PointerAdjustment));
+                    throw new MissingMethodException("Method ~allocator<type-parameter-0-0> ignored in specialization global::Std.Allocator<sbyte>.");
                     return;
                 }
                 throw new ArgumentOutOfRangeException("_Tp", string.Join(", ", new[] { typeof(_Tp).FullName }), "global::Std.Allocator<_Tp> maps a C++ template class and therefore it only supports a limited set of types and their subclasses: <sbyte>.");
@@ -816,47 +797,6 @@ namespace Std
 
 namespace Std
 {
-    public unsafe static partial class BasicStringExtensions
-    {
-        [StructLayout(LayoutKind.Explicit, Size = 0)]
-        public partial struct __Internal
-        {
-            [SuppressUnmanagedCodeSecurity]
-            [DllImport("Std-symbols", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl,
-                EntryPoint="_ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEC2EPKcRKS3_")]
-            internal static extern global::System.IntPtr BasicString(global::System.IntPtr instance, [MarshalAs(UnmanagedType.LPStr)] string __s, global::System.IntPtr __a);
-
-            [SuppressUnmanagedCodeSecurity]
-            [DllImport("Std-symbols", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl,
-                EntryPoint="_ZNKSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE5c_strEv")]
-            internal static extern global::System.IntPtr CStr(global::System.IntPtr instance);
-        }
-
-        public static global::Std.BasicString<sbyte, global::Std.CharTraits<sbyte>, global::Std.Allocator<sbyte>> BasicString(string __s, global::Std.Allocator<sbyte> __a)
-        {
-            if (ReferenceEquals(__a, null))
-                throw new global::System.ArgumentNullException("__a", "Cannot be null because it is a C++ reference (&).");
-            var __arg1 = __a.__Instance;
-            if (ReferenceEquals(__s, null))
-                throw new global::System.ArgumentNullException(__s, "The underlying std::string cannot take null.");
-            var __ret = Marshal.AllocHGlobal(32);
-            __Internal.BasicString(__ret, __s, __arg1);
-            global::Std.BasicString<sbyte, global::Std.CharTraits<sbyte>, global::Std.Allocator<sbyte>> __result0;
-            if (__ret == IntPtr.Zero) __result0 = null;
-            else if (global::Std.BasicString<sbyte, global::Std.CharTraits<sbyte>, global::Std.Allocator<sbyte>>.NativeToManagedMap.ContainsKey(__ret))
-                __result0 = (global::Std.BasicString<sbyte, global::Std.CharTraits<sbyte>, global::Std.Allocator<sbyte>>) global::Std.BasicString<sbyte, global::Std.CharTraits<sbyte>, global::Std.Allocator<sbyte>>.NativeToManagedMap[__ret];
-            else __result0 = global::Std.BasicString<sbyte, global::Std.CharTraits<sbyte>, global::Std.Allocator<sbyte>>.__CreateInstance(__ret);
-            return __result0;
-        }
-
-        public static string CStr(this global::Std.BasicString<sbyte, global::Std.CharTraits<sbyte>, global::Std.Allocator<sbyte>> @this)
-        {
-            var __arg0 = ReferenceEquals(@this, null) ? global::System.IntPtr.Zero : @this.__Instance;
-            var __ret = __Internal.CStr(__arg0);
-            return Marshal.PtrToStringAnsi(__ret);
-        }
-    }
-
     namespace BasicString
     {
         [StructLayout(LayoutKind.Explicit, Size = 32)]
@@ -871,6 +811,11 @@ namespace Std
             [FieldOffset(16)]
             internal global::Std.BasicString._.__Internalc__N_std_N___cxx11_S_basic_string__C___N_std_S_char_traits__C___N_std_S_allocator__C _;
 
+            [SuppressUnmanagedCodeSecurity]
+            [DllImport("Std-symbols", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl,
+                EntryPoint="_ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEC2Ev")]
+            internal static extern void ctorc__N_std_N___cxx11_S_basic_string__C___N_std_S_char_traits__C___N_std_S_allocator__C(global::System.IntPtr instance);
+
             [SuppressUnmanagedCodeSecurity]
             [DllImport("Std-symbols", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl,
                 EntryPoint="_ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEED2Ev")]
@@ -949,6 +894,22 @@ namespace Std
             __Instance = new global::System.IntPtr(native);
         }
 
+        public BasicString()
+        {
+            var ___CharT = typeof(_CharT);
+            var ___Traits = typeof(_Traits);
+            var ___Alloc = typeof(_Alloc);
+            if (___CharT.IsAssignableFrom(typeof(sbyte)) && ___Traits.IsAssignableFrom(typeof(global::Std.CharTraits<sbyte>)) && ___Alloc.IsAssignableFrom(typeof(global::Std.Allocator<sbyte>)))
+            {
+                __Instance = Marshal.AllocHGlobal(sizeof(global::Std.BasicString.__Internalc__N_std_N___cxx11_S_basic_string__C___N_std_S_char_traits__C___N_std_S_allocator__C));
+                __ownsNativeInstance = true;
+                NativeToManagedMap[__Instance] = this;
+                global::Std.BasicString.__Internalc__N_std_N___cxx11_S_basic_string__C___N_std_S_char_traits__C___N_std_S_allocator__C.ctorc__N_std_N___cxx11_S_basic_string__C___N_std_S_char_traits__C___N_std_S_allocator__C((__Instance + __PointerAdjustment));
+                return;
+            }
+            throw new ArgumentOutOfRangeException("_CharT, _Traits, _Alloc", string.Join(", ", new[] { typeof(_CharT).FullName, typeof(_Traits).FullName, typeof(_Alloc).FullName }), "global::Std.BasicString<_CharT, _Traits, _Alloc> maps a C++ template class and therefore it only supports a limited set of types and their subclasses: <sbyte, global::Std.CharTraits<sbyte>, global::Std.Allocator<sbyte>>.");
+        }
+
         public void Dispose()
         {
             Dispose(disposing: true);
@@ -976,6 +937,54 @@ namespace Std
                 Marshal.FreeHGlobal(__Instance);
             __Instance = IntPtr.Zero;
         }
+
+        public global::Std.BasicString<_CharT, _Traits, _Alloc> Assign(global::Std.BasicString<_CharT, _Traits, _Alloc> __str)
+        {
+            var ___CharT = typeof(_CharT);
+            var ___Traits = typeof(_Traits);
+            var ___Alloc = typeof(_Alloc);
+            if (___CharT.IsAssignableFrom(typeof(sbyte)) && ___Traits.IsAssignableFrom(typeof(global::Std.CharTraits<sbyte>)) && ___Alloc.IsAssignableFrom(typeof(global::Std.Allocator<sbyte>)))
+            {
+                throw new MissingMethodException("Method Assign ignored in specialization global::Std.BasicString<sbyte, global::Std.CharTraits<sbyte>, global::Std.Allocator<sbyte>>.");
+            }
+            throw new ArgumentOutOfRangeException("_CharT, _Traits, _Alloc", string.Join(", ", new[] { typeof(_CharT).FullName, typeof(_Traits).FullName, typeof(_Alloc).FullName }), "global::Std.BasicString<_CharT, _Traits, _Alloc> maps a C++ template class and therefore it only supports a limited set of types and their subclasses: <sbyte, global::Std.CharTraits<sbyte>, global::Std.Allocator<sbyte>>.");
+        }
+    }
+
+    public unsafe static partial class BasicStringExtensions
+    {
+        [StructLayout(LayoutKind.Explicit, Size = 0)]
+        public partial struct __Internal
+        {
+            [SuppressUnmanagedCodeSecurity]
+            [DllImport("Std-symbols", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl,
+                EntryPoint="_ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE6assignEPKc")]
+            internal static extern global::System.IntPtr Assign(global::System.IntPtr instance, [MarshalAs(UnmanagedType.LPStr)] string __s);
+
+            [SuppressUnmanagedCodeSecurity]
+            [DllImport("Std-symbols", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl,
+                EntryPoint="_ZNKSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE5c_strEv")]
+            internal static extern global::System.IntPtr CStr(global::System.IntPtr instance);
+        }
+
+        public static global::Std.BasicString<sbyte, global::Std.CharTraits<sbyte>, global::Std.Allocator<sbyte>> Assign(this global::Std.BasicString<sbyte, global::Std.CharTraits<sbyte>, global::Std.Allocator<sbyte>> @this, string __s)
+        {
+            var __arg0 = ReferenceEquals(@this, null) ? global::System.IntPtr.Zero : @this.__Instance;
+            var __ret = __Internal.Assign(__arg0, __s);
+            global::Std.BasicString<sbyte, global::Std.CharTraits<sbyte>, global::Std.Allocator<sbyte>> __result0;
+            if (__ret == IntPtr.Zero) __result0 = null;
+            else if (global::Std.BasicString<sbyte, global::Std.CharTraits<sbyte>, global::Std.Allocator<sbyte>>.NativeToManagedMap.ContainsKey(__ret))
+                __result0 = (global::Std.BasicString<sbyte, global::Std.CharTraits<sbyte>, global::Std.Allocator<sbyte>>) global::Std.BasicString<sbyte, global::Std.CharTraits<sbyte>, global::Std.Allocator<sbyte>>.NativeToManagedMap[__ret];
+            else __result0 = global::Std.BasicString<sbyte, global::Std.CharTraits<sbyte>, global::Std.Allocator<sbyte>>.__CreateInstance(__ret);
+            return __result0;
+        }
+
+        public static string CStr(this global::Std.BasicString<sbyte, global::Std.CharTraits<sbyte>, global::Std.Allocator<sbyte>> @this)
+        {
+            var __arg0 = ReferenceEquals(@this, null) ? global::System.IntPtr.Zero : @this.__Instance;
+            var __ret = __Internal.CStr(__arg0);
+            return Marshal.PtrToStringAnsi(__ret);
+        }
     }
 }
 

src/CppParser/Bindings/CSharp/x86_64-linux-gnu/Std.cs

@@ -20,11 +20,6 @@ namespace Std
         [StructLayout(LayoutKind.Explicit, Size = 0)]
         public unsafe partial struct __Internal
         {
-            [SuppressUnmanagedCodeSecurity]
-            [DllImport("Std-symbols", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl,
-                EntryPoint="_ZNSaIcEC2Ev")]
-            internal static extern void ctorc__N_std_S_allocator__C(global::System.IntPtr instance);
-
             [SuppressUnmanagedCodeSecurity]
             [DllImport("Std-symbols", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl,
                 EntryPoint="_ZNSaIcED2Ev")]
@@ -73,20 +68,6 @@ namespace Std
             __Instance = new global::System.IntPtr(native);
         }
 
-        public Allocator()
-        {
-            var ___Tp = typeof(_Tp);
-            if (___Tp.IsAssignableFrom(typeof(sbyte)))
-            {
-                __Instance = Marshal.AllocHGlobal(sizeof(global::Std.Allocator.__Internal));
-                __ownsNativeInstance = true;
-                NativeToManagedMap[__Instance] = this;
-                global::Std.Allocator.__Internal.ctorc__N_std_S_allocator__C((__Instance + __PointerAdjustment));
-                return;
-            }
-            throw new ArgumentOutOfRangeException("_Tp", string.Join(", ", new[] { typeof(_Tp).FullName }), "global::Std.Allocator<_Tp> maps a C++ template class and therefore it only supports a limited set of types and their subclasses: <sbyte>.");
-        }
-
         public void Dispose()
         {
             Dispose(disposing: true);
@@ -103,7 +84,7 @@ namespace Std
                 var ___Tp = typeof(_Tp);
                 if (___Tp.IsAssignableFrom(typeof(sbyte)))
                 {
-                    global::Std.Allocator.__Internal.dtorc__N_std_S_allocator__C((__Instance + __PointerAdjustment));
+                    throw new MissingMethodException("Method ~allocator<type-parameter-0-0> ignored in specialization global::Std.Allocator<sbyte>.");
                     return;
                 }
                 throw new ArgumentOutOfRangeException("_Tp", string.Join(", ", new[] { typeof(_Tp).FullName }), "global::Std.Allocator<_Tp> maps a C++ template class and therefore it only supports a limited set of types and their subclasses: <sbyte>.");
@@ -816,47 +797,6 @@ namespace Std
 
 namespace Std
 {
-    public unsafe static partial class BasicStringExtensions
-    {
-        [StructLayout(LayoutKind.Explicit, Size = 0)]
-        public partial struct __Internal
-        {
-            [SuppressUnmanagedCodeSecurity]
-            [DllImport("Std-symbols", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl,
-                EntryPoint="_ZNSsC2EPKcRKSaIcE")]
-            internal static extern global::System.IntPtr BasicString(global::System.IntPtr instance, [MarshalAs(UnmanagedType.LPStr)] string __s, global::System.IntPtr __a);
-
-            [SuppressUnmanagedCodeSecurity]
-            [DllImport("Std-symbols", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl,
-                EntryPoint="_ZNKSs5c_strEv")]
-            internal static extern global::System.IntPtr CStr(global::System.IntPtr instance);
-        }
-
-        public static global::Std.BasicString<sbyte, global::Std.CharTraits<sbyte>, global::Std.Allocator<sbyte>> BasicString(string __s, global::Std.Allocator<sbyte> __a)
-        {
-            if (ReferenceEquals(__a, null))
-                throw new global::System.ArgumentNullException("__a", "Cannot be null because it is a C++ reference (&).");
-            var __arg1 = __a.__Instance;
-            if (ReferenceEquals(__s, null))
-                throw new global::System.ArgumentNullException(__s, "The underlying std::string cannot take null.");
-            var __ret = Marshal.AllocHGlobal(8);
-            __Internal.BasicString(__ret, __s, __arg1);
-            global::Std.BasicString<sbyte, global::Std.CharTraits<sbyte>, global::Std.Allocator<sbyte>> __result0;
-            if (__ret == IntPtr.Zero) __result0 = null;
-            else if (global::Std.BasicString<sbyte, global::Std.CharTraits<sbyte>, global::Std.Allocator<sbyte>>.NativeToManagedMap.ContainsKey(__ret))
-                __result0 = (global::Std.BasicString<sbyte, global::Std.CharTraits<sbyte>, global::Std.Allocator<sbyte>>) global::Std.BasicString<sbyte, global::Std.CharTraits<sbyte>, global::Std.Allocator<sbyte>>.NativeToManagedMap[__ret];
-            else __result0 = global::Std.BasicString<sbyte, global::Std.CharTraits<sbyte>, global::Std.Allocator<sbyte>>.__CreateInstance(__ret);
-            return __result0;
-        }
-
-        public static string CStr(this global::Std.BasicString<sbyte, global::Std.CharTraits<sbyte>, global::Std.Allocator<sbyte>> @this)
-        {
-            var __arg0 = ReferenceEquals(@this, null) ? global::System.IntPtr.Zero : @this.__Instance;
-            var __ret = __Internal.CStr(__arg0);
-            return Marshal.PtrToStringAnsi(__ret);
-        }
-    }
-
     namespace BasicString
     {
         [StructLayout(LayoutKind.Explicit, Size = 8)]
@@ -865,6 +805,11 @@ namespace Std
             [FieldOffset(0)]
             internal global::Std.BasicString.AllocHider.__Internal _M_dataplus;
 
+            [SuppressUnmanagedCodeSecurity]
+            [DllImport("Std-symbols", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl,
+                EntryPoint="_ZNSsC2Ev")]
+            internal static extern void ctorc__N_std_S_basic_string__C___N_std_S_char_traits__C___N_std_S_allocator__C(global::System.IntPtr instance);
+
             [SuppressUnmanagedCodeSecurity]
             [DllImport("Std-symbols", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl,
                 EntryPoint="_ZNSsD2Ev")]
@@ -929,6 +874,22 @@ namespace Std
             __Instance = new global::System.IntPtr(native);
         }
 
+        public BasicString()
+        {
+            var ___CharT = typeof(_CharT);
+            var ___Traits = typeof(_Traits);
+            var ___Alloc = typeof(_Alloc);
+            if (___CharT.IsAssignableFrom(typeof(sbyte)) && ___Traits.IsAssignableFrom(typeof(global::Std.CharTraits<sbyte>)) && ___Alloc.IsAssignableFrom(typeof(global::Std.Allocator<sbyte>)))
+            {
+                __Instance = Marshal.AllocHGlobal(sizeof(global::Std.BasicString.__Internalc__N_std_S_basic_string__C___N_std_S_char_traits__C___N_std_S_allocator__C));
+                __ownsNativeInstance = true;
+                NativeToManagedMap[__Instance] = this;
+                global::Std.BasicString.__Internalc__N_std_S_basic_string__C___N_std_S_char_traits__C___N_std_S_allocator__C.ctorc__N_std_S_basic_string__C___N_std_S_char_traits__C___N_std_S_allocator__C((__Instance + __PointerAdjustment));
+                return;
+            }
+            throw new ArgumentOutOfRangeException("_CharT, _Traits, _Alloc", string.Join(", ", new[] { typeof(_CharT).FullName, typeof(_Traits).FullName, typeof(_Alloc).FullName }), "global::Std.BasicString<_CharT, _Traits, _Alloc> maps a C++ template class and therefore it only supports a limited set of types and their subclasses: <sbyte, global::Std.CharTraits<sbyte>, global::Std.Allocator<sbyte>>.");
+        }
+
         public void Dispose()
         {
             Dispose(disposing: true);
@@ -956,6 +917,54 @@ namespace Std
                 Marshal.FreeHGlobal(__Instance);
             __Instance = IntPtr.Zero;
         }
+
+        public global::Std.BasicString<_CharT, _Traits, _Alloc> Assign(global::Std.BasicString<_CharT, _Traits, _Alloc> __str)
+        {
+            var ___CharT = typeof(_CharT);
+            var ___Traits = typeof(_Traits);
+            var ___Alloc = typeof(_Alloc);
+            if (___CharT.IsAssignableFrom(typeof(sbyte)) && ___Traits.IsAssignableFrom(typeof(global::Std.CharTraits<sbyte>)) && ___Alloc.IsAssignableFrom(typeof(global::Std.Allocator<sbyte>)))
+            {
+                throw new MissingMethodException("Method Assign ignored in specialization global::Std.BasicString<sbyte, global::Std.CharTraits<sbyte>, global::Std.Allocator<sbyte>>.");
+            }
+            throw new ArgumentOutOfRangeException("_CharT, _Traits, _Alloc", string.Join(", ", new[] { typeof(_CharT).FullName, typeof(_Traits).FullName, typeof(_Alloc).FullName }), "global::Std.BasicString<_CharT, _Traits, _Alloc> maps a C++ template class and therefore it only supports a limited set of types and their subclasses: <sbyte, global::Std.CharTraits<sbyte>, global::Std.Allocator<sbyte>>.");
+        }
+    }
+
+    public unsafe static partial class BasicStringExtensions
+    {
+        [StructLayout(LayoutKind.Explicit, Size = 0)]
+        public partial struct __Internal
+        {
+            [SuppressUnmanagedCodeSecurity]
+            [DllImport("Std-symbols", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl,
+                EntryPoint="_ZNSs6assignEPKc")]
+            internal static extern global::System.IntPtr Assign(global::System.IntPtr instance, [MarshalAs(UnmanagedType.LPStr)] string __s);
+
+            [SuppressUnmanagedCodeSecurity]
+            [DllImport("Std-symbols", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl,
+                EntryPoint="_ZNKSs5c_strEv")]
+            internal static extern global::System.IntPtr CStr(global::System.IntPtr instance);
+        }
+
+        public static global::Std.BasicString<sbyte, global::Std.CharTraits<sbyte>, global::Std.Allocator<sbyte>> Assign(this global::Std.BasicString<sbyte, global::Std.CharTraits<sbyte>, global::Std.Allocator<sbyte>> @this, string __s)
+        {
+            var __arg0 = ReferenceEquals(@this, null) ? global::System.IntPtr.Zero : @this.__Instance;
+            var __ret = __Internal.Assign(__arg0, __s);
+            global::Std.BasicString<sbyte, global::Std.CharTraits<sbyte>, global::Std.Allocator<sbyte>> __result0;
+            if (__ret == IntPtr.Zero) __result0 = null;
+            else if (global::Std.BasicString<sbyte, global::Std.CharTraits<sbyte>, global::Std.Allocator<sbyte>>.NativeToManagedMap.ContainsKey(__ret))
+                __result0 = (global::Std.BasicString<sbyte, global::Std.CharTraits<sbyte>, global::Std.Allocator<sbyte>>) global::Std.BasicString<sbyte, global::Std.CharTraits<sbyte>, global::Std.Allocator<sbyte>>.NativeToManagedMap[__ret];
+            else __result0 = global::Std.BasicString<sbyte, global::Std.CharTraits<sbyte>, global::Std.Allocator<sbyte>>.__CreateInstance(__ret);
+            return __result0;
+        }
+
+        public static string CStr(this global::Std.BasicString<sbyte, global::Std.CharTraits<sbyte>, global::Std.Allocator<sbyte>> @this)
+        {
+            var __arg0 = ReferenceEquals(@this, null) ? global::System.IntPtr.Zero : @this.__Instance;
+            var __ret = __Internal.CStr(__arg0);
+            return Marshal.PtrToStringAnsi(__ret);
+        }
     }
 }
 

src/CppParser/Bindings/CSharp/x86_64-pc-win32-msvc/Std.cs

@@ -379,10 +379,6 @@ namespace Std
         [StructLayout(LayoutKind.Explicit, Size = 0)]
         public unsafe partial struct __Internal
         {
-            [SuppressUnmanagedCodeSecurity]
-            [DllImport("Std-symbols", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl,
-                EntryPoint="??0?$allocator@D@std@@QEAA@XZ")]
-            internal static extern global::System.IntPtr ctorc__N_std_S_allocator__C(global::System.IntPtr instance);
         }
     }
 
@@ -427,20 +423,6 @@ namespace Std
             __Instance = new global::System.IntPtr(native);
         }
 
-        public Allocator()
-        {
-            var ___Ty = typeof(_Ty);
-            if (___Ty.IsAssignableFrom(typeof(sbyte)))
-            {
-                __Instance = Marshal.AllocHGlobal(sizeof(global::Std.Allocator.__Internal));
-                __ownsNativeInstance = true;
-                NativeToManagedMap[__Instance] = this;
-                global::Std.Allocator.__Internal.ctorc__N_std_S_allocator__C((__Instance + __PointerAdjustment));
-                return;
-            }
-            throw new ArgumentOutOfRangeException("_Ty", string.Join(", ", new[] { typeof(_Ty).FullName }), "global::Std.Allocator<_Ty> maps a C++ template class and therefore it only supports a limited set of types and their subclasses: <sbyte>.");
-        }
-
         public void Dispose()
         {
             Dispose(disposing: true);
@@ -461,47 +443,6 @@ namespace Std
 
 namespace Std
 {
-    public unsafe static partial class BasicStringExtensions
-    {
-        [StructLayout(LayoutKind.Explicit, Size = 0)]
-        public partial struct __Internal
-        {
-            [SuppressUnmanagedCodeSecurity]
-            [DllImport("Std-symbols", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl,
-                EntryPoint="??0?$basic_string@DU?$char_traits@D@std@@V?$allocator@D@2@@std@@QEAA@QEBDAEBV?$allocator@D@1@@Z")]
-            internal static extern global::System.IntPtr BasicString(global::System.IntPtr instance, [MarshalAs(UnmanagedType.LPStr)] string _Ptr, global::System.IntPtr _Al);
-
-            [SuppressUnmanagedCodeSecurity]
-            [DllImport("Std-symbols", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl,
-                EntryPoint="?c_str@?$basic_string@DU?$char_traits@D@std@@V?$allocator@D@2@@std@@QEBAPEBDXZ")]
-            internal static extern global::System.IntPtr CStr(global::System.IntPtr instance);
-        }
-
-        public static global::Std.BasicString<sbyte, global::Std.CharTraits<sbyte>, global::Std.Allocator<sbyte>> BasicString(string _Ptr, global::Std.Allocator<sbyte> _Al)
-        {
-            if (ReferenceEquals(_Al, null))
-                throw new global::System.ArgumentNullException("_Al", "Cannot be null because it is a C++ reference (&).");
-            var __arg1 = _Al.__Instance;
-            if (ReferenceEquals(_Ptr, null))
-                throw new global::System.ArgumentNullException(_Ptr, "The underlying std::string cannot take null.");
-            var __ret = Marshal.AllocHGlobal(32);
-            __Internal.BasicString(__ret, _Ptr, __arg1);
-            global::Std.BasicString<sbyte, global::Std.CharTraits<sbyte>, global::Std.Allocator<sbyte>> __result0;
-            if (__ret == IntPtr.Zero) __result0 = null;
-            else if (global::Std.BasicString<sbyte, global::Std.CharTraits<sbyte>, global::Std.Allocator<sbyte>>.NativeToManagedMap.ContainsKey(__ret))
-                __result0 = (global::Std.BasicString<sbyte, global::Std.CharTraits<sbyte>, global::Std.Allocator<sbyte>>) global::Std.BasicString<sbyte, global::Std.CharTraits<sbyte>, global::Std.Allocator<sbyte>>.NativeToManagedMap[__ret];
-            else __result0 = global::Std.BasicString<sbyte, global::Std.CharTraits<sbyte>, global::Std.Allocator<sbyte>>.__CreateInstance(__ret);
-            return __result0;
-        }
-
-        public static string CStr(this global::Std.BasicString<sbyte, global::Std.CharTraits<sbyte>, global::Std.Allocator<sbyte>> @this)
-        {
-            var __arg0 = ReferenceEquals(@this, null) ? global::System.IntPtr.Zero : @this.__Instance;
-            var __ret = __Internal.CStr(__arg0);
-            return Marshal.PtrToStringAnsi(__ret);
-        }
-    }
-
     namespace BasicString
     {
         [StructLayout(LayoutKind.Explicit, Size = 32)]
@@ -510,6 +451,11 @@ namespace Std
             [FieldOffset(0)]
             internal global::Std.CompressedPair.__Internalc__N_std_S__Compressed_pair____N_std_S_allocator__C___N_std_S__String_val____N_std_S__Simple_types__C_Vb1 _Mypair;
 
+            [SuppressUnmanagedCodeSecurity]
+            [DllImport("Std-symbols", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl,
+                EntryPoint="??0?$basic_string@DU?$char_traits@D@std@@V?$allocator@D@2@@std@@QEAA@XZ")]
+            internal static extern global::System.IntPtr ctorc__N_std_S_basic_string__C___N_std_S_char_traits__C___N_std_S_allocator__C(global::System.IntPtr instance);
+
             [SuppressUnmanagedCodeSecurity]
             [DllImport("Std-symbols", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl,
                 EntryPoint="??1?$basic_string@DU?$char_traits@D@std@@V?$allocator@D@2@@std@@QEAA@XZ")]
@@ -563,6 +509,22 @@ namespace Std
             __Instance = new global::System.IntPtr(native);
         }
 
+        public BasicString()
+        {
+            var ___Elem = typeof(_Elem);
+            var ___Traits = typeof(_Traits);
+            var ___Alloc = typeof(_Alloc);
+            if (___Elem.IsAssignableFrom(typeof(sbyte)) && ___Traits.IsAssignableFrom(typeof(global::Std.CharTraits<sbyte>)) && ___Alloc.IsAssignableFrom(typeof(global::Std.Allocator<sbyte>)))
+            {
+                __Instance = Marshal.AllocHGlobal(sizeof(global::Std.BasicString.__Internalc__N_std_S_basic_string__C___N_std_S_char_traits__C___N_std_S_allocator__C));
+                __ownsNativeInstance = true;
+                NativeToManagedMap[__Instance] = this;
+                global::Std.BasicString.__Internalc__N_std_S_basic_string__C___N_std_S_char_traits__C___N_std_S_allocator__C.ctorc__N_std_S_basic_string__C___N_std_S_char_traits__C___N_std_S_allocator__C((__Instance + __PointerAdjustment));
+                return;
+            }
+            throw new ArgumentOutOfRangeException("_Elem, _Traits, _Alloc", string.Join(", ", new[] { typeof(_Elem).FullName, typeof(_Traits).FullName, typeof(_Alloc).FullName }), "global::Std.BasicString<_Elem, _Traits, _Alloc> maps a C++ template class and therefore it only supports a limited set of types and their subclasses: <sbyte, global::Std.CharTraits<sbyte>, global::Std.Allocator<sbyte>>.");
+        }
+
         public void Dispose()
         {
             Dispose(disposing: true);
@@ -590,6 +552,18 @@ namespace Std
                 Marshal.FreeHGlobal(__Instance);
             __Instance = IntPtr.Zero;
         }
+
+        public global::Std.BasicString<_Elem, _Traits, _Alloc> Assign(global::Std.BasicString<_Elem, _Traits, _Alloc> _Right)
+        {
+            var ___Elem = typeof(_Elem);
+            var ___Traits = typeof(_Traits);
+            var ___Alloc = typeof(_Alloc);
+            if (___Elem.IsAssignableFrom(typeof(sbyte)) && ___Traits.IsAssignableFrom(typeof(global::Std.CharTraits<sbyte>)) && ___Alloc.IsAssignableFrom(typeof(global::Std.Allocator<sbyte>)))
+            {
+                throw new MissingMethodException("Method Assign ignored in specialization global::Std.BasicString<sbyte, global::Std.CharTraits<sbyte>, global::Std.Allocator<sbyte>>.");
+            }
+            throw new ArgumentOutOfRangeException("_Elem, _Traits, _Alloc", string.Join(", ", new[] { typeof(_Elem).FullName, typeof(_Traits).FullName, typeof(_Alloc).FullName }), "global::Std.BasicString<_Elem, _Traits, _Alloc> maps a C++ template class and therefore it only supports a limited set of types and their subclasses: <sbyte, global::Std.CharTraits<sbyte>, global::Std.Allocator<sbyte>>.");
+        }
     }
 
     namespace StringVal
@@ -624,6 +598,42 @@ namespace Std
         }
 
     }
+
+    public unsafe static partial class BasicStringExtensions
+    {
+        [StructLayout(LayoutKind.Explicit, Size = 0)]
+        public partial struct __Internal
+        {
+            [SuppressUnmanagedCodeSecurity]
+            [DllImport("Std-symbols", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl,
+                EntryPoint="?assign@?$basic_string@DU?$char_traits@D@std@@V?$allocator@D@2@@std@@QEAAAEAV12@QEBD@Z")]
+            internal static extern global::System.IntPtr Assign(global::System.IntPtr instance, [MarshalAs(UnmanagedType.LPStr)] string _Ptr);
+
+            [SuppressUnmanagedCodeSecurity]
+            [DllImport("Std-symbols", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl,
+                EntryPoint="?c_str@?$basic_string@DU?$char_traits@D@std@@V?$allocator@D@2@@std@@QEBAPEBDXZ")]
+            internal static extern global::System.IntPtr CStr(global::System.IntPtr instance);
+        }
+
+        public static global::Std.BasicString<sbyte, global::Std.CharTraits<sbyte>, global::Std.Allocator<sbyte>> Assign(this global::Std.BasicString<sbyte, global::Std.CharTraits<sbyte>, global::Std.Allocator<sbyte>> @this, string _Ptr)
+        {
+            var __arg0 = ReferenceEquals(@this, null) ? global::System.IntPtr.Zero : @this.__Instance;
+            var __ret = __Internal.Assign(__arg0, _Ptr);
+            global::Std.BasicString<sbyte, global::Std.CharTraits<sbyte>, global::Std.Allocator<sbyte>> __result0;
+            if (__ret == IntPtr.Zero) __result0 = null;
+            else if (global::Std.BasicString<sbyte, global::Std.CharTraits<sbyte>, global::Std.Allocator<sbyte>>.NativeToManagedMap.ContainsKey(__ret))
+                __result0 = (global::Std.BasicString<sbyte, global::Std.CharTraits<sbyte>, global::Std.Allocator<sbyte>>) global::Std.BasicString<sbyte, global::Std.CharTraits<sbyte>, global::Std.Allocator<sbyte>>.NativeToManagedMap[__ret];
+            else __result0 = global::Std.BasicString<sbyte, global::Std.CharTraits<sbyte>, global::Std.Allocator<sbyte>>.__CreateInstance(__ret);
+            return __result0;
+        }
+
+        public static string CStr(this global::Std.BasicString<sbyte, global::Std.CharTraits<sbyte>, global::Std.Allocator<sbyte>> @this)
+        {
+            var __arg0 = ReferenceEquals(@this, null) ? global::System.IntPtr.Zero : @this.__Instance;
+            var __ret = __Internal.CStr(__arg0);
+            return Marshal.PtrToStringAnsi(__ret);
+        }
+    }
 }
 
 namespace Std

src/CppParser/Parser.cpp

@@ -900,8 +900,11 @@ bool Parser::IsSupported(const clang::CXXMethodDecl* MD)
     using namespace clang;
 
     return !c->getSourceManager().isInSystemHeader(MD->getBeginLoc()) ||
-        isa<CXXConstructorDecl>(MD) || isa<CXXDestructorDecl>(MD) ||
-        (MD->getDeclName().isIdentifier() && MD->getName() == "c_str" &&
+        (isa<CXXConstructorDecl>(MD) && MD->getNumParams() == 0) ||
+        isa<CXXDestructorDecl>(MD) ||
+        (MD->getDeclName().isIdentifier() &&
+         ((MD->getName() == "c_str" && MD->getNumParams() == 0) ||
+          (MD->getName() == "assign" && MD->getNumParams() == 1)) &&
          supportedStdTypes.find(MD->getParent()->getName()) !=
             supportedStdTypes.end());
 }

src/Generator/Generators/CSharp/CSharpSources.cs

@@ -377,9 +377,7 @@ namespace CppSharp.Generators.CSharp
 
             if (@class.IsDependent && !@class.IsGenerated)
                 return true;
-
-            var typeMaps = new List<System.Type>();
-            var keys = new List<string>();
+            
             // disable the type maps, if any, for this class because of copy ctors, operators and others
             this.DisableTypeMap(@class);
 
@@ -924,7 +922,8 @@ namespace CppSharp.Generators.CSharp
 
             if (marshal.Context.Return.StringBuilder.Length > 0)
             {
-                Write($"{ctx.ReturnVarName} = ");
+                if (ctx.ReturnVarName.Length > 0)
+                    Write($"{ctx.ReturnVarName} = ");
                 if (type.IsPointer())
                 {
                     Type pointee = type.GetFinalPointee();
@@ -2818,15 +2817,6 @@ namespace CppSharp.Generators.CSharp
                 }
             }
 
-            // special validation when constructing std::string as it cannot take null as a value
-            if (method != null && method.OriginalName == "basic_string" &&
-                method.TranslationUnit.IsSystemHeader)
-            {
-                WriteLine($"if (ReferenceEquals({method.Parameters[0].Name}, null))");
-                WriteLineIndent($@"throw new global::System.ArgumentNullException({
-                    method.Parameters[0].Name}, ""The underlying std::string cannot take null."");");
-            }
-
             if (needsReturn && !originalFunction.HasIndirectReturnTypeParameter)
                 Write("var {0} = ", Helpers.ReturnIdentifier);
 

src/Generator/Passes/IgnoreSystemDeclarationsPass.cs

@@ -55,7 +55,8 @@ namespace CppSharp.Passes
             switch (@class.Name)
             {
                 case "basic_string":
-                    foreach (var method in @class.Methods.Where(m => !m.IsDestructor && m.OriginalName != "c_str"))
+                    foreach (var method in @class.Methods.Where(m => !m.IsDestructor &&
+                        m.OriginalName != "c_str" && m.OriginalName != "assign"))
                         method.ExplicitlyIgnore();
                     foreach (var basicString in GetCharSpecializations(@class))
                     {
@@ -63,9 +64,11 @@ namespace CppSharp.Passes
                         foreach (var method in basicString.Methods)
                         {
                             if (method.IsDestructor || method.OriginalName == "c_str" ||
-                                (method.IsConstructor && method.Parameters.Count == 2 &&
-                                 method.Parameters[0].Type.Desugar().IsPointerToPrimitiveType(PrimitiveType.Char) &&
-                                 !method.Parameters[1].Type.Desugar().IsPrimitiveType()))
+                                (method.OriginalName == "assign" &&
+                                 method.Parameters.Count == 1 &&
+                                 method.Parameters[0].Type.IsPointerToPrimitiveType()) ||
+                                (method.IsConstructor &&
+                                 !method.Parameters.Where(p => p.Kind == ParameterKind.Regular).Any()))
                             {
                                 method.GenerationKind = GenerationKind.Generate;
                                 method.Namespace.GenerationKind = GenerationKind.Generate;
@@ -80,26 +83,15 @@ namespace CppSharp.Passes
                     }
                     break;
                 case "allocator":
-                    foreach (var method in @class.Methods.Where(Unused))
+                    foreach (var method in @class.Methods)
                         method.ExplicitlyIgnore();
                     foreach (var allocator in GetCharSpecializations(@class))
                     {
-                        allocator.GenerationKind = GenerationKind.Generate;
                         foreach (var method in allocator.Methods)
-                        {
-                            if (Unused(method))
-                                method.ExplicitlyIgnore();
-                            else
-                            {
-                                method.GenerationKind = GenerationKind.Generate;
-                                if (method.InstantiatedFrom != null)
-                                    method.InstantiatedFrom.GenerationKind =
-                                        method.InstantiatedFrom.Namespace.GenerationKind =
-                                        GenerationKind.Generate;
-                                foreach (var parameter in method.Parameters)
-                                    parameter.DefaultArgument = null;
-                            }
-                        }
+                            method.ExplicitlyIgnore();
+                        allocator.GenerationKind = GenerationKind.Generate;
+                        allocator.TemplatedDecl.TemplatedDecl.GenerationKind = GenerationKind.Generate;
+                        allocator.GenerationKind = GenerationKind.Generate;
                     }
                     break;
                 case "char_traits":
@@ -117,11 +109,6 @@ namespace CppSharp.Passes
             return true;
         }
 
-        private static bool Unused(Method m)
-        {
-            return !m.IsDestructor && (!m.IsConstructor || m.Parameters.Count > 0);
-        }
-
         private static IEnumerable<ClassTemplateSpecialization> GetCharSpecializations(Class @class)
         {
             return @class.Specializations.Where(s =>

src/Generator/Types/Std/Stdlib.cs

@@ -113,34 +113,32 @@ namespace CppSharp.Types.Std
 
         public override void CSharpMarshalToNative(CSharpMarshalContext ctx)
         {
-            var type = ctx.Parameter.Type.Desugar();
+            Type type = ctx.Parameter.Type.Desugar();
             ClassTemplateSpecialization basicString = GetBasicString(type);
             var typePrinter = new CSharpTypePrinter(ctx.Context);
-            if (!ctx.Parameter.Type.Desugar().IsAddress())
+            if (!ctx.Parameter.Type.Desugar().IsAddress() &&
+                !(ctx.Declaration is Field))
                 ctx.Return.Write($"*({typePrinter.PrintNative(basicString)}*) ");
-            var allocator = ctx.Context.ASTContext.FindClass("allocator", false, true).First(
-                a => a.IsDependent && a.TranslationUnit.IsSystemHeader);
-            var allocatorChar = allocator.Specializations.First(s => !s.Ignore);
             string qualifiedBasicString = GetQualifiedBasicString(basicString);
-            if (type.IsPointer() || (type.IsReference() && ctx.Declaration is Field))
+            var assign = basicString.Methods.First(m => m.OriginalName == "assign");
+            if (ctx.Declaration is Field)
             {
-                ctx.Return.Write($@"{qualifiedBasicString}Extensions.{basicString.Name}({
-                    ctx.Parameter.Name}, new {allocatorChar.Visit(typePrinter)}()).{
-                    Helpers.InstanceIdentifier}");
+                ctx.Return.Write($@"{qualifiedBasicString}Extensions.{
+                    Helpers.InternalStruct}.{assign.Name}(new {
+                    CSharpTypePrinter.IntPtrType}(&{
+                    ctx.ReturnVarName}), {ctx.Parameter.Name})");
+                ctx.ReturnVarName = string.Empty;
             }
             else
             {
-                var varAllocator = $"__allocator{ctx.ParameterIndex}";
                 var varBasicString = $"__basicString{ctx.ParameterIndex}";
-                ctx.Before.WriteLine($@"var {varAllocator} = new {
-                    allocatorChar.Visit(typePrinter)}();");
-                ctx.Before.WriteLine($@"var {varBasicString} = {
-                    qualifiedBasicString}Extensions.{basicString.Name}({ctx.Parameter.Name}, {
-                    varAllocator});");
+                ctx.Before.WriteLine($@"var {varBasicString} = new {
+                    basicString.Visit(typePrinter)}();");
+                ctx.Before.WriteLine($@"{qualifiedBasicString}Extensions.{
+                    assign.Name}({varBasicString}, {ctx.Parameter.Name});");
                 ctx.Return.Write($"{varBasicString}.{Helpers.InstanceIdentifier}");
-                ctx.Cleanup.WriteLine($@"{varBasicString}.Dispose({
-                    (type.IsPointer() ? "true" : "false")});");
-                ctx.Cleanup.WriteLine($"{varAllocator}.Dispose();");
+                if (!type.IsAddress())
+                    ctx.Cleanup.WriteLine($"{varBasicString}.Dispose(false);");
             }
         }
 

tests/Common/Common.Tests.cs

@@ -777,7 +777,6 @@ This is a very long string. This is a very long string. This is a very long stri
         }
     }
 
-    [Test, Platform(Exclude = "Win")]
     public void TestNullStdString()
     {
         using (var hasStdString = new HasStdString())