// Copyright (c) Microsoft Corporation. All rights reserved.

// Licensed under the MIT license.

using System;

using System.Collections;

using System.Collections.Generic;

using System.Diagnostics;

using System.Dynamic;

using System.Globalization;

using System.Linq;

using System.Linq.Expressions;

using System.Reflection;

using System.Runtime.InteropServices;

using System.Runtime.InteropServices.ComTypes;

using System.Runtime.InteropServices.Expando;

using Microsoft.ClearScript.Util;

using Microsoft.ClearScript.Util.COM;

namespace Microsoft.ClearScript

{

internal partial class HostItem : DynamicObject, IReflect, IDynamic, IEnumVARIANT, ICustomQueryInterface, IScriptMarshalWrapper, IHostTargetContext

{

#region data

private HostTargetMemberData targetMemberData;

private static readonly PropertyInfo[] reflectionProperties =

{

typeof(Delegate).GetProperty("Method"),

typeof(Exception).GetProperty("TargetSite")

};

internal static bool EnableVTablePatching;

[ThreadStatic] private static bool bypassVTablePatching;

#endregion

#region constructors

private HostItem(ScriptEngine engine, HostTarget target, HostItemFlags flags)

{

Engine = engine;

Target = target;

Flags = flags;

BindSpecialTarget();

BindTargetMemberData();

}

#endregion

#region wrappers

public static object Wrap(ScriptEngine engine, object obj)

{

return Wrap(engine, obj, null, HostItemFlags.None);

}

public static object Wrap(ScriptEngine engine, object obj, Type type)

{

return Wrap(engine, obj, type, HostItemFlags.None);

}

public static object Wrap(ScriptEngine engine, object obj, HostItemFlags flags)

{

return Wrap(engine, obj, null, flags);

}

private static object Wrap(ScriptEngine engine, object obj, Type type, HostItemFlags flags)

{

if (obj == null)

{

return null;

}

if (obj is HostItem hostItem)

{

obj = hostItem.Target;

}

if (obj is HostTarget hostTarget)

{

return BindOrCreate(engine, hostTarget, flags);

}

if (type == null)

{

type = obj.GetTypeOrTypeInfo();

}

else

{

Debug.Assert(type.IsInstanceOfType(obj));

}

if (obj is Enum)

{

return BindOrCreate(engine, obj, type, flags);

}

var typeCode = Type.GetTypeCode(type);

if ((typeCode == TypeCode.Object) || (typeCode == TypeCode.DateTime))

{

return BindOrCreate(engine, obj, type, flags);

}

return obj;

}

#endregion

#region public members

public delegate HostItem CreateFunc(ScriptEngine engine, HostTarget target, HostItemFlags flags);

public HostTarget Target { get; }

public HostItemFlags Flags { get; }

public Invocability Invocability

{

get

{

if (TargetInvocability == null)

{

TargetInvocability = Target.GetInvocability(this, GetCommonBindFlags(), Flags.HasFlag(HostItemFlags.HideDynamicMembers));

}

return TargetInvocability.GetValueOrDefault();

}

}

public object InvokeMember(string name, BindingFlags invokeFlags, object[] args, object[] bindArgs, CultureInfo culture, bool bypassTunneling)

{

return InvokeMember(name, invokeFlags, args, bindArgs, culture, bypassTunneling, out _);

}

public object InvokeMember(string name, BindingFlags invokeFlags, object[] args, object[] bindArgs, CultureInfo culture, bool bypassTunneling, out bool isCacheable)

{

name = AdjustInvokeName(name);

AdjustInvokeFlags(ref invokeFlags);

isCacheable = false;

if (Target.TryInvokeAuxMember(this, name, invokeFlags, args, bindArgs, out var result))

{

if (Target is IHostVariable)

{

// the variable may have been reassigned

BindSpecialTarget();

}

return result;

}

if (TargetDynamic != null)

{

return InvokeDynamicMember(name, invokeFlags, args);

}

if (TargetPropertyBag != null)

{

return InvokePropertyBagMember(name, invokeFlags, args, bindArgs);

}

if (TargetList != null)

{

if (int.TryParse(name, NumberStyles.Integer, CultureInfo.InvariantCulture, out var index))

{

return InvokeListElement(index, invokeFlags, args, bindArgs);

}

}

if (!bypassTunneling)

{

int testLength;

if (invokeFlags.HasFlag(BindingFlags.InvokeMethod))

{

testLength = invokeFlags.HasFlag(BindingFlags.GetField) ? 0 : -1;

}

else

{

testLength = invokeFlags.HasFlag(BindingFlags.SetField) ? 1 : 0;

}

if ((args.Length > testLength) && (name != SpecialMemberNames.Default))

{

var value = GetHostProperty(name, GetCommonBindFlags(), ArrayHelpers.GetEmptyArray<object>(), ArrayHelpers.GetEmptyArray<object>(), false, out _);

if (!(value is Nonexistent))

{

if (Engine.MarshalToScript(value) is HostItem hostItem)

{

return hostItem.InvokeMember(SpecialMemberNames.Default, invokeFlags, args, bindArgs, culture, true, out isCacheable);

}

}

}

}

return InvokeHostMember(name, invokeFlags, args, bindArgs, out isCacheable);

}

#endregion

#region internal members

#region interface accessors

private IReflect ThisReflect => this;

private IDynamic ThisDynamic => this;

#endregion

#region collateral accessors

private IDynamic TargetDynamic => Collateral.TargetDynamic.Get(this);

private IPropertyBag TargetPropertyBag

{

get => Collateral.TargetPropertyBag.Get(this);

set => Collateral.TargetPropertyBag.Set(this, value);

}

private IHostList TargetList

{

get => Collateral.TargetList.Get(this);

set => Collateral.TargetList.Set(this, value);

}

private DynamicHostMetaObject TargetDynamicMetaObject

{

get => Collateral.TargetDynamicMetaObject.Get(this);

set => Collateral.TargetDynamicMetaObject.Set(this, value);

}

private IEnumerator TargetEnumerator => Collateral.TargetEnumerator.Get(this);

private HashSet<string> ExpandoMemberNames

{

get => Collateral.ExpandoMemberNames.Get(this);

set => Collateral.ExpandoMemberNames.Set(this, value);

}

private Dictionary<string, HostMethod> HostMethodMap

{

get => Collateral.HostMethodMap.Get(this);

set => Collateral.HostMethodMap.Set(this, value);

}

private Dictionary<string, HostIndexedProperty> HostIndexedPropertyMap

{

get => Collateral.HostIndexedPropertyMap.Get(this);

set => Collateral.HostIndexedPropertyMap.Set(this, value);

}

private int[] PropertyIndices

{

get => Collateral.ListData.GetOrCreate(this).PropertyIndices;

set => Collateral.ListData.GetOrCreate(this).PropertyIndices = value;

}

private int CachedListCount

{

get => Collateral.ListData.GetOrCreate(this).CachedCount;

set => Collateral.ListData.GetOrCreate(this).CachedCount = value;

}

private HostItemCollateral Collateral => Engine.HostItemCollateral;

#endregion

#region target member data accessors

private string[] TypeEventNames

{

get => targetMemberData.TypeEventNames;

set => targetMemberData.TypeEventNames = value;

}

private string[] TypeFieldNames

{

get => targetMemberData.TypeFieldNames;

set => targetMemberData.TypeFieldNames = value;

}

private string[] TypeMethodNames

{

get => targetMemberData.TypeMethodNames;

set => targetMemberData.TypeMethodNames = value;

}

private string[] TypePropertyNames

{

get => targetMemberData.TypePropertyNames;

set => targetMemberData.TypePropertyNames = value;

}

private string[] AllFieldNames

{

get => targetMemberData.AllFieldNames;

set => targetMemberData.AllFieldNames = value;

}

private string[] AllMethodNames

{

get => targetMemberData.AllMethodNames;

set => targetMemberData.AllMethodNames = value;

}

private string[] OwnMethodNames

{

get => targetMemberData.OwnMethodNames;

set => targetMemberData.OwnMethodNames = value;

}

private string[] EnumeratedMethodNames => Engine.EnumerateInstanceMethods ? (Engine.EnumerateExtensionMethods ? AllMethodNames : OwnMethodNames) : ArrayHelpers.GetEmptyArray<string>();

private string[] AllPropertyNames

{

get => targetMemberData.AllPropertyNames;

set => targetMemberData.AllPropertyNames = value;

}

private string[] AllMemberNames

{

get => targetMemberData.AllMemberNames;

set => targetMemberData.AllMemberNames = value;

}

private FieldInfo[] AllFields

{

get => targetMemberData.AllFields;

set => targetMemberData.AllFields = value;

}

private MethodInfo[] AllMethods

{

get => targetMemberData.AllMethods;

set => targetMemberData.AllMethods = value;

}

private PropertyInfo[] AllProperties

{

get => targetMemberData.AllProperties;

set => targetMemberData.AllProperties = value;

}

private object EnumerationSettingsToken

{

get => targetMemberData.EnumerationSettingsToken;

set => targetMemberData.EnumerationSettingsToken = value;

}

private ExtensionMethodSummary ExtensionMethodSummary

{

get => targetMemberData.ExtensionMethodSummary;

set => targetMemberData.ExtensionMethodSummary = value;

}

private Invocability? TargetInvocability

{

get => targetMemberData.TargetInvocability;

set => targetMemberData.TargetInvocability = value;

}

private Type CurrentAccessContext => Flags.HasFlag(HostItemFlags.PrivateAccess) ? Target.Type : Engine.AccessContext;

private ScriptAccess CurrentDefaultAccess => Engine.DefaultAccess;

private HostTargetFlags CurrentTargetFlags => Target.GetFlags(this);

private Type CachedAccessContext => (targetMemberData is HostTargetMemberDataWithContext targetMemberDataWithContext) ? targetMemberDataWithContext.AccessContext : CurrentAccessContext;

private ScriptAccess CachedDefaultAccess

{

get

{

var targetMemberDataWithContext = targetMemberData as HostTargetMemberDataWithContext;

return targetMemberDataWithContext?.DefaultAccess ?? CurrentDefaultAccess;

}

}

private HostTargetFlags CachedTargetFlags

{

get

{

var targetMemberDataWithContext = targetMemberData as HostTargetMemberDataWithContext;

return targetMemberDataWithContext?.TargetFlags ?? CurrentTargetFlags;

}

}

#endregion

#region initialization

private static bool TargetSupportsExpandoMembers(HostTarget target, HostItemFlags flags)

{

if (!TargetSupportsSpecialTargets(target))

{

return false;

}

if (typeof(IDynamic).IsAssignableFrom(target.Type))

{

return true;

}

if (target is IHostVariable)

{

if (target.Type.IsImport)

{

return true;

}

}

else

{

if ((target.InvokeTarget is IDispatchEx dispatchEx) && dispatchEx.GetType().IsCOMObject)

{

return true;

}

}

if (typeof(IPropertyBag).IsAssignableFrom(target.Type))

{

return true;

}

if (!flags.HasFlag(HostItemFlags.HideDynamicMembers) && typeof(IDynamicMetaObjectProvider).IsAssignableFrom(target.Type))

{

return true;

}

return false;

}

private bool CanAddExpandoMembers()

{

return (TargetDynamic != null) || ((TargetPropertyBag != null) && !TargetPropertyBag.IsReadOnly) || (TargetDynamicMetaObject != null);

}

private static object BindOrCreate(ScriptEngine engine, object target, Type type, HostItemFlags flags)

{

return BindOrCreate(engine, HostObject.Wrap(target, type), flags);

}

private static object BindOrCreate(ScriptEngine engine, HostTarget target, HostItemFlags flags)

{

return engine.GetOrCreateHostItem(target, flags, Create);

}

private void BindSpecialTarget()

{

if (TargetSupportsSpecialTargets(Target))

{

if (BindSpecialTarget(Collateral.TargetDynamic))

{

TargetPropertyBag = null;

TargetList = null;

TargetDynamicMetaObject = null;

}

else if (BindSpecialTarget(Collateral.TargetPropertyBag))

{

TargetList = null;

TargetDynamicMetaObject = null;

}

else

{

if (!Flags.HasFlag(HostItemFlags.HideDynamicMembers) && BindSpecialTarget(out IDynamicMetaObjectProvider dynamicMetaObjectProvider))

{

var dynamicMetaObject = dynamicMetaObjectProvider.GetMetaObject(Expression.Constant(Target.InvokeTarget));

TargetDynamicMetaObject = new DynamicHostMetaObject(dynamicMetaObjectProvider, dynamicMetaObject);

TargetList = null;

}

else

{

TargetDynamicMetaObject = null;

BindSpecialTarget(Collateral.TargetList);

}

}

}

}

private bool BindSpecialTarget<T>(CollateralObject<HostItem, T> property) where T : class

{

if (BindSpecialTarget(out T value))

{

property.Set(this, value);

return true;

}

property.Clear(this);

return false;

}

private bool BindSpecialTarget<T>(out T specialTarget) where T : class

{

if (Target.InvokeTarget == null)

{

specialTarget = null;

return false;

}

if (typeof(T) == typeof(IDynamic))

{

// provide fully dynamic behavior for exposed IDispatch[Ex] implementations

if ((Target.InvokeTarget is IDispatchEx dispatchEx) && Target.Type.IsUnknownCOMObject())

{

specialTarget = (T)(object)(new DynamicDispatchExWrapper(this, dispatchEx));

return true;

}

if ((Target.InvokeTarget is IDispatch dispatch) && Target.Type.IsUnknownCOMObject())

{

specialTarget = (T)(object)(new DynamicDispatchWrapper(this, dispatch));

return true;

}

}

else if (typeof(T) == typeof(IHostList))

{

// generic list support

if (Target.Type.IsAssignableToGenericType(typeof(IList<>), out var typeArgs))

{

if (typeof(IList).IsAssignableFrom(Target.Type))

{

specialTarget = new HostList(Engine, (IList)Target.InvokeTarget, typeArgs[0]) as T;

return specialTarget != null;

}

specialTarget = typeof(HostList<>).MakeGenericType(typeArgs).CreateInstance(Engine, Target.InvokeTarget) as T;

return specialTarget != null;

}

if (typeof(IList).IsAssignableFrom(Target.Type))

{

specialTarget = new HostList(Engine, (IList)Target.InvokeTarget, typeof(object)) as T;

return specialTarget != null;

}

if (Target.Type.IsAssignableToGenericType(typeof(IReadOnlyList<>), out typeArgs))

{

specialTarget = typeof(ReadOnlyHostList<>).MakeGenericType(typeArgs).CreateInstance(Engine, Target.InvokeTarget) as T;

return specialTarget != null;

}

specialTarget = null;

return false;

}

// The check here is required because the item may be bound to a specific target base

// class or interface - one that must not trigger special treatment.

if (typeof(T).IsAssignableFrom(Target.Type))

{

specialTarget = Target.InvokeTarget as T;

return specialTarget != null;

}

specialTarget = null;

return false;

}

private void BindTargetMemberData()

{

if ((targetMemberData == null) || (AccessContext != CurrentAccessContext) || (DefaultAccess != CurrentDefaultAccess) || (TargetFlags != CurrentTargetFlags))

{

if (Target is HostMethod)

{

// host methods can share their (dummy) member data

targetMemberData = Engine.SharedHostMethodMemberData;

return;

}

if (Target is HostIndexedProperty)

{

// host indexed properties can share their (dummy) member data

targetMemberData = Engine.SharedHostIndexedPropertyMemberData;

return;

}

if (Target is ScriptMethod)

{

// script methods can share their (dummy) member data

targetMemberData = Engine.SharedScriptMethodMemberData;

return;

}

if (Target is HostObject hostObject)

{

if ((TargetDynamic == null) && (TargetPropertyBag == null) && (TargetList == null) && (TargetDynamicMetaObject == null))

{

// host objects without dynamic members can share their member data

targetMemberData = Engine.GetSharedHostObjectMemberData(hostObject, CurrentAccessContext, CurrentDefaultAccess, CurrentTargetFlags);

return;

}

}

// all other targets use unique member data

targetMemberData = new HostTargetMemberDataWithContext(CurrentAccessContext, CurrentDefaultAccess, CurrentTargetFlags);

}

}

private static bool TargetSupportsSpecialTargets(HostTarget target)

{

return (target is HostObject) || (target is IHostVariable) || (target is IByRefArg);

}

#endregion

#region member data maintenance

private string[] GetLocalEventNames()

{

if (TypeEventNames == null)

{

var localEvents = Target.Type.GetScriptableEvents(this, GetCommonBindFlags());

TypeEventNames = localEvents.Select(eventInfo => eventInfo.GetScriptName()).ToArray();

}

return TypeEventNames;

}

private string[] GetLocalFieldNames()

{

if (TypeFieldNames == null)

{

var localFields = Target.Type.GetScriptableFields(this, GetCommonBindFlags());

TypeFieldNames = localFields.Select(field => field.GetScriptName()).ToArray();

}

return TypeFieldNames;

}

private string[] GetLocalMethodNames()

{

if (TypeMethodNames == null)

{

var localMethods = Target.Type.GetScriptableMethods(this, GetMethodBindFlags());

TypeMethodNames = localMethods.Select(method => method.GetScriptName()).ToArray();

}

return TypeMethodNames;

}

private string[] GetLocalPropertyNames()

{

if (TypePropertyNames == null)

{

var localProperties = Target.Type.GetScriptableProperties(this, GetCommonBindFlags());

TypePropertyNames = localProperties.Select(property => property.GetScriptName()).ToArray();

}

return TypePropertyNames;

}

private string[] GetAllFieldNames()

{

if ((TargetDynamic == null) && (TargetPropertyBag == null))

{

return GetLocalFieldNames().Concat(GetLocalEventNames()).Distinct().ToArray();

}

return ArrayHelpers.GetEmptyArray<string>();

}

private string[] GetAllMethodNames(out string[] ownMethodNames)

{

ownMethodNames = null;

var names = Target.GetAuxMethodNames(this, GetMethodBindFlags()).AsEnumerable() ?? Enumerable.Empty<string>();

if ((TargetDynamic == null) && (TargetPropertyBag == null))

{

names = names.Concat(GetLocalMethodNames());

if (TargetFlags.HasFlag(HostTargetFlags.AllowExtensionMethods))

{

var extensionMethodSummary = Engine.ExtensionMethodSummary;

ExtensionMethodSummary = extensionMethodSummary;

var extensionMethodNames = extensionMethodSummary.MethodNames;

if (extensionMethodNames.Length > 0)

{

ownMethodNames = names.Distinct().ToArray();

names = ownMethodNames.Concat(extensionMethodNames);

}

}

}

var result = names.Distinct().ToArray();

if (ownMethodNames == null)

{

ownMethodNames = result;

}

return result;

}

private string[] GetAllPropertyNames()

{

var names = Target.GetAuxPropertyNames(this, GetCommonBindFlags()).AsEnumerable() ?? Enumerable.Empty<string>();

if (TargetDynamic != null)

{

names = names.Concat(TargetDynamic.GetPropertyNames());

names = names.Concat(TargetDynamic.GetPropertyIndices().Select(index => index.ToString(CultureInfo.InvariantCulture)));

}

else if (TargetPropertyBag != null)

{

names = names.Concat(TargetPropertyBag.Keys);

}

else

{

names = names.Concat(GetLocalPropertyNames());

if (TargetList != null)

{

CachedListCount = TargetList.Count;

if (CachedListCount > 0)

{

names = names.Concat(Enumerable.Range(0, CachedListCount).Select(index => index.ToString(CultureInfo.InvariantCulture)));

}

}

if (TargetDynamicMetaObject != null)

{

names = names.Concat(TargetDynamicMetaObject.GetDynamicMemberNames());

}

}

if (ExpandoMemberNames != null)

{

names = names.Except(ExpandoMemberNames);

}

return names.Distinct().ToArray();

}

private void UpdateFieldNames(out bool updated)

{

if (AllFieldNames == null)

{

AllFieldNames = GetAllFieldNames();

updated = true;

}

else

{

updated = false;

}

}

private void UpdateMethodNames(out bool updated)

{

if ((AllMethodNames == null) ||

(TargetFlags.HasFlag(HostTargetFlags.AllowExtensionMethods) && (ExtensionMethodSummary != Engine.ExtensionMethodSummary)))

{

AllMethodNames = GetAllMethodNames(out var ownMethodNames);

OwnMethodNames = ownMethodNames;

updated = true;

}

else

{

updated = false;

}

}

private void UpdatePropertyNames(out bool updated)

{

if ((AllPropertyNames == null) ||

(TargetDynamic != null) ||

(TargetPropertyBag != null) ||

(TargetDynamicMetaObject != null) ||

((TargetList != null) && (CachedListCount != TargetList.Count)))

{

AllPropertyNames = GetAllPropertyNames();

updated = true;

}

else

{

updated = false;

}

}

private void UpdateEnumerationSettingsToken(out bool updated)

{

var enumerationSettingsToken = Engine.EnumerationSettingsToken;

if (EnumerationSettingsToken != enumerationSettingsToken)

{

EnumerationSettingsToken = enumerationSettingsToken;

updated = true;

}

else

{

updated = false;

}

}

protected virtual void AddExpandoMemberName(string name)

{

if (ExpandoMemberNames == null)

{

ExpandoMemberNames = new HashSet<string>();

}

ExpandoMemberNames.Add(name);

}

protected virtual void RemoveExpandoMemberName(string name)

{

ExpandoMemberNames?.Remove(name);

}

#endregion

#region member invocation

private bool UseCaseInsensitiveMemberBinding => Engine.UseCaseInsensitiveMemberBinding;

private StringComparison MemberNameComparison => UseCaseInsensitiveMemberBinding ? StringComparison.OrdinalIgnoreCase : StringComparison.Ordinal;

private StringComparer MemberNameComparer => UseCaseInsensitiveMemberBinding ? StringComparer.OrdinalIgnoreCase : StringComparer.Ordinal;

private T HostInvoke<T>(Func<T> func)

{

BindTargetMemberData();

return Engine.HostInvoke(func);

}

private BindingFlags GetCommonBindFlags()

{

var bindFlags = BindingFlags.Public | BindingFlags.NonPublic;

if (TargetFlags.HasFlag(HostTargetFlags.AllowStaticMembers))

{

bindFlags |= BindingFlags.Static | BindingFlags.FlattenHierarchy;

}

if (TargetFlags.HasFlag(HostTargetFlags.AllowInstanceMembers))

{

bindFlags |= BindingFlags.Instance;

}

if (UseCaseInsensitiveMemberBinding)

{

bindFlags |= BindingFlags.IgnoreCase;

}

return bindFlags;

}

private BindingFlags GetMethodBindFlags()

{

return GetCommonBindFlags() | BindingFlags.OptionalParamBinding;

}

protected virtual string AdjustInvokeName(string name)

{

return name;

}

private void AdjustInvokeFlags(ref BindingFlags invokeFlags)

{

const BindingFlags onFlags =

BindingFlags.Public |

BindingFlags.NonPublic |

BindingFlags.OptionalParamBinding;

const BindingFlags offFlags =

BindingFlags.DeclaredOnly |

BindingFlags.ExactBinding;

const BindingFlags setPropertyFlags =

BindingFlags.SetProperty |

BindingFlags.PutDispProperty |

BindingFlags.PutRefDispProperty;

invokeFlags |= onFlags;

invokeFlags &= ~offFlags;

if (TargetFlags.HasFlag(HostTargetFlags.AllowStaticMembers))

{

invokeFlags |= BindingFlags.Static | BindingFlags.FlattenHierarchy;

}

else

{

invokeFlags &= ~BindingFlags.Static;

}

if (TargetFlags.HasFlag(HostTargetFlags.AllowInstanceMembers))

{

invokeFlags |= BindingFlags.Instance;

}

else

{

invokeFlags &= ~BindingFlags.Instance;

}

if (UseCaseInsensitiveMemberBinding)

{

invokeFlags |= BindingFlags.IgnoreCase;

}

else

{

invokeFlags &= ~BindingFlags.IgnoreCase;

}

if (invokeFlags.HasFlag(BindingFlags.GetProperty))

{

invokeFlags |= BindingFlags.GetField;

}

if ((invokeFlags & setPropertyFlags) != 0)

{

invokeFlags |= BindingFlags.SetField;

}

}

private object InvokeReflectMember(string name, BindingFlags invokeFlags, object[] wrappedArgs, CultureInfo culture, string[] namedParams)

{

return InvokeReflectMember(name, invokeFlags, wrappedArgs, culture, namedParams, out _);

}

private object InvokeReflectMember(string name, BindingFlags invokeFlags, object[] wrappedArgs, CultureInfo culture, string[] namedParams, out bool isCacheable)

{

var resultIsCacheable = false;

var result = Engine.MarshalToScript(HostInvoke(() =>

{

var args = Engine.MarshalToHost(wrappedArgs, false);

var argOffset = 0;

if ((namedParams != null) && (namedParams.Length > 0) && (namedParams[0] == SpecialParamNames.This))

{

args = args.Skip(1).ToArray();

argOffset = 1;

}

var bindArgs = args;

if ((args.Length > 0) && (invokeFlags.HasFlag(BindingFlags.InvokeMethod) || invokeFlags.HasFlag(BindingFlags.CreateInstance)))

{

bindArgs = Engine.MarshalToHost(wrappedArgs, true);

if (argOffset > 0)

{

bindArgs = bindArgs.Skip(argOffset).ToArray();

}

var savedArgs = (object[])args.Clone();

var tempResult = InvokeMember(name, invokeFlags, args, bindArgs, culture, false, out resultIsCacheable);

for (var index = 0; index < args.Length; index++)

{

var arg = args[index];

if (!ReferenceEquals(arg, savedArgs[index]))

{

wrappedArgs[argOffset + index] = Engine.MarshalToScript(arg);

}

}

return tempResult;

}

return InvokeMember(name, invokeFlags, args, bindArgs, culture, false, out resultIsCacheable);

}));

isCacheable = resultIsCacheable;

return result;

}

private object InvokeDynamicMember(string name, BindingFlags invokeFlags, object[] args)

{

if (invokeFlags.HasFlag(BindingFlags.CreateInstance))

{

if (name == SpecialMemberNames.Default)

{

return TargetDynamic.Invoke(true, args);

}

throw new InvalidOperationException("Invalid constructor invocation");

}

if (invokeFlags.HasFlag(BindingFlags.InvokeMethod))

{

if (name == SpecialMemberNames.Default)

{

try

{

return TargetDynamic.Invoke(false, args);

}

catch

{

if (invokeFlags.HasFlag(BindingFlags.GetField) && (args.Length < 1))

{

return Target;

}

throw;

}

}

try

{

return TargetDynamic.InvokeMethod(name, args);

}

catch