Author: sudha
Date: 2005-04-13 02:31:50 -0400 (Wed, 13 Apr 2005)
New Revision: 42887

Modified:
   trunk/mcs/class/Microsoft.VisualBasic/Microsoft.VisualBasic/ForEachEnum.cs
   
trunk/mcs/class/Microsoft.VisualBasic/Microsoft.VisualBasic/Microsoft.VisualBasic.CompilerServices/ChangeLog
   
trunk/mcs/class/Microsoft.VisualBasic/Microsoft.VisualBasic/Microsoft.VisualBasic.CompilerServices/LateBinding.cs
   
trunk/mcs/class/Microsoft.VisualBasic/Microsoft.VisualBasic/Microsoft.VisualBasic.CompilerServices/ObjectType.cs
   
trunk/mcs/class/Microsoft.VisualBasic/Microsoft.VisualBasic/Microsoft.VisualBasic.CompilerServices/StringType.cs
   
trunk/mcs/class/Microsoft.VisualBasic/Microsoft.VisualBasic/Microsoft.VisualBasic.CompilerServices/VBBinder.cs
Log:
* StringType.cs, ForEachEnum.cs: Removed a warning
* VBBinder.cs
* LateBinding.cs :
                Added support for Late Binding. (Not yet complete. Just a basic 
'LateCall' works)
* ObjectType.cs :
                Fixed the functions 'CTypeHelper', 'IsWideningConversion' and 
'IsWiderNumeric'



Modified: 
trunk/mcs/class/Microsoft.VisualBasic/Microsoft.VisualBasic/ForEachEnum.cs
===================================================================
--- trunk/mcs/class/Microsoft.VisualBasic/Microsoft.VisualBasic/ForEachEnum.cs  
2005-04-13 05:32:50 UTC (rev 42886)
+++ trunk/mcs/class/Microsoft.VisualBasic/Microsoft.VisualBasic/ForEachEnum.cs  
2005-04-13 06:31:50 UTC (rev 42887)
@@ -43,7 +43,7 @@
 
                 public ForEachEnum (Collection Collection)
                 {
-                        this.collection = collection;
+                        this.collection = Collection;
                 }
 
                 public void AdjustIndex (int itemIndex, bool remove)

Modified: 
trunk/mcs/class/Microsoft.VisualBasic/Microsoft.VisualBasic/Microsoft.VisualBasic.CompilerServices/ChangeLog
===================================================================
--- 
trunk/mcs/class/Microsoft.VisualBasic/Microsoft.VisualBasic/Microsoft.VisualBasic.CompilerServices/ChangeLog
        2005-04-13 05:32:50 UTC (rev 42886)
+++ 
trunk/mcs/class/Microsoft.VisualBasic/Microsoft.VisualBasic/Microsoft.VisualBasic.CompilerServices/ChangeLog
        2005-04-13 06:31:50 UTC (rev 42887)
@@ -1,3 +1,11 @@
+2005-04-13  Satya Sudha K <[EMAIL PROTECTED]>
+       * StringType.cs: Removed a warning
+       * VBBinder.cs 
+       * LateBinding.cs :
+               Added support for Late Binding. (Not yet complete. Just a basic 
'LateCall' works)
+       * ObjectType.cs :
+               Fixed the functions 'CTypeHelper', 'IsWideningConversion' and 
'IsWiderNumeric'
+
 2005-03-18  Satya Sudha K <[EMAIL PROTECTED]>
        * StringType.cs: Fixed the 'StrLikeBinary' and 'inBracketBinary' methods
 

Modified: 
trunk/mcs/class/Microsoft.VisualBasic/Microsoft.VisualBasic/Microsoft.VisualBasic.CompilerServices/LateBinding.cs
===================================================================
--- 
trunk/mcs/class/Microsoft.VisualBasic/Microsoft.VisualBasic/Microsoft.VisualBasic.CompilerServices/LateBinding.cs
   2005-04-13 05:32:50 UTC (rev 42886)
+++ 
trunk/mcs/class/Microsoft.VisualBasic/Microsoft.VisualBasic/Microsoft.VisualBasic.CompilerServices/LateBinding.cs
   2005-04-13 06:31:50 UTC (rev 42887)
@@ -404,22 +404,55 @@
                        object[] args,
                        string[] paramnames,
                        bool[] CopyBack) {
+
+                               InternalLateCall (o, objType, name, args, 
paramnames, CopyBack, true);
+               }
+
+               [System.Diagnostics.DebuggerStepThroughAttribute]
+               [System.Diagnostics.DebuggerHiddenAttribute]
+               internal static object InternalLateCall( object o,
+                                                        Type objType,
+                                                        string name,
+                                                        object[] args,
+                                                        string[] paramnames,
+                                                        bool[] CopyBack, 
+                                                        bool IgnoreReturn) {
                        if (objType == null) {
-                               if (o == null)
+                               if (o == null) {
                                        throw new NullReferenceException();
+                               }
                                objType = o.GetType();
                        }
-                       Type[] typeArr = null;
+
+                       IReflect objReflect = (IReflect) objType;
+
+                       BindingFlags flags = BindingFlags.FlattenHierarchy |
+                                            BindingFlags.IgnoreCase |
+                                            BindingFlags.Instance |
+                                            BindingFlags.Public |
+                                            BindingFlags.Static |
+                                            BindingFlags.InvokeMethod;
+
+                       if (name == null) {
+                               name = "";
+                       }
+                       MemberInfo [] memberinfo = objReflect.GetMember (name, 
flags);
+
+                       if (memberinfo == null || memberinfo.Length == 0) {
+                               throw new MissingMemberException ("Public 
Member '" + name + "' not found on type '" + objType + "'");
+                       }
+
                        if (args != null) {
-                               typeArr = new Type[args.Length];
-                               for (int i = 0; i < typeArr.Length; i++) {
-                                       typeArr[i] = args[i].GetType();
+                               foreach (MemberInfo mi in memberinfo) {
+                                       if (mi.MemberType == MemberTypes.Field) 
+                                               throw new ArgumentException 
("Expression '" + name + "' is not a procedure, but occurs as a target of a 
procedure call");
                                }
                        }
-                       MethodInfo methodInfo = objType.GetMethod(name, 
typeArr);
-                       if (methodInfo == null)
-                               throw new NullReferenceException();
-                       methodInfo.Invoke(o, args);
+
+                       VBBinder binder = new VBBinder (CopyBack);
+                       return binder.InvokeMember (name, flags, objType, 
objReflect, o, args, null, null, paramnames);
                }
+
+               
        }
 }

Modified: 
trunk/mcs/class/Microsoft.VisualBasic/Microsoft.VisualBasic/Microsoft.VisualBasic.CompilerServices/ObjectType.cs
===================================================================
--- 
trunk/mcs/class/Microsoft.VisualBasic/Microsoft.VisualBasic/Microsoft.VisualBasic.CompilerServices/ObjectType.cs
    2005-04-13 05:32:50 UTC (rev 42886)
+++ 
trunk/mcs/class/Microsoft.VisualBasic/Microsoft.VisualBasic/Microsoft.VisualBasic.CompilerServices/ObjectType.cs
    2005-04-13 06:31:50 UTC (rev 42887)
@@ -930,34 +930,30 @@
                }
 
                internal static object CTypeHelper(object obj, TypeCode toType) 
{
-                       return CTypeHelper(obj, 
toType.GetType());//toType.getValue));
-               }
-
-               internal static object CTypeHelper(object obj, int toType) {
                        if (obj == null)
                                return null;
                        switch (toType) {
-                               case (int)TypeCode.Boolean :
+                               case TypeCode.Boolean :
                                        return BooleanType.FromObject(obj);
-                               case (int)TypeCode.Byte :
+                               case TypeCode.Byte :
                                        return ByteType.FromObject(obj);
-                               case (int)TypeCode.Int16 :
+                               case TypeCode.Int16 :
                                        return ShortType.FromObject(obj);
-                               case (int)TypeCode.Int32 :
+                               case TypeCode.Int32 :
                                        return IntegerType.FromObject(obj);
-                               case (int)TypeCode.Int64 :
+                               case TypeCode.Int64 :
                                        return LongType.FromObject(obj);
-                               case (int)TypeCode.Decimal :
+                               case TypeCode.Decimal :
                                        return DecimalType.FromObject(obj);
-                               case (int)TypeCode.Single :
+                               case TypeCode.Single :
                                        return SingleType.FromObject(obj);
-                               case (int)TypeCode.Double :
+                               case TypeCode.Double :
                                        return DoubleType.FromObject(obj);
-                               case (int)TypeCode.String :
+                               case TypeCode.String :
                                        return StringType.FromObject(obj);
-                               case (int)TypeCode.Char :
+                               case TypeCode.Char :
                                        return CharType.FromObject(obj);
-                               case (int)TypeCode.DateTime :
+                               case TypeCode.DateTime :
                                        return DateType.FromObject(obj);
 
                        }
@@ -980,10 +976,9 @@
                        //      return obj;
 
                        Type type = obj.GetType();
-                       //    if (toType.IsByRef) {
-                       //        toType = toType.GetElementType();
-                       //        local2 = true;
-                       //    }
+                       if (toType.IsByRef) {
+                               toType = toType.GetElementType();
+                       }
                        //    if (type.IsByRef)
                        //        local1 = local1.GetElementType();
                        if (type == toType)
@@ -993,16 +988,16 @@
                        if (tc == TypeCode.Object) {
                                if (toType.IsAssignableFrom(type))
                                        return obj;
-                               //TODO:
-                               //            if (obj is string
-                               //                && toType == 
char[].class).GetType()
-                               //                return 
CharArrayType.FromString((string) obj);
+                               if (obj is string
+                                   && toType == typeof (char[])) {
+                                       return 
CharArrayType.FromString((string) obj);
+                               }
                                
-                                           throw new InvalidCastException(
-                                               Utils.GetResourceString(
-                                                   "InvalidCast_FromTo",
-                                                   Utils.VBFriendlyName(type),
-                                                   
Utils.VBFriendlyName(toType)));
+                               throw new InvalidCastException(
+                                       Utils.GetResourceString(
+                                       "InvalidCast_FromTo",
+                                       Utils.VBFriendlyName(type),
+                                       Utils.VBFriendlyName(toType)));
                        }
 
                        object retVal = CTypeHelper(obj, tc);
@@ -1310,50 +1305,47 @@
                internal static bool IsWideningConversion(Type FromType, Type 
ToType) {
                        TypeCode typeCode1 = Type.GetTypeCode(FromType);
                        TypeCode typeCode2 = Type.GetTypeCode(ToType);
-                       if (typeCode1 == TypeCode.Object) {
-                               //TODO:
-                               //            if ((FromType == 
char[].class.GetType()) &&
-                               //               (typeCode2 == TypeCode.String 
|| ToType == char[].class).GetType())
-                               //            {
-                               //                return true;
-                               //            }
-                               //            if (typeCode2 != TypeCode.Object)
-                               //            {
-                               //                return false;
-                               //            }
-                               //            if (!FromType.IsArray() || 
!ToType.IsArray())
-                               //            {
-                               //                return 
ToType.IsAssignableFrom(FromType);
-                               //            }
-                               //            //if (FromType.GetArrayRank() == 
ToType.GetArrayRank())
-                               //            //{
-                               //            //    return 
ToType.GetElementType().IsAssignableFrom(FromType.GetElementType());
-                               //            //}
-                               //            //else
-                               //            //{
-                               //                return false;
-                               //            //}
+                       
+                       if (typeCode1 == typeCode2)
+                               return true;
+
+                       if (IsWiderNumeric (ToType, FromType))
+                               return true;
+
+                       if (typeCode2 == TypeCode.String) {
+                               if (FromType == typeof (char[]))
+                                       return true;
+                               return false;
                        }
-                       if (typeCode2 == TypeCode.Object) {
-                               //TODO:
-                               //            if (ToType == 
char[].class.GetType() && typeCode1 == TypeCode.string)
-                               //            {
-                               //                return false;
-                               //            }
-                               return ToType.IsAssignableFrom(FromType);
-                       }
-                       if (ToType.IsEnum) {
+
+                       if (typeCode1 == TypeCode.String) {
+                               if (typeCode2 == TypeCode.Char)
+                                       return true;
                                return false;
                        }
-                       int index1 = getVType2FromTypeCode(typeCode2);
-                       int index2 = getVType2FromTypeCode(typeCode1);
-                       int cC = ConversionClassTable[index1,index2];
-                       if (cC != 3 /*CC.Wide*/ && cC != 1 /*CC.Same*/) {//TODO 
replace hard coded values with enum, after enum is converted
+
+                       if (typeCode1 == TypeCode.DateTime || typeCode2 == 
TypeCode.DateTime)
                                return false;
+
+                       if (typeCode1 == TypeCode.Char || typeCode2 == 
TypeCode.Char)
+                               return false;
+
+                       if (! FromType.IsValueType ) {
+                               if (ToType.IsValueType)
+                                       return false;
+                               if (!FromType.IsArray || !ToType.IsArray)
+                               {
+                                       return 
ToType.IsAssignableFrom(FromType);
+                               }
+                               if (FromType.GetArrayRank() == 
ToType.GetArrayRank())
+                                   return 
ToType.GetElementType().IsAssignableFrom(FromType.GetElementType());
+                               else
+                                       return false;
                        }
-                       else {
-                               return true;
+                       if (! ToType.IsValueType) {
+                               return ToType.IsAssignableFrom(FromType);
                        }
+                       return false;
                }
 
                //checked
@@ -1364,18 +1356,68 @@
                        if (!Utils.IsNumericType(Type1) || 
!Utils.IsNumericType(Type2)) {
                                return false;
                        }
-                       if (typeCode1 == TypeCode.Boolean || typeCode2 == 
TypeCode.Boolean) {
-                               return false;
+
+                       if (Type1 == Type2)
+                               return true;
+                       switch (typeCode1) {
+
+                       case TypeCode.Empty :
+                               return true;
+                       case TypeCode.Boolean:
+                                       if (typeCode2 == TypeCode.Byte)
+                                               return true;
+                                       return false;
+                       case TypeCode.Byte :
+                                       return false;
+                       case TypeCode.Int16 :
+                               switch (typeCode2) {
+                               case TypeCode.Boolean:
+                               case TypeCode.Byte:
+                                       return true;
+                               default :
+                                       return false;
+                               }
+                       case TypeCode.Int32 :
+                               switch (typeCode2) {
+                               case TypeCode.Boolean:
+                               case TypeCode.Byte:
+                               case TypeCode.Int16:
+                                       return true;
+                               default:
+                                       return false;
+                               }
+                       case TypeCode.Int64 :
+                               switch (typeCode2) {
+                               case TypeCode.Boolean:
+                               case TypeCode.Byte:
+                               case TypeCode.Int16:
+                               case TypeCode.Int32:
+                                       return true;
+                               default:
+                                       return false;
+                               }
+                       case TypeCode.Decimal :
+                               switch (typeCode2) {
+                               case TypeCode.Single:
+                               case TypeCode.Double:
+                               case TypeCode.Empty:
+                                       return false;
+                               default:
+                                       return true;
+                               }
+                       case TypeCode.Single :
+                               switch (typeCode2) {
+                               case TypeCode.Double:
+                               case TypeCode.Empty:
+                                       return false;
+                               default :
+                                       return true;
+                               }
+                       case TypeCode.Double :
+                               return true;
                        }
-                       if (Type1.IsEnum) {
-                               return false;
-                       }
 
-                       //int index1 = getVTypeFromTypeCode(typeCode1);
-                       //int index2 = getVTypeFromTypeCode(typeCode2);
-                       throw new 
NotImplementedException("MSVB.CS.IsWiderNumeric needs help");
-                       //TODO:
-                       //return )WiderType[index1,index2] == 
getVTypeFromTypeCode(typeCode1);
+                       return false;
                }
 
                //checked

Modified: 
trunk/mcs/class/Microsoft.VisualBasic/Microsoft.VisualBasic/Microsoft.VisualBasic.CompilerServices/StringType.cs
===================================================================
--- 
trunk/mcs/class/Microsoft.VisualBasic/Microsoft.VisualBasic/Microsoft.VisualBasic.CompilerServices/StringType.cs
    2005-04-13 05:32:50 UTC (rev 42886)
+++ 
trunk/mcs/class/Microsoft.VisualBasic/Microsoft.VisualBasic/Microsoft.VisualBasic.CompilerServices/StringType.cs
    2005-04-13 06:31:50 UTC (rev 42887)
@@ -657,7 +657,7 @@
                                        continue;
                                }
                                else if (currentPatternChar == ']') {
-                                       string sub = 
pattern.Substring(patternIndex);
+                                       //string sub = 
pattern.Substring(patternIndex);
                                        isMatch =
                                                compareBinary(
                                                isNotSignAppears,

Modified: 
trunk/mcs/class/Microsoft.VisualBasic/Microsoft.VisualBasic/Microsoft.VisualBasic.CompilerServices/VBBinder.cs
===================================================================
--- 
trunk/mcs/class/Microsoft.VisualBasic/Microsoft.VisualBasic/Microsoft.VisualBasic.CompilerServices/VBBinder.cs
      2005-04-13 05:32:50 UTC (rev 42886)
+++ 
trunk/mcs/class/Microsoft.VisualBasic/Microsoft.VisualBasic/Microsoft.VisualBasic.CompilerServices/VBBinder.cs
      2005-04-13 06:31:50 UTC (rev 42887)
@@ -46,11 +46,25 @@
                {
                }
 
+               public VBBinder(bool [] CopyBack) : base()
+               {
+                       byRefFlags = CopyBack;
+               }
+
                private class BinderState
                {
                        public object[] args;
+                       public bool[] byRefFlags;
                }
 
+
+               public enum ConversionType {
+                       Exact = 0,
+                       Widening,
+                       Narrowing,
+                       None = -1
+               }
+
                public override FieldInfo BindToField(
                        BindingFlags bindingAttr,
                        FieldInfo[] match,
@@ -61,6 +75,10 @@
                        return null;
                }
 
+               private bool[] byRefFlags;
+               private Type objectType;
+               private string bindToName;
+
                public override MethodBase BindToMethod(
                        BindingFlags bindingAttr,
                        MethodBase[] match,
@@ -77,29 +95,141 @@
                        args.CopyTo(arguments, 0);
                        binderState.args = arguments;
                        state = binderState;
+                       MethodBase mbase = null;
                        if(match == null)
                                throw new ArgumentNullException();
                                
+                       ConversionType bestMatch = ConversionType.None;
+                       int numWideningConversions = 0, numNarrowingConversions 
= 0;
                        for(int x = 0; x < match.Length; x++)
                        {
-                               int count = 0;
                                ParameterInfo[] parameters = 
match[x].GetParameters();
-                               if(args.Length != parameters.Length)
-                                       continue;
+                               ConversionType ctype = GetConversionType 
(parameters, args);
+                               if (bestMatch == ConversionType.None || ctype < 
bestMatch) {
+                                       bestMatch = ctype;
+                                       if (ctype == ConversionType.Narrowing)
+                                               numNarrowingConversions ++;
+                                       if (ctype == ConversionType.Widening)
+                                               numWideningConversions ++;
+                                       mbase = match [x];
+                               } else if (bestMatch == ctype) {
+                                       if (bestMatch == 
ConversionType.Widening || bestMatch == ConversionType.Exact) {
+                                               // Got a widening conversion 
before also.
+                                               // Find the best among the two
+                                               int closestMatch = 
GetClosestMatch (mbase, match [x]);
+                                               if (closestMatch == -1) {
+                                                       numWideningConversions 
++;
+                                               }
+                                               else if (closestMatch == 1)
+                                                       mbase = match [x];
+                                       } else {
+                                               numNarrowingConversions ++;
+                                       }
+                               }
+                       }
 
+                       if (bestMatch == ConversionType.Narrowing && 
numNarrowingConversions > 1) {
+                               //TODO : print the methods too
+                               throw new AmbiguousMatchException ("No 
overloaded '" + this.objectType + "." + this.bindToName + "' can be called 
without a narrowing conversion");
+                       }
+                       if ((bestMatch == ConversionType.Widening || bestMatch 
== ConversionType.Exact) && numWideningConversions > 1) {
+                               //TODO : print the methods too
+                               throw new AmbiguousMatchException ("No 
overloaded '" + this.objectType + "." + this.bindToName + "' can be called 
without a widening conversion");
+                       }
+
+                       if (mbase != null) {
+                               int count = 0;
+                               ParameterInfo[] parameters = 
mbase.GetParameters ();
                                for(int y = 0; y < args.Length; y++)
                                {
-                                       if(ChangeType(args[y], 
parameters[y].ParameterType, culture) != null)
+                                       if((args [y] = ObjectType.CTypeHelper 
(args[y], parameters[y].ParameterType)) != null)
                                                count++;
                                        else
                                                break;
                                }
-                               if(count == args.Length)
-                                       return match[x];
+                               if (count != args.Length)
+                                       return null;
                        }
-                       return null;
+
+                       ParameterInfo [] pars = mbase.GetParameters ();
+                       int index = 0;
+                       if (byRefFlags == null || pars.Length == 0 || 
!ByRefParamsExist (pars)) {
+                               return mbase;
+                       }
+                       for (index = 0; index < pars.Length; index ++) {
+                               ParameterInfo p = pars [index];
+                               if (p.ParameterType.IsByRef) {
+                                       if (byRefFlags [index] != false)
+                                               byRefFlags [index] = true;
+                               } else
+                                       byRefFlags [index] = false;
+                       }
+                       return mbase;
                }
 
+               private int GetClosestMatch (MethodBase bestMatch, MethodBase 
candidate) {
+                       // flag to indicate which one has been better so far
+                       // -1 : none is better than other
+                       // 0 : bestMatch has been better so far
+                       // 1 : candidate is better than bestMatch
+                       int isBetter = -2;
+                       ParameterInfo[] bestMatchParams = 
bestMatch.GetParameters ();
+                       ParameterInfo[] candidateParams = 
candidate.GetParameters ();
+                       int numParams = Math.Min (bestMatchParams.Length, 
candidateParams.Length);
+                       for (int i = 0; i < numParams; i ++) {
+                               if (bestMatchParams [i].ParameterType == 
candidateParams [i].ParameterType)
+                                       continue;
+
+                               if (ObjectType.IsWideningConversion 
(bestMatchParams [i].ParameterType, candidateParams [i].ParameterType)) {
+                                       // ith param of candidate is wider than 
that of bestMatch
+                                       if (isBetter == -2) {
+                                               isBetter = 0;
+                                               continue;
+                                       } else if (isBetter != 0) {
+                                               isBetter = -1;
+                                               continue;
+                                       }
+                                       isBetter = 0;
+                                       
+                               } else if (ObjectType.IsWideningConversion 
(candidateParams [i].ParameterType, bestMatchParams [i].ParameterType)) {
+                                       // ith param of bestMatch is wider than 
that of candidate
+                                       if (isBetter == -2) {
+                                               isBetter = 1;
+                                               continue;
+                                       } else if (isBetter != 1) {
+                                               isBetter = -1;
+                                               continue;
+                                       }
+                                       isBetter = 1;
+                               }
+                       }
+                       return isBetter;
+               }
+
+               private ConversionType GetConversionType (ParameterInfo[] 
parameters, object[] args) {
+                       int numParams = parameters.Length;
+                       int numArgs = args.Length;
+                       int minParams = Math.Min (numParams, numArgs);
+                       ConversionType ctype = ConversionType.None;
+                       for (int index = 0; index < minParams; index ++) {
+                               ConversionType currentCType = 
ConversionType.None;
+                               Type type1 = args [index].GetType ();
+                               Type type2 = parameters [index].ParameterType;
+                               if (type1 == type2) {
+                                       currentCType = ConversionType.Exact;
+                                       if (ctype < currentCType) {
+                                               ctype = ConversionType.Exact;
+                                       }
+                               } else if (ObjectType.IsWideningConversion 
(type1, type2)) {
+                                       currentCType = ConversionType.Widening;
+                                       if (ctype < currentCType)
+                                               ctype = ConversionType.Widening;
+                               } else 
+                                       ctype = ConversionType.Narrowing;
+                       }
+                       return ctype;
+               }
+
                public override object ChangeType(
                        object value,
                        Type myChangeType,
@@ -191,6 +321,108 @@
                        return null;
                }
                
+               public Object InvokeMember (string name, 
+                                           BindingFlags flags,
+                                           Type objType,
+                                           IReflect objReflect,
+                                           object target,
+                                           object[] args,
+                                           ParameterModifier[] modifiers,
+                                           CultureInfo culture,
+                                           string[] paramNames) {
 
+                       this.objectType = objType;
+                       this.bindToName = name;
+                       if (name == null) {
+                               // Must be a default property
+                               Type t = objType;
+                               while (t != null) {
+                                       object[] attrArray = 
t.GetCustomAttributes (typeof (DefaultMemberAttribute), false);
+                                       if (attrArray != null && 
attrArray.Length != 0) {
+                                               name = 
((DefaultMemberAttribute) attrArray[0]).MemberName;
+                                               break;
+                                       }
+                                       // not found, search in the base type
+                                       t = t.BaseType;
+                               }
+                       }
+
+                       if (name == null) {
+                               throw new MissingMemberException ("No default 
members defined for type '" + objType + "'");
+                       }
+
+                       MemberInfo[] memberinfo = objReflect.GetMember (name, 
flags);
+                       MethodBase[] methodbase = GetMostDerivedMembers 
(memberinfo);
+                       if (methodbase == null || methodbase.Length == 0) {
+                               throw new MissingMemberException ("No member '" 
+ name + "' defined for type '" + objType + "'");
+                       }
+
+                       object objState = null;
+                       MethodBase mbase = BindToMethod (flags, methodbase, ref 
args, modifiers, culture, paramNames, out objState);
+                       if (mbase == null) {
+                               throw new MissingMemberException ("No member '" 
+ name + "' defined for type '" + objType + "' which takes the given set of 
arguments");
+                       }
+
+                       if (objState != null && 
((BinderState)objState).byRefFlags != null) {
+                               this.byRefFlags = 
((BinderState)objState).byRefFlags; 
+                       }
+
+                       MethodInfo mi = (MethodInfo) mbase;
+                       object retVal =  mi.Invoke (target, args);
+
+
+                       return retVal;
+               }
+
+               private bool ByRefParamsExist (ParameterInfo [] pars) {
+                       foreach (ParameterInfo p in pars) {
+                               if (p.ParameterType.IsByRef)
+                                       return true;
+                       }
+                       return false;
+               }
+               private static MethodBase [] GetMostDerivedMembers 
(MemberInfo[] memberinfo) {
+                       int i = 0;
+                       int numElementsEliminated = 0;
+                       for (i = 0; i < memberinfo.Length; i++) {
+                               MemberInfo mi = memberinfo [i];
+                               for (int j = i + 1; j < memberinfo.Length; j++) 
{
+                                       bool eliminateBaseMembers = false;
+                                       Type t1 = mi.DeclaringType;
+                                       Type t2 = memberinfo [j].DeclaringType;
+                                       if (mi.MemberType == MemberTypes.Field)
+                                               eliminateBaseMembers = true;
+                                       if (mi.MemberType == 
MemberTypes.Method) {
+                                               MethodInfo methodinfo = 
(MethodInfo) mi;
+                                               if (methodinfo.IsVirtual)
+                                                       eliminateBaseMembers = 
true;
+                                       }
+                                       if (mi.MemberType == 
MemberTypes.Property) {
+                                               PropertyInfo propertyinfo = 
(PropertyInfo) mi;
+                                               MethodInfo method = 
propertyinfo.GetGetMethod ();
+                                               if (method.IsVirtual)
+                                                       eliminateBaseMembers = 
true;
+                                       }
+                                       if (eliminateBaseMembers) {
+                                               if (t1.IsSubclassOf (t2)) {
+                                                       memberinfo [j] = null;
+                                                       numElementsEliminated 
++;
+                                               } else if (t2.IsSubclassOf 
(t1)) {
+                                                       memberinfo [i] = null;
+                                                       numElementsEliminated 
++;
+                                               }
+                                       }
+                               }
+                       }
+
+                       MethodBase [] newMemberList = new MethodBase 
[memberinfo.Length - numElementsEliminated];
+                       int newIndex = 0;
+                       for (int index = 0; index < memberinfo.Length; index 
++) {
+                               if (memberinfo [index] != null) {
+                                       newMemberList [newIndex ++] = 
(MethodBase) memberinfo [index];
+                               }
+                       }
+                       return newMemberList;
+               }
        }
 }

_______________________________________________
Mono-patches maillist  -  [email protected]
http://lists.ximian.com/mailman/listinfo/mono-patches

Reply via email to