public InteropMethodSignature Add(InteropMethodSignature method)
{
method.Index = Methods.Count;
int indexOf = Methods.IndexOf(method);
if (indexOf>=0)
return Methods[indexOf];
Methods.Add(method);
return method;
}
public InteropMethodSignature Add(InteropMethodSignature method)
{
method.Index = Methods.Count;
int indexOf = Methods.IndexOf(method);
if (indexOf >= 0)
{
return(Methods[indexOf]);
}
Methods.Add(method);
return(method);
}
public override bool Equals(object obj)
{
if (obj == null)
{
return(false);
}
InteropMethodSignature against = obj as InteropMethodSignature;
if (against == null)
{
return(false);
}
if (this.ReturnType != against.ReturnType)
{
return(false);
}
if (this.IsFunction != against.IsFunction)
{
return(false);
}
if (this.ParameterTypes.Count != against.ParameterTypes.Count)
{
return(false);
}
if (this.IsLocal != against.IsLocal)
{
return(false);
}
for (int i = 0; i < ParameterTypes.Count; i++)
{
if (ParameterTypes[i] != against.ParameterTypes[i])
{
return(false);
}
}
return(true);
}
/// <summary>
/// Registers the native interop signature.
/// </summary>
/// <param name="csMethod">The cs method.</param>
private void RegisterNativeInteropSignature(CsMethod csMethod)
{
// Tag if the method is a function
var cSharpInteropCalliSignature = new InteropMethodSignature { IsFunction = (csMethod is CsFunction) };
// Handle Return Type parameter
// MarshalType.Type == null, then check that it is a structure
if (csMethod.ReturnType.PublicType is CsStruct || csMethod.ReturnType.PublicType is CsEnum)
{
// Return type and 1st parameter are implicitly a pointer to the structure to fill
if (csMethod.IsReturnStructLarge)
{
cSharpInteropCalliSignature.ReturnType = typeof(void*);
cSharpInteropCalliSignature.ParameterTypes.Add(typeof(void*));
}
else
{
// Patch for Mono bug with structs marshalling and calli. TEMPORARY
var returnQualifiedName = csMethod.ReturnType.PublicType.QualifiedName;
if (returnQualifiedName == "SharpDX.Result")
cSharpInteropCalliSignature.ReturnType = typeof (int);
else if (returnQualifiedName == "SharpDX.PointerSize" || returnQualifiedName == "SharpDX.Direct3D9.EffectHandle")
cSharpInteropCalliSignature.ReturnType = typeof(void*);
else
cSharpInteropCalliSignature.ReturnType = csMethod.ReturnType.PublicType.QualifiedName;
}
}
else if (csMethod.ReturnType.MarshalType.Type != null)
{
Type type = csMethod.ReturnType.MarshalType.Type;
//if (type == typeof(IntPtr))
// type = typeof(void*);
cSharpInteropCalliSignature.ReturnType = type;
}
else
{
throw new ArgumentException(string.Format(System.Globalization.CultureInfo.InvariantCulture, "Invalid return type {0} for method {1}", csMethod.ReturnType.PublicType.QualifiedName, csMethod.CppElement));
}
// Handle Parameters
foreach (var param in csMethod.Parameters)
{
InteropType interopType;
string publicName = param.PublicType.QualifiedName;
// Patch for Mono bug with structs marshalling and calli. TEMPORARY
if (publicName == "SharpDX.PointerSize" || param.PublicType.QualifiedName == "SharpDX.Direct3D9.EffectHandle")
{
interopType = typeof(void*);
}
else if (param.MarshalType.Type == null)
{
if (param.PublicType is CsStruct)
{
// If parameter is a struct, then a LocalInterop is needed
interopType = param.PublicType.QualifiedName;
cSharpInteropCalliSignature.IsLocal = true;
}
else
{
throw new ArgumentException(string.Format(System.Globalization.CultureInfo.InvariantCulture, "Invalid parameter {0} for method {1}", param.PublicType.QualifiedName, csMethod.CppElement));
}
}
else
{
Type type = param.MarshalType.Type;
// Patch for Mono bug with structs marshalling and calli. TEMPORARY
if (type == typeof(IntPtr))
type = typeof(void*);
interopType = type;
}
cSharpInteropCalliSignature.ParameterTypes.Add(interopType);
}
var assembly = csMethod.GetParent<CsAssembly>();
cSharpInteropCalliSignature = assembly.Interop.Add(cSharpInteropCalliSignature);
csMethod.Interop = cSharpInteropCalliSignature;
}
public InteropMethodSignature Add(InteropMethodSignature method)
{
methods.Add(method);
return(methods.First(mthd => mthd.Equals(method)));
}