public override DynamicMetaObject BindInvoke(InvokeBinder binder, DynamicMetaObject[] args) {
ContractUtils.RequiresNotNull(binder, "binder");
ComMethodDesc method;
if (_self.TryGetGetItem(out method)) {
bool[] isByRef = ComBinderHelpers.ProcessArgumentsForCom(ref args);
return BindComInvoke(args, method, binder.CallInfo, isByRef);
}
return base.BindInvoke(binder, args);
}
public override MetaObject/*!*/ BindInvoke(InvokeBinder/*!*/ action, MetaObject/*!*/[]/*!*/ args) {
RubyCallSignature callSignature;
if (RubyCallSignature.TryCreate(action.Arguments, out callSignature)) {
return action.FallbackInvoke(this, args);
}
var context = new MetaObject(
Methods.GetContextFromProc.OpCall(AstUtils.Convert(Expression, typeof(Proc))),
Restrictions.Empty,
RubyOps.GetContextFromProc((Proc)Value)
);
var metaBuilder = new MetaObjectBuilder();
Proc.SetCallActionRule(metaBuilder, new CallArguments(context, this, args, callSignature), true);
return metaBuilder.CreateMetaObject(action, args);
}
public Runtime()
{
unaryOps = new Dictionary<ExpressionType, UnaryOperationBinder>();
binaryOps = new Dictionary<ExpressionType, BinaryOperationBinder>();
InvokeCallSite = new InvokeBinder();
ConvertCallSite = new ConvertBinder();
GetIndexCallSite = new GetIndexBinder();
SetIndexCallSite = new SetIndexBinder();
BuiltIns = new Dictionary<string, Expression>();
RegisterClass("Foo", null);
RegisterFunction("range", args =>
{
return Iter.Range(((Number)args[0]).Value, ((Number)args[1]).Value);
});
RegisterFunction("using", args =>
{
var filename = args[0].ToString();
var scanner = new Scanner(File.ReadAllText(filename));
var parser = new Parser(this, scanner);
var expr = parser.Parse();
var func = expr.Compile();
return func();
});
RegisterFunction("print", args => Console.WriteLine(string.Join(" ", args)));
RegisterModule("maths", new Dictionary<string, Any>
{
{"PI", new Number(Math.PI)},
{"cos", new Function(args => new Number(Math.Cos(((Number) args[0]).Value)))},
{"sin", new Function(args => new Number(Math.Sin(((Number) args[0]).Value)))},
});
}
public override bool TryInvoke(InvokeBinder binder, object[] args, out object result)
{
return(base.TryInvoke(binder, args, out result));
}
public override bool TryInvoke(InvokeBinder binder, object[] args, out object result)
{
result = InvokeAsync(null, Arguments.From(args, binder.CallInfo.ArgumentNames));
return(true);
}
/// <summary>
/// Makes it easier to call this builtin as if it was a normal callable.
/// You'll have to use the 'dynamic' type for your FlameBuiltin object though.
/// </summary>
public override bool TryInvoke(InvokeBinder binder, object[] args, out object result)
{
result = flameserver.call("invokeBuiltin", builtin, args, new Hashtable(0));
return(true);
}
internal virtual bool InvokeOperation(InvokeBinder binder, Args args, out Any result)
{
result = null;
return(false);
}
public override DynamicMetaObject BindInvoke(InvokeBinder binder, DynamicMetaObject[] args) {
CodeContext context = BinderState.GetBinderState(binder).Context;
PythonContext ctx = PythonContext.GetContext(context);
ArgumentMarshaller[] signature = GetArgumentMarshallers(args);
BindingRestrictions restrictions = BindingRestrictions.GetTypeRestriction(
Expression,
Value.GetType()
).Merge(
BindingRestrictions.GetExpressionRestriction(
Expression.Call(
typeof(ModuleOps).GetMethod("CheckFunctionId"),
Expression.Convert(Expression, typeof(_CFuncPtr)),
Expression.Constant(Value.Id)
)
)
);
foreach (var arg in signature) {
restrictions = restrictions.Merge(arg.GetRestrictions());
}
Expression call = MakeCall(signature, GetNativeReturnType());
List<Expression> block = new List<Expression>();
Expression res;
if (call.Type != typeof(void)) {
ParameterExpression tmp = Expression.Parameter(call.Type, "ret");
block.Add(Expression.Assign(tmp, call));
AddKeepAlives(signature, block);
block.Add(tmp);
res = Expression.Block(new[] { tmp }, block);
} else {
block.Add(call);
AddKeepAlives(signature, block);
res = Expression.Block(block);
}
return new DynamicMetaObject(Utils.Convert(res, typeof(object)), restrictions);
}
public override DynamicMetaObject/*!*/ BindInvoke(InvokeBinder/*!*/ call, params DynamicMetaObject/*!*/[]/*!*/ args) {
return new FunctionBinderHelper(call, this, null, args).MakeMetaObject();
}
public override DynamicMetaObject/*!*/ BindInvoke(InvokeBinder/*!*/ call, params DynamicMetaObject/*!*/[]/*!*/ args) {
return MakeCallRule(call, AstUtils.Constant(BinderState.GetBinderState(call).Context), args);
}
public override DynamicMetaObject BindInvoke(InvokeBinder binder, DynamicMetaObject[] args)
{
return(IsOverridden(nameof(DynamicProxy <T> .TryInvoke))
? CallMethodWithResult(nameof(DynamicProxy <T> .TryInvoke), binder, GetArgArray(args), e => binder.FallbackInvoke(this, args, e))
: base.BindInvoke(binder, args));
}
public override bool TryInvoke(InvokeBinder binder, object[] args, out object result)
{
result = null;
if (args.Length == 2)
{
object temp = args[0];
args[0] = args[1];
args[1] = temp;
return true;
}
return false;
}
public override DynamicMetaObject BindInvoke(InvokeBinder binder, DynamicMetaObject[] args) {
return BindGetOrInvoke(args, binder.CallInfo) ??
base.BindInvoke(binder, args);
}
public new bool TryInvoke(InvokeBinder binder, object[] args, out object result)
{
if (args.Length == 2)
{
int x;
int y;
try
{
x = Convert.ToInt32(args[0]);
y = Convert.ToInt32(args[1]);
}
catch (Exception)
{
result = null;
return false;
}
result = checked((int)Math.Pow(x, y));
return true;
}
result = null;
return false;
}
public override DynamicMetaObject BindInvoke(InvokeBinder binder, DynamicMetaObject[] args) {
ContractUtils.RequiresNotNull(binder, "binder");
return binder.Defer(args.AddFirst(WrapSelf()));
}
public override MetaObject BindInvoke(InvokeBinder binder, MetaObject[] args) {
if (args.Any(arg => ComBinderHelpers.IsStrongBoxArg(arg))) {
return ComBinderHelpers.RewriteStrongBoxAsRef(binder, this, args);
}
return BindComInvoke(binder.Arguments, args);
}
public override bool TryInvoke(InvokeBinder binder, object[] args, out object result)
{
throw new InvalidOperationException("不能当作函数使用");
}
public virtual bool TryInvoke(T instance, InvokeBinder binder, object[] args, out object result)
{
result = null;
return(false);
}
public sealed override DynamicMetaObject BindInvoke(InvokeBinder binder, DynamicMetaObject[] args) => VariantValue.BindInvoke(binder, args);
public override DynamicMetaObject/*!*/ BindInvoke(InvokeBinder/*!*/ call, params DynamicMetaObject/*!*/[]/*!*/ args) {
return MakeCallRule(call, AstUtils.Constant(PythonContext.GetPythonContext(call).SharedContext), args);
}
public override bool TryInvoke(InvokeBinder binder, object[] args, out object result)
{
return(((MemberAccessWrapper)MemberAccessWrapper).TryInvoke(binder, args, out result));
}
public virtual bool TryInvoke(InvokeBinder binder, object[] args, out object result) {
throw new NotSupportedException();
}
public override DynamicMetaObject BindInvoke(InvokeBinder binder, DynamicMetaObject[] args)
{
return(BindGetOrInvoke(args, binder.CallInfo) ??
base.BindInvoke(binder, args));
}
public static bool TryBindInvoke(InvokeBinder binder, DynamicMetaObject instance, DynamicMetaObject[] args, out DynamicMetaObject result) {
ContractUtils.RequiresNotNull(binder, "binder");
ContractUtils.RequiresNotNull(instance, "instance");
ContractUtils.RequiresNotNull(args, "args");
if (TryGetMetaObject(ref instance)) {
//
// Demand Full Trust to proceed with the binding.
//
new PermissionSet(PermissionState.Unrestricted).Demand();
result = instance.BindInvoke(binder, args);
return true;
} else {
result = null;
return false;
}
}
public override DynamicMetaObject/*!*/ BindInvoke(InvokeBinder/*!*/ callAction, params DynamicMetaObject/*!*/[]/*!*/ args) {
return InvokeWorker(callAction, args);
}
/// <summary>
/// Performs the binding of the dynamic invoke operation.
/// </summary>
/// <param name="binder">An instance of the <see cref="InvokeBinder"/> that represents the details of the dynamic operation.</param>
/// <param name="args">An array of <see cref="DynamicMetaObject"/> instances - arguments to the invoke operation.</param>
/// <returns>The new <see cref="DynamicMetaObject"/> representing the result of the binding.</returns>
public virtual DynamicMetaObject BindInvoke(InvokeBinder binder, DynamicMetaObject[] args) {
ContractUtils.RequiresNotNull(binder, "binder");
return binder.FallbackInvoke(this, args);
}
public override DynamicMetaObject BindInvoke( InvokeBinder binder, DynamicMetaObject[] args )
{
DEBUG.IndentLine( "\n-- BindInvoke: {0}", TypeHelper.ToString( MetaList2List( args ), "()" ) );
var obj = (DynamicNode)this.Value;
var node = new DynamicNode.Invoke( obj, MetaList2List( args ) ) { _Parser = obj._Parser };
obj._Parser._LastNode = node;
var par = Expression.Variable( typeof( DynamicNode ), "ret" );
var exp = Expression.Block(
new ParameterExpression[] { par },
Expression.Assign( par, Expression.Constant( node ) )
);
DEBUG.Unindent();
return new DynamicMetaNode( exp, this.Restrictions, node );
}
public virtual bool TryInvoke(InvokeBinder binder, object[] args, out object result) {
result = null;
return false;
}
public override bool TryInvoke(InvokeBinder binder, object[] args, out object result)
{
result = PerformOperation(String.Empty, args);
return(true);
}
public override DynamicMetaObject BindInvoke(InvokeBinder binder, DynamicMetaObject[] args) {
if (IsOverridden("TryInvoke")) {
return CallMethodWithResult("TryInvoke", binder, GetArgArray(args), (e) => binder.FallbackInvoke(this, args, e));
}
return base.BindInvoke(binder, args);
}
internal static Delegate CreateDelegateForDynamicObject(LanguageContext context, object dynamicObject, Type delegateType, MethodInfo invoke)
{
PerfTrack.NoteEvent(PerfTrack.Categories.DelegateCreate, delegateType.ToString());
Type returnType = invoke.ReturnType;
ParameterInfo[] parameterInfos = invoke.GetParameters();
var parameters = new List <ParameterExpression>();
for (int i = 0; i < parameterInfos.Length; i++)
{
parameters.Add(Expression.Parameter(parameterInfos[i].ParameterType, "p" + i));
}
InvokeBinder invokeBinder = context.CreateInvokeBinder(new CallInfo(parameterInfos.Length));
ConvertBinder convertBinder = (returnType != typeof(void)) ? context.CreateConvertBinder(returnType, explicitCast: true) : null;
CallSite invokeSite = CallSite.Create(DynamicSiteHelpers.MakeCallSiteDelegate(MakeSiteSignature(parameterInfos)), invokeBinder);
Type invokeSiteType = invokeSite.GetType();
Type convertSiteType;
CallSite convertSite;
if (convertBinder != null)
{
convertSite = CallSite.Create(DynamicSiteHelpers.MakeCallSiteDelegate(typeof(object), returnType), convertBinder);
convertSiteType = convertSite.GetType();
}
else
{
convertSiteType = null;
convertSite = null;
}
var locals = new List <ParameterExpression>();
ParameterExpression invokeSiteVar = Expression.Parameter(invokeSiteType, "site");
ParameterExpression convertSiteVar = null;
var args = new List <Expression>();
args.Add(invokeSiteVar);
args.Add(Expression.Constant(dynamicObject));
int strongBoxVarsStart = locals.Count;
for (int i = 0; i < parameterInfos.Length; i++)
{
if (parameterInfos[i].ParameterType.IsByRef)
{
var argType = parameterInfos[i].ParameterType;
Type elementType = argType.GetElementType();
Type concreteType = typeof(StrongBox <>).MakeGenericType(elementType);
var strongBox = Expression.Parameter(concreteType, "box" + i);
locals.Add(strongBox);
args.Add(
Expression.Assign(
strongBox,
Expression.New(
concreteType.GetConstructor(new Type[] { elementType }),
parameters[i]
)
)
);
}
else
{
args.Add(parameters[i]);
}
}
int strongBoxVarsEnd = locals.Count;
Expression invocation = Expression.Invoke(
Expression.Field(
Expression.Assign(
invokeSiteVar,
Expression.Convert(Expression.Constant(invokeSite), invokeSiteType)
),
invokeSiteType.GetDeclaredField("Target")
),
args
);
if (convertBinder != null)
{
convertSiteVar = Expression.Parameter(convertSiteType, "convertSite");
invocation = Expression.Invoke(
Expression.Field(
Expression.Assign(
convertSiteVar,
Expression.Convert(Expression.Constant(convertSite), convertSiteType)
),
convertSiteType.GetDeclaredField("Target")
),
convertSiteVar,
invocation
);
}
locals.Add(invokeSiteVar);
if (convertSiteVar != null)
{
locals.Add(convertSiteVar);
}
Expression body;
// copy back from StrongBox.Value
if (strongBoxVarsEnd > strongBoxVarsStart)
{
var block = new Expression[1 + strongBoxVarsEnd - strongBoxVarsStart + 1];
var resultVar = Expression.Parameter(invocation.Type, "result");
locals.Add(resultVar);
int b = 0;
int l = strongBoxVarsStart;
// values of strong boxes are initialized in invocation expression:
block[b++] = Expression.Assign(resultVar, invocation);
for (int i = 0; i < parameterInfos.Length; i++)
{
if (parameterInfos[i].ParameterType.IsByRef)
{
var local = locals[l++];
block[b++] = Expression.Assign(
parameters[i],
Expression.Field(local, local.Type.GetDeclaredField("Value"))
);
}
}
block[b++] = resultVar;
Debug.Assert(l == strongBoxVarsEnd);
Debug.Assert(b == block.Length);
body = Expression.Block(locals, block);
}
else
{
body = Expression.Block(locals, invocation);
}
var lambda = Expression.Lambda(delegateType, body, "_Scripting_", parameters);
return(lambda.Compile());
}
public override DynamicMetaObject /*!*/ BindInvoke(InvokeBinder /*!*/ call, params DynamicMetaObject /*!*/[] /*!*/ args)
{
// TODO: Context should come from BuiltinFunction
return(InvokeWorker(call, PythonContext.GetCodeContext(call), args));
}
public override DynamicMetaObject BindInvoke(InvokeBinder binder, DynamicMetaObject[] args) => GetTargetDynamicCall(binder, binder.ReturnType, args);
public override bool TryInvoke(InvokeBinder binder, object[] args, out object result)
{
throw new NotSupportedException();
}
public override DynamicMetaObject /*!*/ BindInvoke(InvokeBinder /*!*/ callAction, params DynamicMetaObject /*!*/[] /*!*/ args)
{
return(InvokeWorker(callAction, args));
}
public override bool TryInvoke(InvokeBinder binder, object[] args, out object result)
{
result = new DynamicArray(_function.Call(args), _state);
return(true);
}
public override DynamicMetaObject BindInvoke(InvokeBinder binder, DynamicMetaObject[] args)
{
return(Create());
}
public override DynamicMetaObject BindInvoke(InvokeBinder binder, DynamicMetaObject[] args)
{
CodeContext context = PythonContext.GetPythonContext(binder).SharedContext;
ArgumentMarshaller[] signature = GetArgumentMarshallers(args);
BindingRestrictions restrictions = BindingRestrictions.GetTypeRestriction(
Expression,
Value.GetType()
).Merge(
BindingRestrictions.GetExpressionRestriction(
Expression.Call(
typeof(ModuleOps).GetMethod(nameof(ModuleOps.CheckFunctionId)),
Expression.Convert(Expression, typeof(_CFuncPtr)),
Expression.Constant(Value.Id)
)
)
);
foreach (var arg in signature)
{
restrictions = restrictions.Merge(arg.GetRestrictions());
}
int argCount = args.Length;
if (Value._comInterfaceIndex != -1)
{
argCount--;
}
// need to verify we have the correct # of args
if (Value._argtypes != null)
{
if (argCount < Value._argtypes.Count || (Value.CallingConvention != CallingConvention.Cdecl && argCount > Value._argtypes.Count))
{
return(IncorrectArgCount(binder, restrictions, Value._argtypes.Count, argCount));
}
}
else
{
CFuncPtrType funcType = ((CFuncPtrType)Value.NativeType);
if (funcType._argtypes != null &&
(argCount < funcType._argtypes.Length || (Value.CallingConvention != CallingConvention.Cdecl && argCount > funcType._argtypes.Length)))
{
return(IncorrectArgCount(binder, restrictions, funcType._argtypes.Length, argCount));
}
}
if (Value._comInterfaceIndex != -1 && args.Length == 0)
{
return(NoThisParam(binder, restrictions));
}
Expression call = MakeCall(signature, GetNativeReturnType(), Value.Getrestype() == null, GetFunctionAddress(args));
List <Expression> block = new List <Expression>();
Expression res;
if (call.Type != typeof(void))
{
ParameterExpression tmp = Expression.Parameter(call.Type, "ret");
block.Add(Expression.Assign(tmp, call));
AddKeepAlives(signature, block);
block.Add(tmp);
res = Expression.Block(new[] { tmp }, block);
}
else
{
block.Add(call);
AddKeepAlives(signature, block);
res = Expression.Block(block);
}
res = AddReturnChecks(context, args, res);
return(new DynamicMetaObject(Utils.Convert(res, typeof(object)), restrictions));
}
/// <summary>
/// Tries to invoke.
/// </summary>
/// <param name="binder"></param>
/// <param name="args"></param>
/// <param name="result"></param>
/// <returns></returns>
public override bool TryInvoke(InvokeBinder binder, object[] args, out object result)
{
result = Impromptu.InvokeConstructor(_type, Util.NameArgsIfNecessary(binder.CallInfo, args));
return(true);
}
public override DynamicMetaObject BindInvoke(InvokeBinder binder, DynamicMetaObject[] args) => _innerMetaObject.BindInvoke(binder, args);
public override DynamicMetaObject /*!*/ BindInvoke(InvokeBinder /*!*/ call, params DynamicMetaObject /*!*/[] /*!*/ args)
{
return(InvokeWorker(call, args, PythonContext.GetCodeContext(call)));
}
public override DynamicMetaObject BindInvoke(InvokeBinder binder, DynamicMetaObject[] args)
{
var expression = MetamethodFallbacks.Call(null, this, args);
return(new DynamicMetaObject(expression, RuntimeHelpers.MergeTypeRestrictions(this)));
}
/// <inheritdoc/>
/// <exception cref="ArgumentException">
/// One of the supplied arguments is a <see cref="LuaReference"/> which is tied to a different <see cref="Lua"/> environment.
/// </exception>
/// <exception cref="InvalidOperationException">The <see cref="LuaThread"/> cannot be resumed.</exception>
/// <exception cref="LuaException">A Lua error occurs.</exception>
public override bool TryInvoke(InvokeBinder binder, object[] args, out object result)
{
result = Resume(args);
return(true);
}
public override bool TryInvoke(InvokeBinder binder, object[] args, out object result)
{
Console.WriteLine("TryInvoke被调用了");
return(base.TryInvoke(binder, args, out result));
}
public override DynamicMetaObject BindInvoke(InvokeBinder binder, DynamicMetaObject[] args) {
CodeContext context = PythonContext.GetPythonContext(binder).SharedContext;
PythonContext ctx = PythonContext.GetContext(context);
ArgumentMarshaller[] signature = GetArgumentMarshallers(args);
BindingRestrictions restrictions = BindingRestrictions.GetTypeRestriction(
Expression,
Value.GetType()
).Merge(
BindingRestrictions.GetExpressionRestriction(
Expression.Call(
typeof(ModuleOps).GetMethod("CheckFunctionId"),
Expression.Convert(Expression, typeof(_CFuncPtr)),
Expression.Constant(Value.Id)
)
)
);
foreach (var arg in signature) {
restrictions = restrictions.Merge(arg.GetRestrictions());
}
// need to verify we have the correct # of args
if (Value._argtypes != null) {
if (args.Length < Value._argtypes.Count || (Value.CallingConvention != CallingConvention.Cdecl && args.Length > Value._argtypes.Count)) {
return IncorrectArgCount(restrictions, Value._argtypes.Count, args.Length);
}
} else {
CFuncPtrType funcType = ((CFuncPtrType)Value.NativeType);
if (funcType._argtypes != null &&
(args.Length < funcType._argtypes.Length || (Value.CallingConvention != CallingConvention.Cdecl && args.Length > funcType._argtypes.Length))) {
return IncorrectArgCount(restrictions, funcType._argtypes.Length, args.Length);
}
}
Expression call = MakeCall(signature, GetNativeReturnType(), Value.Getrestype() == null);
List<Expression> block = new List<Expression>();
Expression res;
if (call.Type != typeof(void)) {
ParameterExpression tmp = Expression.Parameter(call.Type, "ret");
block.Add(Expression.Assign(tmp, call));
AddKeepAlives(signature, block);
block.Add(tmp);
res = Expression.Block(new[] { tmp }, block);
} else {
block.Add(call);
AddKeepAlives(signature, block);
res = Expression.Block(block);
}
res = AddReturnChecks(context, args, res);
return new DynamicMetaObject(Utils.Convert(res, typeof(object)), restrictions);
}
public virtual bool \u200F(\u0001 _param1, InvokeBinder _param2, object[] _param3, out object _param4)
{
// ISSUE: unable to decompile the method.
}
public override DynamicMetaObject/*!*/ BindInvoke(InvokeBinder/*!*/ action, DynamicMetaObject/*!*/[]/*!*/ args) {
Expression context = Ast.Call(
typeof(PythonOps).GetMethod("GetPythonTypeContext"),
Ast.Property(
AstUtils.Convert(Expression, typeof(IPythonObject)),
"PythonType"
)
);
return InvokeWorker(
action,
context,
args
);
}
public override bool TryInvoke(InvokeBinder binder, object[] args, out object result)
{
List <Type> outReturnTypes = new List <Type>();
List <object> returns = new List <object>();
int startIndex = 0;
ParameterInfo[] pis = _mi.GetParameters();
for (startIndex = pis.Length; startIndex > 0; --startIndex)
{
ParameterInfo pi = pis[startIndex - 1];
if ((pi.Attributes & ParameterAttributes.Out) == ParameterAttributes.Out)
{
outReturnTypes.Insert(0, pi.ParameterType);
}
else
{
break;
}
}
object[] uargs = UnwrapArray(args, outReturnTypes.Count);
// Possible varargs
if ((outReturnTypes.Count == 0) && (pis.Length > 0) && (uargs.Length >= pis.Length) && (pis[pis.Length - 1].ParameterType == typeof(object[])))
{
// Copy up to last argument (pis.Length - 1)
object[] xargs = new object[pis.Length];
Array.Copy(uargs, xargs, pis.Length - 1);
// Copy remaining parameters into a trailing array
object[] targs = new object[uargs.Length - pis.Length + 1];
Array.Copy(uargs, pis.Length - 1, targs, 0, targs.Length);
xargs[pis.Length - 1] = targs;
uargs = xargs;
}
object ret = _mi.Invoke(_target, uargs);
if (_mi.ReturnType != typeof(void))
{
returns.Add(DynamicComObjectWrapper.Wrap(_registry, ret, _mi.ReturnType));
}
// Promote out parameters
if (outReturnTypes.Count > 0)
{
for (int i = 0; i < outReturnTypes.Count; ++i)
{
returns.Add(DynamicComObjectWrapper.Wrap(_registry, uargs[startIndex + i], outReturnTypes[i]));
}
}
if (returns.Count == 0)
{
ret = null;
}
else if (returns.Count == 1)
{
ret = returns[0];
}
else
{
ret = Activator.CreateInstance(typeof(Tuple <>).MakeGenericType(returns.Select(o => o != null ? o.GetType() : typeof(object)).ToArray()), returns.ToArray());
}
result = ret;
return(true);
}
public override DynamicMetaObject/*!*/ BindInvoke(InvokeBinder/*!*/ call, params DynamicMetaObject/*!*/[]/*!*/ args) {
return InvokeWorker(call, args, PythonContext.GetCodeContext(call));
}
public override DynamicMetaObject BindInvoke(InvokeBinder binder, DynamicMetaObject[] args)
{
var expression = Info.GetInvokeExpression(binder.CallInfo, binder.ReturnType, null, args);
return(new DynamicMetaObject(expression, typeRestriction));
}
public override DynamicMetaObject/*!*/ BindInvoke(InvokeBinder/*!*/ call, params DynamicMetaObject/*!*/[]/*!*/ args) {
// TODO: Context should come from BuiltinFunction
return InvokeWorker(call, BinderState.GetCodeContext(call), args);
}
/// <summary>
/// Override on DynamicObject
/// </summary>
/// <param name="binder"></param>
/// <param name="args"></param>
/// <param name="result"></param>
/// <returns></returns>
public override bool TryInvoke(InvokeBinder binder, object[] args, out object result)
{
result = new Mimic();
return(true);
}
public override DynamicMetaObject/*!*/ BindInvoke(InvokeBinder/*!*/ invoke, params DynamicMetaObject/*!*/[]/*!*/ args) {
return InvokeWorker(invoke, PythonContext.GetCodeContext(invoke), args);
}
public override DynamicMetaObject BindInvoke(InvokeBinder binder, DynamicMetaObject[] args)
{
return(scriptItem.PostProcessBindResult(metaDynamic.BindInvoke(binder, args)));
}
