Value RuntimeInvoke(MethodMirror method, object target, Value[] values, bool enableOutArgs, out Value[] outArgs) { outArgs = null; if (values != null) { // Some arguments may need to be boxed var mparams = method.GetParameters(); if (mparams.Length != values.Length) { throw new EvaluatorException("Invalid number of arguments when calling: " + method.Name); } for (int n = 0; n < mparams.Length; n++) { var tm = mparams[n].ParameterType; if (tm.IsValueType || tm.IsPrimitive) { continue; } var type = Adapter.GetValueType(this, values[n]); var argTypeMirror = type as TypeMirror; var argType = type as Type; if (IsValueTypeOrPrimitive(argTypeMirror) || IsValueTypeOrPrimitive(argType)) { // A value type being assigned to a parameter which is not a value type. The value has to be boxed. try { values[n] = Thread.Domain.CreateBoxedValue(values [n]); } catch (NotSupportedException) { // This runtime doesn't support creating boxed values throw new EvaluatorException("This runtime does not support creating boxed values."); } } } } if (!method.IsStatic && method.DeclaringType.IsClass && !IsValueTypeOrPrimitive(method.DeclaringType)) { object type = Adapter.GetValueType(this, target); var targetTypeMirror = type as TypeMirror; var targetType = type as Type; if ((target is StructMirror && ((StructMirror)target).Type != method.DeclaringType) || (IsValueTypeOrPrimitive(targetTypeMirror) || IsValueTypeOrPrimitive(targetType))) { // A value type being assigned to a parameter which is not a value type. The value has to be boxed. try { target = Thread.Domain.CreateBoxedValue((Value)target); } catch (NotSupportedException) { // This runtime doesn't support creating boxed values throw new EvaluatorException("This runtime does not support creating boxed values."); } } } try { return(method.Evaluate(target is TypeMirror ? null : (Value)target, values)); } catch (NotSupportedException) { AssertTargetInvokeAllowed(); var mc = new MethodCall(this, method, target, values, enableOutArgs); //Since runtime is returning NOT_SUSPENDED error if two methods invokes are executed //at same time we have to lock invoking to prevent this... lock (method.VirtualMachine) { Adapter.AsyncExecute(mc, Options.EvaluationTimeout); } if (enableOutArgs) { outArgs = mc.OutArgs; } return(mc.ReturnValue); } }
public Value RuntimeInvoke(MethodMirror method, object target, Value[] values) { if (values != null) { // Some arguments may need to be boxed ParameterInfoMirror[] mparams = method.GetParameters(); if (mparams.Length != values.Length) { throw new EvaluatorException("Invalid number of arguments when calling: " + method.Name); } for (int n = 0; n < mparams.Length; n++) { TypeMirror tm = mparams [n].ParameterType; if (tm.IsValueType || tm.IsPrimitive) { continue; } object type = Adapter.GetValueType(this, values [n]); TypeMirror argTypeMirror = type as TypeMirror; Type argType = type as Type; if ((argTypeMirror != null && (argTypeMirror.IsValueType || argTypeMirror.IsPrimitive)) || (argType != null && (argType.IsValueType || argType.IsPrimitive))) { // A value type being assigned to a parameter which is not a value type. The value has to be boxed. try { values [n] = Thread.Domain.CreateBoxedValue(values [n]); } catch (NotSupportedException) { // This runtime doesn't support creating boxed values throw new EvaluatorException("This runtime does not support creating boxed values."); } } } } if (!method.IsStatic && method.DeclaringType.IsClass) { object type = Adapter.GetValueType(this, target); TypeMirror targetTypeMirror = type as TypeMirror; Type targetType = type as Type; if ((targetTypeMirror != null && (targetTypeMirror.IsValueType || targetTypeMirror.IsPrimitive)) || (targetType != null && (targetType.IsValueType || targetType.IsPrimitive))) { // A value type being assigned to a parameter which is not a value type. The value has to be boxed. try { target = Thread.Domain.CreateBoxedValue((Value)target); } catch (NotSupportedException) { // This runtime doesn't support creating boxed values throw new EvaluatorException("This runtime does not support creating boxed values."); } } } MethodCall mc = new MethodCall(this, method, target, values); Adapter.AsyncExecute(mc, Options.EvaluationTimeout); return(mc.ReturnValue); }
Value RuntimeInvoke(MethodMirror method, object target, Value[] values, bool enableOutArgs, out Value[] outArgs) { outArgs = null; if (values != null) { // Some arguments may need to be boxed var mparams = method.GetParameters(); if (mparams.Length != values.Length) { throw new EvaluatorException("Invalid number of arguments when calling: " + method.Name); } for (int n = 0; n < mparams.Length; n++) { var tm = mparams[n].ParameterType; if (tm.IsValueType || tm.IsPrimitive) { continue; } var type = Adapter.GetValueType(this, values[n]); var argTypeMirror = type as TypeMirror; var argType = type as Type; if (IsValueTypeOrPrimitive(argTypeMirror) || IsValueTypeOrPrimitive(argType)) { // A value type being assigned to a parameter which is not a value type. The value has to be boxed. try { values[n] = Thread.Domain.CreateBoxedValue(values [n]); } catch (NotSupportedException) { // This runtime doesn't support creating boxed values throw new EvaluatorException("This runtime does not support creating boxed values."); } } } } if (!method.IsStatic && method.DeclaringType.IsClass && !IsValueTypeOrPrimitive(method.DeclaringType)) { object type = Adapter.GetValueType(this, target); var targetTypeMirror = type as TypeMirror; var targetType = type as Type; if ((target is StructMirror && ((StructMirror)target).Type != method.DeclaringType) || (IsValueTypeOrPrimitive(targetTypeMirror) || IsValueTypeOrPrimitive(targetType))) { // A value type being assigned to a parameter which is not a value type. The value has to be boxed. try { target = Thread.Domain.CreateBoxedValue((Value)target); } catch (NotSupportedException) { // This runtime doesn't support creating boxed values throw new EvaluatorException("This runtime does not support creating boxed values."); } } } try { return(method.Evaluate(target is TypeMirror ? null : (Value)target, values)); } catch (NotSupportedException) { AssertTargetInvokeAllowed(); var threadState = Thread.ThreadState; if ((threadState & ThreadState.WaitSleepJoin) == ThreadState.WaitSleepJoin) { DC.DebuggerLoggingService.LogMessage("Thread state before evaluation is {0}", threadState); throw new EvaluatorException("Evaluation is not allowed when the thread is in 'Wait' state"); } var invocableMirror = target as IInvocableMethodOwnerMirror; if (invocableMirror == null) { throw new ArgumentException("Soft debugger method calls cannot be invoked on objects of type " + target.GetType().Name); } var mc = new SoftMethodCall(this, method, invocableMirror, values, enableOutArgs); //Since runtime is returning NOT_SUSPENDED error if two methods invokes are executed //at same time we have to lock invoking to prevent this... lock (method.VirtualMachine) { var result = (SoftOperationResult)Adapter.InvokeSync(mc, Options.EvaluationTimeout).ThrowIfException(this); if (enableOutArgs) { outArgs = result.OutArgs; } return(result.Result); } } }
protected override IEnumerable <ValueReference> GetMembers(EvaluationContext ctx, object t, object co, BindingFlags bindingFlags) { Dictionary <string, PropertyInfoMirror> subProps = new Dictionary <string, PropertyInfoMirror> (); TypeMirror type = t as TypeMirror; TypeMirror realType = null; if (co != null && (bindingFlags & BindingFlags.Instance) != 0) { realType = GetValueType(ctx, co) as TypeMirror; } // First of all, get a list of properties overriden in sub-types while (realType != null && realType != type) { foreach (PropertyInfoMirror prop in realType.GetProperties(bindingFlags | BindingFlags.DeclaredOnly)) { MethodMirror met = prop.GetGetMethod(true); if (met == null || met.GetParameters().Length != 0 || met.IsAbstract || !met.IsVirtual || met.IsStatic) { continue; } if (met.IsPublic && ((bindingFlags & BindingFlags.Public) == 0)) { continue; } if (!met.IsPublic && ((bindingFlags & BindingFlags.NonPublic) == 0)) { continue; } subProps [prop.Name] = prop; } realType = realType.BaseType; } while (type != null) { foreach (FieldInfoMirror field in type.GetFields()) { if (field.IsStatic && ((bindingFlags & BindingFlags.Static) == 0)) { continue; } if (!field.IsStatic && ((bindingFlags & BindingFlags.Instance) == 0)) { continue; } if (field.IsPublic && ((bindingFlags & BindingFlags.Public) == 0)) { continue; } if (!field.IsPublic && ((bindingFlags & BindingFlags.NonPublic) == 0)) { continue; } yield return(new FieldValueReference(ctx, field, co, type)); } foreach (PropertyInfoMirror prop in type.GetProperties(bindingFlags)) { MethodMirror met = prop.GetGetMethod(true); if (met == null || met.GetParameters().Length != 0 || met.IsAbstract) { continue; } if (met.IsStatic && ((bindingFlags & BindingFlags.Static) == 0)) { continue; } if (!met.IsStatic && ((bindingFlags & BindingFlags.Instance) == 0)) { continue; } if (met.IsPublic && ((bindingFlags & BindingFlags.Public) == 0)) { continue; } if (!met.IsPublic && ((bindingFlags & BindingFlags.NonPublic) == 0)) { continue; } // If a property is overriden, return the override instead of the base property PropertyInfoMirror overriden; if (met.IsVirtual && subProps.TryGetValue(prop.Name, out overriden)) { yield return(new PropertyValueReference(ctx, overriden, co, overriden.DeclaringType, null)); } else { yield return(new PropertyValueReference(ctx, prop, co, type, null)); } } if ((bindingFlags & BindingFlags.DeclaredOnly) != 0) { break; } type = type.BaseType; } }