public static object LateCall(object Instance, Type Type, string MemberName, object[] Arguments, string[] ArgumentNames, Type[] TypeArguments, bool[] CopyBack, bool IgnoreReturn)
{
if (Arguments == null)
{
Arguments = Symbols.NoArguments;
}
if (ArgumentNames == null)
{
ArgumentNames = Symbols.NoArgumentNames;
}
if (TypeArguments == null)
{
TypeArguments = Symbols.NoTypeArguments;
}
Symbols.Container BaseReference = Type == null ? new Symbols.Container(Instance) : new Symbols.Container(Type);
if (BaseReference.IsCOMObject)
{
return(LateBinding.InternalLateCall(Instance, Type, MemberName, Arguments, ArgumentNames, CopyBack, IgnoreReturn));
}
BindingFlags InvocationFlags = BindingFlags.InvokeMethod | BindingFlags.GetProperty;
if (IgnoreReturn)
{
InvocationFlags |= BindingFlags.IgnoreReturn;
}
OverloadResolution.ResolutionFailure Failure = OverloadResolution.ResolutionFailure.None;
return(NewLateBinding.CallMethod(BaseReference, MemberName, Arguments, ArgumentNames, TypeArguments, CopyBack, InvocationFlags, true, ref Failure));
}
public static void LateIndexSetComplex(object Instance, object[] Arguments, string[] ArgumentNames, bool OptimisticSet, bool RValueBase)
{
if (Arguments == null)
{
Arguments = Symbols.NoArguments;
}
if (ArgumentNames == null)
{
ArgumentNames = Symbols.NoArgumentNames;
}
Symbols.Container BaseReference = new Symbols.Container(Instance);
if (BaseReference.IsArray)
{
if (ArgumentNames.Length > 0)
{
throw new ArgumentException(Utils.GetResourceString("Argument_InvalidNamedArgs"));
}
BaseReference.SetArrayValue(Arguments);
}
else
{
if (ArgumentNames.Length > Arguments.Length)
{
throw new ArgumentException(Utils.GetResourceString("Argument_InvalidValue"));
}
if (Arguments.Length < 1)
{
throw new ArgumentException(Utils.GetResourceString("Argument_InvalidValue"));
}
string MemberName = "";
if (BaseReference.IsCOMObject)
{
LateBinding.LateIndexSetComplex(Instance, Arguments, ArgumentNames, OptimisticSet, RValueBase);
}
else
{
BindingFlags bindingFlags = BindingFlags.SetProperty;
MemberInfo[] members = BaseReference.GetMembers(ref MemberName, true);
OverloadResolution.ResolutionFailure Failure = OverloadResolution.ResolutionFailure.None;
Symbols.Method TargetProcedure = NewLateBinding.ResolveCall(BaseReference, MemberName, members, Arguments, ArgumentNames, Symbols.NoTypeArguments, bindingFlags, false, ref Failure);
if (Failure == OverloadResolution.ResolutionFailure.None)
{
if (RValueBase && BaseReference.IsValueType)
{
throw new Exception(Utils.GetResourceString("RValueBaseForValueType", BaseReference.VBFriendlyName, BaseReference.VBFriendlyName));
}
BaseReference.InvokeMethod(TargetProcedure, Arguments, (bool[])null, bindingFlags);
}
else if (!OptimisticSet)
{
NewLateBinding.ResolveCall(BaseReference, MemberName, members, Arguments, ArgumentNames, Symbols.NoTypeArguments, bindingFlags, true, ref Failure);
throw new InternalErrorException();
}
}
}
}
public static void LateIndexSetComplex(object Instance, object[] Arguments, string[] ArgumentNames, bool OptimisticSet, bool RValueBase)
{
if (Arguments == null)
{
Arguments = Symbols.NoArguments;
}
if (ArgumentNames == null)
{
ArgumentNames = Symbols.NoArgumentNames;
}
Symbols.Container baseReference = new Symbols.Container(Instance);
if (baseReference.IsArray)
{
if (ArgumentNames.Length > 0)
{
throw new ArgumentException(Utils.GetResourceString("Argument_InvalidNamedArgs"));
}
baseReference.SetArrayValue(Arguments);
}
else
{
OverloadResolution.ResolutionFailure failure = 0;
if (ArgumentNames.Length > Arguments.Length)
{
throw new ArgumentException(Utils.GetResourceString("Argument_InvalidValue"));
}
if (Arguments.Length < 1)
{
throw new ArgumentException(Utils.GetResourceString("Argument_InvalidValue"));
}
string memberName = "";
if (baseReference.IsCOMObject)
{
throw new InvalidOperationException("Never expected to see a COM object in Telesto");
}
BindingFlags setProperty = BindingFlags.SetProperty;
MemberInfo[] members = baseReference.GetMembers(ref memberName, true);
Symbols.Method targetProcedure = ResolveCall(baseReference, memberName, members, Arguments, ArgumentNames, Symbols.NoTypeArguments, setProperty, false, ref failure);
if (failure == OverloadResolution.ResolutionFailure.None)
{
if (RValueBase && baseReference.IsValueType)
{
throw new Exception(Utils.GetResourceString("RValueBaseForValueType", new string[] { baseReference.VBFriendlyName, baseReference.VBFriendlyName }));
}
baseReference.InvokeMethod(targetProcedure, Arguments, null, setProperty);
}
else if (!OptimisticSet)
{
ResolveCall(baseReference, memberName, members, Arguments, ArgumentNames, Symbols.NoTypeArguments, setProperty, true, ref failure);
throw new InternalErrorException();
}
}
}
public static object LateCall(object Instance, Type Type, string MemberName, object[] Arguments, string[] ArgumentNames, Type[] TypeArguments, bool[] CopyBack, bool IgnoreReturn)
{
Symbols.Container container;
OverloadResolution.ResolutionFailure failure = 0;
if (Arguments == null)
{
Arguments = Symbols.NoArguments;
}
if (ArgumentNames == null)
{
ArgumentNames = Symbols.NoArgumentNames;
}
if (TypeArguments == null)
{
TypeArguments = Symbols.NoTypeArguments;
}
if (Type != null)
{
container = new Symbols.Container(Type);
}
else
{
container = new Symbols.Container(Instance);
}
if (container.IsCOMObject)
{
throw new InvalidOperationException("Never expected to see a COM object in Telesto");
}
BindingFlags invocationFlags = BindingFlags.GetProperty | BindingFlags.InvokeMethod;
if (IgnoreReturn)
{
invocationFlags |= BindingFlags.IgnoreReturn;
}
return(CallMethod(container, MemberName, Arguments, ArgumentNames, TypeArguments, CopyBack, invocationFlags, true, ref failure));
}
internal static Symbols.Method ResolveCall(Symbols.Container BaseReference, string MethodName, MemberInfo[] Members, object[] Arguments, string[] ArgumentNames, Type[] TypeArguments, BindingFlags LookupFlags, bool ReportErrors, ref OverloadResolution.ResolutionFailure Failure)
{
Failure = OverloadResolution.ResolutionFailure.None;
if ((Members[0].MemberType != MemberTypes.Method) && (Members[0].MemberType != MemberTypes.Property))
{
Failure = OverloadResolution.ResolutionFailure.InvalidTarget;
if (ReportErrors)
{
throw new ArgumentException(Utils.GetResourceString("ExpressionNotProcedure", new string[] { MethodName, BaseReference.VBFriendlyName }));
}
return(null);
}
int length = Arguments.Length;
object argument = null;
if (Symbols.HasFlag(LookupFlags, BindingFlags.SetProperty))
{
if (Arguments.Length == 0)
{
Failure = OverloadResolution.ResolutionFailure.InvalidArgument;
if (ReportErrors)
{
throw new InvalidCastException(Utils.GetResourceString("PropertySetMissingArgument1", new string[] { MethodName }));
}
return(null);
}
object[] sourceArray = Arguments;
Arguments = new object[(length - 2) + 1];
Array.Copy(sourceArray, Arguments, Arguments.Length);
argument = sourceArray[length - 1];
}
Symbols.Method targetProcedure = OverloadResolution.ResolveOverloadedCall(MethodName, Members, Arguments, ArgumentNames, TypeArguments, LookupFlags, ReportErrors, ref Failure);
if (Failure != OverloadResolution.ResolutionFailure.None)
{
return(null);
}
if (!targetProcedure.ArgumentsValidated && !OverloadResolution.CanMatchArguments(targetProcedure, Arguments, ArgumentNames, TypeArguments, false, null))
{
Failure = OverloadResolution.ResolutionFailure.InvalidArgument;
if (!ReportErrors)
{
return(null);
}
string str = "";
List <string> list = new List <string>();
bool flag = OverloadResolution.CanMatchArguments(targetProcedure, Arguments, ArgumentNames, TypeArguments, false, list);
foreach (string str2 in list)
{
str = str + "\r\n " + str2;
}
throw new InvalidCastException(Utils.GetResourceString("MatchArgumentFailure2", new string[] { targetProcedure.ToString(), str }));
}
if (targetProcedure.IsProperty)
{
if (MatchesPropertyRequirements(targetProcedure, LookupFlags) == null)
{
Failure = OverloadResolution.ResolutionFailure.InvalidTarget;
if (ReportErrors)
{
throw ReportPropertyMismatch(targetProcedure, LookupFlags);
}
return(null);
}
}
else if (Symbols.HasFlag(LookupFlags, BindingFlags.SetProperty))
{
Failure = OverloadResolution.ResolutionFailure.InvalidTarget;
if (ReportErrors)
{
throw new MissingMemberException(Utils.GetResourceString("MethodAssignment1", new string[] { targetProcedure.AsMethod().Name }));
}
return(null);
}
if (!Symbols.HasFlag(LookupFlags, BindingFlags.SetProperty))
{
return(targetProcedure);
}
ParameterInfo[] parameters = GetCallTarget(targetProcedure, LookupFlags).GetParameters();
ParameterInfo parameter = parameters[parameters.Length - 1];
bool requiresNarrowingConversion = false;
bool allNarrowingIsFromObject = false;
if (OverloadResolution.CanPassToParameter(targetProcedure, argument, parameter, false, false, null, ref requiresNarrowingConversion, ref allNarrowingIsFromObject))
{
return(targetProcedure);
}
Failure = OverloadResolution.ResolutionFailure.InvalidArgument;
if (!ReportErrors)
{
return(null);
}
string str3 = "";
List <string> errors = new List <string>();
allNarrowingIsFromObject = false;
requiresNarrowingConversion = false;
bool flag2 = OverloadResolution.CanPassToParameter(targetProcedure, argument, parameter, false, false, errors, ref allNarrowingIsFromObject, ref requiresNarrowingConversion);
foreach (string str4 in errors)
{
str3 = str3 + "\r\n " + str4;
}
throw new InvalidCastException(Utils.GetResourceString("MatchArgumentFailure2", new string[] { targetProcedure.ToString(), str3 }));
}
private static object InternalLateIndexGet(object Instance, object[] Arguments, string[] ArgumentNames, bool ReportErrors, ref OverloadResolution.ResolutionFailure Failure, bool[] CopyBack)
{
Failure = OverloadResolution.ResolutionFailure.None;
if (Arguments == null)
{
Arguments = Symbols.NoArguments;
}
if (ArgumentNames == null)
{
ArgumentNames = Symbols.NoArgumentNames;
}
Symbols.Container baseReference = new Symbols.Container(Instance);
if (baseReference.IsCOMObject)
{
return(LateBinding.LateIndexGet(Instance, Arguments, ArgumentNames));
}
if (!baseReference.IsArray)
{
return(CallMethod(baseReference, "", Arguments, ArgumentNames, Symbols.NoTypeArguments, CopyBack, BindingFlags.GetProperty | BindingFlags.InvokeMethod, ReportErrors, ref Failure));
}
if (ArgumentNames.Length > 0)
{
Failure = OverloadResolution.ResolutionFailure.InvalidArgument;
if (ReportErrors)
{
throw new ArgumentException(Utils.GetResourceString("Argument_InvalidNamedArgs"));
}
return(null);
}
ResetCopyback(CopyBack);
return(baseReference.GetArrayValue(Arguments));
}
private static object CallMethod(Symbols.Container BaseReference, string MethodName, object[] Arguments, string[] ArgumentNames, Type[] TypeArguments, bool[] CopyBack, BindingFlags InvocationFlags, bool ReportErrors, ref OverloadResolution.ResolutionFailure Failure)
{
Failure = OverloadResolution.ResolutionFailure.None;
if ((ArgumentNames.Length > Arguments.Length) || ((CopyBack != null) && (CopyBack.Length != Arguments.Length)))
{
Failure = OverloadResolution.ResolutionFailure.InvalidArgument;
if (ReportErrors)
{
throw new ArgumentException(Utils.GetResourceString("Argument_InvalidValue"));
}
return(null);
}
if (Symbols.HasFlag(InvocationFlags, BindingFlags.SetProperty) && (Arguments.Length < 1))
{
Failure = OverloadResolution.ResolutionFailure.InvalidArgument;
if (ReportErrors)
{
throw new ArgumentException(Utils.GetResourceString("Argument_InvalidValue"));
}
return(null);
}
MemberInfo[] members = BaseReference.GetMembers(ref MethodName, ReportErrors);
if ((members == null) || (members.Length == 0))
{
Failure = OverloadResolution.ResolutionFailure.MissingMember;
if (ReportErrors)
{
members = BaseReference.GetMembers(ref MethodName, true);
}
return(null);
}
Symbols.Method targetProcedure = ResolveCall(BaseReference, MethodName, members, Arguments, ArgumentNames, TypeArguments, InvocationFlags, ReportErrors, ref Failure);
if (Failure == OverloadResolution.ResolutionFailure.None)
{
return(BaseReference.InvokeMethod(targetProcedure, Arguments, CopyBack, InvocationFlags));
}
return(null);
}
internal static object InternalLateIndexGet(object Instance, object[] Arguments, string[] ArgumentNames, bool ReportErrors, ref OverloadResolution.ResolutionFailure Failure)
{
Failure = OverloadResolution.ResolutionFailure.None;
if (Arguments == null)
{
Arguments = Symbols.NoArguments;
}
if (ArgumentNames == null)
{
ArgumentNames = Symbols.NoArgumentNames;
}
Symbols.Container baseReference = new Symbols.Container(Instance);
if (baseReference.IsCOMObject)
{
throw new InvalidOperationException("Never expected to see a COM object in Telesto");
}
if (!baseReference.IsArray)
{
return(CallMethod(baseReference, "", Arguments, ArgumentNames, Symbols.NoTypeArguments, null, BindingFlags.GetProperty | BindingFlags.InvokeMethod, ReportErrors, ref Failure));
}
if (ArgumentNames.Length <= 0)
{
return(baseReference.GetArrayValue(Arguments));
}
Failure = OverloadResolution.ResolutionFailure.InvalidArgument;
if (ReportErrors)
{
throw new ArgumentException(Utils.GetResourceString("Argument_InvalidNamedArgs"));
}
return(null);
}
public static void LateSet(object Instance, Type Type, string MemberName, object[] Arguments, string[] ArgumentNames, Type[] TypeArguments, bool OptimisticSet, bool RValueBase, CallType CallType)
{
Symbols.Container container;
if (Arguments == null)
{
Arguments = Symbols.NoArguments;
}
if (ArgumentNames == null)
{
ArgumentNames = Symbols.NoArgumentNames;
}
if (TypeArguments == null)
{
TypeArguments = Symbols.NoTypeArguments;
}
if (Type != null)
{
container = new Symbols.Container(Type);
}
else
{
container = new Symbols.Container(Instance);
}
if (container.IsCOMObject)
{
throw new InvalidOperationException();
}
MemberInfo[] members = container.GetMembers(ref MemberName, true);
if (members[0].MemberType == MemberTypes.Field)
{
if (TypeArguments.Length > 0)
{
throw new ArgumentException(Utils.GetResourceString("Argument_InvalidValue"));
}
if (Arguments.Length == 1)
{
if (RValueBase && container.IsValueType)
{
throw new Exception(Utils.GetResourceString("RValueBaseForValueType", new string[] { container.VBFriendlyName, container.VBFriendlyName }));
}
container.SetFieldValue((FieldInfo)members[0], Arguments[0]);
}
else
{
LateIndexSetComplex(container.GetFieldValue((FieldInfo)members[0]), Arguments, ArgumentNames, OptimisticSet, true);
}
}
else
{
OverloadResolution.ResolutionFailure failure = 0;
Symbols.Method method;
BindingFlags setProperty = BindingFlags.SetProperty;
if (ArgumentNames.Length > Arguments.Length)
{
throw new ArgumentException(Utils.GetResourceString("Argument_InvalidValue"));
}
if (TypeArguments.Length == 0)
{
method = ResolveCall(container, MemberName, members, Arguments, ArgumentNames, Symbols.NoTypeArguments, setProperty, false, ref failure);
if (failure == OverloadResolution.ResolutionFailure.None)
{
if (RValueBase && container.IsValueType)
{
throw new Exception(Utils.GetResourceString("RValueBaseForValueType", new string[] { container.VBFriendlyName, container.VBFriendlyName }));
}
container.InvokeMethod(method, Arguments, null, setProperty);
return;
}
}
BindingFlags lookupFlags = BindingFlags.GetProperty | BindingFlags.InvokeMethod;
switch (failure)
{
case OverloadResolution.ResolutionFailure.None:
case OverloadResolution.ResolutionFailure.MissingMember:
method = ResolveCall(container, MemberName, members, Symbols.NoArguments, Symbols.NoArgumentNames, TypeArguments, lookupFlags, false, ref failure);
if (failure == OverloadResolution.ResolutionFailure.None)
{
object instance = container.InvokeMethod(method, Symbols.NoArguments, null, lookupFlags);
if (instance == null)
{
throw new MissingMemberException(Utils.GetResourceString("IntermediateLateBoundNothingResult1", new string[] { method.ToString(), container.VBFriendlyName }));
}
LateIndexSetComplex(instance, Arguments, ArgumentNames, OptimisticSet, true);
return;
}
break;
}
if (!OptimisticSet)
{
if (TypeArguments.Length == 0)
{
ResolveCall(container, MemberName, members, Arguments, ArgumentNames, TypeArguments, setProperty, true, ref failure);
}
else
{
ResolveCall(container, MemberName, members, Symbols.NoArguments, Symbols.NoArgumentNames, TypeArguments, lookupFlags, true, ref failure);
}
throw new InternalErrorException();
}
}
}
public static object LateIndexGet(object Instance, object[] Arguments, string[] ArgumentNames)
{
OverloadResolution.ResolutionFailure failure = 0;
return(InternalLateIndexGet(Instance, Arguments, ArgumentNames, true, ref failure));
}
public static object LateGet(object Instance, Type Type, string MemberName, object[] Arguments, string[] ArgumentNames, Type[] TypeArguments, bool[] CopyBack)
{
Symbols.Container container;
OverloadResolution.ResolutionFailure failure = 0;
if (Arguments == null)
{
Arguments = Symbols.NoArguments;
}
if (ArgumentNames == null)
{
ArgumentNames = Symbols.NoArgumentNames;
}
if (TypeArguments == null)
{
TypeArguments = Symbols.NoTypeArguments;
}
if (Type != null)
{
container = new Symbols.Container(Type);
}
else
{
container = new Symbols.Container(Instance);
}
BindingFlags lookupFlags = BindingFlags.GetProperty | BindingFlags.InvokeMethod;
if (container.IsCOMObject)
{
throw new InvalidOperationException("Never expected to see a COM object in Telesto");
}
MemberInfo[] members = container.GetMembers(ref MemberName, true);
if (members[0].MemberType == MemberTypes.Field)
{
if (TypeArguments.Length > 0)
{
throw new ArgumentException(Utils.GetResourceString("Argument_InvalidValue"));
}
object fieldValue = container.GetFieldValue((FieldInfo)members[0]);
if (Arguments.Length == 0)
{
return(fieldValue);
}
return(LateIndexGet(fieldValue, Arguments, ArgumentNames));
}
if ((ArgumentNames.Length > Arguments.Length) || ((CopyBack != null) && (CopyBack.Length != Arguments.Length)))
{
throw new ArgumentException(Utils.GetResourceString("Argument_InvalidValue"));
}
Symbols.Method targetProcedure = ResolveCall(container, MemberName, members, Arguments, ArgumentNames, TypeArguments, lookupFlags, false, ref failure);
if (failure == OverloadResolution.ResolutionFailure.None)
{
return(container.InvokeMethod(targetProcedure, Arguments, CopyBack, lookupFlags));
}
if (Arguments.Length > 0)
{
targetProcedure = ResolveCall(container, MemberName, members, Symbols.NoArguments, Symbols.NoArgumentNames, TypeArguments, lookupFlags, false, ref failure);
if (failure == OverloadResolution.ResolutionFailure.None)
{
object instance = container.InvokeMethod(targetProcedure, Symbols.NoArguments, null, lookupFlags);
if (instance == null)
{
throw new MissingMemberException(Utils.GetResourceString("IntermediateLateBoundNothingResult1", new string[] { targetProcedure.ToString(), container.VBFriendlyName }));
}
instance = InternalLateIndexGet(instance, Arguments, ArgumentNames, false, ref failure);
if (failure == OverloadResolution.ResolutionFailure.None)
{
return(instance);
}
}
}
ResolveCall(container, MemberName, members, Arguments, ArgumentNames, TypeArguments, lookupFlags, true, ref failure);
throw new InternalErrorException();
}
internal static Symbols.Method ResolveCall(Symbols.Container BaseReference, string MethodName, MemberInfo[] Members, object[] Arguments, string[] ArgumentNames, Type[] TypeArguments, BindingFlags LookupFlags, bool ReportErrors, ref OverloadResolution.ResolutionFailure Failure)
{
Failure = OverloadResolution.ResolutionFailure.None;
if (Members[0].MemberType != MemberTypes.Method && Members[0].MemberType != MemberTypes.Property)
{
Failure = OverloadResolution.ResolutionFailure.InvalidTarget;
if (ReportErrors)
{
throw new ArgumentException(Utils.GetResourceString("ExpressionNotProcedure", MethodName, BaseReference.VBFriendlyName));
}
return((Symbols.Method)null);
}
int length = Arguments.Length;
object obj1 = (object)null;
if (Symbols.HasFlag(LookupFlags, BindingFlags.SetProperty))
{
if (Arguments.Length == 0)
{
Failure = OverloadResolution.ResolutionFailure.InvalidArgument;
if (ReportErrors)
{
throw new InvalidCastException(Utils.GetResourceString("PropertySetMissingArgument1", new string[1]
{
MethodName
}));
}
return((Symbols.Method)null);
}
object[] objArray = Arguments;
Arguments = new object[checked (length - 2 + 1)];
Array.Copy((Array)objArray, (Array)Arguments, Arguments.Length);
obj1 = objArray[checked (length - 1)];
}
Symbols.Method TargetProcedure1 = OverloadResolution.ResolveOverloadedCall(MethodName, Members, Arguments, ArgumentNames, TypeArguments, LookupFlags, ReportErrors, ref Failure);
if (Failure != OverloadResolution.ResolutionFailure.None)
{
return((Symbols.Method)null);
}
if (!TargetProcedure1.ArgumentsValidated && !OverloadResolution.CanMatchArguments(TargetProcedure1, Arguments, ArgumentNames, TypeArguments, false, (List <string>)null))
{
Failure = OverloadResolution.ResolutionFailure.InvalidArgument;
if (ReportErrors)
{
string str = "";
List <string> Errors = new List <string>();
OverloadResolution.CanMatchArguments(TargetProcedure1, Arguments, ArgumentNames, TypeArguments, false, Errors);
List <string> .Enumerator enumerator = Ported.VisualBasic.CompilerServices.OverloadResolution.InitEnumerator <string>();
try
{
enumerator = Errors.GetEnumerator();
while (enumerator.MoveNext())
{
string current = enumerator.Current;
str = str + "\r\n " + current;
}
}
finally
{
enumerator.Dispose();
}
throw new InvalidCastException(Utils.GetResourceString("MatchArgumentFailure2", TargetProcedure1.ToString(), str));
}
return((Symbols.Method)null);
}
if (TargetProcedure1.IsProperty)
{
if (NewLateBinding.MatchesPropertyRequirements(TargetProcedure1, LookupFlags) == null)
{
Failure = OverloadResolution.ResolutionFailure.InvalidTarget;
if (ReportErrors)
{
throw NewLateBinding.ReportPropertyMismatch(TargetProcedure1, LookupFlags);
}
return((Symbols.Method)null);
}
}
else if (Symbols.HasFlag(LookupFlags, BindingFlags.SetProperty))
{
Failure = OverloadResolution.ResolutionFailure.InvalidTarget;
if (ReportErrors)
{
throw new MissingMemberException(Utils.GetResourceString("MethodAssignment1", new string[1]
{
TargetProcedure1.AsMethod().Name
}));
}
return((Symbols.Method)null);
}
if (Symbols.HasFlag(LookupFlags, BindingFlags.SetProperty))
{
ParameterInfo[] parameters = NewLateBinding.GetCallTarget(TargetProcedure1, LookupFlags).GetParameters();
ParameterInfo parameterInfo = parameters[checked (parameters.Length - 1)];
Symbols.Method TargetProcedure2 = TargetProcedure1;
object obj2 = obj1;
ParameterInfo Parameter1 = parameterInfo;
int num1 = 0;
int num2 = 0;
// ISSUE: variable of the null type
object local1 = null;
bool flag1 = false;
ref bool local2 = ref flag1;
bool flag2 = false;
ref bool local3 = ref flag2;
public static void LateSet(object Instance, Type Type, string MemberName, object[] Arguments, string[] ArgumentNames, Type[] TypeArguments, bool OptimisticSet, bool RValueBase, CallType CallType)
{
if (Arguments == null)
{
Arguments = Symbols.NoArguments;
}
if (ArgumentNames == null)
{
ArgumentNames = Symbols.NoArgumentNames;
}
if (TypeArguments == null)
{
TypeArguments = Symbols.NoTypeArguments;
}
Symbols.Container BaseReference = Type == null ? new Symbols.Container(Instance) : new Symbols.Container(Type);
if (BaseReference.IsCOMObject)
{
try
{
LateBinding.InternalLateSet(Instance, ref Type, MemberName, Arguments, ArgumentNames, OptimisticSet, CallType);
if (RValueBase && Type.IsValueType)
{
throw new Exception(Utils.GetResourceString("RValueBaseForValueType", Utils.VBFriendlyName(Type, Instance), Utils.VBFriendlyName(Type, Instance)));
}
}
catch (MissingMemberException ex) when(OptimisticSet)
{
}
}
else
{
MemberInfo[] members = BaseReference.GetMembers(ref MemberName, true);
if (members[0].MemberType == MemberTypes.Field)
{
if (TypeArguments.Length > 0)
{
throw new ArgumentException(Utils.GetResourceString("Argument_InvalidValue"));
}
if (Arguments.Length == 1)
{
if (RValueBase && BaseReference.IsValueType)
{
throw new Exception(Utils.GetResourceString("RValueBaseForValueType", BaseReference.VBFriendlyName, BaseReference.VBFriendlyName));
}
BaseReference.SetFieldValue((FieldInfo)members[0], Arguments[0]);
}
else
{
NewLateBinding.LateIndexSetComplex(BaseReference.GetFieldValue((FieldInfo)members[0]), Arguments, ArgumentNames, OptimisticSet, true);
}
}
else
{
BindingFlags bindingFlags1 = BindingFlags.SetProperty;
if (ArgumentNames.Length > Arguments.Length)
{
throw new ArgumentException(Utils.GetResourceString("Argument_InvalidValue"));
}
OverloadResolution.ResolutionFailure Failure = OverloadResolution.ResolutionFailure.None;
if (TypeArguments.Length == 0)
{
Symbols.Method TargetProcedure = NewLateBinding.ResolveCall(BaseReference, MemberName, members, Arguments, ArgumentNames, Symbols.NoTypeArguments, bindingFlags1, false, ref Failure);
if (Failure == OverloadResolution.ResolutionFailure.None)
{
if (RValueBase && BaseReference.IsValueType)
{
throw new Exception(Utils.GetResourceString("RValueBaseForValueType", BaseReference.VBFriendlyName, BaseReference.VBFriendlyName));
}
BaseReference.InvokeMethod(TargetProcedure, Arguments, (bool[])null, bindingFlags1);
return;
}
}
BindingFlags bindingFlags2 = BindingFlags.InvokeMethod | BindingFlags.GetProperty;
if (Failure == OverloadResolution.ResolutionFailure.None || Failure == OverloadResolution.ResolutionFailure.MissingMember)
{
Symbols.Method TargetProcedure = NewLateBinding.ResolveCall(BaseReference, MemberName, members, Symbols.NoArguments, Symbols.NoArgumentNames, TypeArguments, bindingFlags2, false, ref Failure);
if (Failure == OverloadResolution.ResolutionFailure.None)
{
object Instance1 = BaseReference.InvokeMethod(TargetProcedure, Symbols.NoArguments, (bool[])null, bindingFlags2);
if (Instance1 == null)
{
throw new MissingMemberException(Utils.GetResourceString("IntermediateLateBoundNothingResult1", TargetProcedure.ToString(), BaseReference.VBFriendlyName));
}
NewLateBinding.LateIndexSetComplex(Instance1, Arguments, ArgumentNames, OptimisticSet, true);
return;
}
}
if (!OptimisticSet)
{
if (TypeArguments.Length == 0)
{
NewLateBinding.ResolveCall(BaseReference, MemberName, members, Arguments, ArgumentNames, TypeArguments, bindingFlags1, true, ref Failure);
}
else
{
NewLateBinding.ResolveCall(BaseReference, MemberName, members, Symbols.NoArguments, Symbols.NoArgumentNames, TypeArguments, bindingFlags2, true, ref Failure);
}
throw new InternalErrorException();
}
}
}
}
public static object LateGet(object Instance, Type Type, string MemberName, object[] Arguments, string[] ArgumentNames, Type[] TypeArguments, bool[] CopyBack)
{
if (Arguments == null)
{
Arguments = Symbols.NoArguments;
}
if (ArgumentNames == null)
{
ArgumentNames = Symbols.NoArgumentNames;
}
if (TypeArguments == null)
{
TypeArguments = Symbols.NoTypeArguments;
}
Symbols.Container BaseReference = Type == null ? new Symbols.Container(Instance) : new Symbols.Container(Type);
BindingFlags bindingFlags = BindingFlags.InvokeMethod | BindingFlags.GetProperty;
if (BaseReference.IsCOMObject)
{
return(LateBinding.LateGet(Instance, Type, MemberName, Arguments, ArgumentNames, CopyBack));
}
MemberInfo[] members = BaseReference.GetMembers(ref MemberName, true);
if (members[0].MemberType == MemberTypes.Field)
{
if (TypeArguments.Length > 0)
{
throw new ArgumentException(Utils.GetResourceString("Argument_InvalidValue"));
}
object fieldValue = BaseReference.GetFieldValue((FieldInfo)members[0]);
if (Arguments.Length == 0)
{
return(fieldValue);
}
return(NewLateBinding.LateIndexGet(fieldValue, Arguments, ArgumentNames));
}
if (ArgumentNames.Length > Arguments.Length || CopyBack != null && CopyBack.Length != Arguments.Length)
{
throw new ArgumentException(Utils.GetResourceString("Argument_InvalidValue"));
}
OverloadResolution.ResolutionFailure Failure = OverloadResolution.ResolutionFailure.None;
Symbols.Method TargetProcedure1 = NewLateBinding.ResolveCall(BaseReference, MemberName, members, Arguments, ArgumentNames, TypeArguments, bindingFlags, false, ref Failure);
if (Failure == OverloadResolution.ResolutionFailure.None)
{
return(BaseReference.InvokeMethod(TargetProcedure1, Arguments, CopyBack, bindingFlags));
}
if (Arguments.Length > 0)
{
Symbols.Method TargetProcedure2 = NewLateBinding.ResolveCall(BaseReference, MemberName, members, Symbols.NoArguments, Symbols.NoArgumentNames, TypeArguments, bindingFlags, false, ref Failure);
if (Failure == OverloadResolution.ResolutionFailure.None)
{
object Instance1 = BaseReference.InvokeMethod(TargetProcedure2, Symbols.NoArguments, (bool[])null, bindingFlags);
if (Instance1 == null)
{
throw new MissingMemberException(Utils.GetResourceString("IntermediateLateBoundNothingResult1", TargetProcedure2.ToString(), BaseReference.VBFriendlyName));
}
object obj = NewLateBinding.InternalLateIndexGet(Instance1, Arguments, ArgumentNames, false, ref Failure);
if (Failure == OverloadResolution.ResolutionFailure.None)
{
return(obj);
}
}
}
NewLateBinding.ResolveCall(BaseReference, MemberName, members, Arguments, ArgumentNames, TypeArguments, bindingFlags, true, ref Failure);
throw new InternalErrorException();
}
internal static object InternalLateIndexGet(object Instance, object[] Arguments, string[] ArgumentNames, bool ReportErrors, ref OverloadResolution.ResolutionFailure Failure)
{
Failure = OverloadResolution.ResolutionFailure.None;
if (Arguments == null)
{
Arguments = Symbols.NoArguments;
}
if (ArgumentNames == null)
{
ArgumentNames = Symbols.NoArgumentNames;
}
Symbols.Container BaseReference = new Symbols.Container(Instance);
if (BaseReference.IsCOMObject)
{
return(LateBinding.LateIndexGet(Instance, Arguments, ArgumentNames));
}
if (!BaseReference.IsArray)
{
return(NewLateBinding.CallMethod(BaseReference, "", Arguments, ArgumentNames, Symbols.NoTypeArguments, (bool[])null, BindingFlags.InvokeMethod | BindingFlags.GetProperty, ReportErrors, ref Failure));
}
if (ArgumentNames.Length <= 0)
{
return(BaseReference.GetArrayValue(Arguments));
}
Failure = OverloadResolution.ResolutionFailure.InvalidArgument;
if (ReportErrors)
{
throw new ArgumentException(Utils.GetResourceString("Argument_InvalidNamedArgs"));
}
return((object)null);
}
public static object LateIndexGet(object Instance, object[] Arguments, string[] ArgumentNames)
{
OverloadResolution.ResolutionFailure Failure = OverloadResolution.ResolutionFailure.None;
return(NewLateBinding.InternalLateIndexGet(Instance, Arguments, ArgumentNames, true, ref Failure));
}
