// Sean MacIsaac (macisaac@ximian.com)
// Paolo Molaro (lupus@ximian.com)
// Gonzalo Paniagua Javier (gonzalo@ximian.com)
+// Marek Safar (marek.safar@gmail.com)
//
// (C) Ximian, Inc. 2001 - 2003
// (c) Copyright 2004 Novell, Inc. (http://www.novell.com)
-
-//
-// Copyright (C) 2004 Novell, Inc (http://www.novell.com)
+// Copyright (C) 2012 Xamarin Inc (http://www.xamarin.com)
//
// Permission is hereby granted, free of charge, to any person obtaining
// a copy of this software and associated documentation files (the
using System.Globalization;
using System.Runtime.InteropServices;
+using System.Collections.Generic;
namespace System.Reflection
{
public abstract MethodBase SelectMethod (BindingFlags bindingAttr, MethodBase[] match, Type[] types, ParameterModifier[] modifiers);
public abstract PropertyInfo SelectProperty( BindingFlags bindingAttr, PropertyInfo[] match, Type returnType, Type[] indexes, ParameterModifier[] modifiers);
- static Binder default_binder = new Default ();
+ static readonly Binder default_binder = new Default ();
internal static Binder DefaultBinder {
get {
}
}
- internal static bool ConvertArgs (Binder binder, object[] args, ParameterInfo[] pinfo, CultureInfo culture) {
+ internal void ConvertValues (object[] args, ParameterInfo[] pinfo, CultureInfo culture, bool exactMatch)
+ {
if (args == null) {
- if ( pinfo.Length == 0)
- return true;
- else
- throw new TargetParameterCountException ();
+ if (pinfo.Length == 0)
+ return;
+
+ throw new TargetParameterCountException ();
}
+
if (pinfo.Length != args.Length)
throw new TargetParameterCountException ();
+
for (int i = 0; i < args.Length; ++i) {
- object v = binder.ChangeType (args [i], pinfo[i].ParameterType, culture);
- if ((v == null) && (args [i] != null))
- return false;
- args [i] = v;
+ var arg = args [i];
+ var pi = pinfo [i];
+ if (arg == Type.Missing) {
+ args [i] = pi.DefaultValue;
+ continue;
+ }
+
+ args [i] = ConvertValue (arg, pi.ParameterType, culture, exactMatch);
+ }
+ }
+
+ internal object ConvertValue (object value, Type type, CultureInfo culture, bool exactMatch)
+ {
+ bool failed = false;
+ var res = TryConvertToType (value, type, ref failed);
+ if (!failed)
+ return res;
+
+ if (exactMatch || this == default_binder)
+ throw new ArgumentException ("Object type " + value.GetType() + " cannot be converted to target type: " + type.FullName);
+
+ return ChangeType (value, type, culture);
+ }
+
+ object TryConvertToType (object value, Type type, ref bool failed)
+ {
+ if (type.IsInstanceOfType (value)) {
+ return value;
+ }
+
+ if (type.IsByRef) {
+ var elementType = type.GetElementType ();
+ if (value == null || elementType.IsInstanceOfType (value)) {
+ return value;
+ }
+ }
+
+ if (value == null)
+ return value;
+
+ if (type.IsEnum) {
+ type = Enum.GetUnderlyingType (type);
+ if (type == value.GetType ())
+ return value;
+ }
+
+ if (type.IsPrimitive) {
+ var res = IsConvertibleToPrimitiveType (value, type);
+ if (res != null)
+ return res;
+ } else if (type.IsPointer) {
+ var vtype = value.GetType ();
+ if (vtype == typeof (IntPtr) || vtype == typeof (UIntPtr))
+ return value;
+ }
+
+ failed = true;
+ return null;
+ }
+
+ // Binder uses some incompatible conversion rules. For example
+ // int value cannot be used with decimal parameter but in other
+ // ways it's more flexible than normal convertor, for example
+ // long value can be used with int based enum
+ static object IsConvertibleToPrimitiveType (object value, Type targetType)
+ {
+ var type = value.GetType ();
+ if (type.IsEnum) {
+ type = Enum.GetUnderlyingType (type);
+ if (type == targetType)
+ return value;
+ }
+
+ var from = Type.GetTypeCode (type);
+ var to = Type.GetTypeCode (targetType);
+
+ switch (to) {
+ case TypeCode.Char:
+ switch (from) {
+ case TypeCode.Byte:
+ return (Char) (Byte) value;
+ case TypeCode.UInt16:
+ return value;
+ }
+ break;
+ case TypeCode.Int16:
+ switch (from) {
+ case TypeCode.Byte:
+ return (Int16) (Byte) value;
+ case TypeCode.SByte:
+ return (Int16) (SByte) value;
+ }
+ break;
+ case TypeCode.UInt16:
+ switch (from) {
+ case TypeCode.Byte:
+ return (UInt16) (Byte) value;
+ case TypeCode.Char:
+ return value;
+ }
+ break;
+ case TypeCode.Int32:
+ switch (from) {
+ case TypeCode.Byte:
+ return (Int32) (Byte) value;
+ case TypeCode.SByte:
+ return (Int32) (SByte) value;
+ case TypeCode.Char:
+ return (Int32) (Char) value;
+ case TypeCode.Int16:
+ return (Int32) (Int16) value;
+ case TypeCode.UInt16:
+ return (Int32) (UInt16) value;
+ }
+ break;
+ case TypeCode.UInt32:
+ switch (from) {
+ case TypeCode.Byte:
+ return (UInt32) (Byte) value;
+ case TypeCode.Char:
+ return (UInt32) (Char) value;
+ case TypeCode.UInt16:
+ return (UInt32) (UInt16) value;
+ }
+ break;
+ case TypeCode.Int64:
+ switch (from) {
+ case TypeCode.Byte:
+ return (Int64) (Byte) value;
+ case TypeCode.SByte:
+ return (Int64) (SByte) value;
+ case TypeCode.Int16:
+ return (Int64) (Int16) value;
+ case TypeCode.Char:
+ return (Int64) (Char) value;
+ case TypeCode.UInt16:
+ return (Int64) (UInt16) value;
+ case TypeCode.Int32:
+ return (Int64) (Int32) value;
+ case TypeCode.UInt32:
+ return (Int64) (UInt32) value;
+ }
+ break;
+ case TypeCode.UInt64:
+ switch (from) {
+ case TypeCode.Byte:
+ return (UInt64) (Byte) value;
+ case TypeCode.Char:
+ return (UInt64) (Char) value;
+ case TypeCode.UInt16:
+ return (UInt64) (UInt16) value;
+ case TypeCode.UInt32:
+ return (UInt64) (UInt32) value;
+ }
+ break;
+ case TypeCode.Single:
+ switch (from) {
+ case TypeCode.Byte:
+ return (Single) (Byte) value;
+ case TypeCode.SByte:
+ return (Single) (SByte) value;
+ case TypeCode.Int16:
+ return (Single) (Int16) value;
+ case TypeCode.Char:
+ return (Single) (Char) value;
+ case TypeCode.UInt16:
+ return (Single) (UInt16) value;
+ case TypeCode.Int32:
+ return (Single) (Int32) value;
+ case TypeCode.UInt32:
+ return (Single) (UInt32) value;
+ case TypeCode.Int64:
+ return (Single) (Int64) value;
+ case TypeCode.UInt64:
+ return (Single) (UInt64) value;
+ }
+ break;
+ case TypeCode.Double:
+ switch (from) {
+ case TypeCode.Byte:
+ return (Double) (Byte) value;
+ case TypeCode.SByte:
+ return (Double) (SByte) value;
+ case TypeCode.Char:
+ return (Double) (Char) value;
+ case TypeCode.Int16:
+ return (Double) (Int16) value;
+ case TypeCode.UInt16:
+ return (Double) (UInt16) value;
+ case TypeCode.Int32:
+ return (Double) (Int32) value;
+ case TypeCode.UInt32:
+ return (Double) (UInt32) value;
+ case TypeCode.Int64:
+ return (Double) (Int64) value;
+ case TypeCode.UInt64:
+ return (Double) (UInt64) value;
+ case TypeCode.Single:
+ return (Double) (Single) value;
+ }
+ break;
}
- return true;
+
+ // Everything else is rejected
+ return null;
}
internal static int GetDerivedLevel (Type type)
// If the argument types differ we
// have an ambigous match, as well
if (matchId >= 0) {
- ParameterInfo[] p1 = m.GetParameters ();
- ParameterInfo[] p2 = match [matchId].GetParameters ();
+ ParameterInfo[] p1 = m.GetParametersInternal ();
+ ParameterInfo[] p2 = match [matchId].GetParametersInternal ();
bool equal = true;
if (p1.Length != p2.Length)
return null;
}
- //
- // FIXME: There was a MonoTODO, but it does not explain what the problem is
- //
public override MethodBase BindToMethod (BindingFlags bindingAttr, MethodBase[] match, ref object[] args, ParameterModifier[] modifiers, CultureInfo culture, string[] names, out object state)
{
Type[] types;
MethodBase selected = null;
if (names != null) {
foreach (var m in match) {
- var parameters = m.GetParameters ();
+ var parameters = m.GetParametersInternal ();
int i;
/*
* Find the corresponding parameter for each parameter name,
* reorder types/modifiers array during the search.
*/
- Type[] newTypes = (Type[])types.Clone ();
- ParameterModifier[] newModifiers = modifiers != null ? (ParameterModifier[])modifiers.Clone () : null;
+ Type[] newTypes = new Type [types.Length];
+ Array.FastCopy (types, 0, newTypes, 0, types.Length);
+
+ ParameterModifier[] newModifiers = null;
+ if (modifiers != null) {
+ newModifiers = new ParameterModifier [modifiers.Length];
+ Array.FastCopy (modifiers, 0, newModifiers, 0, modifiers.Length);
+ }
+
for (i = 0; i < names.Length; ++i) {
/* Find the corresponding parameter */
int nindex = -1;
if (i < names.Length)
continue;
- selected = SelectMethod (bindingAttr, new MethodBase [] { m }, newTypes, newModifiers, true, args);
+ selected = SelectMethod (bindingAttr, new MethodBase [] { m }, newTypes, newModifiers, true, ref args);
if (selected != null)
break;
}
} else {
- selected = SelectMethod (bindingAttr, match, types, modifiers, true, args);
+ selected = SelectMethod (bindingAttr, match, types, modifiers, true, ref args);
}
state = null;
if (selected != null) {
if (args == null)
- args = new object [0];
+ args = EmptyArray<object>.Value;
AdjustArguments (selected, ref args);
}
// probably belongs in ReorderArgumentArray
static void AdjustArguments (MethodBase selected, ref object [] args)
{
- var parameters = selected.GetParameters ();
+ var parameters = selected.GetParametersInternal ();
var parameters_length = parameters.Length;
if (parameters_length == 0)
return;
{
object [] newArgs = new object [args.Length];
Array.Copy (args, newArgs, args.Length);
- ParameterInfo [] plist = selected.GetParameters ();
+ ParameterInfo [] plist = selected.GetParametersInternal ();
for (int n = 0; n < names.Length; n++)
for (int p = 0; p < plist.Length; p++) {
if (names [n] == plist [p].Name) {
}
Array.Copy (newArgs, args, args.Length);
}
-
- static bool IsArrayAssignable (Type object_type, Type target_type)
- {
- if (object_type.IsArray && target_type.IsArray)
- return IsArrayAssignable (object_type.GetElementType (), target_type.GetElementType ());
-
- if (target_type.IsAssignableFrom (object_type))
- return true;
-
- return false;
- }
public override object ChangeType (object value, Type type, CultureInfo culture)
{
- if (value == null)
- return null;
- Type vtype = value.GetType ();
- if (type.IsByRef)
- type = type.GetElementType ();
- if (vtype == type || type.IsInstanceOfType (value))
- return value;
- if (vtype.IsArray && type.IsArray){
- if (IsArrayAssignable (vtype.GetElementType (), type.GetElementType ()))
- return value;
- }
-
- if (check_type (vtype, type)) {
- // These are not supported by Convert
- if (type.IsEnum)
- return Enum.ToObject (type, value);
- if (vtype == typeof (Char)) {
- if (type == typeof (double))
- return (double)(char)value;
- if (type == typeof (float))
- return (float)(char)value;
- }
- if (vtype == typeof (IntPtr) && type.IsPointer)
- return value;
- return Convert.ChangeType (value, type);
- }
- return null;
+ throw new NotSupportedException ();
}
[MonoTODO ("This method does not do anything in Mono")]
public override MethodBase SelectMethod (BindingFlags bindingAttr, MethodBase [] match, Type [] types, ParameterModifier [] modifiers)
{
- return SelectMethod (bindingAttr, match, types, modifiers,
- false, null);
+ object[] args = null;
+ return SelectMethod (bindingAttr, match, types, modifiers, false, ref args);
}
- MethodBase SelectMethod (BindingFlags bindingAttr, MethodBase[] match, Type[] types, ParameterModifier[] modifiers, bool allowByRefMatch, object[] parameters)
+ MethodBase SelectMethod (BindingFlags bindingAttr, MethodBase[] match, Type[] types, ParameterModifier[] modifiers, bool allowByRefMatch, ref object[] arguments)
{
MethodBase m;
int i, j;
MethodBase exact_match = null;
for (i = 0; i < match.Length; ++i) {
m = match [i];
- ParameterInfo[] args = m.GetParameters ();
- if (args.Length != types.Length)
+ if (m.GetParametersCount () != types.Length)
continue;
+
+ ParameterInfo[] args = m.GetParametersInternal ();
for (j = 0; j < types.Length; ++j) {
if (types [j] != args [j].ParameterType)
break;
return exact_match;
/* Try methods with ParamArray attribute */
- bool isdefParamArray = false;
- Type elementType = null;
- for (i = 0; i < match.Length; ++i) {
- m = match [i];
- ParameterInfo[] args = m.GetParameters ();
- if (args.Length > types.Length + 1)
- continue;
- else if (args.Length == 0)
- continue;
- isdefParamArray = Attribute.IsDefined (args [args.Length - 1], typeof (ParamArrayAttribute));
- if (!isdefParamArray)
- continue;
- elementType = args [args.Length - 1].ParameterType.GetElementType ();
- for (j = 0; j < types.Length; ++j) {
- if (j < (args.Length - 1) && types [j] != args [j].ParameterType)
- break;
- else if (j >= (args.Length - 1) && types [j] != elementType)
- break;
+ if (arguments != null) {
+ for (i = 0; i < match.Length; ++i) {
+ m = match [i];
+
+ var count = m.GetParametersCount ();
+ if (count == 0 || count > types.Length + 1)
+ continue;
+
+ var pi = m.GetParametersInternal ();
+ if (!Attribute.IsDefined (pi [pi.Length - 1], typeof (ParamArrayAttribute)))
+ continue;
+
+ var elementType = pi [pi.Length - 1].ParameterType.GetElementType ();
+ for (j = 0; j < types.Length; ++j) {
+ if (j < (pi.Length - 1) && types [j] != pi [j].ParameterType)
+ break;
+
+ if (j >= (pi.Length - 1) && types [j] != elementType)
+ break;
+ }
+
+ if (j == types.Length)
+ return m;
}
- if (j == types.Length)
- return m;
}
- if ((int)(bindingAttr & BindingFlags.ExactBinding) != 0)
+ if ((bindingAttr & BindingFlags.ExactBinding) != 0)
return null;
MethodBase result = null;
+ ParameterInfo[] result_pi = null;
for (i = 0; i < match.Length; ++i) {
m = match [i];
- ParameterInfo[] args = m.GetParameters ();
- if (args.Length != types.Length)
- continue;
- if (!check_arguments (types, args, allowByRefMatch))
+ var pi = m.GetParametersInternal ();
+ var full_pi = pi;
+ if (pi.Length != types.Length) {
+ if ((bindingAttr & BindingFlags.OptionalParamBinding) == 0)
+ continue;
+
+ List<ParameterInfo> pi_reduced = null;
+ for (var ii = pi.Length - 1; ii >= 0; --ii) {
+ if ((pi [ii].Attributes & ParameterAttributes.HasDefault) == 0)
+ break;
+
+ if (pi_reduced == null) {
+ pi_reduced = new List<ParameterInfo> (pi);
+ }
+
+ pi_reduced.RemoveAt (ii);
+ }
+
+ if (pi_reduced == null || pi_reduced.Count != types.Length)
+ continue;
+
+ pi = pi_reduced.ToArray ();
+ }
+
+ if (!check_arguments (types, pi, allowByRefMatch))
continue;
- if (result != null)
+ if (result != null) {
result = GetBetterMethod (result, m, types);
- else
- result = m;
+ if (result != m)
+ continue;
+ }
+
+ result = m;
+ result_pi = full_pi;
}
- if (result != null || parameters == null || types.Length != parameters.Length)
+ if (result != null) {
+ i = arguments == null ? 0 : arguments.Length;
+ Array.Resize (ref arguments, result_pi.Length);
+ for (; i < arguments.Length; ++i)
+ arguments [i] = result_pi [i].DefaultValue;
+
return result;
+ }
+
+ if (arguments == null || types.Length != arguments.Length)
+ return null;
// Xamarin-5278: try with parameters that are COM objects
// REVIEW: do we also need to implement best method match?
for (i = 0; i < match.Length; ++i) {
m = match [i];
- ParameterInfo[] methodArgs = m.GetParameters ();
+ ParameterInfo[] methodArgs = m.GetParametersInternal ();
if (methodArgs.Length != types.Length)
continue;
for (j = 0; j < types.Length; ++j) {
var requiredType = methodArgs [j].ParameterType;
if (types [j] == requiredType)
continue;
+#if !MOBILE
if (types [j] == typeof (__ComObject) && requiredType.IsInterface) {
- var iface = Marshal.GetComInterfaceForObject (parameters [j], requiredType);
+ var iface = Marshal.GetComInterfaceForObject (arguments [j], requiredType);
if (iface != IntPtr.Zero) {
// the COM object implements the desired interface
Marshal.Release (iface);
continue;
}
}
+#endif
break;
}
MethodBase GetBetterMethod (MethodBase m1, MethodBase m2, Type [] types)
{
- ParameterInfo [] pl1 = m1.GetParameters ();
- ParameterInfo [] pl2 = m2.GetParameters ();
+ ParameterInfo [] pl1 = m1.GetParametersInternal ();
+ ParameterInfo [] pl2 = m2.GetParametersInternal ();
int prev = 0;
for (int i = 0; i < pl1.Length; i++) {
int cmp = CompareCloserType (pl1 [i].ParameterType, pl2 [i].ParameterType);
projects / mono.git / blobdiff