pimhwang
/
CppSharp
mirror of https://github.com/mono/CppSharp.git
1
0
Fork 0
Code Issues Projects Releases Wiki Activity
Browse Source

Manually merge d28bc89..faa6350

pull/1/head
Alex Corrado 15 years ago
parent
2116e1f175
commit
94cf0c5afd
14 changed files with 472 additions and 554 deletions
Whitespace
Show all changes Ignore whitespace when comparing lines Ignore changes in amount of whitespace Ignore changes in whitespace at EOL
Unified View
Diff Options
Show Stats Download Patch File Download Diff File
  1. 655
      src/Mono.VisualC.Interop/ABI/CppAbi.cs
  2. 101
      src/Mono.VisualC.Interop/ABI/Impl/ItaniumAbi.cs
  3. 79
      src/Mono.VisualC.Interop/ABI/Impl/ItaniumTypeInfo.cs
  4. 5
      src/Mono.VisualC.Interop/ABI/Impl/MsvcAbi.cs
  5. 4
      src/Mono.VisualC.Interop/ABI/Impl/MsvcTypeInfo.cs
  6. 1
      src/Mono.VisualC.Interop/ABI/MethodType.cs
  7. 14
      src/Mono.VisualC.Interop/Attributes.cs
  8. 10
      src/Mono.VisualC.Interop/CppInstancePtr.cs
  9. 38
      src/Mono.VisualC.Interop/CppLibrary.cs
  10. 64
      src/Mono.VisualC.Interop/CppTypeInfo.cs
  11. 8
      src/Mono.VisualC.Interop/Interfaces.cs
  12. 1
      src/Mono.VisualC.Interop/Mono.VisualC.Interop.csproj
  13. 10
      src/Mono.VisualC.Interop/Util/DelegateTypeCache.cs
  14. 36
      src/Mono.VisualC.Interop/Util/MethodSignature.cs

655
src/Mono.VisualC.Interop/ABI/CppAbi.cs
Unescape View File

@ -20,32 +20,6 @@ using Mono.VisualC.Interop.Util;
namespace Mono.VisualC.Interop.ABI { namespace Mono.VisualC.Interop.ABI {
//
// Marshalling to be done for a single parameter
//
public enum ParameterMarshal {
Default = 0,
ClassByRef = 1,
ClassByVal = 2
}
//
// Describes the signature of the pinvoke wrapper of a c++ method, along with
// marshalling information
//
public class PInvokeSignature {
// The original c# method this signature was generated from
public MethodInfo OrigMethod;
public List<Type> ParameterTypes { get; set; }
public List<ParameterMarshal> ParameterMarshallers { get; set; }
public Type ReturnType { get; set; }
// Whenever to return a class value
public bool ReturnClass { get; set; }
// Whenever to return a class value by passing a hidden first argument
// Used by the itanium c++ abi
public bool ReturnByAddr { get; set; }
}
//FIXME: Exception handling, operator overloading etc. //FIXME: Exception handling, operator overloading etc.
//FIXME: Allow interface to override default calling convention //FIXME: Allow interface to override default calling convention
public abstract partial class CppAbi { public abstract partial class CppAbi {
@ -53,7 +27,8 @@ namespace Mono.VisualC.Interop.ABI {
protected TypeBuilder impl_type; protected TypeBuilder impl_type;
protected Type interface_type, layout_type, wrapper_type; protected Type interface_type, layout_type, wrapper_type;
protected string library, class_name; protected CppLibrary library;
protected string class_name;
protected FieldBuilder typeinfo_field; protected FieldBuilder typeinfo_field;
protected ILGenerator ctor_il; protected ILGenerator ctor_il;
@ -61,17 +36,33 @@ namespace Mono.VisualC.Interop.ABI {
protected MemberFilter vtable_override_filter = VTable.BindToSignatureAndAttribute; protected MemberFilter vtable_override_filter = VTable.BindToSignatureAndAttribute;
// Cache some frequently used methodinfos: // Cache some frequently used methodinfos:
private static readonly MethodInfo typeinfo_nativesize = typeof (CppTypeInfo).GetProperty ("NativeSize").GetGetMethod (); private static readonly MethodInfo typeinfo_nativesize = typeof (CppTypeInfo).GetProperty ("NativeSize").GetGetMethod ();
private static readonly MethodInfo typeinfo_vtable = typeof (CppTypeInfo).GetProperty ("VTable").GetGetMethod (); private static readonly MethodInfo typeinfo_vtable = typeof (CppTypeInfo).GetProperty ("VTable").GetGetMethod ();
private static readonly MethodInfo typeinfo_adjvcall = typeof (CppTypeInfo).GetMethod ("GetAdjustedVirtualCall"); private static readonly MethodInfo typeinfo_adjvcall = typeof (CppTypeInfo).GetMethod ("GetAdjustedVirtualCall");
private static readonly MethodInfo vtable_initinstance = typeof (VTable).GetMethod ("InitInstance"); private static readonly MethodInfo typeinfo_fieldoffset = typeof (CppTypeInfo).GetProperty ("FieldOffsetPadding").GetGetMethod ();
private static readonly MethodInfo vtable_resetinstance = typeof (VTable).GetMethod ("ResetInstance"); private static readonly MethodInfo vtable_initinstance = typeof (VTable).GetMethod ("InitInstance");
private static readonly MethodInfo vtable_resetinstance = typeof (VTable).GetMethod ("ResetInstance");
private static readonly MethodInfo cppobj_native = typeof (ICppObject).GetProperty ("Native").GetGetMethod ();
private static readonly MethodInfo cppip_native = typeof (CppInstancePtr).GetProperty ("Native").GetGetMethod ();
private static readonly MethodInfo cppip_managedalloc = typeof (CppInstancePtr).GetProperty ("IsManagedAlloc").GetGetMethod ();
private static readonly MethodInfo cppip_getmanaged = typeof (CppInstancePtr).GetMethod ("GetManaged", BindingFlags.Static | BindingFlags.NonPublic);
private static readonly ConstructorInfo cppip_fromnative = typeof (CppInstancePtr).GetConstructor (new Type [] { typeof (IntPtr) });
private static readonly ConstructorInfo cppip_fromsize = typeof (CppInstancePtr).GetConstructor (new Type [] { typeof (int) });
private static readonly ConstructorInfo cppip_fromsize_managed = typeof (CppInstancePtr).GetConstructor (BindingFlags.Instance | BindingFlags.NonPublic, null,
new Type[] { typeof (int), typeof (object) }, null);
private static readonly ConstructorInfo notimplementedexception = typeof (NotImplementedException).GetConstructor (new Type [] { typeof (string) });
private static readonly MethodInfo type_gettypefromhandle = typeof (Type).GetMethod ("GetTypeFromHandle");
private static readonly MethodInfo marshal_offsetof = typeof (Marshal).GetMethod ("OffsetOf");
private static readonly MethodInfo marshal_structuretoptr = typeof (Marshal).GetMethod ("StructureToPtr");
// These methods might be more commonly overridden for a given C++ ABI: // These methods might be more commonly overridden for a given C++ ABI:
public virtual MethodType GetMethodType (MethodInfo imethod) public virtual MethodType GetMethodType (MethodInfo imethod)
{ {
if (imethod.IsDefined (typeof (ConstructorAttribute), false)) if (IsInline (imethod) && library.InlineMethodPolicy == InlineMethods.NotPresent)
return MethodType.NotImplemented;
else if (imethod.IsDefined (typeof (ConstructorAttribute), false))
return MethodType.NativeCtor; return MethodType.NativeCtor;
else if (imethod.Name.Equals ("Alloc")) else if (imethod.Name.Equals ("Alloc"))
return MethodType.ManagedAlloc; return MethodType.ManagedAlloc;
@ -94,12 +85,12 @@ namespace Mono.VisualC.Interop.ABI {
// The ImplementClass overrides are the main entry point to the Abi API: // The ImplementClass overrides are the main entry point to the Abi API:
private struct EmptyNativeLayout { } private struct EmptyNativeLayout { }
public Iface ImplementClass<Iface> (Type wrapperType, string lib, string className) public Iface ImplementClass<Iface> (Type wrapperType, CppLibrary lib, string className)
{ {
return this.ImplementClass<Iface,EmptyNativeLayout> (wrapperType, lib, className); return this.ImplementClass<Iface,EmptyNativeLayout> (wrapperType, lib, className);
} }
public virtual Iface ImplementClass<Iface, NLayout> (Type wrapperType, string lib, string className) public virtual Iface ImplementClass<Iface, NLayout> (Type wrapperType, CppLibrary lib, string className)
where NLayout : struct where NLayout : struct
//where Iface : ICppClassInstantiatable or ICppClassOverridable //where Iface : ICppClassInstantiatable or ICppClassOverridable
{ {
@ -113,8 +104,8 @@ namespace Mono.VisualC.Interop.ABI {
DefineImplType (); DefineImplType ();
var properties = GetProperties (); var properties = GetProperties ();
var methods = GetMethods (); var methods = GetMethods ().Select (m => GetPInvokeSignature (m));
CppTypeInfo typeInfo = MakeTypeInfo (methods, methods.Where (m => IsVirtual (m))); var typeInfo = MakeTypeInfo (methods);
// Implement all methods // Implement all methods
int vtableIndex = 0; int vtableIndex = 0;
@ -130,9 +121,9 @@ namespace Mono.VisualC.Interop.ABI {
return (Iface)Activator.CreateInstance (impl_type.CreateType (), typeInfo); return (Iface)Activator.CreateInstance (impl_type.CreateType (), typeInfo);
} }
protected virtual CppTypeInfo MakeTypeInfo (IEnumerable<MethodInfo> methods, IEnumerable<MethodInfo> virtualMethods) protected virtual CppTypeInfo MakeTypeInfo (IEnumerable<PInvokeSignature> methods)
{ {
return new CppTypeInfo (this, virtualMethods, layout_type); return new CppTypeInfo (this, methods.Where (m => IsVirtual (m.OrigMethod)), layout_type);
} }
protected virtual IEnumerable<PropertyInfo> GetProperties () protected virtual IEnumerable<PropertyInfo> GetProperties ()
@ -171,8 +162,6 @@ namespace Mono.VisualC.Interop.ABI {
impl_type = impl_module.DefineType (implTypeName, TypeAttributes.Class | TypeAttributes.Sealed); impl_type = impl_module.DefineType (implTypeName, TypeAttributes.Class | TypeAttributes.Sealed);
impl_type.AddInterfaceImplementation (interface_type); impl_type.AddInterfaceImplementation (interface_type);
//vtable_field = impl_type.DefineField ("_vtable", typeof (VTable), FieldAttributes.InitOnly | FieldAttributes.Private);
//native_size_field = impl_type.DefineField ("_nativeSize", typeof (int), FieldAttributes.InitOnly | FieldAttributes.Private);
typeinfo_field = impl_type.DefineField ("_typeInfo", typeof (CppTypeInfo), FieldAttributes.InitOnly | FieldAttributes.Private); typeinfo_field = impl_type.DefineField ("_typeInfo", typeof (CppTypeInfo), FieldAttributes.InitOnly | FieldAttributes.Private);
ConstructorBuilder ctor = impl_type.DefineConstructor (MethodAttributes.Public, CallingConventions.Standard, ConstructorBuilder ctor = impl_type.DefineConstructor (MethodAttributes.Public, CallingConventions.Standard,
@ -184,38 +173,32 @@ namespace Mono.VisualC.Interop.ABI {
ctor_il.Emit (OpCodes.Ldarg_0); ctor_il.Emit (OpCodes.Ldarg_0);
ctor_il.Emit (OpCodes.Ldarg_1); ctor_il.Emit (OpCodes.Ldarg_1);
ctor_il.Emit (OpCodes.Stfld, typeinfo_field); ctor_il.Emit (OpCodes.Stfld, typeinfo_field);
/*
// this._vtable = (VTable passed to constructor)
ctor_il.Emit (OpCodes.Ldarg_0);
ctor_il.Emit (OpCodes.Ldarg_1);
ctor_il.Emit (OpCodes.Stfld, vtable_field);
// this._nativeSize = (native size passed to constructor)
ctor_il.Emit (OpCodes.Ldarg_0);
ctor_il.Emit (OpCodes.Ldarg_2);
ctor_il.Emit (OpCodes.Stfld, native_size_field);
*/
} }
protected virtual MethodBuilder DefineMethod (MethodInfo interfaceMethod, CppTypeInfo typeInfo, ref int vtableIndex) protected virtual MethodBuilder DefineMethod (PInvokeSignature psig, CppTypeInfo typeInfo, ref int vtableIndex)
{ {
// 0. Introspect method var interfaceMethod = psig.OrigMethod;
MethodType methodType = GetMethodType (interfaceMethod);
Type [] parameterTypes = ReflectionHelper.GetMethodParameterTypes (interfaceMethod);
// 1. Generate managed trampoline to call native method // 1. Generate managed trampoline to call native method
MethodBuilder trampoline = GetMethodBuilder (interfaceMethod); MethodBuilder trampoline = GetMethodBuilder (interfaceMethod);
ILGenerator il = trampoline.GetILGenerator (); ILGenerator il = trampoline.GetILGenerator ();
if (methodType == MethodType.NoOp) { switch (psig.Type) {
case MethodType.NotImplemented:
il.Emit (OpCodes.Ldstr, "This method is not available.");
il.Emit (OpCodes.Newobj, notimplementedexception);
il.Emit (OpCodes.Throw);
goto case MethodType.NoOp; // fallthrough
case MethodType.NoOp:
// return NULL if method is supposed to return a value // return NULL if method is supposed to return a value
// FIXME: this will make value types explode?
if (!interfaceMethod.ReturnType.Equals (typeof (void))) if (!interfaceMethod.ReturnType.Equals (typeof (void)))
il.Emit (OpCodes.Ldnull); il.Emit (OpCodes.Ldnull);
il.Emit (OpCodes.Ret); il.Emit (OpCodes.Ret);
return trampoline; return trampoline;
} else if (methodType == MethodType.ManagedAlloc) {
case MethodType.ManagedAlloc:
EmitManagedAlloc (il, interfaceMethod); EmitManagedAlloc (il, interfaceMethod);
il.Emit (OpCodes.Ret); il.Emit (OpCodes.Ret);
return trampoline; return trampoline;
@ -224,93 +207,43 @@ namespace Mono.VisualC.Interop.ABI {
bool isStatic = IsStatic (interfaceMethod); bool isStatic = IsStatic (interfaceMethod);
LocalBuilder cppInstancePtr = null; LocalBuilder cppInstancePtr = null;
LocalBuilder nativePtr = null; LocalBuilder nativePtr = null;
LocalBuilder retVal = null;
LocalBuilder retArg = null;
// If we're an instance method, load up the "this" pointer // If we're an instance method, load up the "this" pointer
if (!isStatic) if (!isStatic)
{ {
if (parameterTypes.Length < 1) if (psig.ParameterTypes.Count == 0)
throw new ArgumentException ("First argument to non-static C++ method must be IntPtr or CppInstancePtr."); throw new ArgumentException ("First argument to non-static C++ method must be IntPtr or CppInstancePtr.");
// 2. Load the native C++ instance pointer // 2. Load the native C++ instance pointer
EmitLoadInstancePtr (il, parameterTypes [0], out cppInstancePtr, out nativePtr); EmitLoadInstancePtr (il, interfaceMethod.GetParameters () [0].ParameterType, out cppInstancePtr, out nativePtr);
// 3. Make sure our native pointer is a valid reference. If not, throw ObjectDisposedException // 3. Make sure our native pointer is a valid reference. If not, throw ObjectDisposedException
EmitCheckDisposed (il, nativePtr, methodType); EmitCheckDisposed (il, nativePtr, psig.Type);
} }
MethodInfo nativeMethod; MethodInfo nativeMethod;
var psig = GetPInvokeSignature (typeInfo, interfaceMethod); if (IsVirtual (interfaceMethod) && psig.Type != MethodType.NativeDtor) {
nativeMethod = EmitPrepareVirtualCall (il, typeInfo, nativePtr, vtableIndex++);
if (psig.ReturnClass) { } else {
Debug.Assert (wrapper_type != null); if (IsVirtual (interfaceMethod))
retVal = il.DeclareLocal (wrapper_type); vtableIndex++;
// Construct the manager wrapper object
var ctor = wrapper_type.GetConstructor (BindingFlags.Instance | BindingFlags.NonPublic, null, new Type [] { typeof (CppLibrary) }, null);
Debug.Assert (ctor != null);
il.Emit (OpCodes.Ldnull);
il.Emit (OpCodes.Newobj, ctor);
il.Emit (OpCodes.Stloc, retVal);
psig.ReturnType = layout_type;
}
if (psig.ReturnByAddr) { nativeMethod = GetPInvokeForMethod (psig);
//
// When using the Itanium c++ abi, some classes are returned by passing a
// hidden first argument.
//
// Put the address of the native return memory into a local
retArg = il.DeclareLocal (typeof (IntPtr));
il.Emit (OpCodes.Ldloc, retVal);
EmitLoadNativePtr (il);
il.Emit (OpCodes.Stloc, retArg);
psig.ReturnType = typeof (void);
} }
if (IsVirtual (interfaceMethod) && methodType != MethodType.NativeDtor) switch (psig.Type) {
nativeMethod = EmitPrepareVirtualCall (il, typeInfo, nativePtr, vtableIndex++);
else
nativeMethod = GetPInvokeForMethod (interfaceMethod, psig);
switch (methodType) {
case MethodType.NativeCtor: case MethodType.NativeCtor:
EmitConstruct (il, nativeMethod, psig, nativePtr); EmitConstruct (il, nativeMethod, psig, nativePtr);
break; break;
case MethodType.NativeDtor: case MethodType.NativeDtor:
EmitDestruct (il, nativeMethod, psig, cppInstancePtr, nativePtr); EmitDestruct (il, nativeMethod, psig, cppInstancePtr, nativePtr);
break; break;
default: default:
EmitNativeCall (il, nativeMethod, isStatic, psig, nativePtr, retArg); EmitNativeCall (il, nativeMethod, psig, nativePtr);
break; break;
} }
if (psig.ReturnClass) {
if (!psig.ReturnByAddr) {
//
// The method return a struct in native format which is on the stack,
// have to copy into the native memory belonging to our object
//
// Save the method return value
var rval = il.DeclareLocal (layout_type);
il.Emit (OpCodes.Stloc, rval);
// Load the ptr to the native memory (dest)
il.Emit (OpCodes.Ldloc, retVal);
EmitLoadNativePtr (il);
// Load the address of the method return value (src)
il.Emit (OpCodes.Ldloca, rval);
// Copy
il.Emit (OpCodes.Cpobj, layout_type);
}
il.Emit (OpCodes.Ldloc, retVal);
}
il.Emit (OpCodes.Ret); il.Emit (OpCodes.Ret);
return trampoline; return trampoline;
} }
@ -320,50 +253,67 @@ namespace Mono.VisualC.Interop.ABI {
if (property.CanWrite) if (property.CanWrite)
throw new InvalidProgramException ("Properties in C++ interface must be read-only."); throw new InvalidProgramException ("Properties in C++ interface must be read-only.");
MethodInfo imethod = property.GetGetMethod (); var imethod = property.GetGetMethod ();
string methodName = imethod.Name; var methodName = imethod.Name;
string propName = property.Name; var propName = property.Name;
Type retType = imethod.ReturnType; var retType = imethod.ReturnType;
FieldBuilder fieldData;
var fieldProp = impl_type.DefineProperty (propName, PropertyAttributes.None, retType, Type.EmptyTypes);
var methodAttr = MethodAttributes.Public | MethodAttributes.Virtual | MethodAttributes.SpecialName | MethodAttributes.HideBySig;
var fieldGetter = impl_type.DefineMethod (methodName, methodAttr, retType, Type.EmptyTypes);
var il = fieldGetter.GetILGenerator ();
// C++ interface properties are either to return the CppTypeInfo or to access C++ fields // C++ interface properties are either to return the CppTypeInfo or to access C++ fields
if (retType.IsGenericType && retType.GetGenericTypeDefinition ().Equals (typeof (CppField<>))) { if (retType.IsGenericType && retType.GetGenericTypeDefinition ().Equals (typeof (CppField<>))) {
// define a new field for the property // define a new field for the property
// fieldData = impl_type.DefineField ("__" + propName + "_Data", retType, FieldAttributes.InitOnly | FieldAttributes.Private); var fieldData = impl_type.DefineField ("__" + propName + "_Data", retType, FieldAttributes.InitOnly | FieldAttributes.Private);
// we need to lazy init the field because we don't have accurate field offset until after
// all base classes have been added (by ctor)
var lazyInit = il.DefineLabel ();
il.Emit (OpCodes.Ldarg_0);
il.Emit (OpCodes.Ldfld, fieldData);
il.Emit (OpCodes.Dup);
il.Emit (OpCodes.Brfalse_S, lazyInit);
il.Emit (OpCodes.Ret);
// init new CppField
il.MarkLabel (lazyInit);
il.Emit (OpCodes.Pop);
il.Emit (OpCodes.Ldarg_0);
// init our field data with a new instance of CppField
// first, get field offset // first, get field offset
//ctor_il.Emit (OpCodes.Ldarg_0); // = ((int)Marshal.OffsetOf (layout_type, propName)) + FieldOffsetPadding;
il.Emit(OpCodes.Ldtoken, layout_type);
/* TODO: Code prolly should not emit hardcoded offsets n such, in case we end up saving these assemblies in the future. il.Emit(OpCodes.Call, type_gettypefromhandle);
* Something more like this perhaps? (need to figure out how to get field offset padding into this) il.Emit(OpCodes.Ldstr, propName);
* ctorIL.Emit(OpCodes.Ldtoken, nativeLayout); il.Emit(OpCodes.Call, marshal_offsetof);
* ctorIL.Emit(OpCodes.Call, typeof(Type).GetMethod("GetTypeFromHandle"));
* ctorIL.Emit(OpCodes.Ldstr, propName);
* ctorIL.Emit(OpCodes.Call, typeof(Marshal).GetMethod("OffsetOf"));
*/
/*
int fieldOffset = ((int)Marshal.OffsetOf (layout_type, propName)) + FieldOffsetPadding;
ctor_il.Emit (OpCodes.Ldc_I4, fieldOffset);
ctor_il.Emit (OpCodes.Newobj, retType.GetConstructor (new Type[] { typeof(int) }));
ctor_il.Emit (OpCodes.Stfld, fieldData);
*/
throw new NotImplementedException ("CppFields need to be reimplemented to use CppTypeInfo.");
} else if (retType.Equals (typeof (CppTypeInfo)))
fieldData = typeinfo_field;
else
throw new InvalidProgramException ("Properties in C++ interface can only be of type CppField.");
PropertyBuilder fieldProp = impl_type.DefineProperty (propName, PropertyAttributes.None, retType, Type.EmptyTypes); il.Emit (OpCodes.Ldarg_0);
il.Emit (OpCodes.Ldfld, typeinfo_field);
il.Emit (OpCodes.Callvirt, typeinfo_fieldoffset);
MethodAttributes methodAttr = MethodAttributes.Public | MethodAttributes.Virtual | MethodAttributes.SpecialName | MethodAttributes.HideBySig; il.Emit (OpCodes.Add);
MethodBuilder fieldGetter = impl_type.DefineMethod (methodName, methodAttr, retType, Type.EmptyTypes);
ILGenerator il = fieldGetter.GetILGenerator ();
il.Emit (OpCodes.Ldarg_0); // new CppField<T> (<field offset>)
il.Emit (OpCodes.Ldfld, fieldData); il.Emit (OpCodes.Newobj, retType.GetConstructor (new Type[] { typeof(int) }));
il.Emit (OpCodes.Ret);
il.Emit (OpCodes.Stfld, fieldData);
il.Emit (OpCodes.Ldarg_0);
il.Emit (OpCodes.Ldfld, fieldData);
il.Emit (OpCodes.Ret);
} else if (retType.Equals (typeof (CppTypeInfo))) {
il.Emit (OpCodes.Ldarg_0);
il.Emit (OpCodes.Ldfld, typeinfo_field);
il.Emit (OpCodes.Ret);
} else
throw new InvalidProgramException ("Properties in C++ interface can only be of type CppField.");
fieldProp.SetGetMethod (fieldGetter); fieldProp.SetGetMethod (fieldGetter);
@ -379,43 +329,47 @@ namespace Mono.VisualC.Interop.ABI {
if (wrapper_type == null) if (wrapper_type == null)
return null; return null;
MethodInfo interfaceMethod = typeInfo.VirtualMethods [vtableIndex]; var sig = typeInfo.VirtualMethods [vtableIndex];
MethodInfo targetMethod = FindManagedOverrideTarget (interfaceMethod); var interfaceMethod = sig.OrigMethod;
var targetMethod = FindManagedOverrideTarget (interfaceMethod);
if (targetMethod == null) if (targetMethod == null)
return null; return null;
var psig = GetPInvokeSignature (typeInfo, interfaceMethod); var interfaceArgs = ReflectionHelper.GetMethodParameterTypes (interfaceMethod);
var nativeArgs = sig.ParameterTypes.ToArray ();
// TODO: According to http://msdn.microsoft.com/en-us/library/w16z8yc4.aspx // TODO: According to http://msdn.microsoft.com/en-us/library/w16z8yc4.aspx
// The dynamic method created with this constructor has access to public and internal members of all the types contained in module m. // The dynamic method created with this constructor has access to public and internal members of all the types contained in module m.
// This does not appear to hold true, so we also disable JIT visibility checks. // This does not appear to hold true, so we also disable JIT visibility checks.
DynamicMethod trampolineIn = new DynamicMethod (wrapper_type.Name + "_" + interfaceMethod.Name + "_FromNative", psig.ReturnType, var trampolineIn = new DynamicMethod (wrapper_type.Name + "_" + interfaceMethod.Name + "_FromNative", sig.ReturnType,
psig.ParameterTypes.ToArray (), typeof (CppInstancePtr).Module, true); nativeArgs, typeof (CppInstancePtr).Module, true);
ReflectionHelper.ApplyMethodParameterAttributes (interfaceMethod, trampolineIn, true); ReflectionHelper.ApplyMethodParameterAttributes (interfaceMethod, trampolineIn, true);
ILGenerator il = trampolineIn.GetILGenerator (); ILGenerator il = trampolineIn.GetILGenerator ();
// for static methods: // for static (target) methods:
OpCode callInstruction = OpCodes.Call; OpCode callInstruction = OpCodes.Call;
int argLoadStart = 1; int argLoadStart = IsStatic (interfaceMethod)? 0 : 1; // chop off C++ instance ptr if there is one
// for instance methods, we need an instance to call them on! // for instance methods, we need a managed instance to call them on!
if (!targetMethod.IsStatic) { if (!targetMethod.IsStatic) {
callInstruction = OpCodes.Callvirt; callInstruction = OpCodes.Callvirt;
//argLoadStart = 1; argLoadStart = 1;
il.Emit (OpCodes.Ldarg_0); il.Emit (OpCodes.Ldarg_0);
il.Emit (OpCodes.Ldc_I4, typeInfo.NativeSize); il.Emit (OpCodes.Ldc_I4, typeInfo.NativeSize);
MethodInfo getManagedObj = typeof (CppInstancePtr).GetMethod ("GetManaged", BindingFlags.Static | BindingFlags.NonPublic).MakeGenericMethod (wrapper_type); MethodInfo getManagedObj = cppip_getmanaged.MakeGenericMethod (wrapper_type);
il.Emit (OpCodes.Call, getManagedObj); il.Emit (OpCodes.Call, getManagedObj);
} }
for (int i = argLoadStart; i < psig.ParameterTypes.Count; i++) { for (int i = argLoadStart; i < interfaceArgs.Length; i++) {
il.Emit (OpCodes.Ldarg, i); il.Emit (OpCodes.Ldarg, i);
EmitInboundMarshal (il, nativeArgs [i], interfaceArgs [i]);
} }
il.Emit (OpCodes.Tailcall);
il.Emit (callInstruction, targetMethod); il.Emit (callInstruction, targetMethod);
EmitOutboundMarshal (il, targetMethod.ReturnType, sig.ReturnType);
il.Emit (OpCodes.Ret); il.Emit (OpCodes.Ret);
return trampolineIn.CreateDelegate (typeInfo.VTableDelegateTypes [vtableIndex]); return trampolineIn.CreateDelegate (typeInfo.VTableDelegateTypes [vtableIndex]);
@ -423,6 +377,9 @@ namespace Mono.VisualC.Interop.ABI {
protected virtual MethodInfo FindManagedOverrideTarget (MethodInfo interfaceMethod) protected virtual MethodInfo FindManagedOverrideTarget (MethodInfo interfaceMethod)
{ {
if (interfaceMethod == null)
return null;
// FIXME: Does/should this look in superclasses? // FIXME: Does/should this look in superclasses?
MemberInfo [] possibleMembers = wrapper_type.FindMembers (MemberTypes.Method, BindingFlags.Public | BindingFlags.NonPublic | MemberInfo [] possibleMembers = wrapper_type.FindMembers (MemberTypes.Method, BindingFlags.Public | BindingFlags.NonPublic |
BindingFlags.Instance | BindingFlags.Static, vtable_override_filter, interfaceMethod); BindingFlags.Instance | BindingFlags.Static, vtable_override_filter, interfaceMethod);
@ -444,31 +401,30 @@ namespace Mono.VisualC.Interop.ABI {
MethodBuilder methodBuilder = impl_type.DefineMethod (interfaceMethod.Name, MethodAttributes.Public | MethodAttributes.Virtual, MethodBuilder methodBuilder = impl_type.DefineMethod (interfaceMethod.Name, MethodAttributes.Public | MethodAttributes.Virtual,
interfaceMethod.ReturnType, parameterTypes); interfaceMethod.ReturnType, parameterTypes);
ReflectionHelper.ApplyMethodParameterAttributes (interfaceMethod, methodBuilder, false); ReflectionHelper.ApplyMethodParameterAttributes (interfaceMethod, methodBuilder, false);
return methodBuilder; return methodBuilder;
} }
/** /**
* Defines a new MethodBuilder that calls the specified C++ (non-virtual) method using its mangled name * Defines a new MethodBuilder that calls the specified C++ (non-virtual) method using its mangled name
*/ */
protected virtual MethodBuilder GetPInvokeForMethod (MethodInfo signature, PInvokeSignature psig) protected virtual MethodBuilder GetPInvokeForMethod (PInvokeSignature sig)
{ {
string entryPoint = GetMangledMethodName (signature); string entryPoint = sig.Name;
if (entryPoint == null) if (entryPoint == null)
throw new NotSupportedException ("Could not mangle method name."); throw new NotSupportedException ("Could not mangle method name.");
string lib; string lib;
if (IsInline (signature)) if (IsInline (sig.OrigMethod) && library.InlineMethodPolicy == InlineMethods.SurrogateLib)
lib = library + "-inline"; lib = library.Name + "-inline";
else else
lib = library; lib = library.Name;
MethodBuilder builder = impl_type.DefinePInvokeMethod ("__$" + signature.Name + "_Impl", lib, entryPoint, MethodBuilder builder = impl_type.DefinePInvokeMethod (entryPoint, lib, entryPoint,
MethodAttributes.Private | MethodAttributes.Static | MethodAttributes.PinvokeImpl, MethodAttributes.Private | MethodAttributes.Static | MethodAttributes.PinvokeImpl,
CallingConventions.Standard, psig.ReturnType, psig.ParameterTypes.ToArray (), CallingConventions.Standard, sig.ReturnType, sig.ParameterTypes.ToArray (),
GetCallingConvention (signature).Value, CharSet.Ansi); sig.CallingConvention.Value, CharSet.Ansi);
builder.SetImplementationFlags (builder.GetMethodImplementationFlags () | MethodImplAttributes.PreserveSig); builder.SetImplementationFlags (builder.GetMethodImplementationFlags () | MethodImplAttributes.PreserveSig);
ReflectionHelper.ApplyMethodParameterAttributes (signature, builder, true); ReflectionHelper.ApplyMethodParameterAttributes (sig.OrigMethod, builder, true);
return builder; return builder;
} }
@ -502,38 +458,41 @@ namespace Mono.VisualC.Interop.ABI {
il.Emit (OpCodes.Ldfld, typeinfo_field); il.Emit (OpCodes.Ldfld, typeinfo_field);
il.Emit (OpCodes.Callvirt, typeinfo_nativesize); il.Emit (OpCodes.Callvirt, typeinfo_nativesize);
if (wrapper_type != null) { if (wrapper_type != null && interfaceMethod.GetParameters ().Any ()) {
// load managed wrapper // load managed wrapper
il.Emit (OpCodes.Ldarg_1); il.Emit (OpCodes.Ldarg_1);
il.Emit (OpCodes.Newobj, typeof (CppInstancePtr).GetConstructor (BindingFlags.Instance | BindingFlags.NonPublic, null, new Type[] { typeof (int), typeof (object) }, null)); il.Emit (OpCodes.Newobj, cppip_fromsize_managed);
} else } else
il.Emit (OpCodes.Newobj, typeof (CppInstancePtr).GetConstructor (BindingFlags.Instance | BindingFlags.NonPublic, null, new Type[] { typeof (int) }, null)); il.Emit (OpCodes.Newobj, cppip_fromsize);
} }
protected virtual void EmitConstruct (ILGenerator il, MethodInfo nativeMethod, protected virtual void EmitConstruct (ILGenerator il, MethodInfo nativeMethod, PInvokeSignature psig, LocalBuilder nativePtr)
PInvokeSignature psig,
LocalBuilder nativePtr)
{ {
EmitNativeCall (il, nativeMethod, false, psig, nativePtr, null); Debug.Assert (psig.Type == MethodType.NativeCtor);
// FIXME: Why is this needed ? The c++ ctor initializes it EmitNativeCall (il, nativeMethod, psig, nativePtr);
//EmitInitVTable (il, nativePtr); EmitInitVTable (il, nativePtr);
} }
protected virtual void EmitDestruct (ILGenerator il, MethodInfo nativeMethod, protected virtual void EmitDestruct (ILGenerator il, MethodInfo nativeMethod, PInvokeSignature psig,
PInvokeSignature psig, LocalBuilder cppInstancePtr, LocalBuilder nativePtr)
LocalBuilder cppInstancePtr, LocalBuilder nativePtr)
{ {
Debug.Assert (psig.Type == MethodType.NativeDtor);
// we don't do anything if the object wasn't managed alloc
if (cppInstancePtr == null)
return;
// bail if we weren't alloc'd by managed code // bail if we weren't alloc'd by managed code
Label bail = il.DefineLabel (); Label bail = il.DefineLabel ();
il.Emit (OpCodes.Ldloca_S, cppInstancePtr); il.Emit (OpCodes.Ldloca_S, cppInstancePtr);
il.Emit (OpCodes.Brfalse_S, bail); // <- FIXME? (would this ever branch?) il.Emit (OpCodes.Brfalse_S, bail); // <- FIXME? (would this ever branch?)
il.Emit (OpCodes.Ldloca_S, cppInstancePtr); il.Emit (OpCodes.Ldloca_S, cppInstancePtr);
il.Emit (OpCodes.Call, typeof (CppInstancePtr).GetProperty ("IsManagedAlloc").GetGetMethod ()); il.Emit (OpCodes.Call, cppip_managedalloc);
il.Emit (OpCodes.Brfalse_S, bail); il.Emit (OpCodes.Brfalse_S, bail);
EmitResetVTable (il, nativePtr); EmitResetVTable (il, nativePtr);
EmitNativeCall (il, nativeMethod, false, psig, nativePtr, null); EmitNativeCall (il, nativeMethod, psig, nativePtr);
il.MarkLabel (bail); il.MarkLabel (bail);
} }
@ -543,142 +502,206 @@ namespace Mono.VisualC.Interop.ABI {
* GetPInvokeForMethod or the MethodInfo of a vtable method. * GetPInvokeForMethod or the MethodInfo of a vtable method.
* To complete method, emit OpCodes.Ret. * To complete method, emit OpCodes.Ret.
*/ */
protected virtual void EmitNativeCall (ILGenerator il, MethodInfo nativeMethod, protected virtual void EmitNativeCall (ILGenerator il, MethodInfo nativeMethod, PInvokeSignature psig, LocalBuilder nativePtr)
bool isStatic, PInvokeSignature psig,
LocalBuilder nativePtr, LocalBuilder retArg)
{ {
// var interfaceMethod = psig.OrigMethod;
// The managed signature looks like this: var interfaceArgs = interfaceMethod.GetParameters ();
// (<.net this>, @this (if not static), <additional args>
// The native signature looks like this:
// (<hidden retarg if present>, @this, <additional args>)
//
// The managed argument index, skip .net this
int aindex = 1;
// Do conversions
LocalBuilder[] args = new LocalBuilder [psig.ParameterTypes.Count];
aindex = 1;
for (int pindex = 0; pindex < psig.ParameterTypes.Count; pindex++) {
if (!isStatic && pindex == 0) {
// For instance methods, strip off CppInstancePtr and pass the corresponding IntPtr
args [pindex] = nativePtr;
aindex ++;
continue;
}
Type ptype = psig.ParameterTypes [pindex]; int argLoadStart = 1; // For static methods, just strip off arg0 (.net this pointer)
switch (psig.ParameterMarshallers [pindex]) { if (!IsStatic (interfaceMethod))
case ParameterMarshal.Default: {
// FIXME: Why is this needed ? argLoadStart = 2; // For instance methods, strip off CppInstancePtr and pass the corresponding IntPtr
// auto marshal bool to C++ bool type (0 = false , 1 = true ) il.Emit (OpCodes.Ldloc_S, nativePtr);
if (ptype.Equals (typeof (bool))) { }
args [pindex] = il.DeclareLocal (typeof (bool));
Label isTrue = il.DefineLabel (); // load and marshal arguments
Label done = il.DefineLabel (); for (int i = argLoadStart; i <= interfaceArgs.Length; i++) {
il.Emit (OpCodes.Ldarg, aindex); il.Emit (OpCodes.Ldarg, i);
il.Emit (OpCodes.Brtrue_S, isTrue); EmitOutboundMarshal (il, interfaceArgs [i - 1].ParameterType, psig.ParameterTypes [i - 1]);
il.Emit (OpCodes.Ldc_I4_0); }
il.Emit (OpCodes.Br_S, done);
il.MarkLabel (isTrue); il.Emit (OpCodes.Call, nativeMethod);
il.Emit (OpCodes.Ldc_I4_1);
il.MarkLabel (done); // Marshal return value
il.Emit (OpCodes.Stloc, args [pindex]); EmitInboundMarshal (il, psig.ReturnType, interfaceMethod.ReturnType);
//il.Emit (OpCodes.Conv_I1); }
}
break;
case ParameterMarshal.ClassByRef: { public virtual PInvokeSignature GetPInvokeSignature (MethodInfo method)
args [pindex] = il.DeclareLocal (typeof (IntPtr)); {
// Pass the native pointer of the class var parameters = method.GetParameters ();
// Null check var pinvokeTypes = new List<Type> (parameters.Length);
Label isNull = il.DefineLabel ();
Label contLabel = il.DefineLabel (); foreach (var pi in parameters) {
il.Emit (OpCodes.Ldarg, aindex); pinvokeTypes.Add (ToPInvokeType (pi.ParameterType, pi));
il.Emit (OpCodes.Brfalse_S, isNull); }
// Non-null case
il.Emit (OpCodes.Ldarg, aindex); return new PInvokeSignature {
EmitLoadNativePtr (il); OrigMethod = method,
// FIXME: Dispose check Name = GetMangledMethodName (method),
il.Emit (OpCodes.Br_S, contLabel); Type = GetMethodType (method),
// Null case CallingConvention = GetCallingConvention (method),
il.MarkLabel (isNull); ParameterTypes = pinvokeTypes,
il.Emit (OpCodes.Ldnull); ReturnType = ToPInvokeType (method.ReturnType, method.ReturnTypeCustomAttributes)
il.Emit (OpCodes.Conv_I); };
// Common case }
il.MarkLabel (contLabel);
il.Emit (OpCodes.Stloc, args [pindex]); public virtual Type ToPInvokeType (Type t, ICustomAttributeProvider icap)
break; {
if (t == typeof (bool)) {
return typeof (byte);
} else if (typeof (ICppObject).IsAssignableFrom (t)) {
if (IsByVal (icap)) {
// Can't use an interface/cattr since the native layout type is private
// Pass it as a type argument to I<Foo> ?
var f = t.GetField ("native_layout", BindingFlags.Static|BindingFlags.NonPublic);
if (f == null || f.FieldType != typeof (Type))
throw new NotImplementedException ("Type '" + t + "' needs to have a 'native_layout' field before it can be passed by value.");
t = (Type)f.GetValue (null);
if (!t.IsValueType)
throw new NotSupportedException ("The value for 'native_layout' for type '" + t + "' must be a value type.");
return t;
} else { // by ref
return typeof (IntPtr);
} }
case ParameterMarshal.ClassByVal: { }
// Pass a copy of the native memory of the class
args [pindex] = il.DeclareLocal (ptype); return t;
Label normalLabel = il.DefineLabel (); }
il.Emit (OpCodes.Ldarg, aindex);
il.Emit (OpCodes.Brtrue_S, normalLabel); // The above should return parameter/return types that
// correspond with the marshalling implemented in the next 2 methods.
// This method marshals from managed -> C++
// The value it is marshaling will be on the stack.
protected virtual void EmitOutboundMarshal (ILGenerator il, Type managedType, Type targetType)
{
var nextArg = il.DefineLabel ();
// FIXME: Why is this needed ?
// auto marshal bool to C++ bool type (0 = false , 1 = true )
if (managedType.Equals (typeof (bool))) {
Label isTrue = il.DefineLabel ();
Label done = il.DefineLabel ();
il.Emit (OpCodes.Brtrue, isTrue);
il.Emit (OpCodes.Ldc_I4_0);
il.Emit (OpCodes.Br, done);
il.MarkLabel (isTrue);
il.Emit (OpCodes.Ldc_I4_1);
il.MarkLabel (done);
//il.Emit (OpCodes.Conv_I1);
}
// auto marshal ICppObject
if (typeof (ICppObject).IsAssignableFrom (managedType)) {
var nullCase = il.DefineLabel ();
var param = il.DeclareLocal (typeof (CppInstancePtr));
// check for null
il.Emit (OpCodes.Dup);
il.Emit (OpCodes.Brfalse_S, nullCase);
// FIXME: ICppObject could be implemented by a value type
il.Emit (OpCodes.Callvirt, cppobj_native);
il.Emit (OpCodes.Stloc, param);
if (targetType == typeof (IntPtr)) { // by ref
il.Emit (OpCodes.Ldloca, param);
il.Emit (OpCodes.Call, cppip_native);
il.MarkLabel (nullCase);
} else { // by val
var val = il.DeclareLocal (targetType);
il.Emit (OpCodes.Ldloca, val); // dest
il.Emit (OpCodes.Ldloca, param);
il.Emit (OpCodes.Call, cppip_native); // src
il.Emit (OpCodes.Cpobj, targetType);
il.Emit (OpCodes.Ldloc, val);
il.Emit (OpCodes.Br_S, nextArg);
il.MarkLabel (nullCase);
// Null case // Null case
il.Emit (OpCodes.Ldstr, "Cannot pass null object of type '" + ptype.DeclaringType + "' to c++ by value"); il.Emit (OpCodes.Ldstr, "Cannot pass null object of type '" + managedType + "' to c++ by value");
il.Emit (OpCodes.Newobj, typeof (ArgumentException).GetConstructor (new Type[] { typeof(string) })); il.Emit (OpCodes.Newobj, typeof (ArgumentException).GetConstructor (new Type[] { typeof(string) }));
il.Emit (OpCodes.Throw); il.Emit (OpCodes.Throw);
// Non-null case
il.MarkLabel (normalLabel);
// Dest
il.Emit (OpCodes.Ldloca, args [pindex]);
// Load the native ptr of the object (src)
il.Emit (OpCodes.Ldarg, aindex);
EmitLoadNativePtr (il);
// FIXME: Dispose check
// Copy
il.Emit (OpCodes.Cpobj, ptype);
break;
} }
default:
throw new NotImplementedException ();
}
aindex ++;
} }
// Pass arguments il.MarkLabel (nextArg);
}
aindex = 1;
int pindexStart = 0;
if (retArg != null) { // This method marshals from C++ -> managed
pindexStart ++; // The value it is marshaling will be on the stack.
il.Emit (OpCodes.Ldloc, retArg); protected virtual void EmitInboundMarshal (ILGenerator il, Type nativeType, Type targetType)
} {
var next = il.DefineLabel ();
for (int pindex = pindexStart; pindex < psig.ParameterTypes.Count; pindex++) { // marshal IntPtr -> ICppObject
// The first argument is the .net this argument if (nativeType == typeof (IntPtr) && typeof (ICppObject).IsAssignableFrom (targetType)) {
if (args [pindex] != null)
il.Emit (OpCodes.Ldloc, args [pindex]);
else
il.Emit (OpCodes.Ldarg, aindex);
aindex ++; var isNull = il.DefineLabel ();
}
// Make the call // first, we check for null
il.Emit (OpCodes.Dup);
il.Emit (OpCodes.Brfalse_S, isNull);
il.Emit (OpCodes.Call, nativeMethod); il.Emit (OpCodes.Newobj, cppip_fromnative);
} EmitCreateCppObjectFromNative (il, targetType);
public virtual PInvokeSignature GetPInvokeSignature (CppTypeInfo typeInfo, MethodInfo method) { il.MarkLabel (isNull);
var originalTypes = ReflectionHelper.GetMethodParameterTypes (method); il.Emit (OpCodes.Pop);
il.Emit (OpCodes.Ldnull);
} else if (nativeType.IsValueType && typeof (ICppObject).IsAssignableFrom (targetType)) {
// marshal value type -> ICppObject
// Obviously, we lose all managed overrides if we pass by value,
// but this "slicing" happens in vanilla C++ as well
var ptr = il.DeclareLocal (typeof (CppInstancePtr));
il.Emit (OpCodes.Box, nativeType); // structure
il.Emit (OpCodes.Sizeof, nativeType);
il.Emit (OpCodes.Newobj, cppip_fromsize);
il.Emit (OpCodes.Stloc, ptr);
il.Emit (OpCodes.Ldloca, ptr);
il.Emit (OpCodes.Call, cppip_native); // ptr
il.Emit (OpCodes.Ldc_I4_0); // fDeleteOld
var pinvokeTypes = originalTypes.Transform ( il.Emit (OpCodes.Call, marshal_structuretoptr);
For.AnyInputIn (typeof (bool)).Emit (typeof (byte)),
// CppInstancePtr implements ICppObject il.Emit (OpCodes.Ldloc, ptr);
For.InputsWhere ((Type t) => typeof (ICppObject).IsAssignableFrom (t)).Emit (typeof (IntPtr)), EmitCreateCppObjectFromNative (il, targetType);
}
il.MarkLabel (next);
}
For.UnmatchedInput<Type> ().Emit (t => t) // Expects CppInstancePtr on stack. No null check performed
); protected virtual void EmitCreateCppObjectFromNative (ILGenerator il, Type targetType)
{
if (targetType == typeof (ICppObject))
targetType = typeof (CppInstancePtr);
Type returnType = method.ReturnType; // check for a native constructor (i.e. a public ctor in the wrapper that takes CppInstancePtr)
var ctor = targetType.GetConstructor (BindingFlags.ExactBinding | BindingFlags.Public | BindingFlags.Instance, null, new Type [] { typeof (CppInstancePtr) }, null);
if (ctor == null)
throw new InvalidProgramException (string.Format ("Type `{0}' implements ICppObject but does not contain a public constructor that takes CppInstancePtr", targetType));
return new PInvokeSignature { OrigMethod = method, ParameterTypes = pinvokeTypes.ToList (), ReturnType = returnType }; il.Emit (OpCodes.Newobj, ctor);
} }
/** /**
@ -756,7 +779,7 @@ namespace Mono.VisualC.Interop.ABI {
} }
protected virtual void EmitLoadInstancePtr (ILGenerator il, Type firstParamType, out LocalBuilder cppip, protected virtual void EmitLoadInstancePtr (ILGenerator il, Type firstParamType, out LocalBuilder cppip,
out LocalBuilder native) out LocalBuilder native)
{ {
cppip = null; cppip = null;
native = null; native = null;
@ -767,7 +790,7 @@ namespace Mono.VisualC.Interop.ABI {
native = il.DeclareLocal (typeof (IntPtr)); native = il.DeclareLocal (typeof (IntPtr));
il.Emit (OpCodes.Stloc_S, cppip); il.Emit (OpCodes.Stloc_S, cppip);
il.Emit (OpCodes.Ldloca_S, cppip); il.Emit (OpCodes.Ldloca_S, cppip);
il.Emit (OpCodes.Call, typeof (CppInstancePtr).GetProperty ("Native").GetGetMethod ()); il.Emit (OpCodes.Call, cppip_native);
il.Emit (OpCodes.Stloc_S, native); il.Emit (OpCodes.Stloc_S, native);
} else if (firstParamType.Equals (typeof (IntPtr))) { } else if (firstParamType.Equals (typeof (IntPtr))) {
native = il.DeclareLocal (typeof (IntPtr)); native = il.DeclareLocal (typeof (IntPtr));
@ -779,17 +802,6 @@ namespace Mono.VisualC.Interop.ABI {
throw new ArgumentException ("First argument to non-static C++ method must be byref, IntPtr or CppInstancePtr."); throw new ArgumentException ("First argument to non-static C++ method must be byref, IntPtr or CppInstancePtr.");
} }
// Emit obj.Native.Native
// On enter, the stack should contain a reference to a CppInstancePtr
// On exit, it contains an IntPtr
void EmitLoadNativePtr (ILGenerator il) {
LocalBuilder cppip = il.DeclareLocal (typeof (CppInstancePtr));
il.Emit (OpCodes.Call, typeof (ICppObject).GetMethod ("get_Native"));
il.Emit (OpCodes.Stloc_S, cppip);
il.Emit (OpCodes.Ldloca_S, cppip);
il.Emit (OpCodes.Call, typeof (CppInstancePtr).GetProperty ("Native").GetGetMethod ());
}
protected virtual void EmitCheckManagedAlloc (ILGenerator il, LocalBuilder cppip) protected virtual void EmitCheckManagedAlloc (ILGenerator il, LocalBuilder cppip)
{ {
// make sure we were allocated by managed code // make sure we were allocated by managed code
@ -822,4 +834,5 @@ namespace Mono.VisualC.Interop.ABI {
} }
} }
} }
} }

101
src/Mono.VisualC.Interop/ABI/Impl/ItaniumAbi.cs
Unescape View File

@ -30,6 +30,7 @@ using System;
using System.Linq; using System.Linq;
using System.Text; using System.Text;
using System.Reflection; using System.Reflection;
using System.Reflection.Emit;
using System.Collections.Generic; using System.Collections.Generic;
using System.Runtime.InteropServices; using System.Runtime.InteropServices;
@ -42,21 +43,36 @@ namespace Mono.VisualC.Interop.ABI {
{ {
} }
protected override CppTypeInfo MakeTypeInfo (IEnumerable<MethodInfo> methods, IEnumerable<MethodInfo> virtualMethods) protected override CppTypeInfo MakeTypeInfo (IEnumerable<PInvokeSignature> methods)
{ {
bool hasExplicitCopyCtor = false; return new CppTypeInfo (this, GetVirtualMethodSlots (methods), layout_type);
bool hasExplicitDtor = false; }
foreach (var m in methods) { private IEnumerable<PInvokeSignature> GetVirtualMethodSlots (IEnumerable<PInvokeSignature> methods)
if (m.IsDefined (typeof (CopyConstructorAttribute), false) && !m.IsDefined (typeof (ArtificialAttribute), false)) {
hasExplicitCopyCtor = true; foreach (var method in methods) {
if (m.IsDefined (typeof (DestructorAttribute), false) && !m.IsDefined (typeof (ArtificialAttribute), false)) if (!IsVirtual (method.OrigMethod))
hasExplicitDtor = true; continue;
}
yield return method;
return new ItaniumTypeInfo (this, virtualMethods, layout_type) { HasExplicitCopyCtor = hasExplicitCopyCtor, HasExplicitDtor = hasExplicitDtor }; // Itanium has extra slot for virt dtor
if (method.Type == MethodType.NativeDtor)
yield return null;
}
} }
protected override MethodBuilder DefineMethod (PInvokeSignature sig, CppTypeInfo typeInfo, ref int vtableIndex)
{
var builder = base.DefineMethod (sig, typeInfo, ref vtableIndex);
// increment vtableIndex an extra time for that extra vdtor slot (already incremented once in base)
if (IsVirtual (sig.OrigMethod) && sig.Type == MethodType.NativeDtor)
vtableIndex++;
return builder;
}
public override CallingConvention? GetCallingConvention (MethodInfo methodInfo) public override CallingConvention? GetCallingConvention (MethodInfo methodInfo)
{ {
return CallingConvention.Cdecl; return CallingConvention.Cdecl;
@ -71,6 +87,10 @@ namespace Mono.VisualC.Interop.ABI {
ParameterInfo [] parameters = methodInfo.GetParameters (); ParameterInfo [] parameters = methodInfo.GetParameters ();
StringBuilder nm = new StringBuilder ("_ZN", 30); StringBuilder nm = new StringBuilder ("_ZN", 30);
if (IsConst (methodInfo))
nm.Append ('K');
nm.Append (class_name.Length).Append (class_name); nm.Append (class_name.Length).Append (class_name);
compressMap [class_name] = compressMap.Count; compressMap [class_name] = compressMap.Count;
@ -158,64 +178,7 @@ namespace Mono.VisualC.Interop.ABI {
return code.ToString (); return code.ToString ();
} }
public override PInvokeSignature GetPInvokeSignature (CppTypeInfo typeInfo, MethodInfo method) {
Type returnType = method.ReturnType;
bool retClass = false;
bool retByAddr = false;
if (typeof (ICppObject).IsAssignableFrom (returnType)) {
retClass = true;
if ((typeInfo as ItaniumTypeInfo).HasExplicitCopyCtor ||
(typeInfo as ItaniumTypeInfo).HasExplicitDtor) {
// Section 3.1.4:
// Classes with non-default copy ctors/destructors are returned using a
// hidden argument
retByAddr = true;
}
}
ParameterInfo[] parameters = method.GetParameters ();
var ptypes = new List<Type> ();
var pmarshal = new List<ParameterMarshal> ();
// FIXME: Handle ByVal attributes
foreach (var pi in parameters) {
Type t = pi.ParameterType;
Type ptype = t;
ParameterMarshal m = ParameterMarshal.Default;
if (t == typeof (bool)) {
ptype = typeof (byte);
} else if (typeof (ICppObject).IsAssignableFrom (t) && t != typeof (CppInstancePtr)) {
if (pi.IsDefined (typeof (ByValAttribute), false)) {
m = ParameterMarshal.ClassByVal;
// Can't use an interface/cattr since the native layout type is private
// Pass it as a type argument to I<Foo> ?
var f = t.GetField ("native_layout", BindingFlags.Static|BindingFlags.NonPublic);
if (f == null || f.FieldType != typeof (Type))
throw new NotImplementedException ("Type '" + t + "' needs to have a 'native_layout' field before it can be passed by value.");
ptype = (Type)f.GetValue (null);
} else {
ptype = typeof (IntPtr);
m = ParameterMarshal.ClassByRef;
}
} else if (typeof (ICppObject).IsAssignableFrom (t)) {
// CppInstancePtr implements ICppObject
ptype = typeof (IntPtr);
}
ptypes.Add (ptype);
pmarshal.Add (m);
}
if (retByAddr) {
ptypes.Insert (0, typeof (IntPtr));
pmarshal.Insert (0, ParameterMarshal.Default);
}
return new PInvokeSignature { OrigMethod = method, ParameterTypes = ptypes, ParameterMarshallers = pmarshal, ReturnType = returnType, ReturnClass = retClass, ReturnByAddr = retByAddr };
}
} }
} }

79
src/Mono.VisualC.Interop/ABI/Impl/ItaniumTypeInfo.cs
Unescape View File

@ -1,79 +0,0 @@
//
// Author:
// Andreia Gaita (shana@spoiledcat.net)
//
// Permission is hereby granted, free of charge, to any person obtaining
// a copy of this software and associated documentation files (the
// "Software"), to deal in the Software without restriction, including
// without limitation the rights to use, copy, modify, merge, publish,
// distribute, sublicense, and/or sell copies of the Software, and to
// permit persons to whom the Software is furnished to do so, subject to
// the following conditions:
//
// The above copyright notice and this permission notice shall be
// included in all copies or substantial portions of the Software.
//
// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
// EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
// NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
// LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
// OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
// WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
using System;
using System.Linq;
using System.Collections.Generic;
using System.Reflection;
namespace Mono.VisualC.Interop.ABI {
public class ItaniumTypeInfo : CppTypeInfo {
private bool hasVirtualDtor;
public ItaniumTypeInfo (ItaniumAbi abi, IEnumerable<MethodInfo> virtualMethods, Type nativeLayout)
: base (abi, virtualMethods, nativeLayout)
{
// Remove all virtual destructors from their declared position in the vtable
for (int i = 0; i < VirtualMethods.Count; i++) {
if (Abi.GetMethodType (VirtualMethods [i]) != MethodType.NativeDtor)
continue;
hasVirtualDtor = true;
VirtualMethods.RemoveAt (i);
VTableDelegateTypes.RemoveAt (i);
VTableOverrides.RemoveAt (i);
break;
}
}
public bool HasVirtualDestructor {
get { return hasVirtualDtor; }
}
public bool HasExplicitCopyCtor { get; set; }
public bool HasExplicitDtor { get; set; }
public override void AddBase (CppTypeInfo baseType)
{
if (TypeComplete)
return;
hasVirtualDtor |= ((ItaniumTypeInfo)baseType).HasVirtualDestructor;
base.AddBase (baseType, false);
}
// Itanium puts all its virtual dtors at the bottom of the vtable (2 slots each).
// Since we will never be in a position of calling a dtor virtually, we can just pad the vtable out.
public override int VTableBottomPadding {
get {
if (!hasVirtualDtor)
return 0;
return 2 + CountBases (b => ((ItaniumTypeInfo)b).HasVirtualDestructor) * 2;
}
}
}
}

5
src/Mono.VisualC.Interop/ABI/Impl/MsvcAbi.cs
Unescape View File

@ -44,9 +44,9 @@ namespace Mono.VisualC.Interop.ABI {
{ {
} }
protected override CppTypeInfo MakeTypeInfo (IEnumerable<MethodInfo> methods, IEnumerable<MethodInfo> virtualMethods) protected override CppTypeInfo MakeTypeInfo (IEnumerable<PInvokeSignature> methods)
{ {
return new MsvcTypeInfo (this, virtualMethods, layout_type); return new MsvcTypeInfo (this, methods.Where (m => IsVirtual (m.OrigMethod)), layout_type);
} }
public override CallingConvention? GetCallingConvention (MethodInfo methodInfo) public override CallingConvention? GetCallingConvention (MethodInfo methodInfo)
@ -209,7 +209,6 @@ namespace Mono.VisualC.Interop.ABI {
code.Append(mangleType.ElementTypeName); code.Append(mangleType.ElementTypeName);
code.Append ("@@"); code.Append ("@@");
break; break;
} }
return code.ToString (); return code.ToString ();

4
src/Mono.VisualC.Interop/ABI/Impl/MsvcTypeInfo.cs
Unescape View File

@ -29,9 +29,11 @@ using System.Collections.Generic;
using System.Runtime.InteropServices; using System.Runtime.InteropServices;
using System.Reflection; using System.Reflection;
using Mono.VisualC.Interop.Util;
namespace Mono.VisualC.Interop.ABI { namespace Mono.VisualC.Interop.ABI {
public class MsvcTypeInfo : CppTypeInfo { public class MsvcTypeInfo : CppTypeInfo {
public MsvcTypeInfo (MsvcAbi abi, IEnumerable<MethodInfo> virtualMethods, Type nativeLayout) public MsvcTypeInfo (MsvcAbi abi, IEnumerable<PInvokeSignature> virtualMethods, Type nativeLayout)
: base (abi, virtualMethods, nativeLayout) : base (abi, virtualMethods, nativeLayout)
{ {
} }

1
src/Mono.VisualC.Interop/ABI/MethodType.cs
Unescape View File

@ -27,6 +27,7 @@ using System;
namespace Mono.VisualC.Interop { namespace Mono.VisualC.Interop {
public enum MethodType { public enum MethodType {
NoOp, NoOp,
NotImplemented,
Native, Native,
NativeCtor, NativeCtor,
NativeDtor, NativeDtor,

14
src/Mono.VisualC.Interop/Attributes.cs
Unescape View File

@ -49,7 +49,7 @@ namespace Mono.VisualC.Interop {
[AttributeUsage (AttributeTargets.Method)] [AttributeUsage (AttributeTargets.Method)]
public class CopyConstructorAttribute : Attribute {} public class CopyConstructorAttribute : Attribute {}
[AttributeUsage (AttributeTargets.Parameter)] [AttributeUsage (AttributeTargets.Parameter | AttributeTargets.ReturnValue)]
public class ByValAttribute : Attribute {} public class ByValAttribute : Attribute {}
[AttributeUsage (AttributeTargets.Parameter | AttributeTargets.ReturnValue)] [AttributeUsage (AttributeTargets.Parameter | AttributeTargets.ReturnValue)]
@ -119,6 +119,18 @@ using Mono.VisualC.Interop;
{ {
return method.IsDefined (typeof (InlineAttribute), false); return method.IsDefined (typeof (InlineAttribute), false);
} }
public virtual bool IsArtificial (MethodInfo method)
{
return method.IsDefined (typeof (ArtificialAttribute), false);
}
public virtual bool IsCopyConstructor (MethodInfo method)
{
return method.IsDefined (typeof (CopyConstructorAttribute), false);
}
public virtual bool IsByVal (ICustomAttributeProvider icap)
{
return icap.IsDefined (typeof (ByValAttribute), false);
}
public virtual CppType GetMangleType (ICustomAttributeProvider icap, Type managedType) public virtual CppType GetMangleType (ICustomAttributeProvider icap, Type managedType)
{ {

10
src/Mono.VisualC.Interop/CppInstancePtr.cs
Unescape View File

@ -55,7 +55,7 @@ namespace Mono.VisualC.Interop {
if (!implCache.TryGetValue (typeof (Iface), out cachedImpl)) if (!implCache.TryGetValue (typeof (Iface), out cachedImpl))
{ {
VirtualOnlyAbi virtualABI = new VirtualOnlyAbi (VTable.BindToSignature); VirtualOnlyAbi virtualABI = new VirtualOnlyAbi (VTable.BindToSignature);
impl = virtualABI.ImplementClass<Iface> (typeof (TWrapper), string.Empty, string.Empty); impl = virtualABI.ImplementClass<Iface> (typeof (TWrapper), new CppLibrary (string.Empty), string.Empty);
implCache.Add (typeof (Iface), impl); implCache.Add (typeof (Iface), impl);
} }
else else
@ -86,7 +86,7 @@ namespace Mono.VisualC.Interop {
} }
// Alloc a new C++ instance when there is no managed wrapper. // Alloc a new C++ instance when there is no managed wrapper.
internal CppInstancePtr (int nativeSize) public CppInstancePtr (int nativeSize)
{ {
ptr = Marshal.AllocHGlobal (nativeSize); ptr = Marshal.AllocHGlobal (nativeSize);
manage_memory = true; manage_memory = true;
@ -127,12 +127,6 @@ namespace Mono.VisualC.Interop {
get { return this; } get { return this; }
} }
public int NativeSize {
get {
throw new NotImplementedException ();
}
}
public bool IsManagedAlloc { public bool IsManagedAlloc {
get { return manage_memory; } get { return manage_memory; }
} }

38
src/Mono.VisualC.Interop/CppLibrary.cs
Unescape View File

@ -38,12 +38,29 @@ using System.Reflection.Emit;
using Mono.VisualC.Interop.ABI; using Mono.VisualC.Interop.ABI;
namespace Mono.VisualC.Interop { namespace Mono.VisualC.Interop {
public enum InlineMethods {
// Normally, C++ inline methods are not exported from the library, so C++ interop cannot call them.
// This is the default option. It throws a NotImplementedException if you try to call the native version of one of these methods.
// Use this if you reimplement the inline methods in managed code, or if they are not to be available in the bindings.
NotPresent,
// Expect the inline methods to be present in the specified library
// For example, if the library was compiled with GCC's -fkeep-inline-functions option
Present,
// Expect the inline methods to be exported in a separate library named %name%-inline
SurrogateLib,
}
public sealed class CppLibrary { public sealed class CppLibrary {
internal static AssemblyBuilder interopAssembly; internal static AssemblyBuilder interopAssembly;
internal static ModuleBuilder interopModule; internal static ModuleBuilder interopModule;
public CppAbi Abi { get; private set; } public CppAbi Abi { get; private set; }
public string Name { get; private set; } public string Name { get; private set; }
public InlineMethods InlineMethodPolicy { get; private set; }
static CppLibrary () static CppLibrary ()
{ {
@ -55,17 +72,17 @@ namespace Mono.VisualC.Interop {
} }
public CppLibrary (string name) public CppLibrary (string name)
: this (name, InlineMethods.NotPresent)
{ {
if (name == null) }
throw new ArgumentNullException ("Name cannot be NULL.");
this.Name = name;
// FIXME: This is where we'd auto detect the ABI public CppLibrary (string name, InlineMethods inlinePolicy)
this.Abi = new ItaniumAbi (); : this (name, new ItaniumAbi (), inlinePolicy)
{
//FIXME: Ideally we would auto-detect ABI here.
} }
public CppLibrary (string name, CppAbi abi) public CppLibrary (string name, CppAbi abi, InlineMethods inlinePolicy)
{ {
if (name == null) if (name == null)
throw new ArgumentNullException ("Name cannot be NULL."); throw new ArgumentNullException ("Name cannot be NULL.");
@ -74,6 +91,7 @@ namespace Mono.VisualC.Interop {
this.Name = name; this.Name = name;
this.Abi = abi; this.Abi = abi;
this.InlineMethodPolicy = inlinePolicy;
} }
// Mainly for debugging at this point // Mainly for debugging at this point
@ -87,7 +105,7 @@ namespace Mono.VisualC.Interop {
public Iface GetClass<Iface> (string className) public Iface GetClass<Iface> (string className)
where Iface : ICppClass where Iface : ICppClass
{ {
return Abi.ImplementClass<Iface> (null, Name, className); return Abi.ImplementClass<Iface> (null, this, className);
} }
// For instantiating or working with a class that may have fields // For instantiating or working with a class that may have fields
@ -96,7 +114,7 @@ namespace Mono.VisualC.Interop {
where Iface : ICppClassInstantiatable where Iface : ICppClassInstantiatable
where NativeLayout : struct where NativeLayout : struct
{ {
return Abi.ImplementClass<Iface, NativeLayout> (null, Name, className); return Abi.ImplementClass<Iface, NativeLayout> (null, this, className);
} }
/* The most powerful override. Allows the following from managed code: /* The most powerful override. Allows the following from managed code:
@ -109,7 +127,7 @@ namespace Mono.VisualC.Interop {
where NativeLayout : struct where NativeLayout : struct
where Managed : ICppObject where Managed : ICppObject
{ {
return Abi.ImplementClass<Iface, NativeLayout> (typeof (Managed), Name, className); return Abi.ImplementClass<Iface, NativeLayout> (typeof (Managed), this, className);
} }
} }

64
src/Mono.VisualC.Interop/CppTypeInfo.cs
Unescape View File

@ -45,7 +45,7 @@ namespace Mono.VisualC.Interop {
public CppAbi Abi { get; private set; } public CppAbi Abi { get; private set; }
public Type NativeLayout {get; private set; } public Type NativeLayout {get; private set; }
public IList<MethodInfo> VirtualMethods { get; private set; } public IList<PInvokeSignature> VirtualMethods { get; private set; }
public LazyGeneratedList<Type> VTableDelegateTypes { get; private set; } public LazyGeneratedList<Type> VTableDelegateTypes { get; private set; }
public LazyGeneratedList<Delegate> VTableOverrides { get; private set; } public LazyGeneratedList<Delegate> VTableOverrides { get; private set; }
@ -62,14 +62,14 @@ namespace Mono.VisualC.Interop {
private VTable lazy_vtable; private VTable lazy_vtable;
public CppTypeInfo (CppAbi abi, IEnumerable<MethodInfo> virtualMethods, Type nativeLayout) public CppTypeInfo (CppAbi abi, IEnumerable<PInvokeSignature> virtualMethods, Type nativeLayout)
{ {
Abi = abi; Abi = abi;
NativeLayout = nativeLayout; NativeLayout = nativeLayout;
VirtualMethods = new List<MethodInfo> (virtualMethods); VirtualMethods = new List<PInvokeSignature> (virtualMethods);
VTableDelegateTypes = new LazyGeneratedList<Type> (VirtualMethods.Count, VTableDelegateTypeGenerator); VTableDelegateTypes = new LazyGeneratedList<Type> (VirtualMethods.Count, i => DelegateTypeCache.GetDelegateType (VirtualMethods [i]));
VTableOverrides = new LazyGeneratedList<Delegate> (VirtualMethods.Count, VTableOverrideGenerator); VTableOverrides = new LazyGeneratedList<Delegate> (VirtualMethods.Count, i => Abi.GetManagedOverrideTrampoline (this, i));
BaseClasses = new List<CppTypeInfo> (); BaseClasses = new List<CppTypeInfo> ();
BaseVTableSlots = 0; BaseVTableSlots = 0;
@ -83,8 +83,6 @@ namespace Mono.VisualC.Interop {
public virtual void AddBase (CppTypeInfo baseType) public virtual void AddBase (CppTypeInfo baseType)
{ {
if (TypeComplete)
return;
// by default, do not add another vtable pointer for this new base class // by default, do not add another vtable pointer for this new base class
AddBase (baseType, false); AddBase (baseType, false);
@ -92,6 +90,9 @@ namespace Mono.VisualC.Interop {
protected virtual void AddBase (CppTypeInfo baseType, bool addVTablePointer) protected virtual void AddBase (CppTypeInfo baseType, bool addVTablePointer)
{ {
if (TypeComplete)
return;
BaseClasses.Add (baseType); BaseClasses.Add (baseType);
if (!addVTablePointer) { if (!addVTablePointer) {
@ -121,7 +122,6 @@ namespace Mono.VisualC.Interop {
return count; return count;
} }
// FIXME: Make this thread safe?
public virtual void CompleteType () public virtual void CompleteType ()
{ {
if (TypeComplete) if (TypeComplete)
@ -131,16 +131,25 @@ namespace Mono.VisualC.Interop {
baseClass.CompleteType (); baseClass.CompleteType ();
TypeComplete = true; TypeComplete = true;
RemoveVTableDuplicates (ms => true);
}
protected virtual void RemoveVTableDuplicates (Predicate<MethodSignature> pred)
{
// check that any virtual methods overridden in a subclass are only included once // check that any virtual methods overridden in a subclass are only included once
HashSet<MethodSignature> vsignatures = new HashSet<MethodSignature> (); var vsignatures = new HashSet<MethodSignature> ();
for (int i = 0; i < VirtualMethods.Count; i++) {
MethodSignature sig = GetVTableMethodSignature (i);
if (vsignatures.Contains (sig)) for (int i = 0; i < VirtualMethods.Count; i++) {
VirtualMethods.RemoveAt (i--); var sig = VirtualMethods [i];
else if (sig == null)
continue;
if (vsignatures.Contains (sig)) {
if (pred (sig))
VirtualMethods.RemoveAt (i--);
} else {
vsignatures.Add (sig); vsignatures.Add (sig);
}
} }
} }
@ -186,33 +195,6 @@ namespace Mono.VisualC.Interop {
public virtual int VTableBottomPadding { public virtual int VTableBottomPadding {
get { return 0; } get { return 0; }
} }
public virtual MethodSignature GetVTableMethodSignature (int index)
{
MethodInfo method = VirtualMethods [index];
return new MethodSignature () { Name = method.Name,
Type = Abi.GetMethodType (method),
Signature = GetVTableDelegateSignature (index) };
}
public virtual DelegateSignature GetVTableDelegateSignature (int index)
{
MethodInfo method = VirtualMethods [index];
var psig = Abi.GetPInvokeSignature (this, method);
return new DelegateSignature () { ParameterTypes = psig.ParameterTypes,
ReturnType = method.ReturnType,
CallingConvention = Abi.GetCallingConvention (method) };
}
private Type VTableDelegateTypeGenerator (int index)
{
return DelegateTypeCache.GetDelegateType (GetVTableDelegateSignature (index));
}
private Delegate VTableOverrideGenerator (int index)
{
return Abi.GetManagedOverrideTrampoline (this, index);
}
} }
} }

8
src/Mono.VisualC.Interop/Interfaces.cs
Unescape View File

@ -30,6 +30,8 @@ using System;
using Mono.VisualC.Interop.ABI; using Mono.VisualC.Interop.ABI;
namespace Mono.VisualC.Interop { namespace Mono.VisualC.Interop {
// Part of the contract for ICppObject is a public constructor that takes CppInstancePtr (native constructor)
public interface ICppObject : IDisposable { public interface ICppObject : IDisposable {
CppInstancePtr Native { get; } CppInstancePtr Native { get; }
} }
@ -47,7 +49,9 @@ namespace Mono.VisualC.Interop {
// It is recommended that managed wrappers implement ICppObject, but // It is recommended that managed wrappers implement ICppObject, but
// I'm not making it required so that any arbitrary object can be exposed to // I'm not making it required so that any arbitrary object can be exposed to
// C++ via CppInstancePtr.ForManagedObject. // C++ via CppInstancePtr.ForManagedObject.
public interface ICppClassOverridable<T> : ICppClass /* where T : ICppObject */ { public interface ICppClassOverridable<TManaged> : ICppClassInstantiatable
CppInstancePtr Alloc (T managed); /* where TManaged : ICppObject */
{
CppInstancePtr Alloc (TManaged managed);
} }
} }

1
src/Mono.VisualC.Interop/Mono.VisualC.Interop.csproj
Unescape View File

@ -74,7 +74,6 @@
<Compile Include="CppObjectMarshaler.cs" /> <Compile Include="CppObjectMarshaler.cs" />
<Compile Include="CppType.cs" /> <Compile Include="CppType.cs" />
<Compile Include="CppTypeInfo.cs" /> <Compile Include="CppTypeInfo.cs" />
<Compile Include="ABI\Impl\ItaniumTypeInfo.cs" />
<Compile Include="Util\IEnumerableTransform.cs" /> <Compile Include="Util\IEnumerableTransform.cs" />
<Compile Include="Util\LazyGeneratedList.cs" /> <Compile Include="Util\LazyGeneratedList.cs" />
<Compile Include="Util\DelegateTypeCache.cs" /> <Compile Include="Util\DelegateTypeCache.cs" />

10
src/Mono.VisualC.Interop/Util/DelegateTypeCache.cs
Unescape View File

@ -37,7 +37,7 @@ namespace Mono.VisualC.Interop.Util {
public static class DelegateTypeCache { public static class DelegateTypeCache {
private static Dictionary<DelegateSignature, Type> type_cache; private static Dictionary<BasicSignature, Type> type_cache;
public static Type GetDelegateType (MethodInfo signature, CallingConvention? callingConvention) public static Type GetDelegateType (MethodInfo signature, CallingConvention? callingConvention)
{ {
@ -45,13 +45,13 @@ namespace Mono.VisualC.Interop.Util {
} }
public static Type GetDelegateType (IEnumerable<Type> parameterTypes, Type returnType, CallingConvention? callingConvention) public static Type GetDelegateType (IEnumerable<Type> parameterTypes, Type returnType, CallingConvention? callingConvention)
{ {
return GetDelegateType (new DelegateSignature () { ParameterTypes = parameterTypes, ReturnType = returnType, CallingConvention = callingConvention }); return GetDelegateType (new BasicSignature { ParameterTypes = parameterTypes.ToList (), ReturnType = returnType, CallingConvention = callingConvention });
} }
public static Type GetDelegateType (DelegateSignature signature) public static Type GetDelegateType (BasicSignature signature)
{ {
Type delegateType; Type delegateType;
if (type_cache == null) if (type_cache == null)
type_cache = new Dictionary<DelegateSignature, Type> (); type_cache = new Dictionary<BasicSignature, Type> ();
if (!type_cache.TryGetValue (signature, out delegateType)) { if (!type_cache.TryGetValue (signature, out delegateType)) {
delegateType = CreateDelegateType (signature); delegateType = CreateDelegateType (signature);
@ -61,7 +61,7 @@ namespace Mono.VisualC.Interop.Util {
return delegateType; return delegateType;
} }
private static Type CreateDelegateType (DelegateSignature signature) private static Type CreateDelegateType (BasicSignature signature)
{ {
string delTypeName = signature.UniqueName; string delTypeName = signature.UniqueName;

36
src/Mono.VisualC.Interop/Util/MethodSignature.cs
Unescape View File

@ -35,9 +35,9 @@ using System.Collections.Generic;
namespace Mono.VisualC.Interop.Util { namespace Mono.VisualC.Interop.Util {
public struct DelegateSignature { public class BasicSignature {
public CallingConvention? CallingConvention { get; set; } public CallingConvention? CallingConvention { get; set; }
public IEnumerable<Type> ParameterTypes { get; set; } public List<Type> ParameterTypes { get; set; }
public Type ReturnType { get; set; } public Type ReturnType { get; set; }
private string uniqueName; private string uniqueName;
@ -64,18 +64,23 @@ namespace Mono.VisualC.Interop.Util {
} }
} }
public bool IsCompatibleWith (BasicSignature other)
{
return CallingConvention == other.CallingConvention &&
((ParameterTypes == null && other.ParameterTypes == null) ||
ParameterTypes.SequenceEqual (other.ParameterTypes)) &&
ReturnType.Equals (other.ReturnType);
}
public override bool Equals (object obj) public override bool Equals (object obj)
{ {
if (obj == null) if (obj == null)
return false; return false;
if (obj.GetType () != typeof(DelegateSignature)) if (obj.GetType () != typeof(BasicSignature))
return false; return false;
DelegateSignature other = (DelegateSignature)obj; BasicSignature other = (BasicSignature)obj;
return CallingConvention == other.CallingConvention && return IsCompatibleWith (other);
((ParameterTypes == null && other.ParameterTypes == null) ||
ParameterTypes.SequenceEqual (other.ParameterTypes)) &&
ReturnType.Equals (other.ReturnType);
} }
public override int GetHashCode () public override int GetHashCode ()
@ -88,10 +93,9 @@ namespace Mono.VisualC.Interop.Util {
} }
} }
public struct MethodSignature { public class MethodSignature : BasicSignature {
public string Name { get; set; } public string Name { get; set; }
public MethodType Type { get; set; } public MethodType Type { get; set; }
public DelegateSignature Signature { get; set; }
public override bool Equals (object obj) public override bool Equals (object obj)
{ {
@ -100,21 +104,27 @@ namespace Mono.VisualC.Interop.Util {
if (obj.GetType () != typeof(MethodSignature)) if (obj.GetType () != typeof(MethodSignature))
return false; return false;
MethodSignature other = (MethodSignature)obj; MethodSignature other = (MethodSignature)obj;
return Signature.Equals (other.Signature) &&
return IsCompatibleWith (other) &&
Type == other.Type && Type == other.Type &&
(Type != MethodType.Native || Name.Equals (other.Name)); (Name.Equals (other.Name) || Type != MethodType.Native);
} }
public override int GetHashCode () public override int GetHashCode ()
{ {
unchecked { unchecked {
return Signature.GetHashCode () ^ return base.GetHashCode () ^
Type.GetHashCode () ^ Type.GetHashCode () ^
(Type == MethodType.Native? Name.GetHashCode () : 0); (Type == MethodType.Native? Name.GetHashCode () : 0);
} }
} }
} }
public class PInvokeSignature : MethodSignature {
// The original c# method this signature was generated from
public MethodInfo OrigMethod;
}
} }

Write Preview
Loading…
Cancel
Save